elmo/elmo.el

   1 ;;; elmo.el --- Elisp Library for Message Orchestration.
   2
   3 ;; Copyright (C) 1998,1999,2000 Yuuichi Teranishi <teranisi@gohome.org>
   4
   5 ;; Author: Yuuichi Teranishi <teranisi@gohome.org>
   6 ;; Keywords: mail, net news
   7
   8 ;; This file is part of ELMO (Elisp Library for Message Orchestration).
   9
  10 ;; This program is free software; you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation; either version 2, or (at your option)
  13 ;; any later version.
  14 ;;
  15 ;; This program is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19 ;;
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23 ;; Boston, MA 02111-1307, USA.
  24 ;;
  25
  26 ;;; Commentary:
  27 ;;
  28
  29 ;;; Code:
  30 ;;
  31
  32 (require 'luna)
  33
  34 (require 'elmo-version)                 ; reduce recursive-load-depth
  35 (require 'elmo-vars)
  36 (require 'elmo-util)
  37 (require 'elmo-msgdb)
  38
  39 (eval-when-compile (require 'cl))
  40
  41 (if (or (featurep 'dbm)
  42         (featurep 'gnudbm)
  43         (featurep 'berkdb)
  44         (featurep 'berkeley-db))
  45     (require 'elmo-database))
  46
  47 (defcustom elmo-message-fetch-threshold 30000
  48   "Fetch threshold."
  49   :type 'integer
  50   :group 'elmo)
  51
  52 (defcustom elmo-message-fetch-confirm t
  53   "If non-nil, confirm fetching if message size is larger than
  54 `elmo-message-fetch-threshold'.
  55 Otherwise, entire fetching of the message is aborted without confirmation."
  56   :type 'boolean
  57   :group 'elmo)
  58
  59 (defcustom elmo-folder-update-threshold 500
  60   "Update threshold."
  61   :type 'integer
  62   :group 'elmo)
  63
  64 (defcustom elmo-folder-update-confirm t
  65   "Confirm if update number exceeds `elmo-folder-update-threshold'."
  66   :type 'boolean
  67   :group 'elmo)
  68
  69 (defvar elmo-message-displaying nil
  70   "A global switch to indicate message is displaying or not.")
  71
  72 ;;; internal
  73 (defvar elmo-folder-type-alist nil)
  74
  75 (defvar elmo-newsgroups-hashtb nil)
  76
  77 (elmo-define-error 'elmo-error "Error" 'error)
  78 (elmo-define-error 'elmo-open-error "Cannot open" 'elmo-error)
  79 (elmo-define-error 'elmo-authenticate-error "Login failed" 'elmo-open-error)
  80 (elmo-define-error 'elmo-imap4-bye-error "IMAP4 session was terminated" 'elmo-open-error)
  81
  82 ;; autoloads
  83 (eval-and-compile
  84   (autoload 'elmo-dop-queue-flush "elmo-dop")
  85   (autoload 'elmo-nntp-post "elmo-nntp")
  86   (autoload 'elmo-global-flag-p "elmo-flag")
  87   (autoload 'elmo-global-flag-detach "elmo-flag")
  88   (autoload 'elmo-global-flag-detach-messages "elmo-flag")
  89   (autoload 'elmo-global-flag-set "elmo-flag")
  90   (autoload 'elmo-get-global-flags "elmo-flag")
  91   (autoload 'elmo-global-mark-migrate "elmo-flag")
  92   (autoload 'elmo-folder-list-global-flag-messages "elmo-flag"))
  93
  94 (defun elmo-define-folder (prefix backend)
  95   "Define a folder.
  96 If a folder name begins with PREFIX, use BACKEND."
  97   (let ((pair (assq prefix elmo-folder-type-alist)))
  98     (if pair
  99         (progn
 100           (setcar pair prefix)
 101           (setcdr pair backend))
 102       (setq elmo-folder-type-alist (cons (cons prefix backend)
 103                                          elmo-folder-type-alist)))))
 104
 105 (defmacro elmo-folder-type (name)
 106   "Get folder type from NAME string."
 107   `(and (stringp ,name)
 108         (cdr (assoc (string-to-char ,name) elmo-folder-type-alist))))
 109
 110 ;;; ELMO folder
 111 ;; A elmo folder provides uniformed (orchestrated) access
 112 ;; to the internet messages.
 113 (eval-and-compile
 114   (luna-define-class elmo-folder () (type   ; folder type symbol.
 115                                      name   ; orignal folder name string.
 116                                      prefix ; prefix for folder name
 117                                      path   ; directory path for msgdb.
 118                                      msgdb  ; msgdb (may be nil).
 119                                      killed-list  ; killed list.
 120                                      persistent   ; non-nil if persistent.
 121                                      process-duplicates  ; read or hide
 122                                      biff   ; folder for biff
 123                                      ))
 124   (luna-define-internal-accessors 'elmo-folder))
 125
 126 (luna-define-generic elmo-folder-initialize (folder name)
 127   ;; Initialize a FOLDER structure with NAME."
 128   )
 129
 130 (defmacro elmo-folder-send (folder message &rest args)
 131   "Let FOLDER receive the MESSAGE with ARGS."
 132   (` (luna-send (, folder) (, message) (, folder) (,@ args))))
 133
 134 ;;;###autoload
 135 (defun elmo-make-folder (name &optional non-persistent)
 136   "Make an ELMO folder structure specified by NAME.
 137 If optional argument NON-PERSISTENT is non-nil, the folder msgdb is not saved."
 138   (let ((type (elmo-folder-type name))
 139         prefix split class folder original)
 140     (setq original (elmo-string name))
 141     (if type
 142         (progn
 143           (setq prefix (substring name 0 1))
 144           (setq name (substring name 1)))
 145       (setq type (intern (car (setq split (split-string name ":")))))
 146       (if (>= (length split) 2)
 147           (setq name (substring name (+ 1 (length (car split)))))
 148         (error "Error in folder name `%s'" original))
 149       (setq prefix (concat (car split) ":")))
 150     (setq class (format "elmo-%s" (symbol-name type)))
 151     (require (intern class))
 152     (setq folder (luna-make-entity (intern (concat class "-folder"))
 153                                    :type type
 154                                    :prefix prefix
 155                                    :name original
 156                                    :persistent (not non-persistent)))
 157     (save-match-data
 158       (elmo-folder-send folder 'elmo-folder-initialize name))))
 159
 160 ;; Note that this function is for internal use only.
 161 (luna-define-generic elmo-folder-msgdb (folder)
 162   "Return the msgdb of FOLDER (on-demand loading).
 163 \(For internal use only.\)")
 164
 165 (luna-define-method elmo-folder-msgdb ((folder elmo-folder))
 166   (or (elmo-folder-msgdb-internal folder)
 167       (elmo-folder-set-msgdb-internal folder
 168                                       (elmo-folder-msgdb-load folder))))
 169
 170 (luna-define-generic elmo-folder-open (folder &optional load-msgdb)
 171   "Open and setup (load saved status) FOLDER.
 172 If optional LOAD-MSGDB is non-nil, msgdb is loaded.
 173 \(otherwise, msgdb is loaded on-demand)")
 174
 175 (luna-define-generic elmo-folder-open-internal (folder)
 176   "Open FOLDER (without loading saved folder status).")
 177
 178 (luna-define-generic elmo-folder-check (folder)
 179   "Check the FOLDER to obtain newest information at the next list operation.")
 180
 181 (luna-define-generic elmo-folder-clear (folder &optional keep-killed)
 182   "Clear FOLDER to the initial state.
 183 If optional KEEP-KILLED is non-nil, killed-list is not cleared.")
 184
 185 (luna-define-generic elmo-folder-commit (folder)
 186   "Save current status of FOLDER.")
 187
 188 (luna-define-generic elmo-folder-close (folder)
 189   "Close, save and clearnup FOLDER.")
 190
 191 (luna-define-generic elmo-folder-close-internal (folder)
 192   "Close FOLDER (without saving folder status).")
 193
 194 (luna-define-generic elmo-folder-plugged-p (folder)
 195   "Returns t if FOLDER is plugged.")
 196
 197 (luna-define-generic elmo-folder-set-plugged (folder plugged &optional add)
 198   "Set FOLDER as plugged.")
 199
 200 (luna-define-generic elmo-net-port-info (folder)
 201   "Get port information of FOLDER.")
 202
 203 (luna-define-generic elmo-folder-use-flag-p (folder)
 204   "Returns t if FOLDER treats unread/important flag itself.")
 205
 206 (luna-define-generic elmo-folder-diff (folder)
 207   "Get diff of FOLDER.
 208 Return value is cons cell or list:
 209  - a cons cell (new . all)
 210  - a list (new unread all)")
 211
 212 (luna-define-generic elmo-folder-status (folder)
 213   "Returns a cons cell of (MAX-NUMBER . MESSAGES) in the FOLDER.")
 214
 215 (luna-define-generic elmo-folder-reserve-status-p (folder)
 216   "If non-nil, the folder should not close folder after `elmo-folder-status'.")
 217
 218 (luna-define-generic elmo-folder-list-messages (folder &optional visible-only
 219                                                        in-msgdb)
 220   "Return a list of message numbers contained in FOLDER.
 221 If optional VISIBLE-ONLY is non-nil, killed messages are not listed.
 222 If second optional IN-MSGDB is non-nil, only messages in the msgdb are listed.")
 223
 224 (luna-define-method elmo-folder-list-messages ((folder elmo-folder)
 225                                                &optional visible-only in-msgdb)
 226   (let ((list (if in-msgdb
 227                   t
 228                 (elmo-folder-list-messages-internal folder visible-only)))
 229         (killed-list (elmo-folder-killed-list-internal folder)))
 230     (unless (listp list)
 231       ;; Use current list.
 232       (setq list (elmo-msgdb-list-messages (elmo-folder-msgdb folder))))
 233     (if visible-only
 234         (elmo-living-messages list killed-list)
 235       (if (and in-msgdb killed-list)
 236           (elmo-uniq-sorted-list
 237            (sort (nconc (elmo-number-set-to-number-list killed-list) list) #'<)
 238            #'eq)
 239         list))))
 240
 241 (luna-define-generic elmo-folder-list-messages-internal (folder &optional
 242                                                                 visible-only)
 243   ;; Return a list of message numbers contained in FOLDER.
 244   ;; Return t if the message list is not available.
 245   )
 246
 247 (luna-define-generic elmo-folder-list-flagged (folder flag &optional in-msgdb)
 248   "List messages in the FOLDER with FLAG.
 249 FLAG is a symbol which is one of the following:
 250   `new'        (new messages)
 251   `unread'     (unread messages (new messages are included))
 252   `answered'   (answered or forwarded)
 253   `important'  (marked as important)
 254 'sugar' flags:
 255   `read'       (not unread)
 256   `digest'     (unread + important + other flags)
 257   `any'        (digest + answered + other flags)
 258 If optional IN-MSGDB is non-nil, retrieve flag information from msgdb.")
 259
 260 (luna-define-method elmo-folder-list-flagged ((folder elmo-folder) flag
 261                                               &optional in-msgdb)
 262   (let ((msgs (if in-msgdb
 263                   t
 264                 (elmo-folder-list-flagged-internal folder flag))))
 265     (unless (listp msgs)
 266       (setq msgs (elmo-msgdb-list-flagged (elmo-folder-msgdb folder) flag)))
 267     (if in-msgdb
 268         msgs
 269       (elmo-uniq-list
 270        (nconc (elmo-folder-list-global-flag-messages folder flag) msgs)
 271        #'delq))))
 272
 273 (luna-define-generic elmo-folder-list-flagged-internal (folder flag)
 274   "Return a list of message in the FOLDER with FLAG.
 275 Return t if the message list is not available.")
 276
 277 (luna-define-method elmo-folder-list-flagged-internal ((folder elmo-folder)
 278                                                        flag)
 279   t)
 280
 281 (luna-define-generic elmo-folder-list-subfolders (folder &optional one-level)
 282   "Returns a list of subfolders contained in FOLDER.
 283 If optional argument ONE-LEVEL is non-nil, only children of FOLDER is returned.
 284 \(a folder which have children is returned as a list\)
 285 Otherwise, all descendent folders are returned.")
 286
 287 (luna-define-generic elmo-folder-have-subfolder-p (folder)
 288   "Return non-nil when FOLDER has subfolders.")
 289
 290 (luna-define-generic elmo-folder-exists-p (folder)
 291   "Returns non-nil when FOLDER exists.")
 292
 293 (luna-define-generic elmo-folder-creatable-p (folder)
 294   "Returns non-nil when FOLDER is creatable.")
 295
 296 (luna-define-generic elmo-folder-writable-p (folder)
 297   "Returns non-nil when FOLDER is writable.")
 298
 299 (luna-define-generic elmo-folder-persistent-p (folder)
 300   "Return non-nil when FOLDER is persistent.")
 301
 302 (luna-define-generic elmo-folder-create (folder)
 303   "Create a FOLDER.")
 304
 305 (luna-define-generic elmo-message-deletable-p (folder number)
 306   "Returns non-nil when the message in the FOLDER with NUMBER is deletable.")
 307
 308 (luna-define-generic elmo-folder-delete (folder)
 309   "Delete FOLDER completely.")
 310
 311 (luna-define-generic elmo-folder-rename (folder new-name)
 312   "Rename FOLDER to NEW-NAME (string).")
 313
 314 (luna-define-generic elmo-folder-delete-messages (folder numbers)
 315   "Delete messages.
 316 FOLDER is the ELMO folder structure.
 317 NUMBERS is a list of message numbers to be deleted.
 318 It is not recommended to use this function other than internal use.
 319 Use `elmo-folder-move-messages' with dst-folder 'null instead.")
 320
 321 (luna-define-generic elmo-folder-search (folder condition &optional numbers)
 322   "Search and return list of message numbers.
 323 FOLDER is the ELMO folder structure.
 324 CONDITION is a condition structure for searching.
 325 If optional argument NUMBERS is specified and is a list of message numbers,
 326 messages are searched from the list.")
 327
 328 (luna-define-generic elmo-message-match-condition (folder number
 329                                                           condition
 330                                                           numbers)
 331   "Return non-nil when the message in the FOLDER with NUMBER is matched.
 332 CONDITION is a condition structure for testing.
 333 NUMBERS is a list of message numbers,
 334 use to be test for \"last\" and \"first\" predicates.")
 335
 336 (luna-define-generic elmo-folder-msgdb-create (folder numbers flag-table)
 337   "Create a message database (implemented in each backends).
 338 FOLDER is the ELMO folder structure.
 339 NUMBERS is a list of message numbers to create msgdb.
 340 FLAG-TABLE is a hashtable of message-id and flag.")
 341
 342 (luna-define-generic elmo-folder-set-flag (folder numbers flag
 343                                                   &optional is-local)
 344   "Set messages flag.
 345 FOLDER is a ELMO folder structure.
 346 NUMBERS is a list of message number to set flag.
 347
 348 FLAG is a symbol which is one of the following:
 349   `unread'    (set the message as unread)
 350   `answered'  (set the message as answered)
 351   `important' (set the message as important)
 352 'sugar' flag:
 353   `read'      (remove new and unread flags)
 354 If optional IS-LOCAL is non-nil, update only local (not server) status.")
 355
 356 (luna-define-generic elmo-folder-unset-flag (folder numbers flag
 357                                                     &optional is-local)
 358   "Unset messages flag.
 359 FOLDER is a ELMO folder structure.
 360 NUMBERS is a list of message number to unset flag.
 361
 362 FLAG is a symbol which is one of the following:
 363   `unread'    (remove unread and new flag)
 364   `answered'  (remove answered flag)
 365   `important' (remove important flag)
 366 'sugar' flag:
 367   `read'      (set unread flag)
 368   `all'       (remove all flags)
 369 If optional IS-LOCAL is non-nil, update only local (not server) status.")
 370
 371 (luna-define-generic elmo-folder-next-message-number (folder)
 372   "The next message number that will be assigned to a new message.
 373 FOLDER is the ELMO folder structure.")
 374
 375 (luna-define-generic elmo-folder-append-buffer (folder &optional flags
 376                                                        number)
 377   "Append current buffer as a new message.
 378 FOLDER is the destination folder(ELMO folder structure).
 379 FLAGS is the status of appended message (list of symbols).
 380 If optional argument NUMBER is specified, the new message number is set
 381 \(if possible\).
 382 Return nil on failure.")
 383
 384 (luna-define-generic elmo-folder-append-messages (folder
 385                                                   src-folder
 386                                                   numbers
 387                                                   &optional
 388                                                   same-number)
 389   "Append messages from folder.
 390 FOLDER is the ELMO folder structure.
 391 Caller should make sure FOLDER is `writable'.
 392 \(Can be checked with `elmo-folder-writable-p'\).
 393 SRC-FOLDER is the source ELMO folder structure.
 394 NUMBERS is the message numbers to be appended in the SRC-FOLDER.
 395 If second optional argument SAME-NUMBER is specified,
 396 message number is preserved \(if possible\).")
 397
 398 (luna-define-generic elmo-folder-pack-numbers (folder)
 399   "Pack message numbers of FOLDER.")
 400
 401 (luna-define-generic elmo-folder-update-number (folder)
 402   "Update number of FOLDER.")
 403
 404 (luna-define-generic elmo-folder-diff-async (folder)
 405   "Get diff of FOLDER asynchronously.")
 406
 407 (luna-define-generic elmo-folder-expand-msgdb-path (folder)
 408   "Expand path for FOLDER.")
 409
 410 (luna-define-generic elmo-folder-get-primitive-list (folder)
 411   "Get primitive folder structure list contained in FOLDER.")
 412
 413 (luna-define-generic elmo-folder-contains-type (folder type)
 414   "Returns t if FOLDER contains TYPE.")
 415
 416 (luna-define-generic elmo-folder-local-p (folder)
 417   "Returns t if FOLDER is local.")
 418
 419 (luna-define-generic elmo-folder-message-file-p (folder)
 420   "Returns t if all messages in the FOLDER are files.")
 421
 422 ;;; Message methods.
 423 (luna-define-generic elmo-message-use-cache-p (folder number)
 424   "Returns t if the message in the FOLDER with NUMBER uses cache.")
 425
 426 (luna-define-generic elmo-message-file-name (folder number)
 427   "Return the file name of a message specified by FOLDER and NUMBER.")
 428
 429 ;;; For archive
 430
 431 ;;; Use original file
 432 (luna-define-generic elmo-folder-message-file-number-p (folder)
 433   "Return t if the file name in the FOLDER is the message number.")
 434
 435 (luna-define-generic elmo-folder-message-file-directory (folder)
 436   "Return the directory of the message files of FOLDER.")
 437
 438 ;;; Use temporary file
 439 (luna-define-generic elmo-folder-message-make-temp-file-p (folder)
 440   "Return t if the messages in the FOLDER makes local temporary file.")
 441
 442 (luna-define-generic elmo-folder-message-make-temp-files (folder
 443                                                           numbers
 444                                                           &optional
 445                                                           start-number)
 446   "Make a new temporary files from the messages in the FOLDER with NUMBERS.
 447 If START-NUMBER is specified, temporary files begin from the number.
 448 Otherwise, same number is used for temporary files.
 449 Return newly created temporary directory name which contains temporary files.")
 450
 451 (luna-define-generic elmo-message-file-p (folder number)
 452   "Return t if message in the FOLDER with NUMBER is a file.")
 453
 454 (luna-define-generic elmo-message-flags (folder number)
 455   "Return a list of flags.
 456 FOLDER is a ELMO folder structure.
 457 NUMBER is a number of the message.")
 458
 459 (luna-define-method elmo-message-flags ((folder elmo-folder) number)
 460   (elmo-msgdb-flags (elmo-folder-msgdb folder) number))
 461
 462 (defsubst elmo-message-flagged-p (folder number flag)
 463   "Return non-nil if the message is set FLAG.
 464 FOLDER is a ELMO folder structure.
 465 NUMBER is a message number to test."
 466   (let ((cur-flags (elmo-message-flags folder number)))
 467     (case flag
 468       (read
 469        (not (memq 'unread cur-flags)))
 470       (t
 471        (memq flag cur-flags)))))
 472
 473 (luna-define-generic elmo-find-fetch-strategy
 474   (folder entity &optional ignore-cache)
 475 ;; Returns the message fetching strategy suitable for the message.
 476 ;; FOLDER is the ELMO folder structure.
 477 ;; ENTITY is the overview entity of the message in the folder.
 478 ;; If optional argument IGNORE-CACHE is non-nil, cache is ignored.
 479 ;; Returned value is a elmo-fetch-strategy object.
 480 ;; If return value is nil, message should not be nil.
 481   )
 482
 483 (defmacro elmo-make-fetch-strategy (entireness
 484                                     &optional
 485                                     use-cache
 486                                     save-cache
 487                                     cache-path)
 488 ;; Make elmo-message-fetching strategy.
 489 ;; ENTIRENESS is 'entire or 'section.
 490 ;; 'entire means fetch message entirely at once.
 491 ;; 'section means fetch message section by section.
 492 ;; If optional USE-CACHE is non-nil, existing cache is used and otherwise,
 493 ;; existing cache is thrown away.
 494 ;; If SAVE-CACHE is non-nil, fetched message is saved.
 495 ;; CACHE-PATH is the cache path to be used as a message cache file.
 496   (` (vector (, entireness)
 497              (, use-cache) (, save-cache) (, cache-path))))
 498
 499 (defmacro elmo-fetch-strategy-entireness (strategy)
 500   ;; Return entireness of STRATEGY.
 501   (` (aref (, strategy) 0)))
 502
 503 (defmacro elmo-fetch-strategy-use-cache (strategy)
 504   ;; Return use-cache of STRATEGY.
 505   (` (aref (, strategy) 1)))
 506
 507 (defmacro elmo-fetch-strategy-save-cache (strategy)
 508   ;; Return save-cache of STRATEGY.
 509   (` (aref (, strategy) 2)))
 510
 511 (defmacro elmo-fetch-strategy-cache-path (strategy)
 512   ;;  Return cache-path of STRATEGY.
 513   (` (aref (, strategy) 3)))
 514
 515 (luna-define-method elmo-find-fetch-strategy
 516   ((folder elmo-folder) entity &optional ignore-cache)
 517   (let (cache-file size message-id number)
 518     (setq size (elmo-message-entity-field entity 'size))
 519     (setq message-id (elmo-message-entity-field entity 'message-id))
 520     (setq number (elmo-message-entity-number entity))
 521     (setq cache-file (elmo-file-cache-get message-id))
 522     (setq ignore-cache (or ignore-cache
 523                            (null (elmo-message-use-cache-p folder number))))
 524     (if (or ignore-cache
 525             (null (elmo-file-cache-status cache-file)))
 526         ;; No cache or ignore-cache.
 527         (if (and (not (elmo-folder-local-p folder))
 528                  elmo-message-fetch-threshold
 529                  (integerp size)
 530                  (>= size elmo-message-fetch-threshold)
 531                  (or (not elmo-message-fetch-confirm)
 532                      (not (prog1 (y-or-n-p
 533                                   (format "Fetch entire message(%dbytes)? "
 534                                           size))
 535                             (message "")))))
 536             ;; Don't fetch message at all.
 537             nil
 538           ;; Don't use existing cache and fetch entire message at once.
 539           (elmo-make-fetch-strategy
 540            'entire nil
 541            (elmo-message-use-cache-p folder number)
 542            (elmo-file-cache-path cache-file)))
 543       ;; Cache exists.
 544       (if (not ignore-cache)
 545           (elmo-make-fetch-strategy
 546            'entire
 547            ;; ...But ignore current section cache and re-fetch
 548            ;; if section cache.
 549            (not (eq (elmo-file-cache-status cache-file) 'section))
 550            ;; Save cache.
 551            (elmo-message-use-cache-p folder number)
 552            (elmo-file-cache-path cache-file))))))
 553
 554 (luna-define-method elmo-folder-list-messages-internal
 555   ((folder elmo-folder) &optional visible-only)
 556   t)
 557
 558 (defun elmo-folder-encache (folder numbers &optional unread)
 559   "Encache messages in the FOLDER with NUMBERS.
 560 If UNREAD is non-nil, messages are not flaged as read."
 561   (dolist (number numbers)
 562     (elmo-message-encache folder number unread)))
 563
 564 (luna-define-generic elmo-message-encache (folder number &optional read)
 565   "Encache message in the FOLDER with NUMBER.
 566 If READ is non-nil, message is flaged as read.")
 567
 568 (luna-define-method elmo-message-encache ((folder elmo-folder) number
 569                                           &optional read)
 570   (let (path)
 571     (elmo-message-fetch
 572      folder number
 573      (elmo-make-fetch-strategy 'entire
 574                                nil ;use-cache
 575                                t   ;save-cache
 576                                (setq path (elmo-file-cache-get-path
 577                                            (elmo-message-field
 578                                             folder number 'message-id))))
 579      nil nil (not read))
 580     path))
 581
 582 (luna-define-generic elmo-message-fetch-bodystructure (folder number strategy)
 583   "Fetch bodystructure of the message in FOLDER with NUMBER using STRATEGY.")
 584
 585 (luna-define-generic elmo-message-fetch (folder number strategy
 586                                                 &optional
 587                                                 section
 588                                                 outbuf
 589                                                 unread)
 590   "Fetch a message and return as a string.
 591 FOLDER is the ELMO folder structure.
 592 NUMBER is the number of the message in the FOLDER.
 593 STRATEGY is the message fetching strategy.
 594 If optional argument SECTION is specified, only the SECTION of the message
 595 is fetched (if possible).
 596 If second optional argument OUTBUF is specified, fetched message is
 597 inserted to the buffer and returns t if fetch was ended successfully.
 598 If third optional argument UNREAD is non-nil, message is not flaged as read.
 599 Returns non-nil if fetching was succeed.")
 600
 601 (luna-define-generic elmo-message-fetch-with-cache-process (folder
 602                                                             number strategy
 603                                                             &optional
 604                                                             section
 605                                                             unread)
 606   "Fetch a message into current buffer with cache process.
 607 FOLDER is the ELMO folder structure.
 608 NUMBER is the number of the message in the FOLDER.
 609 STRATEGY is the message fetching strategy.
 610 If optional argument SECTION is specified, only the SECTION of the message
 611 is fetched (if possible).
 612 If second optional argument UNREAD is non-nil, message is not flaged as read.
 613 Returns non-nil if fetching was succeed.")
 614
 615 (luna-define-generic elmo-message-fetch-internal (folder number strategy
 616                                                          &optional
 617                                                          section
 618                                                          unread)
 619   "Fetch a message into current buffer.
 620 FOLDER is the ELMO folder structure.
 621 NUMBER is the number of the message in the FOLDER.
 622 STRATEGY is the message fetching strategy.
 623 If optional argument SECTION is specified, only the SECTION of the message
 624 is fetched (if possible).
 625 If second optional argument UNREAD is non-nil, message is not flaged as read.
 626 Returns non-nil if fetching was succeed.")
 627
 628 (luna-define-generic elmo-message-fetch-field (folder number field)
 629   "Fetch a message field value.
 630 FOLDER is the ELMO folder structure.
 631 NUMBER is the number of the message in the FOLDER.
 632 FIELD is a symbol of the field name.")
 633
 634 (luna-define-generic elmo-message-folder (folder number)
 635   "Get primitive folder of the message.")
 636
 637 (luna-define-generic elmo-folder-process-crosspost (folder)
 638   "Process crosspost for FOLDER.
 639 Return a cons cell of (NUMBER-CROSSPOSTS . NEW-FLAG-ALIST).")
 640
 641 (luna-define-generic elmo-folder-newsgroups (folder)
 642   "Return list of newsgroup name of FOLDER.")
 643
 644 (luna-define-generic elmo-folder-search-requires-msgdb-p (folder condition)
 645   "Return non-nil if searching in FOLDER by CONDITION requires msgdb fetch.")
 646
 647 (defun elmo-folder-search-requires-msgdb-p-internal (folder condition)
 648   (if (listp condition)
 649       (or (elmo-folder-search-requires-msgdb-p-internal
 650            folder (nth 1 condition))
 651           (elmo-folder-search-requires-msgdb-p-internal
 652            folder (nth 2 condition)))
 653     (and (not (string= (elmo-filter-key condition) "last"))
 654          (not (string= (elmo-filter-key condition) "first")))))
 655
 656 (luna-define-method elmo-folder-search-requires-msgdb-p ((folder elmo-folder)
 657                                                          condition)
 658   (elmo-folder-search-requires-msgdb-p-internal folder condition))
 659
 660 (luna-define-method elmo-folder-newsgroups ((folder elmo-folder))
 661   nil)
 662
 663 (luna-define-method elmo-folder-open ((folder elmo-folder)
 664                                       &optional load-msgdb)
 665   (elmo-generic-folder-open folder load-msgdb))
 666
 667 (defun elmo-generic-folder-open (folder load-msgdb)
 668   (let ((inhibit-quit t))
 669     (if load-msgdb (elmo-folder-msgdb folder))
 670     (elmo-folder-set-killed-list-internal
 671      folder
 672      (elmo-msgdb-killed-list-load (elmo-folder-msgdb-path folder))))
 673   (elmo-folder-open-internal folder))
 674
 675 (luna-define-method elmo-folder-open-internal ((folder elmo-folder))
 676   nil ; default is do nothing.
 677   )
 678
 679 (luna-define-method elmo-folder-check ((folder elmo-folder))
 680   nil) ; default is noop.
 681
 682 (luna-define-method elmo-folder-commit ((folder elmo-folder))
 683   (elmo-generic-folder-commit folder))
 684
 685 (defun elmo-generic-folder-commit (folder)
 686   (let ((msgdb (elmo-folder-msgdb-internal folder)))
 687     (when (and msgdb (elmo-folder-persistent-p folder))
 688       (when (elmo-msgdb-message-modified-p msgdb)
 689         (elmo-folder-set-info-max-by-numdb
 690          folder
 691          (elmo-folder-list-messages folder nil 'in-msgdb))
 692         (elmo-msgdb-killed-list-save
 693          (elmo-folder-msgdb-path folder)
 694          (elmo-folder-killed-list-internal folder)))
 695       (elmo-msgdb-save msgdb))))
 696
 697 (luna-define-method elmo-folder-close-internal ((folder elmo-folder))
 698   ;; do nothing.
 699   )
 700
 701 (luna-define-method elmo-folder-close ((folder elmo-folder))
 702   (elmo-generic-folder-close folder)
 703   (elmo-folder-close-internal folder))
 704
 705 (defun elmo-generic-folder-close (folder)
 706   (elmo-folder-commit folder)
 707   (elmo-folder-set-msgdb-internal folder nil)
 708   (elmo-folder-set-killed-list-internal folder nil))
 709
 710 (luna-define-method elmo-folder-plugged-p ((folder elmo-folder))
 711   t) ; default is plugged.
 712
 713 (luna-define-method elmo-folder-set-plugged ((folder elmo-folder) plugged
 714                                              &optional add)
 715   nil) ; default is do nothing.
 716
 717 (luna-define-method elmo-folder-use-flag-p ((folder elmo-folder))
 718   nil) ; default is no flag.
 719
 720 (luna-define-method elmo-folder-persistent-p ((folder elmo-folder))
 721   (elmo-folder-persistent-internal folder))
 722
 723 (luna-define-method elmo-folder-creatable-p ((folder elmo-folder))
 724   nil) ; default is not creatable.
 725
 726 (luna-define-method elmo-folder-writable-p ((folder elmo-folder))
 727   nil) ; default is not writable.
 728
 729 (luna-define-method elmo-folder-delete ((folder elmo-folder))
 730   (when (yes-or-no-p (format "Delete msgdb of \"%s\"? "
 731                              (elmo-folder-name-internal folder)))
 732     (elmo-msgdb-delete-path folder)
 733     t))
 734
 735 (luna-define-method elmo-folder-rename ((folder elmo-folder) new-name)
 736   (let* ((new-folder (elmo-make-folder new-name)))
 737     (unless (eq (elmo-folder-type-internal folder)
 738                 (elmo-folder-type-internal new-folder))
 739       (error "Not same folder type"))
 740     (if (or (file-exists-p (elmo-folder-msgdb-path new-folder))
 741             (elmo-folder-exists-p new-folder))
 742         (error "Already exists folder: %s" new-name))
 743     (elmo-folder-send folder 'elmo-folder-rename-internal new-folder)
 744     (elmo-msgdb-rename-path folder new-folder)))
 745
 746 (luna-define-method elmo-folder-search ((folder elmo-folder)
 747                                         condition
 748                                         &optional numbers)
 749   (let ((numbers (or numbers (elmo-folder-list-messages folder)))
 750         (msgdb (elmo-folder-msgdb folder))
 751         results)
 752     (setq results (elmo-msgdb-search msgdb condition numbers))
 753     (if (listp results)
 754         results
 755       (let ((len (length numbers))
 756             matched)
 757         (elmo-with-progress-display (> len elmo-display-progress-threshold)
 758             (elmo-folder-search len "Searching...")
 759           (dolist (number numbers)
 760             (let (result)
 761               (setq result (elmo-msgdb-match-condition msgdb
 762                                                        condition
 763                                                        number
 764                                                        numbers))
 765               (when (elmo-filter-condition-p result)
 766                 (setq result (elmo-message-match-condition folder
 767                                                            number
 768                                                            condition
 769                                                            numbers)))
 770               (when result
 771                 (setq matched (cons number matched))))
 772             (elmo-progress-notify 'elmo-folder-search)))
 773         (message "Searching...done")
 774         (nreverse matched)))))
 775
 776 (luna-define-method elmo-message-match-condition ((folder elmo-folder)
 777                                                   number condition
 778                                                   numbers)
 779   (let* (cache cache-path
 780          (filename (cond
 781                     ((elmo-message-file-name folder number))
 782                     ((progn
 783                        (setq cache (elmo-file-cache-get
 784                                     (elmo-message-field folder number
 785                                                         'message-id)))
 786                        (setq cache-path (elmo-file-cache-path cache))
 787                        (and cache-path
 788                             (not (elmo-cache-path-section-p cache-path))))
 789                      cache-path))))
 790     (when (and filename (file-readable-p filename))
 791       (with-temp-buffer
 792         (elmo-set-buffer-multibyte nil)
 793         ;;(insert-file-contents-as-binary filename)
 794         (elmo-message-fetch folder number
 795                             (elmo-make-fetch-strategy 'entire
 796                                                       (and cache t)
 797                                                       nil
 798                                                       cache-path)
 799                             nil (current-buffer) t)
 800         (elmo-set-buffer-multibyte default-enable-multibyte-characters)
 801         (decode-coding-region (point-min) (point-max)
 802                               elmo-mime-display-as-is-coding-system)
 803         (elmo-buffer-field-condition-match condition number numbers)))))
 804
 805 (luna-define-method elmo-folder-pack-numbers ((folder elmo-folder))
 806   nil) ; default is noop.
 807
 808 (luna-define-method elmo-folder-update-number ((folder elmo-folder))
 809   nil) ; default is noop.
 810
 811 (luna-define-method elmo-folder-message-file-p ((folder elmo-folder))
 812   nil) ; default is not file.
 813
 814 (luna-define-method elmo-folder-message-file-number-p ((folder elmo-folder))
 815   nil) ; default is not number.
 816
 817 (luna-define-method elmo-folder-message-make-temp-file-p ((folder elmo-folder))
 818   nil) ; default is not make temp file.
 819
 820 (luna-define-method elmo-message-file-name ((folder elmo-folder)
 821                                                    number)
 822   nil) ; default is no name.
 823
 824 (luna-define-method elmo-folder-local-p ((folder elmo-folder))
 825   t)   ; default is local.
 826
 827 (luna-define-method elmo-folder-have-subfolder-p ((folder elmo-folder))
 828   t)
 829
 830 ;;; Folder info
 831 ;; Folder info is a message number information cache (hashtable)
 832 (defsubst elmo-folder-get-info (folder &optional hashtb)
 833   "Return FOLDER info from HASHTB (default is `elmo-folder-info-hashtb')."
 834   (elmo-get-hash-val (elmo-folder-name-internal folder)
 835                      (or hashtb elmo-folder-info-hashtb)))
 836
 837 (defun elmo-folder-set-info-hashtb (folder max numbers &optional new unread)
 838   "Set FOLDER info (means MAX, NUMBERS, NEW and UNREAD)."
 839   (let ((info (elmo-folder-get-info folder)))
 840     (when info
 841       (or new     (setq new     (nth 0 info)))
 842       (or unread  (setq unread  (nth 1 info)))
 843       (or numbers (setq numbers (nth 2 info)))
 844       (or max     (setq max     (nth 3 info))))
 845     (elmo-set-hash-val (elmo-folder-name-internal folder)
 846                        (list new unread numbers max)
 847                        elmo-folder-info-hashtb)))
 848
 849 (defun elmo-folder-set-info-max-by-numdb (folder numbers)
 850   "Set FOLDER info by MSGDB-NUMBER in msgdb."
 851   (elmo-folder-set-info-hashtb
 852    folder
 853    (if numbers (apply #'max numbers) 0)
 854    nil ;;(length num-db)
 855    ))
 856
 857 (defun elmo-folder-get-info-max (folder)
 858   "Return max number of FODLER from folder info."
 859   (nth 3 (elmo-folder-get-info folder)))
 860
 861 (defun elmo-folder-get-info-length (folder)
 862   "Return length of FODLER from folder info."
 863   (nth 2 (elmo-folder-get-info folder)))
 864
 865 (defun elmo-folder-get-info-unread (folder)
 866   "Return unread of FODLER from folder info."
 867   (nth 1 (elmo-folder-get-info folder)))
 868
 869 (defun elmo-folder-info-make-hashtb (info-alist hashtb)
 870   "Setup folder info hashtable by INFO-ALIST on HASHTB."
 871   (let* ((hashtb (or hashtb
 872                      (elmo-make-hash (length info-alist)))))
 873     (mapcar
 874      (lambda (x)
 875        (let ((info (cadr x)))
 876          (and (intern-soft (car x) hashtb)
 877               (elmo-set-hash-val (car x)
 878                                  (list (nth 2 info)   ;; new
 879                                        (nth 3 info)   ;; unread
 880                                        (nth 1 info)   ;; length
 881                                        (nth 0 info))  ;; max
 882                                  hashtb))))
 883      info-alist)
 884     (setq elmo-folder-info-hashtb hashtb)))
 885
 886 (defsubst elmo-diff-new (diff)
 887   (car diff))
 888
 889 (defsubst elmo-diff-unread (diff)
 890   (when (consp (cdr diff))
 891     (nth 1 diff)))
 892
 893 (defsubst elmo-diff-all (diff)
 894   (if (consp (cdr diff))
 895       (nth 2 diff)
 896     (cdr diff)))
 897
 898 (defsubst elmo-strict-folder-diff (folder)
 899   "Return folder diff information strictly from FOLDER."
 900   (let ((in-db (sort (elmo-msgdb-list-messages (elmo-folder-msgdb folder))
 901                      '<))
 902         (in-folder  (elmo-folder-list-messages folder))
 903         append-list delete-list diff)
 904     (cons (if (equal in-folder in-db)
 905               0
 906             (setq diff (elmo-list-diff in-folder in-db nil))
 907             (setq append-list (car diff))
 908             (setq delete-list (cadr diff))
 909             (if append-list
 910                 (length append-list)
 911               (if delete-list
 912                   (- 0 (length delete-list))
 913                 0)))
 914           (length in-folder))))
 915
 916 (luna-define-method elmo-folder-diff ((folder elmo-folder))
 917   (elmo-generic-folder-diff folder))
 918
 919 (defun elmo-generic-folder-diff (folder)
 920   (if (elmo-string-match-member (elmo-folder-name-internal folder)
 921                                 elmo-strict-diff-folder-list)
 922       (elmo-strict-folder-diff folder)
 923     (let ((cached-in-db-max (elmo-folder-get-info-max folder))
 924           (in-folder (elmo-folder-status folder))
 925           (in-db t)
 926           unsync messages
 927           in-db-max)
 928       (if (not cached-in-db-max)
 929           (let ((number-list (elmo-folder-list-messages folder
 930                                                         nil 'in-msgdb)))
 931             ;; No info-cache.
 932             (setq in-db number-list)
 933             (setq in-db-max (if in-db (apply #'max in-db) 0))
 934             (elmo-folder-set-info-hashtb folder in-db-max nil))
 935         (setq in-db-max cached-in-db-max))
 936       (setq unsync (if (and in-db (car in-folder))
 937                        (- (car in-folder) in-db-max)
 938                      (if (and in-folder (null in-db))
 939                          (cdr in-folder)
 940                        (car in-folder))))
 941       (setq messages (cdr in-folder))
 942       (if (and unsync messages (> unsync messages))
 943           (setq unsync messages))
 944       (cons (or unsync 0) (or messages 0)))))
 945
 946 (defvar elmo-folder-diff-async-callback nil)
 947 (defvar elmo-folder-diff-async-callback-data nil)
 948
 949 (luna-define-method elmo-folder-diff-async ((folder elmo-folder))
 950   (and elmo-folder-diff-async-callback
 951        (funcall elmo-folder-diff-async-callback
 952                 folder
 953                 (elmo-folder-diff folder))))
 954
 955 (luna-define-method elmo-folder-get-primitive-list ((folder elmo-folder))
 956   (list folder))
 957
 958 (luna-define-method elmo-folder-contains-type ((folder elmo-folder) type)
 959   (eq (elmo-folder-type-internal folder) type))
 960
 961 (luna-define-method elmo-folder-next-message-number ((folder elmo-folder))
 962   (+ 1 (elmo-max-of-list (or (elmo-folder-list-messages folder)
 963                              '(0)))))
 964
 965 (luna-define-method elmo-folder-append-messages ((folder elmo-folder)
 966                                                  src-folder
 967                                                  numbers
 968                                                  &optional
 969                                                  same-number)
 970   (elmo-generic-folder-append-messages folder src-folder numbers
 971                                        same-number))
 972
 973 (defun elmo-generic-folder-append-messages (folder src-folder numbers
 974                                                    same-number)
 975   (let ((src-msgdb-exists (not (zerop (elmo-folder-length src-folder))))
 976         unseen table flags
 977         succeed-numbers failure cache id)
 978     (setq table (elmo-flag-table-load (elmo-folder-msgdb-path folder)))
 979     (with-temp-buffer
 980       (set-buffer-multibyte nil)
 981       (while numbers
 982         (setq failure nil
 983               id (and src-msgdb-exists
 984                       (elmo-message-field src-folder (car numbers)
 985                                           'message-id))
 986               flags (elmo-message-flags src-folder (car numbers)))
 987         (condition-case nil
 988             (setq cache (elmo-file-cache-get id)
 989                   failure
 990                   (not
 991                    (and
 992                     (elmo-message-fetch
 993                      src-folder (car numbers)
 994                      (if (elmo-folder-plugged-p src-folder)
 995                          (elmo-make-fetch-strategy
 996                           'entire 'maybe nil
 997                           (and cache (elmo-file-cache-path cache)))
 998                        (or (and elmo-enable-disconnected-operation
 999                                 cache
1000                                 (eq (elmo-file-cache-status cache) 'entire)
1001                                 (elmo-make-fetch-strategy
1002                                  'entire t nil
1003                                  (elmo-file-cache-path cache)))
1004                            (error "Unplugged")))
1005                      nil (current-buffer)
1006                      'unread)
1007                     (> (buffer-size) 0)
1008                     (elmo-folder-append-buffer
1009                      folder
1010                      (or flags '(read))
1011                      (if same-number (car numbers))))))
1012           (error (setq failure t)))
1013         ;; FETCH & APPEND finished
1014         (unless failure
1015           (when id
1016             (elmo-flag-table-set table id flags))
1017           (setq succeed-numbers (cons (car numbers) succeed-numbers)))
1018         (elmo-progress-notify 'elmo-folder-move-messages)
1019         (setq numbers (cdr numbers)))
1020       (when (elmo-folder-persistent-p folder)
1021         (elmo-flag-table-save (elmo-folder-msgdb-path folder) table))
1022       succeed-numbers)))
1023
1024 ;; Arguments should be reduced.
1025 (defun elmo-folder-move-messages (src-folder msgs dst-folder
1026                                              &optional
1027                                              no-delete
1028                                              same-number)
1029   (save-excursion
1030     (let* ((messages msgs)
1031            (elmo-inhibit-display-retrieval-progress t)
1032            (len (length msgs))
1033            succeeds i result)
1034       (if (eq dst-folder 'null)
1035           (setq succeeds messages)
1036         (unless (elmo-folder-writable-p dst-folder)
1037           (error "move: %d is not writable"
1038                  (elmo-folder-name-internal dst-folder)))
1039         (when messages
1040           ;; src is already opened.
1041           (elmo-folder-open-internal dst-folder)
1042           (unless (setq succeeds (elmo-folder-append-messages dst-folder
1043                                                               src-folder
1044                                                               messages
1045                                                               same-number))
1046             (error "move: append message to %s failed"
1047                    (elmo-folder-name-internal dst-folder)))
1048           (elmo-folder-close dst-folder)))
1049       (if (and (not no-delete) succeeds)
1050           (progn
1051             (if (and (elmo-folder-delete-messages src-folder succeeds)
1052                      (elmo-folder-detach-messages src-folder succeeds))
1053                 (progn
1054                   (elmo-global-flag-detach-messages
1055                    src-folder succeeds (eq dst-folder 'null))
1056                   (setq result t))
1057               (message "move: delete messages from %s failed."
1058                        (elmo-folder-name-internal src-folder))
1059               (setq result nil))
1060             result)
1061         (if no-delete
1062             (progn
1063               ;; (message "Copying messages...done")
1064               t)
1065           (if (eq len 0)
1066               (message "No message was moved.")
1067             (message "Moving messages failed.")
1068             nil ; failure
1069             ))))))
1070
1071 (defun elmo-folder-msgdb-path (folder)
1072   "Return the msgdb path for FOLDER."
1073   (or (elmo-folder-path-internal folder)
1074       (elmo-folder-set-path-internal
1075        folder
1076        (elmo-folder-expand-msgdb-path folder))))
1077
1078 (luna-define-generic elmo-message-cached-p (folder number)
1079   "Return non-nil if the message is cached.")
1080
1081 (luna-define-method elmo-message-cached-p ((folder elmo-folder) number)
1082   (elmo-message-flagged-p folder number 'cached))
1083
1084 (defun elmo-message-accessible-p (folder number)
1085   "Get accessibility of the message.
1086 Return non-nil when message is accessible."
1087   (or (elmo-folder-plugged-p folder)
1088       (elmo-folder-local-p folder)
1089       (elmo-message-cached-p folder number)))
1090
1091 (luna-define-generic elmo-message-set-cached (folder number cached)
1092   "Set cache status of the message in the msgdb.
1093 FOLDER is the ELMO folder structure.
1094 NUMBER is a number of the message.
1095 If CACHED is t, message is set as cached.")
1096
1097 (luna-define-method elmo-message-set-cached ((folder elmo-folder)
1098                                              number cached)
1099   (if cached
1100       (elmo-msgdb-set-flag (elmo-folder-msgdb folder) number 'cached)
1101     (elmo-msgdb-unset-flag (elmo-folder-msgdb folder) number 'cached)))
1102
1103 (defun elmo-message-copy-entity (entity)
1104   (elmo-msgdb-copy-message-entity (elmo-message-entity-handler entity)
1105                                   entity))
1106
1107 (luna-define-generic elmo-message-entity (folder key)
1108   "Return the message-entity structure which matches to the KEY.
1109 KEY is a number or a string.
1110 A number is for message number in the FOLDER.
1111 A string is for message-id of the message.")
1112
1113 (luna-define-method elmo-message-entity ((folder elmo-folder) key)
1114   (elmo-msgdb-message-entity (elmo-folder-msgdb folder) key))
1115
1116 (luna-define-generic elmo-message-entity-parent (folder entity)
1117   "Return the parent message-entity structure in the FOLDER.
1118 ENTITY is the message-entity to get the parent.")
1119
1120 (luna-define-method elmo-message-entity-parent ((folder elmo-folder) entity)
1121   (elmo-msgdb-get-parent-entity entity (elmo-folder-msgdb folder)))
1122
1123 (put 'elmo-folder-do-each-message-entity 'lisp-indent-function '1)
1124 (def-edebug-spec elmo-folder-do-each-message-entity
1125   ((symbolp form &rest form) &rest form))
1126
1127 (defsubst elmo-folder-list-message-entities (folder)
1128   ;; List all message entities in the FOLDER.
1129   (mapcar
1130    (lambda (number) (elmo-message-entity folder number))
1131    (elmo-folder-list-messages folder nil t))) ; XXX killed-list is not used.
1132
1133 (defmacro elmo-folder-do-each-message-entity (spec &rest form)
1134   "Iterator for message entity in the folder.
1135 \(elmo-folder-do-each-message-entity \(entity folder\)
1136  ... do the process using entity...
1137 \)"
1138   `(dolist (,(car spec) (elmo-folder-list-message-entities ,(car (cdr spec))))
1139      ,@form))
1140
1141 (luna-define-generic elmo-folder-count-flags (folder)
1142   "Count flagged message number in the msgdb of the FOLDER.
1143 Return a list of numbers (`new' `unread' `answered')")
1144
1145 (luna-define-method elmo-folder-count-flags ((folder elmo-folder))
1146   (let* ((flag-count (elmo-msgdb-flag-count (elmo-folder-msgdb folder)))
1147          (new (or (cdr (assq 'new flag-count)) 0))
1148          (unread (or (cdr (assq 'unread flag-count)) 0))
1149          (answered(or (cdr (assq 'answered flag-count)) 0)))
1150     (list new (- unread new) answered)))
1151
1152 (defun elmo-message-set-flag (folder number flag &optional is-local)
1153   "Set message flag.
1154 FOLDER is a ELMO folder structure.
1155 NUMBER is a message number to set flag.
1156
1157 FLAG is a symbol which is one of the following:
1158   `unread'    (set the message as unread)
1159   `answered'  (set the message as answered)
1160   `important' (set the message as important)
1161 'sugar' flag:
1162   `read'      (remove new and unread flags)
1163 If optional IS-LOCAL is non-nil, update only local (not server) status."
1164   ;; XXX Transitional implementation.
1165   (elmo-folder-set-flag folder (list number) flag is-local))
1166
1167 (defun elmo-message-unset-flag (folder number flag &optional is-local)
1168   "Unset message flag.
1169 FOLDER is a ELMO folder structure.
1170 NUMBER is a message number to set flag.
1171
1172 FLAG is a symbol which is one of the following:
1173   `unread'    (remove unread and new flag)
1174   `answered'  (remove answered flag)
1175   `important' (remove important flag)
1176 'sugar' flag:
1177   `read'      (set unread flag)
1178 If optional IS-LOCAL is non-nil, update only local (not server) status."
1179   ;; XXX Transitional implementation.
1180   (elmo-folder-unset-flag folder (list number) flag is-local))
1181
1182 (luna-define-generic elmo-message-field (folder number field)
1183   "Get message field value in the msgdb.
1184 FOLDER is the ELMO folder structure.
1185 NUMBER is a number of the message.
1186 FIELD is a symbol of the field.")
1187
1188 (luna-define-method elmo-message-field ((folder elmo-folder) number field)
1189   (elmo-message-entity-field (elmo-message-entity folder number) field))
1190
1191 (luna-define-generic elmo-message-set-field (folder number field value)
1192   "Set message field value in the msgdb.
1193 FOLDER is the ELMO folder structure.
1194 NUMBER is a number of the message.
1195 FIELD is a symbol of the field.
1196 VALUE is a value to set.")
1197
1198 (luna-define-method elmo-message-set-field ((folder elmo-folder) number
1199                                             field value)
1200   (elmo-message-entity-set-field (elmo-message-entity folder number)
1201                                  field value))
1202
1203 (luna-define-method elmo-message-use-cache-p ((folder elmo-folder) number)
1204   nil) ; default is not use cache.
1205
1206 (luna-define-method elmo-message-folder ((folder elmo-folder) number)
1207   folder) ; default is folder
1208
1209 (luna-define-method elmo-folder-set-flag ((folder elmo-folder)
1210                                           numbers
1211                                           flag
1212                                           &optional is-local)
1213   (when (elmo-folder-msgdb-internal folder)
1214     (dolist (number numbers)
1215       (when (elmo-global-flag-p flag)
1216         (let ((message-id (elmo-message-field folder number 'message-id)))
1217           (elmo-global-flag-set flag folder number message-id)))
1218       (elmo-msgdb-set-flag (elmo-folder-msgdb folder)
1219                            number
1220                            flag))))
1221
1222 (defun elmo-message-has-global-flag-p (folder number)
1223   "Return non-nil when the message in the FOLDER with NUMBER has global flag."
1224   (let ((flags (elmo-message-flags folder number))
1225         result)
1226     (while flags
1227       (when (and (elmo-global-flag-p (car flags))
1228                  (not (memq (car flags) '(answered unread cached))))
1229         (setq result t
1230               flags nil))
1231       (setq flags (cdr flags)))
1232     result))
1233
1234 (defun elmo-message-set-global-flags (folder number flags &optional local)
1235   "Set global flags of the message in the FOLDER with NUMBER as FLAGS.
1236 If Optional LOCAL is non-nil, don't update server flag."
1237   (dolist (flag flags)
1238     (unless (elmo-global-flag-p flag)
1239       (error "Not a global flag")))
1240   (let ((old-flags (elmo-get-global-flags (elmo-message-flags folder number))))
1241     (dolist (flag flags)
1242       (unless (memq flag old-flags)
1243         (elmo-message-set-flag folder number flag local)))
1244     (dolist (flag old-flags)
1245       (unless (memq flag flags)
1246         (elmo-message-unset-flag folder number flag local)))))
1247
1248 (luna-define-method elmo-folder-unset-flag ((folder elmo-folder)
1249                                             numbers
1250                                             flag
1251                                             &optional is-local)
1252   (when (elmo-folder-msgdb-internal folder)
1253     (dolist (number numbers)
1254       (when (elmo-global-flag-p flag)
1255         (elmo-global-flag-detach flag folder number 'always))
1256       (elmo-msgdb-unset-flag (elmo-folder-msgdb folder)
1257                              number
1258                              flag))))
1259
1260 (luna-define-method elmo-folder-process-crosspost ((folder elmo-folder))
1261   ;; Do nothing.
1262   )
1263
1264 ;;(luna-define-generic elmo-folder-append-message-entity (folder entity
1265 ;;                                                             &optional
1266 ;;                                                             flag-table)
1267 ;;  "Append ENTITY to the folder.")
1268
1269 (defun elmo-msgdb-merge (folder msgdb-merge)
1270   "Return a list of messages which have duplicated message-id."
1271   (let (msgdb duplicates)
1272     (setq msgdb (or (elmo-folder-msgdb-internal folder)
1273                     (elmo-make-msgdb (elmo-folder-msgdb-path folder))))
1274     (setq duplicates (elmo-msgdb-append msgdb msgdb-merge))
1275     (elmo-folder-set-msgdb-internal folder msgdb)
1276     duplicates))
1277
1278 (defsubst elmo-folder-append-msgdb (folder append-msgdb)
1279   (if append-msgdb
1280       (let ((duplicates (elmo-msgdb-merge folder append-msgdb)))
1281         (cond ((eq (elmo-folder-process-duplicates-internal folder)
1282                    'hide)
1283                ;; Let duplicates be a temporary killed message.
1284                (elmo-folder-kill-messages folder duplicates)
1285                ;; Should be flag as read.
1286                (elmo-folder-set-flag folder duplicates 'read))
1287               ((eq (elmo-folder-process-duplicates-internal folder)
1288                    'read)
1289                ;; Flag as read duplicates.
1290                (elmo-folder-set-flag folder duplicates 'read))
1291               (t
1292                ;; Do nothing.
1293                (setq duplicates nil)))
1294         (length duplicates))
1295     0))
1296
1297 (defun elmo-folder-confirm-appends (appends)
1298   (let ((len (length appends))
1299         in)
1300     (if (and elmo-folder-update-threshold
1301              (> len elmo-folder-update-threshold)
1302              elmo-folder-update-confirm)
1303         (if (y-or-n-p (format "Too many messages(%d).  Update all? " len))
1304             appends
1305           (setq in elmo-folder-update-threshold)
1306           (catch 'end
1307             (while t
1308               (setq in (read-from-minibuffer "Update number: "
1309                                              (int-to-string in))
1310                     in (string-to-int in))
1311               (if (< len in)
1312                   (throw 'end len))
1313               (if (y-or-n-p (format
1314                              "%d messages are killed (not appeared). OK? "
1315                              (max (- len in) 0)))
1316                   (throw 'end in))))
1317           (nthcdr (max (- len in) 0) appends))
1318       (if (and elmo-folder-update-threshold
1319                (> len elmo-folder-update-threshold)
1320                (not elmo-folder-update-confirm))
1321           (nthcdr (max (- len elmo-folder-update-threshold) 0) appends)
1322         appends))))
1323
1324 (luna-define-method elmo-message-fetch-bodystructure ((folder elmo-folder)
1325                                                       number strategy)
1326   nil)
1327
1328 (luna-define-method elmo-message-fetch ((folder elmo-folder)
1329                                         number strategy
1330                                         &optional
1331                                         section
1332                                         outbuf
1333                                         unread)
1334   (if outbuf
1335       (with-current-buffer outbuf
1336         (erase-buffer)
1337         (elmo-message-fetch-with-cache-process folder number
1338                                                strategy section unread))
1339     (with-temp-buffer
1340       (elmo-message-fetch-with-cache-process folder number
1341                                              strategy section unread)
1342       (buffer-string))))
1343
1344 (luna-define-method elmo-message-fetch-with-cache-process ((folder elmo-folder)
1345                                                            number strategy
1346                                                            &optional
1347                                                            section unread)
1348   (let ((cache-path (elmo-fetch-strategy-cache-path strategy))
1349         (method-priorities
1350          (cond ((eq (elmo-fetch-strategy-use-cache strategy) 'maybe)
1351                 '(entity cache))
1352                ((elmo-fetch-strategy-use-cache strategy)
1353                 '(cache entity))
1354                (t
1355                 '(entity))))
1356         result err)
1357     (while (and method-priorities
1358                 (null result))
1359       (setq result
1360             (case (car method-priorities)
1361               (cache
1362                (elmo-file-cache-load cache-path section))
1363               (entity
1364                (when (and (condition-case error
1365                               (elmo-message-fetch-internal folder number
1366                                                            strategy
1367                                                            section
1368                                                            unread)
1369                             (error (setq err error) nil))
1370                           (> (buffer-size) 0))
1371                  (when (and (elmo-fetch-strategy-save-cache strategy)
1372                             cache-path)
1373                    (elmo-file-cache-save cache-path section))
1374                  t)))
1375             method-priorities (cdr method-priorities)))
1376     (or result
1377         (and err (signal (car err) (cdr err))))))
1378
1379 (defun elmo-folder-kill-messages-range (folder beg end)
1380   (elmo-folder-set-killed-list-internal
1381    folder
1382    (nconc
1383     (elmo-folder-killed-list-internal folder)
1384     (list (cons beg end)))))
1385
1386 (defun elmo-folder-kill-messages (folder numbers)
1387   "Kill(hide) messages in the FOLDER with NUMBERS."
1388   (elmo-folder-set-killed-list-internal
1389    folder
1390    (elmo-number-set-append-list
1391     (elmo-folder-killed-list-internal folder)
1392     numbers))
1393   (elmo-folder-unset-flag folder numbers 'all 'local-only))
1394
1395 (luna-define-method elmo-folder-clear ((folder elmo-folder)
1396                                        &optional keep-killed)
1397   (unless keep-killed
1398     (elmo-folder-set-killed-list-internal folder nil))
1399   (if (eq elmo-msgdb-convert-type 'sync)
1400       (elmo-folder-set-msgdb-internal
1401        folder
1402        (elmo-make-msgdb (elmo-folder-msgdb-path folder)))
1403     (elmo-msgdb-clear (elmo-folder-msgdb folder))))
1404
1405 (luna-define-generic elmo-folder-synchronize (folder
1406                                               &optional
1407                                               disable-killed
1408                                               ignore-msgdb
1409                                               no-check)
1410   "Synchronize the folder data to the newest status.
1411 FOLDER is the ELMO folder structure.
1412
1413 If optional DISABLE-KILLED is non-nil, killed messages are also synchronized.
1414 If optional IGNORE-MSGDB is non-nil, current msgdb is thrown away except
1415 flag status.
1416 If NO-CHECK is non-nil, rechecking folder is skipped.
1417 Return amount of cross-posted messages.
1418 If update process is interrupted, return nil.")
1419
1420 (luna-define-method elmo-folder-synchronize ((folder elmo-folder)
1421                                              &optional
1422                                              disable-killed
1423                                              ignore-msgdb
1424                                              no-check)
1425   (let ((killed-list (elmo-folder-killed-list-internal folder))
1426         (before-append t)
1427         old-msgdb diff diff-2 delete-list new-list new-msgdb flag
1428         flag-table crossed after-append)
1429     (setq old-msgdb (elmo-folder-msgdb folder))
1430     (setq flag-table (elmo-flag-table-load (elmo-folder-msgdb-path folder)))
1431     (when ignore-msgdb
1432       (elmo-msgdb-flag-table (elmo-folder-msgdb folder) flag-table)
1433       (elmo-folder-clear folder (not disable-killed)))
1434     (unless no-check (elmo-folder-check folder))
1435     (condition-case nil
1436         (progn
1437           (message "Checking folder diff...")
1438           (setq diff (elmo-list-diff (elmo-folder-list-messages
1439                                       folder
1440                                       (not disable-killed))
1441                                      (elmo-folder-list-messages
1442                                       folder
1443                                       (not disable-killed)
1444                                       'in-msgdb)))
1445           (message "Checking folder diff...done")
1446           (setq new-list (elmo-folder-confirm-appends (car diff)))
1447           ;; Set killed list as ((1 . MAX-OF-DISAPPEARED))
1448           (when (and (not (eq (length (car diff))
1449                               (length new-list)))
1450                      (setq diff-2 (elmo-list-diff (car diff) new-list)))
1451             (elmo-folder-kill-messages-range
1452              folder
1453              (car (car diff-2))
1454              (nth (- (length (car diff-2)) 1) (car diff-2))))
1455           (setq delete-list (cadr diff))
1456           (if (or (equal diff '(nil nil))
1457                   (equal diff '(nil))
1458                   (and (eq (length (car diff)) 0)
1459                        (eq (length (cadr diff)) 0)))
1460               (progn
1461                 (elmo-folder-update-number folder)
1462                 (elmo-folder-process-crosspost folder)
1463                 0 ; no updates.
1464                 )
1465             (when delete-list
1466               (elmo-folder-detach-messages folder delete-list))
1467             (when new-list
1468               (elmo-msgdb-out-of-date-messages (elmo-folder-msgdb folder))
1469               (setq new-msgdb (elmo-folder-msgdb-create
1470                                folder new-list flag-table))
1471               ;; Clear flag-table
1472               (if (elmo-folder-persistent-p folder)
1473                   (elmo-flag-table-save (elmo-folder-msgdb-path folder)
1474                                         nil))
1475               (setq before-append nil)
1476               (setq crossed (elmo-folder-append-msgdb folder new-msgdb))
1477               ;; process crosspost.
1478               ;; Return a cons cell of (NUMBER-CROSSPOSTS . NEW-FLAG-ALIST).
1479               (elmo-folder-process-crosspost folder))
1480             ;; return value.
1481             (or crossed 0)))
1482       (quit
1483        ;; Resume to the original status.
1484        (if before-append (elmo-folder-set-msgdb-internal folder old-msgdb))
1485        (elmo-folder-set-killed-list-internal folder killed-list)
1486        nil))))
1487
1488 (luna-define-generic elmo-folder-detach-messages (folder numbers)
1489   "Remove messages with NUMBERS from MSGDB.")
1490
1491 (luna-define-method elmo-folder-detach-messages ((folder elmo-folder)
1492                                                  numbers)
1493   (elmo-msgdb-delete-messages (elmo-folder-msgdb folder) numbers))
1494
1495 (luna-define-generic elmo-folder-length (folder)
1496   "Return number of messages in the FOLDER.")
1497
1498 (luna-define-method elmo-folder-length ((folder elmo-folder))
1499   (if (elmo-folder-msgdb-internal folder)
1500       (elmo-msgdb-length (elmo-folder-msgdb folder))
1501     0))
1502
1503 (defun elmo-folder-msgdb-load (folder &optional silent)
1504   (unless silent
1505     (message "Loading msgdb for %s..." (elmo-folder-name-internal folder)))
1506   (let ((msgdb (elmo-load-msgdb (elmo-folder-msgdb-path folder))))
1507     (elmo-folder-set-info-max-by-numdb
1508      folder
1509      (elmo-msgdb-list-messages msgdb))
1510     (unless silent
1511       (message "Loading msgdb for %s...done"
1512                (elmo-folder-name-internal folder)))
1513     msgdb))
1514
1515 (defun elmo-msgdb-delete-path (folder)
1516   (let ((path (elmo-folder-msgdb-path folder)))
1517     (if (file-directory-p path)
1518         (elmo-delete-directory path t))))
1519
1520 (defun elmo-msgdb-rename-path (old-folder new-folder)
1521   (let* ((old (directory-file-name (elmo-folder-msgdb-path old-folder)))
1522          (new (directory-file-name (elmo-folder-msgdb-path new-folder)))
1523          (new-dir (directory-file-name (file-name-directory new))))
1524     (if (not (file-directory-p old))
1525         ()
1526       (if (file-exists-p new)
1527           (error "Already exists directory: %s" new)
1528         (if (not (file-exists-p new-dir))
1529             (elmo-make-directory new-dir))
1530         (rename-file old new)))))
1531
1532 (defun elmo-setup-subscribed-newsgroups (groups)
1533   "Setup subscribed newsgroups.
1534 GROUPS is a list of newsgroup name string.
1535 Return a hashtable for newsgroups."
1536   (let ((hashtb (or elmo-newsgroups-hashtb
1537                     (setq elmo-newsgroups-hashtb
1538                           (elmo-make-hash (length groups))))))
1539     (dolist (group groups)
1540       (or (elmo-get-hash-val group hashtb)
1541           (elmo-set-hash-val group nil hashtb)))
1542     (setq elmo-newsgroups-hashtb hashtb)))
1543
1544 (defvar elmo-crosspost-message-alist-modified nil)
1545 (defun elmo-crosspost-message-alist-load ()
1546   "Load crosspost message alist."
1547   (setq elmo-crosspost-message-alist (elmo-crosspost-alist-load))
1548   (setq elmo-crosspost-message-alist-modified nil))
1549
1550 (defun elmo-crosspost-message-alist-save ()
1551   "Save crosspost message alist."
1552   (when elmo-crosspost-message-alist-modified
1553     (let ((alist elmo-crosspost-message-alist)
1554           newsgroups)
1555       (while alist
1556         (setq newsgroups
1557               (elmo-delete-if
1558                '(lambda (x)
1559                   (not (intern-soft x elmo-newsgroups-hashtb)))
1560                (nth 1 (car alist))))
1561         (if newsgroups
1562             (setcar (cdar alist) newsgroups)
1563           (setq elmo-crosspost-message-alist
1564                 (delete (car alist) elmo-crosspost-message-alist)))
1565         (setq alist (cdr alist)))
1566       (elmo-crosspost-alist-save elmo-crosspost-message-alist)
1567       (setq elmo-crosspost-message-alist-modified nil))))
1568
1569 (defun elmo-folder-make-temporary-directory (folder)
1570   ;; Make a temporary directory for FOLDER.
1571   (let ((temp-dir (make-temp-name
1572                    (concat
1573                     (file-name-as-directory (elmo-folder-msgdb-path folder))
1574                     "elmo"))))
1575     (elmo-make-directory temp-dir)
1576     temp-dir))
1577
1578 (defun elmo-init ()
1579   "Initialize ELMO module."
1580   (elmo-crosspost-message-alist-load)
1581   (elmo-resque-obsolete-variables)
1582   (elmo-dop-queue-load)
1583   (run-hooks 'elmo-init-hook))
1584
1585 (defun elmo-quit ()
1586   "Quit and cleanup ELMO."
1587   (elmo-crosspost-message-alist-save)
1588   (elmo-dop-queue-save)
1589   ;; Not implemented yet.
1590   (let ((types elmo-folder-type-alist)
1591         class)
1592     (while types
1593       (setq class
1594             (luna-find-class
1595              (intern (format "elmo-%s-folder"
1596                              (symbol-name (cdr (car types)))))))
1597       ;; Call all folder's `elmo-quit' method.
1598       (if class
1599           (dolist (func (luna-class-find-functions class 'elmo-quit))
1600             (funcall func nil)))
1601       (setq types (cdr types)))))
1602
1603 (luna-define-method elmo-folder-rename-internal ((folder elmo-folder)
1604                                                  new-folder)
1605   (error "Cannot rename %s folder"
1606          (symbol-name (elmo-folder-type-internal folder))))
1607
1608 ;;; Define folders.
1609 (elmo-define-folder ?% 'imap4)
1610 (elmo-define-folder ?-  'nntp)
1611 (elmo-define-folder ?\+ 'localdir)
1612 (elmo-define-folder ?\* 'multi)
1613 (elmo-define-folder ?\/ 'filter)
1614 (elmo-define-folder ?\$ 'archive)
1615 (elmo-define-folder ?&  'pop3)
1616 (elmo-define-folder ?=  'localnews)
1617 (elmo-define-folder ?|  'pipe)
1618 (elmo-define-folder ?.  'maildir)
1619 (elmo-define-folder ?'  'internal)
1620 (elmo-define-folder ?\[  'nmz)
1621 (elmo-define-folder ?@  'shimbun)
1622
1623 ;;; Obsolete variables.
1624 (elmo-define-obsolete-variable 'elmo-default-imap4-mailbox
1625                                'elmo-imap4-default-mailbox)
1626 (elmo-define-obsolete-variable 'elmo-default-imap4-server
1627                                'elmo-imap4-default-server)
1628 (elmo-define-obsolete-variable 'elmo-default-imap4-authenticate-type
1629                                'elmo-imap4-default-authenticate-type)
1630 (elmo-define-obsolete-variable 'elmo-default-imap4-user
1631                                'elmo-imap4-default-user)
1632 (elmo-define-obsolete-variable 'elmo-default-imap4-port
1633                                'elmo-imap4-default-port)
1634 (elmo-define-obsolete-variable 'elmo-default-imap4-stream-type
1635                                'elmo-imap4-default-stream-type)
1636 (elmo-define-obsolete-variable 'elmo-default-nntp-server
1637                                'elmo-nntp-default-server)
1638 (elmo-define-obsolete-variable 'elmo-default-nntp-user
1639                                'elmo-nntp-default-user)
1640 (elmo-define-obsolete-variable 'elmo-default-nntp-port
1641                                'elmo-nntp-default-port)
1642 (elmo-define-obsolete-variable 'elmo-default-nntp-stream-type
1643                                'elmo-nntp-default-stream-type)
1644 (elmo-define-obsolete-variable 'elmo-default-pop3-server
1645                                'elmo-pop3-default-server)
1646 (elmo-define-obsolete-variable 'elmo-default-pop3-user
1647                                'elmo-pop3-default-user)
1648 (elmo-define-obsolete-variable 'elmo-default-pop3-authenticate-type
1649                                'elmo-pop3-default-authenticate-type)
1650 (elmo-define-obsolete-variable 'elmo-default-pop3-port
1651                                'elmo-pop3-default-port)
1652 (elmo-define-obsolete-variable 'elmo-default-pop3-stream-type
1653                                'elmo-pop3-default-stream-type)
1654 (elmo-define-obsolete-variable 'elmo-cache-dirname
1655                                'elmo-cache-directory)
1656 (elmo-define-obsolete-variable 'elmo-msgdb-dir
1657                                'elmo-msgdb-directory)
1658
1659 ;; Obsolete functions.
1660 ;; 2001-12-11: *-dir -> *-directory
1661 (defalias 'elmo-folder-make-temp-dir 'elmo-folder-make-temporary-directory)
1662 (make-obsolete 'elmo-folder-make-temp-dir
1663                'elmo-folder-make-temporary-directory)
1664
1665 (require 'product)
1666 (product-provide (provide 'elmo) (require 'elmo-version))
1667
1668 ;;; elmo.el ends here