(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)

  '((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

  "Specifies the behavior for auto-associating buffers with workgroups.

When a buffer is made visible in a window it can be automatically

associated with the current workgroup in the window's frame.

This setting determines whether and how that happens.

Allowable values:

`weak' - weakly associate the buffer with the workgroup

`strong' - strongly associate the buffer with the workgroup

A function (a function-symbol or a lambda) - `funcall' the function to

determine whether and how to associate the buffer with the

workgroup.  The function should accept two arguments -- the

buffer and the workgroup -- and should return one of the

allowable values for this variable.

`nil' or any other value - don't associate the buffer with the

workgroup.

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

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

  :type 'sexp

  :group 'workgroups)

(defcustom wg-dissociate-buffer-on-kill-buffer t

  "Non-nil means dissociate from the current workgroup buffers

killed with `kill-buffer'."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-remap-switch-to-buffer nil

  "Non-nil means remap `switch-to-buffer' to `wg-switch-to-buffer'."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-remap-switch-to-buffer-other-window nil

  "Non-nil means remap `switch-to-buffer-other-window' to

`wg-switch-to-buffer-other-window'.  Otherwise, don't remap."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-remap-switch-to-buffer-other-frame nil

  "Non-nil means remap `switch-to-buffer-other-frame' to

`wg-switch-to-buffer-other-frame'.  Otherwise, don't remap."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-remap-kill-buffer nil

  "Non-nil means remap `kill-buffer' to `wg-kill-buffer'.

Otherwise, don't remap."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-remap-display-buffer nil

  "Non-nil means remap `display-buffer' to `wg-display-buffer'.

Otherwise, don't remap."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-remap-insert-buffer nil

  "Non-nil means remap `insert-buffer' to `wg-insert-buffer'.

Otherwise, don't remap."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-remap-next-buffer nil

  "Non-nil means remap `next-buffer' to `wg-next-buffer'.

Otherwise, don't remap."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-remap-previous-buffer nil

  "Non-nil means remap `previous-buffer' to `wg-previous-buffer'.

Otherwise, don't remap."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-remap-bury-buffer 'bury

  "Non-nil means remap `bury-buffer'.

`banish' means remap `bury-buffer' to `wg-banish-buffer'.

`bury' or other non-nil means remap `bury-buffer' to

`wg-bury-buffer'.  Otherwise, don't remap."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-ido-entry-buffer-replacement-regexp "^ .*Minibuf.*$"

  "Regexp matching the name of a buffer to replace `ido-entry-buffer'.

The regexp should match the name of a live buffer that will never

be a completion candidate under normal circumstances.  You

probably don't want to change this.  See

`wg-get-sneaky-ido-entry-buffer-replacement'."

  :type 'regexp

  :group 'workgroups)

;; morph customization

(defcustom wg-morph-on nil

  "Non-nil means use `wg-morph' when restoring wconfigs."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-morph-hsteps 9

  "Columns/iteration to step window edges during `wg-morph'.

Values lower than 1 are invalid."

  :type 'integer

  :group 'workgroups)

(defcustom wg-morph-vsteps 3

  "Rows/iteration to step window edges during `wg-morph'.

Values lower than 1 are invalid."

  :type 'integer

  :group 'workgroups)

(defcustom wg-morph-terminal-hsteps 3

  "Used instead of `wg-morph-hsteps' in terminal frames.

If nil, `wg-morph-hsteps' is used."

  :type 'integer

  :group 'workgroups)

(defcustom wg-morph-terminal-vsteps 1

  "Used instead of `wg-morph-vsteps' in terminal frames.

If nil, `wg-morph-vsteps' is used."

  :type 'integer

  :group 'workgroups)

(defcustom wg-morph-truncate-partial-width-windows t

  "Bound to `truncate-partial-width-windows' during `wg-morph'.

Non-nil, this prevents weird-looking continuation line behavior,

and can speed up morphing a little.  Lines jump back to their

wrapped status when `wg-morph' is complete."

  :type 'boolean

  :group 'workgroups)

;; mode-line customization

(defcustom wg-mode-line-display-on t

  "Toggles Workgroups' mode-line display."

  :type 'boolean

  :group 'workgroups

  :set (lambda (sym val)

         (custom-set-default sym val)

         (force-mode-line-update)))

(defcustom wg-mode-line-use-faces nil

  "Non-nil means use faces in the mode-line display.

It can be tricky to choose faces that are visible in both active

and inactive mode-lines, so this feature defaults to off."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-mode-line-only-name t

  "Display only workgroup name in modeline without any flags."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-mode-line-decor-left-brace "("

  "String displayed at the left of the mode-line display."

  :type 'string

  :group 'workgroups)

(defcustom wg-mode-line-decor-right-brace ")"

  "String displayed at the right of the mode-line display."

  :type 'string

  :group 'workgroups)

(defcustom wg-mode-line-decor-divider ":"

  "String displayed between elements of the mode-line display."

  :type 'string

  :group 'workgroups)

(defcustom wg-mode-line-decor-strongly-associated

  #("@" 0 1 (help-echo "This buffer is strongly associated with the \

current workgroup"))

  "Indicates that a buffer is strongly associated with the current workgroup."

  :type 'string

  :group 'workgroups)

(defcustom wg-mode-line-decor-weakly-associated

  #("~" 0 1 (help-echo "This buffer is weakly associated with the \

current workgroup"))

  "Indicates that a buffer is weakly associated with the current workgroup."

  :type 'string

  :group 'workgroups)

(defcustom wg-mode-line-decor-unassociated

  #("-" 0 1 (help-echo "This buffer is unassociated with the \

current workgroup"))

  "Indicates that a buffer is unassociated with the current workgroup."

  :type 'string

  :group 'workgroups)

(defcustom wg-mode-line-decor-window-dedicated

  #("#" 0 1 (help-echo "This window is dedicated to its buffer."))

  "Indicates that the window is dedicated to its buffer."

  :type 'string

  :group 'workgroups)

(defcustom wg-mode-line-decor-window-undedicated

  #("-" 0 1 (help-echo "This window is not dedicated to its buffer."))

  "Indicates that the window is not dedicated to its buffer."

  :type 'string

  :group 'workgroups)

(defcustom wg-mode-line-decor-session-modified

  #("*" 0 1 (help-echo "The session is modified"))

  "Indicates that the session is modified."

  :type 'string

  :group 'workgroups)

(defcustom wg-mode-line-decor-session-unmodified

  #("-" 0 1 (help-echo "The session is unmodified"))

  "Indicates that the session is unmodified."

  :type 'string

  :group 'workgroups)

(defcustom wg-mode-line-decor-workgroup-modified

  #("*" 0 1 (help-echo "The current workgroup is modified"))

  "Indicates that the current workgroup is modified."

  :type 'string

  :group 'workgroups)

(defcustom wg-mode-line-decor-workgroup-unmodified

  #("-" 0 1 (help-echo "The current workgroup is unmodified"))

  "Indicates that the current workgroup is unmodified."

  :type 'string

  :group 'workgroups)

;; display customization

(defcustom wg-use-faces t

  "Non-nil means use faces in various displays."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-time-format "%H:%M:%S %A, %B %d %Y"

  "Format string for time display.  Passed to `format-time-string'."

  :type 'string

  :group 'workgroups)

(defcustom wg-display-battery t

  "Non-nil means include `battery', when available, in the time display."

  :type 'boolean

  :group 'workgroups)

(defcustom wg-list-display-decor-left-brace "( "

  "String displayed to the left of the list display."

  :type 'string

  :group 'workgroups)

(defcustom wg-list-display-decor-right-brace " )"

  "String displayed to the right of the list display."

  :type 'string

  :group 'workgroups)

(defcustom wg-list-display-decor-divider " | "

  "String displayed between elements of the list display."

  :type 'string

  :group 'workgroups)

(defcustom wg-list-display-decor-current-left "-<{ "

  "String displayed to the left of the current element of the list display."

  :type 'string

  :group 'workgroups)

(defcustom wg-list-display-decor-current-right " }>-"

  "String displayed to the right of the current element of the list display."

  :type 'string

  :group 'workgroups)

(defcustom wg-list-display-decor-previous-left "< "

  "String displayed to the left of the previous element of the list display."

  :type 'string

  :group 'workgroups)

(defcustom wg-list-display-decor-previous-right " >"

  "String displayed to the right of the previous element of the list display."

  :type 'string

  :group 'workgroups)

(defcustom wg-associate-buffers t

  "Non-nil means when emacs chooses a buffer to display in a

workgroup, prefer buffers whose most recent appearance was in

that workgroup."

  :type 'boolean

  :group 'workgroups)

;;; vars

(defvar workgroups-mode-map nil

  "Workgroups Mode's keymap")

(defvar wg-current-session nil

  "Current session object.")

(defvar wg-workgroups-mode-minor-mode-map-entry nil

  "Workgroups' minor-mode-map entry.")

(defvar wg-wconfig-kill-ring nil

  "Ring of killed or kill-ring-saved wconfigs.")

(defvar wg-last-message nil

  "Holds the last message Workgroups sent to the echo area.")

(defvar wg-face-abbrevs nil

  "Assoc list mapping face abbreviations to face names.")

(defvar wg-buffer-uid nil

  "Symbol for the current buffer's wg-buf's uid.

Every Workgroups buffer object (wg-buf) has a uid.  When

Workgroups creates or encounters an Emacs buffer object

corresponding to a wg-buf, it tags it with the wg-buf's uid to

unambiguously pair the two.")

(make-variable-buffer-local 'wg-buffer-uid)

;; file and modified flag vars

(defvar wg-flag-modified t

  "Dynamically bound to nil around destructive operations to

temporarily disable flagging `modified'.")

;; undo vars

(defvar wg-window-configuration-changed nil

  "Flag set by `window-configuration-change-hook'.")

(defvar wg-already-updated-working-wconfig nil

  "Flag set by `wg-update-working-wconfig-hook'.")

(defvar wg-undoify-window-configuration-change t

  "Flag unset when changes to the window config shouldn't cause

workgroups' undo info to be updated.")

(defvar wg-just-exited-minibuffer nil

  "Flag set by `minibuffer-exit-hook' to exempt from

undoification those window-configuration changes caused by

exiting the minibuffer.  This is ugly, but necessary.  It may

seem like we could just null out

`wg-undoify-window-configuration-change' in

`minibuffer-exit-hook', but that also prevents undoification of