(defun wg-window-tree-to-wtree (window-tree)

  "Return the serialization (a wg-wtree) of Emacs window tree WINDOW-TREE."

  (wg-barf-on-active-minibuffer)

  (cl-labels

      ((inner (w) (if (windowp w) (wg-window-to-win w)

                    (wg-dbind (dir edges . wins) w

                      (wg-make-wtree

                       :dir    dir

                       :edges  edges

                       :wlist  (mapcar #'inner wins))))))

    (let ((w (car window-tree)))

      (when (and (windowp w) (window-minibuffer-p w))

        (error "Workgroups can't operate on minibuffer-only frames."))

      (inner w))))

(defun wg-frame-to-wconfig (&optional frame)

  "Return the serialization (a wg-wconfig) of Emacs frame FRAME.

FRAME nil defaults to `selected-frame'."

  (let* ((frame (or frame (selected-frame)))

         (fullscrn (frame-parameter frame 'fullscreen)))

    (wg-make-wconfig

     :left                  (frame-parameter frame 'left)

     :top                   (frame-parameter frame 'top)

     :width                 (frame-parameter frame 'width)

     :height                (frame-parameter frame 'height)

     :parameters            `((fullscreen . ,fullscrn))

     :vertical-scroll-bars  (frame-parameter frame 'vertical-scroll-bars)

     :scroll-bar-width      (frame-parameter frame 'scroll-bar-width)

     :wtree                 (wg-window-tree-to-wtree (window-tree frame))

     )))

(defun wg-current-wconfig ()

  "Return the current wconfig.

If `wg-current-wconfig' is non-nil, return it.  Otherwise return

`wg-frame-to-wconfig'."

  (or (frame-parameter nil 'wg-current-wconfig)

      (wg-frame-to-wconfig)))

(defmacro wg-with-current-wconfig (frame wconfig &rest body)

  "Eval BODY with WCONFIG current in FRAME.

FRAME nil defaults to `selected-frame'."

  (declare (indent 2))

  (wg-with-gensyms (frame-sym old-value)

    `(let* ((,frame-sym (or ,frame (selected-frame)))

            (,old-value (frame-parameter ,frame-sym 'wg-current-wconfig)))

       (unwind-protect

           (progn

             (set-frame-parameter ,frame-sym 'wg-current-wconfig ,wconfig)

             ,@body)

         (when (frame-live-p ,frame-sym)

           (set-frame-parameter ,frame-sym 'wg-current-wconfig ,old-value))))))

(defun wg-make-blank-wconfig (&optional buffer)

  "Return a new blank wconfig.

BUFFER or `wg-default-buffer' is visible in the only window."

  (save-window-excursion

    (delete-other-windows)

    (switch-to-buffer (or buffer wg-default-buffer))

    (wg-frame-to-wconfig)))

;;; win/wtree/wconfig utils

(defun wg-w-edges (w)

  "Return W's edge list."

  (cl-etypecase w

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

  (cl-etypecase w

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

  (cl-etypecase w

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

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

  w)

(defun wg-min-size (dir)

  "Return the minimum window size in split direction DIR."

  (if dir wg-window-min-height wg-window-min-width))

(defun wg-actual-min-size (dir)

  "Return the actual minimum window size in split direction DIR."

  (if dir wg-actual-min-height wg-actual-min-width))

(defmacro wg-with-edges (w spec &rest body)

  "Bind W's edge list to SPEC and eval BODY."

  (declare (indent 2))

  `(wg-dbind ,spec (wg-w-edges ,w) ,@body))

(defmacro wg-with-bounds (wtree dir spec &rest body)

  "Bind SPEC to W's bounds in DIR, and eval BODY.

\"bounds\" are a direction-independent way of dealing with edge lists."

  (declare (indent 3))

  (wg-with-gensyms (dir-sym l1 t1 r1 b1)

    (wg-dbind (ls1 hs1 lb1 hb1) spec

      `(wg-with-edges ,wtree (,l1 ,t1 ,r1 ,b1)

         (cond (,dir (let ((,ls1 ,l1) (,hs1 ,r1) (,lb1 ,t1) (,hb1 ,b1))

                       ,@body))

               (t    (let ((,ls1 ,t1) (,hs1 ,b1) (,lb1 ,l1) (,hb1 ,r1))

                       ,@body)))))))

(defun wg-set-bounds (w dir ls hs lb hb)

  "Set W's edges in DIR with bounds LS HS LB and HB."

  (wg-set-edges w (if dir (list ls lb hs hb) (list lb ls hb hs))))

(defun wg-step-edges (edges1 edges2 hstep vstep)

  "Return W1's edges stepped once toward W2's by HSTEP and VSTEP."

  (wg-dbind (l1 t1 r1 b1) edges1

    (wg-dbind (l2 t2 r2 b2) edges2

      (let ((left (wg-step-to l1 l2 hstep))

            (top  (wg-step-to t1 t2 vstep)))

        (list left top

              (+ left (wg-step-to (- r1 l1) (- r2 l2) hstep))

              (+ top  (wg-step-to (- b1 t1) (- b2 t2) vstep)))))))

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

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

  (wg-set-edges w (cl-mapcar op (wg-w-edges w) edges)))

(defun wg-first-win (w)

  "Return the first actual window in W."

  (if (wg-win-p w) w

    (wg-first-win (car (wg-wtree-wlist w)))))

(defun wg-last-win (w)

  "Return the last actual window in W."

  (if (wg-win-p w) w

    (wg-last-win (wg-last1 (wg-wtree-wlist w)))))

(defun wg-minify-win (w)

  "Set W's edges to the smallest allowable."

  (let* ((edges (wg-w-edges w))

         (left (car edges))

         (top (cadr edges)))

    (wg-set-edges w (list left top

                          (+ left wg-actual-min-width)

                          (+ top  wg-actual-min-height)))))

(defun wg-minified-copy-of-last-win (w)

  "Minify a copy of the last actual window in W."

  (wg-minify-win (wg-copy-win (wg-last-win w))))

(defun wg-w-size (w &optional height)

  "Return the width or height of W, calculated from its edge list."

  (wg-with-edges w (l1 t1 r1 b1)

    (if height (- b1 t1) (- r1 l1))))

(defun wg-adjust-w-size (w width-fn height-fn &optional new-left new-top)

  "Adjust W's width and height with WIDTH-FN and HEIGHT-FN."

  (wg-with-edges w (left top right bottom)

    (let ((left (or new-left left)) (top (or new-top top)))

      (wg-set-edges (wg-copy-w w)

                    (list left

                          top

                          (+ left (funcall width-fn  (- right  left)))

                          (+ top  (funcall height-fn (- bottom top))))))))

(defun wg-scale-w-size (w width-scale height-scale)

  "Scale W's size by WIDTH-SCALE and HEIGHT-SCALE."

  (cl-labels

      ((wscale (width)  (truncate (* width  width-scale)))

       (hscale (height) (truncate (* height height-scale))))

    (wg-adjust-w-size w #'wscale #'hscale)))

(defun wg-equal-wtrees (w1 w2)

  "Return t when W1 and W2 have equal structure."

  (cond ((and (wg-win-p w1) (wg-win-p w2))

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

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

              (cl-every #'wg-equal-wtrees

                     (wg-wtree-wlist w1)

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

(defun wg-normalize-wtree (wtree)

  "Clean up and return a new wtree from WTREE.

Recalculate the edge lists of all subwins, and remove subwins

outside of WTREE's bounds.  If there's only one element in the

new wlist, return it instead of a new wtree."

  (if (wg-win-p wtree) wtree

    (wg-with-slots wtree ((dir wg-wtree-dir)

                          (wlist wg-wtree-wlist))

      (wg-with-bounds wtree dir (ls1 hs1 lb1 hb1)

        (let* ((min-size (wg-min-size dir))

               (max (- hb1 1 min-size))

               (lastw (wg-last1 wlist)))

          (cl-labels

              ((mapwl

                (wl)

                (wg-dbind (sw . rest) wl

                  (cons (wg-normalize-wtree

                         (wg-set-bounds

                          sw dir ls1 hs1 lb1

                          (setq lb1 (if (eq sw lastw) hb1

                                      (let ((hb2 (+ lb1 (wg-w-size sw dir))))

                                        (if (>= hb2 max) hb1 hb2))))))

                        (when (< lb1 max) (mapwl rest))))))

            (let ((new (mapwl wlist)))

              (if (not (cdr new)) (car new)

                (setf (wg-wtree-wlist wtree) new)

                wtree))))))))

(defun wg-scale-wtree (wtree wscale hscale)

  "Return a copy of WTREE with its dimensions scaled by WSCALE and HSCALE.

All WTREE's subwins are scaled as well."

  (let ((scaled (wg-scale-w-size wtree wscale hscale)))

    (if (wg-win-p wtree) scaled

      (wg-asetf (wg-wtree-wlist scaled)

                (wg-docar (sw it) (wg-scale-wtree sw wscale hscale)))

      scaled)))

(defun wg-scale-wconfigs-wtree (wconfig new-width new-height)

  "Scale WCONFIG's wtree with NEW-WIDTH and NEW-HEIGHT.

Return a copy WCONFIG's wtree scaled with `wg-scale-wtree' by the

ratio or NEW-WIDTH to WCONFIG's width, and NEW-HEIGHT to

WCONFIG's height."

  (wg-normalize-wtree

   (wg-scale-wtree

    (wg-wconfig-wtree wconfig)

    (/ (float new-width)  (wg-wconfig-width wconfig))

    (/ (float new-height) (wg-wconfig-height wconfig)))))

;; (wg-wconfig-width (wg-current-wconfig))

(defun wg-resize-frame-scale-wtree (wconfig)

  "Set FRAME's size to WCONFIG's, returning a possibly scaled wtree.

If the frame size was set correctly, return WCONFIG's wtree

unchanged.  If it wasn't, return a copy of WCONFIG's wtree scaled

with `wg-scale-wconfigs-wtree' to fit the frame as it exists."

  (let ((frame (selected-frame)))

    (wg-with-slots wconfig ((wcwidth wg-wconfig-width)

                            (wcheight wg-wconfig-height))

      (when window-system (set-frame-size frame wcwidth wcheight))

      (let ((fwidth  (frame-parameter frame 'width))

            (fheight (frame-parameter frame 'height)))

        (if (and (= wcwidth fwidth) (= wcheight fheight))

            (wg-wconfig-wtree wconfig)

          (wg-scale-wconfigs-wtree wconfig fwidth fheight))))))

(defun wg-reverse-wlist (w &optional dir)

  "Reverse W's wlist and those of all its sub-wtrees in direction DIR.

If DIR is nil, reverse WTREE horizontally.

If DIR is 'both, reverse WTREE both horizontally and vertically.

Otherwise, reverse WTREE vertically."

  (cl-labels

      ((inner (w) (if (wg-win-p w) w

                    (wg-with-slots w ((d1 wg-wtree-dir))

                      (wg-make-wtree

                       :dir d1

                       :edges (wg-wtree-edges w)

                       :wlist (let ((wl2 (mapcar #'inner (wg-wtree-wlist w))))

                                (if (or (eq dir 'both) (eq dir d1))

                                    (nreverse wl2)

                                  wl2)))))))

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

(defun wg-wtree-move-window (wtree offset)

  "Offset `selected-window' OFFSET places in WTREE."

  (cl-labels

      ((inner (w) (if (wg-win-p w) w

                    (wg-with-slots w ((wlist wg-wtree-wlist))

                      (wg-make-wtree

                       :dir (wg-wtree-dir w)

                       :edges (wg-wtree-edges w)

                       :wlist (wg-aif (cl-find t wlist :key 'wg-win-selected)

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

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

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

(defun wg-reverse-wconfig (wconfig &optional dir)

  "Reverse WCONFIG's wtree's wlist in direction DIR."

  (wg-asetf (wg-wconfig-wtree wconfig) (wg-reverse-wlist it dir))

  wconfig)

(defun wg-wconfig-move-window (wconfig offset)

  "Offset `selected-window' OFFSET places in WCONFIG."

  (wg-asetf (wg-wconfig-wtree wconfig) (wg-wtree-move-window it offset))

  wconfig)

(defun wg-flatten-wtree (wtree &optional key)

  "Return a new list by flattening WTREE.

KEY non returns returns a list of WTREE's wins.

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

  (cl-labels

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

                    (cl-mapcan #'inner (wg-wtree-wlist w)))))

    (inner wtree)))

(defun wg-win-list (wtree)

  "Construct and return a list of all wg-wins in WTREE."

  (wg-flatten-wtree wtree))

(require 'workgroups-specialbufs)

(require 'workgroups-restore)

;;; workgroup utils

(defun wg-flag-workgroup-modified (workgroup)

  "Set WORKGROUP's and the current session's modified flags."

  (when wg-flag-modified

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

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

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

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

  (let ((accessor (cl-ecase slotkey

                    (:name 'wg-workgroup-name)

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

    (or (cl-find value (wg-workgroup-list-or-error noerror) :test 'equal :key accessor)

        (unless noerror

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

                 accessor value)))))

(defun wg-first-workgroup ()

  "Return a first workgroup."

  (interactive)

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

(defun wg-current-workgroup (&optional noerror frame)

  "Return the current workgroup in FRAME, or error unless NOERROR."

  (or wg-current-workgroup

      (wg-aif (frame-parameter frame 'wg-current-workgroup-uid)

          (wg-find-workgroup-by :uid it noerror)

        (unless noerror (error "No current workgroup in this frame")))))

(defun wg-previous-workgroup (&optional noerror frame)

  "Return the previous workgroup in FRAME, or error unless NOERROR."

  (wg-aif (frame-parameter frame 'wg-previous-workgroup-uid)

      (wg-find-workgroup-by :uid it noerror)

    (unless noerror (error "No previous workgroup in this frame"))))

(defun wg-set-current-workgroup (workgroup &optional frame)

  "Set the current workgroup to WORKGROUP.

WORKGROUP should be a workgroup or nil."

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

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

(defun wg-set-previous-workgroup (workgroup &optional frame)

  "Set the previous workgroup to WORKGROUP.

WORKGROUP should be a workgroup or nil."

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

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

(defun wg-current-workgroup-p (workgroup &optional frame)

  "Return t when WORKGROUP is the current workgroup, nil otherwise."

  (wg-awhen (wg-current-workgroup t frame)

    (eq workgroup it)))

(defun wg-previous-workgroup-p (workgroup &optional frame)

  "Return t when WORKGROUP is the previous workgroup, nil otherwise."

  (wg-awhen (wg-previous-workgroup t frame)

    (eq workgroup it)))

(defmacro wg-with-current-workgroup (workgroup &rest body)

  "Execute forms in BODY with WORKGROUP temporarily current.

WORKGROUP should be any workgroup identifier accepted by

`wg-get-workgroup'.  The value returned is the last form

in BODY."

  (declare (indent 1))

  `(let ((wg-current-workgroup (wg-get-workgroup ,workgroup)))

     ,@body))

(defun wg-get-workgroup (obj &optional noerror)

  "Return a workgroup from OBJ.

If OBJ is a workgroup, return it.

If OBJ is a string, return the workgroup named OBJ, or error unless NOERROR.

If OBJ is nil, return the current workgroup, or error unless NOERROR."

  (cond ((wg-workgroup-p obj) obj)

        ((stringp obj) (wg-find-workgroup-by :name obj noerror))

        ((null obj) (wg-current-workgroup noerror))

        (t (error "Can't get workgroup from type:: %S" (type-of obj)))))

;;; workgroup parameters

(defun wg-workgroup-parameter (workgroup parameter &optional default)

  "Return WORKGROUP's value for PARAMETER.

If PARAMETER is not found, return DEFAULT which defaults to nil.

WORKGROUP should be accepted by `wg-get-workgroup'."

  (wg-aget (wg-workgroup-parameters (wg-get-workgroup workgroup))

           parameter default))

(defun wg-set-workgroup-parameter (workgroup parameter value)

  "Set WORKGROUP's value of PARAMETER to VALUE.

WORKGROUP should be a value accepted by `wg-get-workgroup'.

Return VALUE."

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

    (wg-set-parameter (wg-workgroup-parameters workgroup) parameter value)

    (wg-flag-workgroup-modified workgroup)

    value))

(defun wg-remove-workgroup-parameter (workgroup parameter)

  "Remove PARAMETER from WORKGROUP's parameters."

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

    (wg-flag-workgroup-modified workgroup)

    (wg-asetf (wg-workgroup-parameters workgroup) (wg-aremove it parameter))))

(defun wg-workgroup-local-value (variable &optional workgroup)

  "Return the value of VARIABLE in WORKGROUP.

WORKGROUP nil defaults to the current workgroup.  If there is no

current workgroup, or if VARIABLE does not have a workgroup-local

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)

      (let* ((undefined (cl-gensym))

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

        (if (not (eq value undefined)) value

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

(defalias 'wg-local-value 'wg-workgroup-local-value)

;;; workgroup associated buffers

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

  "Return a new list containing all of WORKGROUP's associated buf uids."

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

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

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

  "Return a new list containing all of WORKGROUP's associated bufs."

  (delete nil (mapcar 'wg-find-buf-by-uid

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

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

    (cl-remove-if-not

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

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

(defun wg-workgroup-bufobj-association-type (workgroup bufobj)

  "Return BUFOBJ's association-type in WORKGROUP, or nil if unassociated."

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

    (or (and (member uid (wg-workgroup-strong-buf-uids workgroup)) 'strong)

        (and (member uid (wg-workgroup-weak-buf-uids workgroup)) 'weak))))

(defun wg-workgroup-strongly-associate-bufobj (workgroup bufobj)

  "Strongly associate BUFOBJ with WORKGROUP."

  (let* ((uid (wg-bufobj-uid-or-add bufobj))

         (remp (wg-removef-p uid (wg-workgroup-weak-buf-uids workgroup)

                             :test 'string=))

         (addp (wg-pushnew-p uid (wg-workgroup-strong-buf-uids workgroup)

                             :test 'string=)))

    (when (or remp addp)

      (wg-flag-workgroup-modified workgroup)

      bufobj)))

(defun wg-workgroup-weakly-associate-bufobj (workgroup bufobj)

  "Weakly associate BUFOBJ with WORKGROUP."

  (let* ((uid (wg-bufobj-uid-or-add bufobj))

         (remp (wg-removef-p uid (wg-workgroup-strong-buf-uids workgroup)

                             :test 'string=))

         (addp (wg-pushnew-p uid (wg-workgroup-weak-buf-uids workgroup)

                             :test 'string=)))

    (when (or remp addp)

      (wg-flag-workgroup-modified workgroup)

      bufobj)))

(defun wg-workgroup-dissociate-bufobj (workgroup bufobj)

  "Dissociate BUFOBJ from WORKGROUP."

  (let* ((uid (wg-bufobj-uid-or-add bufobj))

         (rem1p (wg-removef-p uid (wg-workgroup-strong-buf-uids workgroup)

                              :test 'string=))

         (rem2p (wg-removef-p uid (wg-workgroup-weak-buf-uids workgroup)

                              :test 'string=)))

    (wg-awhen (or rem1p rem2p)

      (wg-flag-workgroup-modified workgroup)

      bufobj)))

(defun wg-workgroup-associate-bufobj (workgroup bufobj &optional weak)

  "Associate BUFOBJ with WORKGROUP.

WEAK non-nil means weakly associate it.  Otherwise strongly associate it."

  (if weak (wg-workgroup-weakly-associate-bufobj workgroup bufobj)

    (wg-workgroup-strongly-associate-bufobj workgroup bufobj)))

(defun wg-workgroup-cycle-bufobj-association-type (workgroup bufobj)

  "Cycle the BUFOBJ's association type in WORKGROUP.

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

  (cl-case (wg-workgroup-bufobj-association-type workgroup bufobj)

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

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

  "Dissociate from WORKGROUP all weakly associated buffers."

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

    (wg-flag-workgroup-modified workgroup)

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

(defun wg-workgroup-dissociate-strongly-associated-buffers (workgroup)

  "Dissociate from WORKGROUP all strongly associated buffers."

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

    (wg-flag-workgroup-modified workgroup)

    (setf (wg-workgroup-strong-buf-uids workgroup) nil)))

(defun wg-workgroup-dissociate-all-buffers (workgroup)

  "Dissociate from WORKGROUP all its associated buffers."

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

  (wg-workgroup-dissociate-strongly-associated-buffers workgroup))

(defun wg-auto-dissociate-buffer-hook ()

  "`kill-buffer-hook' that automatically dissociates buffers from workgroups."

  (when wg-dissociate-buffer-on-kill-buffer

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

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

;;; filtered buffer-list construction

(defun wg-get-buffer-list-filter-id-flexibly (blf-id)

  "Return a buffer-list-filter-id one way or another."

  (or blf-id wg-current-buffer-list-filter-id 'all))

(defun wg-get-buffer-list-filter-val (id key &optional noerror)

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

  (let ((slot-num (cl-case key (symbol 0) (indicator 1) (constructor 2))))

    (if (not slot-num)

        (unless noerror

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

      (let* ((id (wg-get-buffer-list-filter-id-flexibly id))

             (entry (assq id (wg-local-value

                              'wg-buffer-list-filter-definitions))))

        (if (not entry)

            (unless noerror

              (error "`%S' is an undefined buffer-list-filter" id))

          (or (nth slot-num entry)

              (unless noerror

                (error "Slot `%S' is undefined in `%S's definition"

                       key id))))))))

(defun wg-filtered-buffer-list (&optional names workgroup bfl-id initial)

  "Return a filtered buffer-list from NAMES, WORKGROUP, BLF-ID and INITIAL.

NAMES non-nil means return a list of buffer-names instead of buffer objects.

WORKGROUP non-nil should be any workgroup identifier accepted by

`wg-get-workgroup'.

BLF-ID non-nil should be the identifier of a defined buffer-list-filter.

It defaults to `wg-get-buffer-list-filter-val'.

INITIAL non-nil should be an initial buffer-list to filter.  It defaults to

`wg-interesting-buffers'."

  (let ((buffer-list (funcall (wg-get-buffer-list-filter-val

                               (wg-get-buffer-list-filter-id-flexibly bfl-id)

                               'constructor)

                              (wg-get-workgroup workgroup)

                              (or initial (wg-interesting-buffers)))))

    (if names (mapcar 'wg-buffer-name buffer-list) buffer-list)))

;; buffer-list filters

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

  "Return all buffers in INITIAL."

  initial)

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

  "Return only those buffers associated with WORKGROUP."

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

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

  "Return only those buffer unassociated with WORKGROUP."

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

    (cl-remove-if (lambda (buffer) (member buffer buffers)) 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."

  (cl-remove-if-not (lambda (bname) (string-match regexp bname))

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

  (cl-remove-if-not (lambda (f) (when f (wg-file-under-root-path-p root-dir f)))

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

  (cl-remove-if-not (lambda (mm) (eq mm major-mode))

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

;; Example custom buffer-list-filters

(defun wg-buffer-list-filter-irc (workgroup buffer-list)

  "Return only those buffers in BUFFER-LIST with names starting in \"#\"."

  (wg-filter-buffer-list-by-regexp "^#" buffer-list))

(defun wg-buffer-list-filter-home-dir (workgroup buffer-list)

  "Return only those buffers in BUFFER-LIST visiting files under ~/."

  (wg-filter-buffer-list-by-root-dir "~/" buffer-list))

(defun wg-buffer-list-filter-elisp (workgroup buffer-list)

  "Return only those buffers in BUFFER-LIST in `emacs-lisp-mode'."

  (wg-filter-buffer-list-by-major-mode 'emacs-lisp-mode buffer-list))

(defun wg-buffer-list-filter-home-dir->elisp (workgroup buffer-list)

  "Example of chaining buffer-list filters.

This returns all buffers under \"~/\" that are also in `emacs-lisp-mode'."

  (wg-buffer-list-filter-elisp

   nil (wg-buffer-list-filter-home-dir nil buffer-list)))

;; buffer-list-filter context

(defun wg-buffer-list-filter-order (command)

  "Return WORKGROUP's buffer-list-filter order for COMMAND, or a default."

  (let ((bfo (wg-local-value 'wg-buffer-list-filter-order-alist)))

    (or (wg-aget bfo command) (wg-aget bfo 'default))))

(defmacro wg-prior-mapping (mode command)

  "Return whatever COMMAND would call if MODE wasn't on."

  `(or (let (,mode) (command-remapping ,command)) ,command))

(defun wg-filter-buffer-list-p ()

  "Return the current workgroup when buffer-list-filters are on."

  (and workgroups-mode wg-buffer-list-filtration-on (wg-current-workgroup t)))

(defmacro wg-with-buffer-list-filters (command &rest body)

  "Create buffer-list filter context for COMMAND, and eval BODY.

Binds `wg-current-buffer-list-filter-id' in BODY."

  (declare (indent 1))

  (wg-with-gensyms (order status)

    `(let* ((wg-previous-minibuffer-contents nil)

            (,order (wg-buffer-list-filter-order ,command)))

       (catch 'wg-result

         (while 'your-mom

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

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

             (cl-case (car ,status)

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

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

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

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

                     (setq wg-previous-minibuffer-contents

                           (cadr ,status))))))))))

;;; workgroup working-wconfig and wconfig undo/redo

(defun wg-workgroup-state-table (&optional frame)

  "Return FRAME's workgroup table, creating it first if necessary."

  (or (frame-parameter frame 'wg-workgroup-state-table)

      (let ((wtree (make-hash-table :test 'equal)))

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

        wtree)))

(defun wg-get-workgroup-state (workgroup &optional frame)

  "Return FRAME's WORKGROUP's state table."

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

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

    (or (gethash uid state-table)

        (let ((wgs (wg-make-workgroup-state

                    :undo-pointer 0

                    :undo-list

                    (list (or (wg-workgroup-selected-frame-wconfig workgroup)

                              (wg-workgroup-base-wconfig workgroup))))))

          (puthash uid wgs state-table)

          wgs))))

(defmacro wg-with-undo (workgroup spec &rest body)

  "Bind WORKGROUP's undo state to SPEC and eval BODY."

  (declare (indent 2))

  (wg-dbind (state undo-pointer undo-list) spec

    `(let* ((,state (wg-get-workgroup-state ,workgroup))

            (,undo-pointer (wg-workgroup-state-undo-pointer ,state))

            (,undo-list (wg-workgroup-state-undo-list ,state)))

       ,@body)))

(defun wg-flag-just-exited-minibuffer ()

  "Added to `minibuffer-exit-hook'."

  (setq wg-just-exited-minibuffer t))

(defun wg-flag-window-configuration-changed ()

  "Set `wg-window-configuration-changed' to t unless the

minibuffer was just exited.  Added to

`window-configuration-change-hook'."

  (if wg-just-exited-minibuffer

      (setq wg-just-exited-minibuffer nil)

    (setq wg-window-configuration-changed t)))

(defun wg-unflag-undoify-window-configuration-change ()

  "Set `wg-undoify-window-configuration-change' to nil, exempting

from undoification any window-configuration changes caused by the

current command."

  (setq wg-undoify-window-configuration-change nil))

(defun wg-set-workgroup-working-wconfig (workgroup wconfig)

  "Set the working-wconfig of WORKGROUP to WCONFIG."

  (wg-flag-workgroup-modified workgroup)

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

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

    (setcar (nthcdr undo-pointer undo-list) wconfig)))

(defun wg-add-wconfig-to-undo-list (workgroup wconfig)

  "Add WCONFIG to WORKGROUP's undo list, truncating its future if necessary."

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

    (let ((undo-list (cons nil (nthcdr undo-pointer undo-list))))

      (wg-awhen (nthcdr wg-wconfig-undo-list-max undo-list) (setcdr it nil))

      (setf (wg-workgroup-state-undo-list state) undo-list))

    (setf (wg-workgroup-state-undo-pointer state) 0))

  (wg-set-workgroup-working-wconfig workgroup wconfig))

(defun wg-workgroup-working-wconfig (workgroup &optional noupdate)

  "Return WORKGROUP's working-wconfig.

If WORKGROUP is the current workgroup in `selected-frame', and

NOUPDATE is nil, set its working wconfig in `selected-frame' to

`wg-current-wconfig' and return the updated wconfig.  Otherwise

return WORKGROUP's current undo state."

  (if (and (not noupdate) (wg-current-workgroup-p workgroup))

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

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

      (nth undo-pointer undo-list))))

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

  "Update `selected-frame's current workgroup's working-wconfig

with `wg-current-wconfig'."

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

    (wg-set-workgroup-working-wconfig it (wg-current-wconfig))))

(defun wg-restore-wconfig-undoably (wconfig &optional noundo)

  "Restore WCONFIG in `selected-frame', saving undo information."

  (when noundo (wg-unflag-undoify-window-configuration-change))

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

  (wg-restore-wconfig wconfig))

(defun wg-workgroup-offset-position-in-undo-list (workgroup increment)

  "Increment WORKGROUP's undo-pointer by INCREMENT.

Also restore the wconfig at the incremented undo-pointer if

WORKGROUP is current."

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

    (let ((new-pointer (+ undo-pointer increment)))

      (when (wg-within new-pointer 0 (length undo-list))

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

          (wg-restore-wconfig-undoably (nth new-pointer undo-list) t))

        (setf (wg-workgroup-state-undo-pointer state) new-pointer)))))

(defun wg-undoify-window-configuration-change ()

  "Conditionally `wg-add-wconfig-to-undo-list'.

Added to `post-command-hook'."

  (when (and

         ;; When the window config has changed,

         wg-window-configuration-changed

         ;; and undoification is still on for the current command

         wg-undoify-window-configuration-change

         ;; and the change didn't occur while the minibuffer is active,

         (wg-minibuffer-inactive-p))

    ;; and there's a current workgroup,

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

      ;; add the current wconfig to that workgroup's undo list:

      (wg-add-wconfig-to-undo-list workgroup (wg-current-wconfig))))

  ;; Reset all flags no matter what:

  (setq wg-window-configuration-changed nil

        wg-undoify-window-configuration-change t

;;; workgroups-structs.el --- Data structures for WG

;;; Commentary:

;;

;; Copyright (C) Sergey Pashinin

;; Author: Sergey Pashinin <sergey@pashinin.com>

;;

;; `wg-defstruct'

;;

;; It creates some functions named like "wg-buf-...", "wg-session-..."

;;

;; To get a value you can use:

;; (wg-session-... (wg-current-session))

;; Like:

;; (wg-session-file-name (wg-current-session))

;;

;; To set a value (in `wg-write-session-file'):

;;

;; (setf (wg-session-file-name (wg-current-session)) filename)

;;

;;; Code:

(require 'workgroups-utils-basic)

(wg-defstruct wg buf

  (uid (wg-generate-uid))

  (name)

  (file-name)

  (point)

  (mark)

  (local-vars)

  (special-data)

  ;; This may be used later:

  (gc))

(wg-defstruct wg win

  (uid)

  (parameters)

  (edges)

  (point)

  (start)

  (hscroll)

  (dedicated)

  (selected)

  (minibuffer-scroll)

  (buf-uid))

(wg-defstruct wg wtree

  (uid)

  (dir)

  (edges)

  (wlist))

(wg-defstruct wg wconfig

  (uid (wg-generate-uid))

  (name)

  (parameters)

  (left)

  (top)

  (width)

  (height)

  (vertical-scroll-bars)

  (scroll-bar-width)

  (wtree)

  ;;(fullscreen)

  )

;; wg-wconfig

(wg-defstruct wg workgroup

  (uid (wg-generate-uid))

  (name)

  (modified)

  (parameters)

  (base-wconfig)

  (selected-frame-wconfig)

  (saved-wconfigs)

  (strong-buf-uids)

  (weak-buf-uids))

(wg-defstruct wg session

  (uid (wg-generate-uid))

  (name)

  (modified)

  (parameters)

  (file-name)

  (version wg-version)

  (workgroup-list)

  (buf-list))

(wg-defstruct wg workgroup-state

  (undo-pointer)

  (undo-list))

(provide 'workgroups-structs)

;;; workgroups-structs.el ends here