`window-configuration-change-hook' to save up to date undo info

before the change."

  (when (and (not wg-already-updated-working-wconfig)

             (wg-minibuffer-inactive-p))

    (wg-update-current-workgroup-working-wconfig)

    (setq wg-already-updated-working-wconfig t)))

;;; base wconfig updating

(defun wg-update-all-base-wconfigs ()

  "Update every workgroup's base wconfig with

`wg-workgroup-update-base-wconfig'."

  (dolist (workgroup (wg-workgroup-list))

    (wg-awhen (wg-workgroup-selected-frame-wconfig workgroup)

      (setf (wg-workgroup-base-wconfig workgroup) it

            (wg-workgroup-selected-frame-wconfig workgroup) nil))))

(defun wg-update-working-wconfig-on-delete-frame (frame)

  "Update FRAME's current workgroup's working-wconfig before

FRAME is deleted, so we don't lose its state."

  (with-selected-frame frame

    (wg-update-current-workgroup-working-wconfig)))

;;; workgroup saved wconfigs

(defun wg-workgroup-saved-wconfig-names (workgroup)

  "Return a new list of the names of all WORKGROUP's saved wconfigs."

  (mapcar 'wg-wconfig-name (wg-workgroup-saved-wconfigs workgroup)))

(defun wg-workgroup-get-saved-wconfig (workgroup wconfig-or-name)

  "Return the wconfig in WORKGROUP's saved wconfigs named WCONFIG-OR-NAME.

WCONFIG-OR-NAME must be either a string or a wconfig.  If

WCONFIG-OR-NAME is a string and there is no saved wconfig with

that name, return nil.  If WCONFIG-OR-NAME is a wconfig, and it

is a member of WORKGROUP's saved wconfigs, return is as given.

Otherwise return nil."

  (let ((wconfigs (wg-workgroup-saved-wconfigs workgroup)))

    (etypecase wconfig-or-name

      (wg-wconfig (car (memq wconfig-or-name wconfigs)))

      (string (wg-find wconfig-or-name wconfigs

                    :key 'wg-wconfig-name

                    :test 'string=)))))

(defun wg-workgroup-save-wconfig (workgroup wconfig)

  "Add WCONFIG to WORKGROUP's saved wconfigs.  WCONFIG must have

a name.  If there's already a wconfig with the same name in

WORKGROUP's saved wconfigs, replace it."

  (let ((name (wg-wconfig-name wconfig)))

    (unless name (error "Attempt to save a nameless wconfig"))

    (setf (wg-workgroup-modified workgroup) t)

    (wg-asetf (wg-workgroup-saved-wconfigs workgroup)

              (cons wconfig (wg-remove* name it

                                     :key 'wg-wconfig-name

                                     :test 'string=)))))

(defun wg-workgroup-kill-saved-wconfig (workgroup wconfig-or-name)

  "Delete WCONFIG-OR-NAME from WORKGROUP's saved wconfigs.

WCONFIG-OR-NAME is resolved with `wg-workgroup-get-saved-wconfig'."

  (wg-when-let ((wconfig (wg-workgroup-get-saved-wconfig

                          workgroup wconfig-or-name)))

    (wg-asetf (wg-workgroup-saved-wconfigs workgroup) (remq wconfig it)

              (wg-workgroup-modified workgroup) t)))

;;; garbage collection

;; update buf list

(defun wg-update-buffer-in-buf-list (&optional buffer)

  "Update BUFFER's corresponding buf in `wg-buf-list'.

BUFFER nil defaults to `current-buffer'."

  (let ((buffer (or buffer (current-buffer))))

    (wg-when-let ((uid (wg-buffer-uid buffer))

                  (old-buf (wg-find-buf-by-uid uid))

                  (new-buf (wg-buffer-to-buf buffer)))

      (setf (wg-buf-uid new-buf) (wg-buf-uid old-buf))

      (wg-asetf (wg-buf-list) (cons new-buf (remove old-buf it))))))

(defun wg-update-buf-list (&optional buffer-list)

  "Update all bufs in `wg-buf-list' corresponding to buffers in BUFFER-LIST."

  (mapc 'wg-update-buffer-in-buf-list (or buffer-list (buffer-list))))

;; gc buf uids

(defun wg-workgroup-gc-buf-uids (workgroup)

  "Remove buf uids from WORKGROUP that have no referent in `wg-buf-list'."

  (wg-asetf (wg-workgroup-strong-buf-uids workgroup)

            (wg-remove-if-not 'wg-find-buf-by-uid it)

            (wg-workgroup-weak-buf-uids workgroup)

            (wg-remove-if-not 'wg-find-buf-by-uid it)))

(defun wg-gc-buf-uids ()

  "Remove from all workgroups those buf uids that have no referent in `wg-buf-list'."

  (mapc 'wg-workgroup-gc-buf-uids (wg-workgroup-list)))

;; gc bufs

(defun wg-wtree-buf-uids (wtree)

  "Return a new list of the buf uids of all wins in wtree."

  (wg-flatten-wtree wtree 'wg-win-buf-uid))

(defun wg-wtree-unique-buf-uids (wtree)

  "Return a list of the unique buf uids of all wins in wtree."

  (wg-remove-duplicates (wg-wtree-buf-uids wtree) :test 'string=))

(defun wg-wconfig-buf-uids (wconfig)

  "Return WCONFIG's wtree's `wg-wtree-buf-uids'."

  (wg-wtree-unique-buf-uids (wg-wconfig-wtree wconfig)))

(defun wg-workgroup-base-wconfig-buf-uids (workgroup)

  "Return a new list of all unique buf uids in WORKGROUP's working wconfig."

  (wg-wconfig-buf-uids (wg-workgroup-base-wconfig workgroup)))

(defun wg-workgroup-saved-wconfigs-buf-uids (workgroup)

  "Return a new list of all unique buf uids in WORKGROUP's base wconfig."

  (wg-reduce 'wg-string-list-union

          (wg-workgroup-saved-wconfigs workgroup)

          :key 'wg-wconfig-buf-uids))

(defun wg-workgroup-all-wconfig-buf-uids (workgroup)

  "Return a new list of all unique buf uids in WORKGROUP's wconfigs."

  (wg-union (wg-workgroup-base-wconfig-buf-uids workgroup)

         (wg-workgroup-saved-wconfigs-buf-uids workgroup)

         :test 'string=))

(defun wg-workgroup-all-buf-uids (workgroup)

  "Return a new list of all unique buf uids in WORKGROUP."

  (wg-reduce 'wg-string-list-union

          (list (wg-workgroup-base-wconfig-buf-uids workgroup)

                (wg-workgroup-saved-wconfigs-buf-uids workgroup)

                (if wg-restore-associated-buffers

                    (wg-workgroup-associated-buf-uids workgroup))

                )))

(defun wg-session-all-buf-uids (&optional session)

  "Return a new list of all unique buf uids in SESSION.

SESSION nil defaults to `wg-current-session'."

  (wg-reduce 'wg-string-list-union

          (wg-session-workgroup-list (or session (wg-current-session)))

          :key 'wg-workgroup-all-buf-uids))

(defun wg-buffer-list-all-uids (&optional buffer-list)

  "Return a list of the uids of all buffers in BUFFER-LIST in

which `wg-buffer-uid' is locally bound.

BUFFER-LIST nil defaults to `buffer-list'."

  (delq nil (mapcar 'wg-buffer-uid (or buffer-list (buffer-list)))))

(defun wg-all-buf-uids (&optional session buffer-list)

  "Return the union of `wg-session-all-buf-uids' and `wg-buffer-list-all-uids'."

  (wg-union (wg-session-all-buf-uids session)

         (wg-buffer-list-all-uids buffer-list)

         :test 'string=))

(defun wg-gc-bufs ()

  "gc bufs from `wg-buf-list' that are no longer needed."

  (let ((all-buf-uids (wg-all-buf-uids)))

    (wg-asetf (wg-buf-list)

              (wg-remove-if-not (lambda (uid) (member uid all-buf-uids)) it

                             :key 'wg-buf-uid))))

;; FIXME: Duplicate buf names probably shouldn't be allowed.  An unrelated error

;; causes two *scratch* buffers to be present, triggering the "uids don't match"

;; error.  Write something to remove bufs with duplicate names.

(defun wg-perform-session-maintenance ()

  "Perform various maintenance operations on the current Workgroups session."

  (wg-update-current-workgroup-working-wconfig)

  (wg-update-all-base-wconfigs)

  (wg-gc-bufs)

  (wg-gc-buf-uids)

  (wg-update-buf-list))

;; session consistency testing

(defun wg-session-uids-consistent-p ()

  "Return t if there are no duplicate bufs or buf uids in the wrong places,

nil otherwise."

  (and (wg-every (lambda (wg)

                (not (wg-dups-p (wg-workgroup-associated-buf-uids wg)

                                :test 'string=)))

              (wg-workgroup-list))

       (not (wg-dups-p (wg-buf-list) :key 'wg-buf-uid :test 'string=))

       (not (wg-dups-p (wg-workgroup-list) :key 'wg-workgroup-uid :test 'string=))))

;;; workgroup restoration

(defun wg-restore-workgroup-associated-buffers-internal (workgroup)

  "Restore all the buffers associated with WORKGROUP that can be restored."

  (save-window-excursion

    (delete nil (mapcar 'wg-restore-buffer

                        (wg-workgroup-associated-bufs workgroup)))))

(defun wg-restore-workgroup (workgroup)

  "Restore WORKGROUP in `selected-frame'."

  (when wg-restore-associated-buffers

    (wg-restore-workgroup-associated-buffers-internal workgroup))

  (let (wg-flag-modified)

    (wg-restore-wconfig-undoably

     (wg-workgroup-working-wconfig workgroup) t)))

;;; workgroup-list ops

(defun wg-delete-workgroup (workgroup)

  "Remove WORKGROUP from `wg-workgroup-list'.

Also delete all references to it by `wg-workgroup-state-table',

`wg-current-workgroup' and `wg-previous-workgroup'."

  (dolist (frame (frame-list))

    (remhash (wg-workgroup-uid workgroup) (wg-workgroup-state-table frame))

    (when (wg-current-workgroup-p workgroup frame)

      (wg-set-current-workgroup nil frame))

    (when (wg-previous-workgroup-p workgroup frame)

      (wg-set-previous-workgroup nil frame)))

  (setf (wg-workgroup-list) (remove workgroup (wg-workgroup-list-or-error)))

  (setf (wg-session-modified (wg-current-session)) t)

  workgroup)

(defun wg-add-workgroup (workgroup &optional index)

  "Add WORKGROUP to `wg-workgroup-list' at INDEX or the end.

If a workgroup with the same name exists, overwrite it."

  (wg-awhen (wg-find-workgroup-by :name (wg-workgroup-name workgroup) t)

    (unless index (setq index (wg-position it (wg-workgroup-list-or-error))))

    (wg-delete-workgroup it))

  (wg-asetf (wg-workgroup-list)

            (wg-insert-before workgroup it (or index (length it))))

  (setf (wg-session-modified (wg-current-session)) t)

  workgroup)

(defun wg-check-and-add-workgroup (workgroup)

  "Add WORKGROUP to `wg-workgroup-list'.

Ask to overwrite if a workgroup with the same name exists."

  (let ((name (wg-workgroup-name workgroup))

        (uid (wg-workgroup-uid workgroup)))

    (when (wg-find-workgroup-by :uid uid t)

      (error "A workgroup with uid %S already exists" uid))

    (when (wg-find-workgroup-by :name name t)

      (unless (or wg-no-confirm-on-destructive-operation

                  (y-or-n-p (format "%S exists. Overwrite? " name)))

        (error "Cancelled"))))

  (wg-add-workgroup workgroup))

(defun wg-make-and-add-workgroup (name &optional blank)

  "Create a workgroup named NAME and add it with `wg-check-and-add-workgroup'."

  (wg-check-and-add-workgroup

   (wg-make-workgroup

    :name name

    :base-wconfig (if blank (wg-make-blank-wconfig)

                    (wg-current-wconfig)))))

(defun wg-get-workgroup-create (workgroup)

  "Return the workgroup specified by WORKGROUP, creating a new one if needed.

If `wg-get-workgroup' on WORKGROUP returns a workgroup, return it.

Otherwise, if WORKGROUP is a string, create a new workgroup with

that name and return it. Otherwise error."

  (or (wg-get-workgroup workgroup t)

      (if (stringp workgroup)

          (when (or (not wg-confirm-on-get-workgroup-create)

                    (y-or-n-p (format "%S doesn't exist.  Create it? "

                                      workgroup)))

            (wg-make-and-add-workgroup workgroup))

        ;; Call this again for its error message

        (wg-get-workgroup workgroup))))

(defun wg-cyclic-offset-workgroup (workgroup n)

  "Offset WORKGROUP's position in `wg-workgroup-list' by N."

  (let ((workgroup-list (wg-workgroup-list-or-error)))

    (unless (member workgroup workgroup-list)

      (error "Workgroup isn't present in `wg-workgroup-list'."))

    (setf (wg-workgroup-list) (wg-cyclic-offset-elt workgroup workgroup-list n)

          (wg-session-modified (wg-current-session)) t)))

(defun wg-swap-workgroups-in-workgroup-list (workgroup1 workgroup2)

  "Swap the positions of WORKGROUP1 and WORKGROUP2 in `wg-workgroup-list'."

  (let ((workgroup-list (wg-workgroup-list-or-error)))

    (when (eq workgroup1 workgroup2)

      (error "Can't swap a workgroup with itself"))

    (unless (and (memq workgroup1 workgroup-list)

                 (memq workgroup2 workgroup-list))

      (error "Both workgroups aren't present in `wg-workgroup-list'."))

    (setf (wg-workgroup-list) (wg-util-swap workgroup1 workgroup2 workgroup-list)

          (wg-session-modified (wg-current-session)) t)))

(defun wg-cyclic-nth-from-workgroup (workgroup &optional n)

  "Return the workgroup N places from WORKGROUP in `wg-workgroup-list'."

  (wg-cyclic-nth-from-elt workgroup (wg-workgroup-list-or-error) (or n 1)))

;;; buffer association

(defun wg-associate-buffers (workgroup window-or-emacs-window-tree)

  "Associate the buffers visible in window elements of

WINDOW-OR-EMACS-WINDOW-TREE with the given WORKGROUP.

WINDOW-OR-EMACS-WINDOW-TREE must be either a window or a tree of

the form produced by `(car (window-tree))'."

  (wg-aif (windowp window-or-emacs-window-tree)

      (with-current-buffer (window-buffer window-or-emacs-window-tree)

        (setq wg-buffer-workgroup workgroup))

    (dolist (w (cddr window-or-emacs-window-tree))

      (when w (wg-associate-buffers workgroup w)))))

(defun wg-associate-frame-buffers ()

  "Associate the buffers visible in the current frame with the

current workgroup (unless it is currently being deactivated)."

  (wg-awhen (wg-current-workgroup :noerror)

    (unless (member it wg-deactivation-list)

      (wg-associate-buffers it (car (window-tree))))))

(defun wg-associate-all-frame-buffers ()

  "Associate all visible buffers with the current

workgroup (unless it is currently being deactivated)."

  (mapcar 'wg-associate-frame-buffers (frame-list)))

(defun wg-buffer-predicate (buffer)

  "Return t iff the given BUFFER should be considered a candidate

for display by `other-buffer' in the current workgroup."

  (or (not wg-associate-buffers)

      (wg-awhen (wg-current-workgroup :noerror)

        (with-current-buffer buffer

          (eq wg-buffer-workgroup it)))))

(defun wg-after-make-frame (frame)

  (set-frame-parameter frame 'buffer-predicate

                       'wg-buffer-predicate))

;;; mode-line

(defun wg-mode-line-buffer-association-indicator (workgroup)

  "Return a string indicating `current-buffer's association-type in WORKGROUP."

  (case (wg-workgroup-bufobj-association-type workgroup (current-buffer))

    (strong wg-mode-line-decor-strongly-associated)

    (weak wg-mode-line-decor-weakly-associated)

    (otherwise wg-mode-line-decor-unassociated)))

(defun wg-mode-line-string ()

  "Return the string to be displayed in the mode-line."

  (let ((wg (wg-current-workgroup t))

        (wg-use-faces wg-mode-line-use-faces))

    (cond (wg (wg-fontify " "

                ;;(consp (cons :div wg-mode-line-decor-left-brace))

                ;;(keywordp (car (cons :div wg-mode-line-decor-left-brace)))

                ;;(:div wg-mode-line-decor-left-brace)

                wg-mode-line-decor-left-brace

                (wg-workgroup-name wg)

                (if (not wg-mode-line-only-name)

                    (progn

                      wg-mode-line-decor-divider

                      (wg-mode-line-buffer-association-indicator wg)

                      wg-mode-line-decor-divider

                      (if (window-dedicated-p)

                                 wg-mode-line-decor-window-dedicated

                               wg-mode-line-decor-window-undedicated)

                      wg-mode-line-decor-divider

                      (if (wg-session-modified (wg-current-session))

                                 wg-mode-line-decor-session-modified

                               wg-mode-line-decor-session-unmodified)

                      (if (wg-workgroup-modified wg)

                          wg-mode-line-decor-workgroup-modified

                        wg-mode-line-decor-workgroup-unmodified)))

                wg-mode-line-decor-right-brace))

          (t (if wg-display-nowg

                 (progn

                   (wg-fontify " "

                     wg-mode-line-decor-left-brace

                     wg-nowg-string

                     wg-mode-line-decor-right-brace))

               "")))))

(defun wg-add-mode-line-display ()

  "Add Workgroups' mode-line format to `mode-line-format'."

    (let ((format '(wg-mode-line-display-on (:eval (wg-mode-line-string))))

      (set-default 'mode-line-format

                   (wg-insert-after format mode-line-format pos))

      (force-mode-line-update))))

(defun wg-remove-mode-line-display ()

  "Remove Workgroups' mode-line format from `mode-line-format'."

  (wg-awhen (assq 'wg-mode-line-display-on mode-line-format)

    (set-default 'mode-line-format (remove it mode-line-format))

    (force-mode-line-update)))

;;; messaging

(defun wg-message (format-string &rest args)

  "Call `message' with FORMAT-STRING and ARGS.

Also save the msg to `wg-last-message'."

  (setq wg-last-message (apply #'message format-string args)))

(defmacro wg-fontified-message (&rest format)

  "`wg-fontify' FORMAT and call `wg-message' on it."

  (declare (indent defun))

  `(wg-message (wg-fontify ,@format)))

;;; fancy displays

;; FIXME: add `wg-display-max-lines' to chop long display strings at max-line

;; and element-name boundaries

(defun wg-element-display (elt elt-string &optional current-elt-p previous-elt-p)

  "Return display string for ELT."

  (cond ((and current-elt-p (funcall current-elt-p elt))

         (wg-fontify (:cur (concat wg-list-display-decor-current-left

                                   elt-string

                                   wg-list-display-decor-current-right))))

        ((and previous-elt-p (funcall previous-elt-p elt))

         (wg-fontify (:prev (concat wg-list-display-decor-previous-left

                                    elt-string

                                    wg-list-display-decor-previous-right))))

        (t (wg-fontify (:other elt-string)))))

(defun wg-workgroup-display (workgroup index)

  "Return display string for WORKGROUP at INDEX."

  (if (not workgroup) wg-nowg-string

    (wg-element-display

     workgroup

     (format "%d: %s" index (wg-workgroup-name workgroup))

     'wg-current-workgroup-p

     'wg-previous-workgroup-p)))

(defun wg-buffer-display (buffer index)

  "Return display string for BUFFER. INDEX is ignored."

  (if (not buffer) "No buffers"

    (wg-element-display

     (wg-get-buffer buffer)

     (format "%s" (wg-buffer-name buffer))

     'wg-current-buffer-p)))

;; (defun wg-display-internal (elt-fn list)

;;   "Return display string built by calling ELT-FN on each element of LIST."

;;   (let ((div (wg-add-face :div wg-list-display-decor-divider))

;;         (i -1))

;;     (wg-fontify

;;       (:brace wg-list-display-decor-left-brace)

;;       (if (not list) (funcall elt-fn nil nil)

;;         (wg-doconcat (elt list div) (funcall elt-fn elt (incf i))))

;;       (:brace wg-list-display-decor-right-brace))))

(defcustom wg-display-max-lines 1

  "FIXME: docstring this"

  :type 'integer

  :group 'workgroups)

(defun wg-display-internal (elt-fn list)

  "Return display string built by calling ELT-FN on each element of LIST."

  (let ((div (wg-add-face :div wg-list-display-decor-divider))

        (wwidth (window-width (minibuffer-window)))

        (i -1)

        (str))

    (setq str

          (wg-fontify

            (:brace wg-list-display-decor-left-brace)

            (if (not list) (funcall elt-fn nil nil)

              (wg-doconcat (elt list div) (funcall elt-fn elt (incf i))))

            (:brace wg-list-display-decor-right-brace)))

    ;; (subseq str 0 wwidth)

    ))

(defun wg-workgroup-list-display (&optional workgroup-list)

  "Return the Workgroups list display string.

The string contains the names of all workgroups in `wg-workgroup-list',

decorated with faces, dividers and strings identifying the

current and previous workgroups."

  (wg-display-internal 'wg-workgroup-display

                       (or workgroup-list (wg-workgroup-list))))

;; TODO: Possibly add scroll animation for the buffer list display during

;; `wg-next-buffer' and `wg-previous-buffer'

(defun wg-buffer-list-display (buffer-list)

  "Return the buffer-list display string."

  (wg-display-internal

   'wg-buffer-display

   (if wg-center-rotate-buffer-list-display

       (wg-center-rotate-list buffer-list) buffer-list)))

(defun wg-buffer-list-filter-display (&optional workgroup blf-id)

  "Return a buffer-list-filter display string from WORKGROUP and BLF-ID."

  (wg-fontify

    "("

    (wg-workgroup-name (wg-get-workgroup workgroup))

    ":"

    (wg-get-buffer-list-filter-val blf-id 'indicator)

    ")"))

(defun wg-buffer-list-filter-prompt (prompt &optional workgroup blf-id)

  "Return a prompt string from PROMPT indicating WORKGROUP and BLF-ID."

  (wg-fontify

    prompt " "

    (wg-buffer-list-filter-display workgroup blf-id)

    ": "))

(defun wg-buffer-command-display (&optional buffer-list)

  "Return the buffer command display string."

  (concat

   (wg-buffer-list-filter-display) ": "

   (wg-buffer-list-display (or buffer-list (wg-filtered-buffer-list)))))

(defun wg-timeline-display (position length)

  "Return a timeline visualization string from POSITION and LENGTH."

  (wg-fontify

    ;;(cons :div "-<{")

    "-<{"

    (wg-make-string (- length position) "-" "=")

    "O"

    (wg-make-string (1+ position) "-" "=")

    "}>-"))

(defun wg-undo-timeline-display (workgroup)

  "Return WORKGROUP's undo timeline string."

  (wg-with-undo workgroup (state undo-pointer undo-list)

    (wg-timeline-display undo-pointer (length undo-list))))

(require 'workgroups-ido)

;;; minibuffer reading

(defun wg-read-buffer (prompt &optional default require-match)

  "Workgroups' version of `read-buffer'."

  (if (not (wg-filter-buffer-list-p))

      (funcall (wg-read-buffer-function) prompt default require-match)

    (wg-with-buffer-list-filters 'read-buffer

      (funcall (wg-read-buffer-function)

               (wg-buffer-list-filter-prompt

                (wg-aif (string-match ": *$" prompt)

                    (substring prompt 0 it) prompt))

               default require-match))))

;; TODO: Add minibuffer commands for killing, cloning, etc.

(defun wg-read-workgroup-name (&optional require-match)

  "Read a workgroup with `wg-completing-read'."

  (wg-completing-read

   "Workgroup: " (wg-workgroup-names) nil require-match nil nil

   (wg-awhen (wg-current-workgroup t) (wg-workgroup-name it))))

(defun wg-new-default-workgroup-name ()

  "Return a new, unique, default workgroup name."

  (let ((names (wg-workgroup-names t)) (index -1) result)

    (while (not result)

      (let ((new-name (format "wg%s" (incf index))))

        (unless (member new-name names)

          (setq result new-name))))

    result))

(defun wg-unique-workgroup-name-p (new-name)

  "Return t if NEW-NAME is unique in `wg-workgroup-list', nil otherwise."

  (wg-every (lambda (existing-name) (not (equal new-name existing-name)))

         (wg-workgroup-names t)))

(defun wg-read-new-workgroup-name (&optional prompt)

  "Read a non-empty name string from the minibuffer."

  (let ((default (wg-new-default-workgroup-name)))

    (wg-read-object

     (or prompt (format "Name (default: %S): " default))

     (lambda (new) (and (stringp new)

                        (not (equal new ""))

                        (wg-unique-workgroup-name-p new)))

     "Please enter a unique, non-empty name"

     nil nil nil nil default)))

(defun wg-read-workgroup-index ()

  "Prompt for the index of a workgroup."

  (let ((max (1- (length (wg-workgroup-list-or-error)))))

    (wg-read-object

     (format "%s\n\nEnter [0-%d]: " (wg-workgroup-list-display) max)

     (lambda (obj) (and (integerp obj) (wg-within obj 0 max t)))

     (format "Please enter an integer [%d-%d]" 0 max)

     nil nil t)))

(defun wg-read-saved-wconfig-name (workgroup &optional prompt require-match)

  "Read the name of a saved wconfig, completing on the names of

WORKGROUP's saved wconfigs."

  (wg-completing-read

   (or prompt "Saved wconfig name: ")

   (wg-workgroup-saved-wconfig-names workgroup)

   nil require-match))

(defun wg-read-saved-wconfig (workgroup)

  "Read the name of and return one of WORKGROUP's saved wconfigs."

  (wg-workgroup-get-saved-wconfig

   workgroup (wg-read-saved-wconfig-name workgroup nil t)))

;;; session resetting

(defun wg-reset-frame (frame)

  "Reset Workgroups' frame-parameters in FRAME to nil."

  (set-frame-parameter frame 'wg-workgroup-state-table nil)

  (set-frame-parameter frame 'wg-current-workgroup-uid nil)

  (set-frame-parameter frame 'wg-previous-workgroup-uid nil))

(defun wg-reset-buffer (buffer)

  "Return BUFFER.

Currently only sets BUFFER's `wg-buffer-uid' to nil."

  (with-current-buffer buffer

    (setq wg-buffer-uid nil)))

(defun wg-reset-internal (&optional session)

  "Reset Workgroups, setting `wg-current-session' to SESSION.

Resets all frame parameters, buffer-local vars, current

Workgroups session object, etc.  SESSION nil defaults to a new,

blank session object."

  (mapc 'wg-reset-frame (frame-list))

  (mapc 'wg-reset-buffer (buffer-list))

  (setq wg-wconfig-kill-ring nil)

  (setq wg-current-session (or session (wg-make-session))))

;; Local Variables:

;; byte-compile-warnings: (not cl-functions)

;; End:

(provide 'workgroups-functions)

;;; workgroups-functions.el ends here

    wg-serialize-wl-folders-buffer

    ;;wg-serialize-wl-summary-buffer

    ;;wg-serialize-mime-view-buffer

    )

  "List of functions providing special buffer serialization/deserialization.

An entry should be either a function symbol or a lambda, and should

accept a single Emacs buffer object as an argument.

When a buffer is to be serialized, it is passed to each of these

functions in turn until one returns non-nil, or the list ends.  A

return value of nil indicates that the function can't handle

buffers of that type.  A non-nil return value indicates that it

can.  The first non-nil return value becomes the buffer's special

serialization data.  The return value should be a cons, with a

deserialization function (a function symbol or a lambda) as the car,

and any other serialization data as the cdr.

When it comes time to deserialize the buffer, the deserialization

function (the car of the cons mentioned above) is passed the

wg-buf object, from which it should restore the buffer.  The

special serialization data itself can be accessed

with (cdr (wg-buf-special-data <wg-buf>)).  The deserialization

function must return the restored Emacs buffer object.

See the definitions of the functions in this list for examples of

how to write your own."

  :type 'alist

  :group 'workgroups)

(defcustom wg-default-buffer "*scratch*"

  "Buffer made visible a window when the window's actual buffer

can't be restored.  Also used when a blank workgroup is created."

  :type 'string

  :group 'workgroups)

(defcustom wg-nowg-string "No workgroups"

  "Display this string if there are no workgroups and

`wg-display-nowg' is t."

  :type 'string

  :group 'workgroups)

(defcustom wg-display-nowg nil

  "Display something if there are no workgroups."

  :type 'boolean

  :group 'workgroups)

;; What to restore:

(defcustom wg-restore-remote-buffers t

  "nil means do not restore buffers that get \"t\" with

`wg-is-file-remote'"

  :type 'boolean

  :group 'workgroups)

(defcustom wg-restore-associated-buffers nil

  "Non-nil means restore ALL buffers associated (opened in) with

the workgroup on workgroup restore.  \"nil\" means to restore

only needed buffers to show them to you."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-restore-frame-position nil

  "Non-nil means restore frame position on workgroup restore."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-restore-scroll-bars t

  "Non-nil means restore scroll-bar settings on workgroup restore."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-restore-fringes t

  "Non-nil means restore fringe settings on workgroup restore."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-restore-margins t

  "Non-nil means restore margin settings on workgroup restore."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-restore-point t

  "Non-nil means restore `point' on workgroup restore.

This is included mainly so point restoration can be suspended

during `wg-morph' -- you probably want this non-nil."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-restore-point-max t

  "Controls point restoration when point is at `point-max'.

If `point' is at `point-max' when a wconfig is created, put

`point' back at `point-max' when the wconfig is restored, even if

`point-max' has increased in the meantime.  This is useful in,

say, irc buffers where `point-max' is constantly increasing."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-restore-mark t

  "Non-nil means restore mark data on workgroup restore."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-restore-window-dedicated-p t

  "Non-nil means restore `window-dedicated-p' on workgroup restore."

  :type 'boolean

  :group 'workgroups)

;; wconfig undo/redo customization

(defcustom wg-wconfig-undo-list-max 20

  "Number of past window configs to retain for undo."

  :type 'integer

  :group 'workgroups)

;; wconfig kill-ring customization

(defcustom wg-wconfig-kill-ring-max 20

  "Maximum length of the `wg-wconfig-kill-ring'."

  :type 'integer

  :group 'workgroups)

;; buffer-list filtration customization

(defcustom wg-buffer-list-filtration-on t

  "Non-nil means Workgroups' buffer-list filtration feature is on.

Nil means ido and iswitchb behave normally.  See

`wg-buffer-list-filter-definitions' for more info."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-buffer-list-filter-definitions

  '((all "all" wg-buffer-list-filter-all)

    (associated "associated" wg-buffer-list-filter-associated)

    (unassociated "unassociated" wg-buffer-list-filter-unassociated)

    (fallback "fallback" nil))

  "List of buffer list filter definitions.

Each entry should be a list containing an identifier symbol, a

prompt string, and a function form that's funcall'd to produce

the filtered buffer-list.

The prompt string is displayed as part of the minibuffer prompt

when its filter is active.

The function form should be either a function-symbol or a lambda, and

should take two arguments: a workgroup and a list of live Emacs

buffers.  The function should return a new list of live buffers,

typically by filtering its second argument in some way.

Default buffer-list-filters include:

`all'           All buffer names

`associated'    Only the names of those live buffers that have

                been associated with the current workgroup

`unassociated'  Only the names of those live buffers that are

                unassociated with the current workgroup

`fallback'      A special case used to fallback to the

                original (non-ido/iswitchb) Emacs command.

                `fallback' isn't actually a buffer-list-filter

                itself, but can be used in

                `wg-buffer-list-filter-order-alist' just the

                same.

A few example custom buffer-list filtration functions are

included, like `wg-buffer-list-filter-home-dir',

`wg-buffer-list-filter-irc' and `wg-buffer-list-filter-elisp'.

See their definitions for more info on how they're defined, and

the utilities they're built on.

Here's an example of how to add an `elisp' buffer-list-filter

definition to `wg-buffer-list-filter-definitions' using the

example function `wg-buffer-list-filter-elisp':

(add-to-list

 'wg-buffer-list-filter-definitions

 '(elisp \"elisp\" wg-buffer-list-filter-elisp))

After this form has been evaluated, `elisp' can be used wherever

other buffer-list-filter identifiers are used, like in

`wg-buffer-list-filter-order-alist'.

Becomes workgroup-local when set with `wg-set-workgroup-parameter'.

Becomes session-local when set with `wg-set-session-parameter'."

  :type 'list

  :group 'workgroups)

(defcustom wg-buffer-list-filter-order-alist

  '((default associated unassociated all fallback))

  "Alist defining the order in which filtered buffer-lists are presented.

The car of each entry should be the symbol of the original Emacs

command (not the ido or iswitchb remappings) -- i.e. one of

`switch-to-buffer', `switch-to-buffer-other-window',

`switch-to-buffer-other-frame', `kill-buffer', `next-buffer',

`previous-buffer', `display-buffer', `insert-buffer',

`read-buffer', or the special symbol `default', which defines the

buffer-list-filter order for all commands not present in this

alist.

The cdr of each entry should be a list of buffer-list-filter

identifiers defining the order in which filtered buffer-lists are

presented for the command.  See

`wg-buffer-list-filter-definitions'.

Becomes workgroup-local when set with `wg-set-workgroup-parameter'.

Becomes session-local when set with `wg-set-session-parameter'."

  :type 'alist

  :group 'workgroups)

(defcustom wg-center-rotate-buffer-list-display nil

  "Non-nil means rotate the buffer list display so that the

current buffer is in the center of the list.  This can make it

easier to see the where `wg-previous-buffer' will take you, but

it doesn't look right if the buffer list display is long enough

to wrap in the miniwindow."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-buffer-auto-association-on t

  "Non-nil means buffer auto-association is on.

nil means it's off.  See `wg-buffer-auto-association'."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-buffer-auto-association 'weak