;; `wg-pre-window-configuration-change-hook' implementation advice

             (fn)

             `(defadvice ,fn (before wg-pre-window-configuration-change-hook)

                "Call `wg-update-working-wconfig-hook' before this

  (wg-when-let

      ((mode (wg-read-buffer-mode))

       (buffer (wg-current-match mode))

    (wg-workgroup-dissociate-bufobj (wg-current-workgroup) buffer)

    (wg-set-current-matches

     (wg-rotate-list (wg-filtered-buffer-list t) pos) mode)))

  (wg-when-let

      ((mode (wg-read-buffer-mode))

       (buffer (wg-current-match mode))

    (wg-workgroup-associate-bufobj (wg-current-workgroup) buffer)

    (wg-set-current-matches

     (wg-rotate-list (wg-filtered-buffer-list t) pos) mode)))

  (wg-workgroup-dissociate-weakly-associated-buffers (wg-current-workgroup))

  (wg-set-current-matches

   (let ((remaining (wg-filtered-buffer-list t)))

(provide 'workgroups-commands-minibuffer)

;;; workgroups-commands-minibuffer.el ends here

;;; Commentary:

;;; Code:

(require 'ring)

(require 'workgroups-variables)

(require 'workgroups-utils-basic)

    (wg-switch-to-workgroup

     (or (nth index wl) (error "There are only %d workgroups" (length wl))))))

    ((define-range-of-switch-to-workgroup-at-index (num)

       `(progn

          ,@(wg-docar (i (wg-range 0 num))

    (force-mode-line-update)

    (wg-fontified-message

      (:cur (buffer-name buffer))

              (strong " strongly associated with ")

              (weak " weakly associated with ")

              (otherwise " unassociated with ")))

(defun wg-save-session-on-exit (behavior)

  "Perform session-saving operations based on BEHAVIOR."

    (ask (wg-query-and-save-if-modified))

    (save

     (if (wg-determine-session-save-file-name)

;;; Commentary:

;;; Code:

(require 'workgroups-compat)

(require 'workgroups-variables)

(require 'workgroups-utils-basic)

(defun wg-modified-p ()

  "Return t when the current session or any of its workgroups are modified."

  (or (wg-session-modified (wg-current-session))

(defun wg-mark-everything-unmodified ()

  "Mark the session and all workgroups as unmodified."

SESSION nil defaults to the current session.  If VARIABLE does

not have a session-local binding in SESSION, the value is

resolved by Emacs."

         (value (wg-session-parameter session variable undefined)))

    (if (not (eq value undefined)) value

      (symbol-value variable))))

(defun wg-bufobj-uid (bufobj)

  "Return BUFOBJ's uid."

    (buffer (wg-buffer-uid bufobj))

    (wg-buf (wg-buf-uid bufobj))

    (string (wg-bufobj-uid (wg-get-buffer bufobj)))))

(defun wg-bufobj-name (bufobj)

  "Return BUFOBJ's buffer name."

    (buffer (buffer-name bufobj))

    (wg-buf (wg-buf-name bufobj))

    (string (wg-buffer-name bufobj))))

(defun wg-bufobj-file-name (bufobj)

  "Return BUFOBJ's filename."

    (buffer (buffer-file-name bufobj))

    (wg-buf (wg-buf-file-name bufobj))

    (string (wg-bufobj-file-name (wg-get-buffer bufobj)))))

(defun wg-bufobj-major-mode (bufobj)

  "Return BUFOBJ's major-mode."

    (buffer (wg-buffer-major-mode bufobj))

    (wg-buf (wg-buf-major-mode bufobj))

    (string (wg-buffer-major-mode bufobj))))

(defun wg-find-bufobj (bufobj bufobj-list)

  "Find BUFOBJ in BUFOBJ-LIST, testing with `wg-equal-bufobjs'."

(defun wg-find-bufobj-by-uid (uid bufobj-list)

  "Find the bufobj in BUFOBJ-LIST with uid UID."

(defun wg-find-buf-in-buf-list (buf buf-list)

  "Find BUF in BUF-LIST.

This is only here for completeness."

(defun wg-find-buffer-in-buffer-list (buffer-or-name buffer-list)

  "Find BUFFER-OR-NAME in BUFFER-LIST."

(defun wg-find-buffer-in-buf-list (buffer-or-name buf-list)

  "Find BUFFER-OR-NAME in BUF-LIST."

(defun wg-buffer-special-data (buffer)

  "Return BUFFER's auxiliary serialization, or nil."

(defun wg-window-point (ewin)

  "Return `point' or :max.  See `wg-restore-point-max'.

(defun wg-bufobj-uid-or-add (bufobj)

  "If BUFOBJ is a wg-buf, return its uid.

If BUFOBJ is a buffer or a buffer name, see `wg-buffer-uid-or-add'."

    (wg-buf (wg-buf-uid bufobj)) ;; possibly also add to `wg-buf-list'

    (buffer (wg-buffer-uid-or-add bufobj))

    (string (wg-bufobj-uid-or-add (wg-get-buffer bufobj)))))

(defun wg-w-edges (w)

  "Return W's edge list."

    (wg-win (wg-win-edges w))

    (wg-wtree (wg-wtree-edges w))))

(defun wg-copy-w (w)

  "Return a copy of W.  W should be a wg-win or a wg-wtree."

    (wg-win (wg-copy-win w))

    (wg-wtree (wg-copy-wtree w))))

(defun wg-set-edges (w edges)

  "Set W's edge list, and return W."

    (wg-win (setf (wg-win-edges w) edges))

    (wg-wtree (setf (wg-wtree-edges w) edges)))

  w)

(defun wg-w-edge-operation (w edges op)

  "Return a copy of W with its edges mapped against EDGES through OP."

(defun wg-first-win (w)

  "Return the first actual window in W."

        ((and (wg-wtree-p w1) (wg-wtree-p w2))

         (and (eq (wg-wtree-dir w1) (wg-wtree-dir w2))

              (equal (wg-wtree-edges w1) (wg-wtree-edges w2))

                     (wg-wtree-wlist w1)

                     (wg-wtree-wlist w2))))))

                      (wg-make-wtree

                       :dir (wg-wtree-dir w)

                       :edges (wg-wtree-edges w)

                                  (wg-cyclic-offset-elt it wlist offset)

                                (mapcar #'inner wlist)))))))

    (wg-normalize-wtree (inner wtree))))

KEY non-nil returns a list of the results of calling KEY on each win."

  (dflet

      ((inner (w) (if (wg-win-p w) (list (if key (funcall key w) w))

    (inner wtree)))

(defun wg-win-list (wtree)

(defun wg-find-workgroup-by (slotkey value &optional noerror)

  "Return the workgroup on which ACCESSOR returns VALUE or error."

                    (:name 'wg-workgroup-name)

                    (:uid  'wg-workgroup-uid))))

        (unless noerror

          (error "No are no workgroups with a %S of %S"

                 accessor value)))))

binding in WORKGROUP, resolve VARIABLE with `wg-session-local-value'."

  (let ((workgroup (wg-get-workgroup workgroup t)))

    (if (not workgroup) (wg-session-local-value variable)

             (value (wg-workgroup-parameter workgroup variable undefined)))

        (if (not (eq value undefined)) value

          (wg-session-local-value variable))))))

(defun wg-workgroup-associated-buffers (workgroup &optional initial names)

  "Return a list of WORKGROUP's live associated buffers."

  (let ((assoc-bufs (wg-workgroup-associated-bufs workgroup)))

     (lambda (buffer) (wg-find-buffer-in-buf-list buffer assoc-bufs))

     (or initial (buffer-list)))))

If it's strongly associated with the workgroup, weakly associate it.

If it's weakly associated with the workgroup, dissociate it.

If it's unassociated with the workgroup, mark it as strongly associated."

    (strong (wg-workgroup-weakly-associate-bufobj workgroup bufobj) 'weak)

    (weak (wg-workgroup-dissociate-bufobj workgroup bufobj) nil)

    (otherwise (wg-workgroup-strongly-associate-bufobj workgroup bufobj) 'strong)))

  "Return ID's KEY's value in `wg-buffer-list-filter-definitions'.

Lots of possible errors here because

`wg-buffer-list-filter-definitions' can be modified by the user."

    (if (not slot-num)

        (unless noerror

          (error "`%S' is not a valid buffer-list-filter definition slot" key))

(defun wg-buffer-list-filter-unassociated (workgroup initial)

  "Return only those buffer unassociated with WORKGROUP."

  (let ((buffers (wg-workgroup-associated-buffers workgroup initial)))

;; buffer-list filtration utils

(defun wg-filter-buffer-list-by-regexp (regexp buffer-list)

  "Return only those buffers in BUFFER-LIST with names matching REGEXP."

                 buffer-list :key 'buffer-name))

(defun wg-filter-buffer-list-by-root-dir (root-dir buffer-list)

  "Return only those buffers in BUFFER-LIST visiting files undo ROOT-DIR."

                 buffer-list :key 'buffer-file-name))

(defun wg-filter-buffer-list-by-major-mode (major-mode buffer-list)

  "Return only those buffers in BUFFER-LIST in major-mode MAJOR-MODE."

                 buffer-list :key 'wg-buffer-major-mode))

         (while 'your-mom

           (let* ((wg-current-buffer-list-filter-id (car ,order))

                  (,status (catch 'wg-action (list 'done (progn ,@body)))))

               (done (throw 'wg-result (cadr ,status)))

               (next (setq ,order (wg-rotate-list ,order 1))

                     (setq wg-previous-minibuffer-contents (cadr ,status)))

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

Otherwise return nil."

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

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

                    :key 'wg-wconfig-name

                    :test 'string=)))))

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

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

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

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

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

(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-workgroup-weak-buf-uids workgroup)

(defun wg-gc-buf-uids ()

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

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

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

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

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

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

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

          (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-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."

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

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

                (if wg-restore-associated-buffers

(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-session-workgroup-list (or session (wg-current-session)))

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

(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-buffer-list-all-uids buffer-list)

         :test 'string=))

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

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

    (wg-asetf (wg-buf-list)

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

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

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

nil otherwise."

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

                                :test 'string=)))

              (wg-workgroup-list))

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

    (wg-delete-workgroup it))

  (wg-asetf (wg-workgroup-list)

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

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

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

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

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

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

  (unless (or (assq 'wg-mode-line-display-on mode-line-format)

              wg-mode-line-disable)

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

;;     (wg-fontify

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

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

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

(defcustom wg-display-max-lines 1

          (wg-fontify

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

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

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

    ;; (subseq str 0 wwidth)

    ))

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

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

    (while (not result)

        (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-workgroup-names t)))

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

;;; Code:

(require 'workgroups-variables)

(defun wg-read-buffer-mode ()

  "Return the buffer switching package (ido or iswitchb) to use, or nil."

  (if (eq wg-current-buffer-list-filter-id 'fallback) 'fallback

      (ido-switch-buffer 'ido)

      (iswitchb-buffer 'iswitchb)

      (otherwise 'fallback))))

(defun wg-read-buffer-function (&optional mode)

  "Return MODE's or `wg-read-buffer-mode's `read-buffer' function."

    (ido 'ido-read-buffer)

    (iswitchb 'iswitchb-read-buffer)

    (fallback (lambda (prompt &optional default require-match)

(defun wg-completing-read

  (prompt choices &optional pred require-match initial-input history default)

  "Do a completing read.  The function called depends on what's on."

    (ido

     (ido-completing-read prompt choices pred require-match

                          initial-input history default))

(defun wg-current-matches (&optional read-buffer-mode)

  "Return READ-BUFFER-MODE's current matches."

    (ido (wg-when-boundp (ido-cur-list) ido-cur-list))

    (iswitchb (wg-when-boundp (iswitchb-buflist) iswitchb-buflist))

    (fallback (list minibuffer-default))))

(defun wg-set-current-matches (match-list &optional read-buffer-mode)

  "Set READ-BUFFER-MODE's current matches, and flag a rescan."

    (ido

     (wg-when-boundp (ido-cur-list)

       (setq ido-cur-list match-list ido-rescan t)))

      (call-interactively (wg-prior-mapping workgroups-mode command))

    (wg-with-buffer-list-filters command

      (let ((wg-buffer-internal-default-buffer default))

          (ido

           (ido-buffer-internal

            (wg-aget wg-ido-method-translations command) nil

;;

;;; Code:

(require 'workgroups-compat)

(require 'workgroups-utils-basic)

  (unless (memq (type-of obj) wg-pickel-pickelable-types)

    (signal 'wg-pickel-unpickelable-type-error

            (format "Can't pickel objects of type: %S" (type-of obj))))

    (cons

     (wg-pickelable-or-error (car obj))

     (wg-pickelable-or-error (cdr obj)))

    (vector

    (hash-table

     (wg-dohash (key value obj)

       (wg-pickelable-or-error key)

    (dflet

     ((inner (obj)

           (unless (gethash obj binds)

                (cons

                 (inner (car obj))

                 (inner (cdr obj)))

      (when (wg-session-parameters copy)

        (wg-asetf (wg-session-parameters copy) (wg-pickel copy)))

      (wg-asetf (wg-session-workgroup-list copy)

      copy))

  (defun wg-unpickel-session-parameters (session)

      (when (wg-session-parameters copy)

        (wg-asetf (wg-session-parameters copy) (wg-unpickel copy)))

      (wg-asetf (wg-session-workgroup-list copy)

      copy))

(provide 'workgroups-pickel)

(defun wg-restore-window-tree-helper (w)

  "Recursion helper for `wg-restore-window-tree'."

  (if (wg-wtree-p w)

    (wg-restore-window w)

    (when (wg-win-selected w)

      (setq wg-window-tree-selected-window (selected-window)))

;;

;;; Code:

(require 'workgroups-variables)

(require 'workgroups-support-macro)

(defun wg-deserialize-buffer-local-variables (buf)

  "Restore BUF's buffer local variables in `current-buffer'."

(provide 'workgroups-specialbufs)

;;; workgroups-specialbufs.el ends here

;;

;;; Code:

(require 'workgroups-compat)

;;; utils used in macros

(defmacro wg-with-gensyms (syms &rest body)

  "Bind all symbols in SYMS to `gensym's, and eval BODY."

  (declare (indent 1))

(defmacro wg-dbind (args expr &rest body)

  "Bind the variables in ARGS to the result of EXPR and execute BODY.

Abbreviation of `destructuring-bind'."

  (declare (indent 2))

(defun wg-partition (list &optional n step)

  "Return list of N-length sublists of LIST, offset by STEP.

(defmacro wg-eager-or (&rest conditions)

  "Evaluate all CONDITIONS.  Return the first non-nil return value."

       (or ,@syms))))

(defmacro wg-eager-and (&rest conditions)

  "Evaluate all conditions.  If any return nil, return nil.

Otherwise return the return value of the last condition."

       (and ,@syms))))

                      (setq i (/ i base))))

      (add-digit)

      (while (> i 0) (add-digit))

      (if (not length) b36

        (concat (make-string (max 0 (- length (length b36))) ?0) b36)))))

  "If ITEM is a `member*' of SEQ-PLACE, remove it from SEQ-PLACE and return t.

Otherwise return nil.  KEYS can be any keywords accepted by `remove*'."

  `(> (length ,seq-place)

(defmacro wg-pushnew-p (item seq-place &rest keys)

  "If ITEM is not a `member' of SEQ-PLACE, push it to SEQ-PLACE and return t.

Otherwise return nil.  KEYS can be any keyword args accepted by `pushnew'."

  `(< (length ,seq-place)

(defun wg-last1 (list)

  "Return the last element of LIST."

(defun wg-insert-after (elt list index)

  "Insert ELT into LIST after INDEX."

    (push elt (cdr (nthcdr index new-list)))

    new-list))

(defun wg-move-elt (elt list index &rest keys)

  "Move ELT before INDEX in LIST.

KEYS is passed to `remove*'."

(defun wg-cyclic-nth (list n)

  "Return the Nth element of LIST, modded by the length of list."

(defun wg-cyclic-offset-elt (elt list n)

  "Cyclically offset ELT's position in LIST by N."

    (wg-move-elt elt list (mod (+ n pos) (length list)))))

(defun wg-cyclic-nth-from-elt (elt list n &rest keys)

  "Return the elt in LIST N places cyclically from ELT.

If ELT is not present is LIST, return nil.

KEYS is passed to `position'."

    (wg-cyclic-nth list (+ pos n))))

(defun wg-util-swap (elt1 elt2 list)

  "Return a copy of LIST with ELT1 and ELT2 swapped.

Return nil when ELT1 and ELT2 aren't both present."

    (wg-move-elt elt1 (wg-move-elt elt2 list p1) p2)))

(defun wg-dups-p (list &rest keys)

\(fn LIST [KEYWORD VALUE]...)"

  (let ((test (or (plist-get keys :test) 'eq))

        (key (or (plist-get keys :key) 'identity)))

(defun wg-string-list-union (&optional list1 list2)

  "Return the `union' of LIST1 and LIST2, using `string=' as the test.

This only exists to get rid of duplicate lambdas in a few reductions."

(defun wg-interesting-buffers ()

  "Return a list of only the interesting buffers in `buffer-list'."

(defun wg-get-first-buffer-matching-regexp (regexp &optional buffer-list)

  "Return the first buffer in BUFFER-LIST with a name matching REGEXP.

BUFFER-LIST should contain buffer objects and/or buffer names."

      ;; too, but it annoyingly requires inclusion of the function's arglist,

      ;; which gets ugly.

      `(eval-and-compile

                       `(,prefixed-name ,@(cdr name-form)))

           ,@slot-defs)

         ,@(rebind "make")

  "Return a copy of STRING fontified according to FACEKEY.

FACEKEY must be a key in `wg-face-abbrevs'."

  (let ((face (wg-aget wg-face-abbrevs facekey))

    (unless face (error "No face with key %s" facekey))

    (if (not wg-use-faces) string

      (put-text-property 0 (length string) 'face face string)

(defun wg-b36-to-time (b36)

  "Parse the time from UID."

(defalias 'wg-uid-to-time 'wg-b36-to-time)

  "`defface' wrapper adding a lookup key used by `wg-fontify'."

  (declare (indent 2))

  `(progn

     (defface ,face ,spec ,doc ,@args)))

(wg-defface wg-current-workgroup-face :cur

;;

;;; Code:

(require 'workgroups-compat)

(require 'workgroups-utils-basic)

(require 'workgroups-pickel)