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

    (wg-message

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

         "Dissociated %S from %s" "%S isn't associated with %s")

     (wg-buffer-name buffer)

     (wg-workgroup-name workgroup))))

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

      (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-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-associate-frame-buffers ()

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

  "Find BUF in BUF-LIST.

This is only here for completeness."

  (cl-find buf buf-list))

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

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

  (cl-find (wg-get-buffer buffer-or-name) buffer-list :key 'wg-get-buffer))

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

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

      (wg-find-bufobj-by-uid it buf-list)

    (wg-find-bufobj buffer-or-name buf-list)))

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

  "Find BUF in BUFFER-LIST."

  (or (wg-find-bufobj-by-uid (wg-buf-uid buf) buffer-list)

      (wg-find-bufobj buf buffer-list)))

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

  "Find a buf in `wg-buf-list' by UID."

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

     :point          (point)

     :mark           (mark)

     :local-vars     (wg-serialize-buffer-local-variables)

     :special-data   (wg-buffer-special-data buffer))))

(defun wg-add-buffer-to-buf-list (buffer)

  "Make a buf from BUFFER, and add it to `wg-buf-list' if necessary.

If there isn't already a buf corresponding to BUFFER in

`wg-buf-list', make one and add it.  Return BUFFER's uid

in either case."

  (with-current-buffer buffer

    (setq wg-buffer-uid

              (wg-buf-uid it)

            (let ((buf (wg-buffer-to-buf buffer)))

              (push buf (wg-buf-list))

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

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

  "Return BUFFER's uid.

If there isn't already a buf corresponding to BUFFER in

`wg-buf-list', make one and add it."

  (or (wg-buffer-uid buffer) (wg-add-buffer-to-buf-list buffer)))

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

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

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

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

  "Workgroups' version of `read-buffer'.

Read with PROMT DEFAULT REQUIRE-MATCH."

  (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

                    (substring prompt 0 it) prompt))

               default require-match))))

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

            `((deserialize . ,(lambda (buffer vars)

                                (when (or wg-restore-remote-buffers

                                          (not (file-remote-p default-directory)))

                                  (let ((d (wg-get-first-existing-dir)))

                                    (if (file-directory-p d) (dired d))))))))

;; `Info-mode'     C-h i

(wg-support 'Info-mode 'info

            `((save . (Info-current-file Info-current-node))

              (deserialize . ,(lambda (buffer vars)

                                ;;(with-current-buffer

                                ;;    (get-buffer-create (wg-buf-name buffer))

                                    (if (fboundp 'Info-find-node)

                                        (apply #'Info-find-node it))

                                  (info)

                                  (get-buffer (wg-buf-name buffer)))))))

;; `help-mode'

;; Bug: https://github.com/pashinin/workgroups2/issues/29

(if nil

(wg-support 'help-mode 'help-mode

            `((save . (help-xref-stack-item help-xref-stack help-xref-forward-stack))

              (deserialize . ,(lambda (buffer vars)

                               (wg-dbind (item stack forward-stack) vars

;;; workgroups-utils.el --- Utilities used by Workgroups

;;; Commentary:

;;

;; A bunch of general purpose-ish utilities used by Workgroups.

;;

;;; Code:

;;; utils used in macros

(require 'cl-lib)

(require 'workgroups-faces)

(require 'workgroups-variables)

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

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

  (declare (indent 1))

  `(let (,@(mapcar (lambda (sym) `(,sym (cl-gensym))) syms)) ,@body))

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

(defmacro wg-doconcat (spec &rest body)

  "do-style wrapper for `mapconcat'.

\(fn (VAR SEQ [SEPARATOR]) BODY...)"

  (declare (indent 1))

  (wg-dbind (elt seq &optional sep) spec

    `(mapconcat (lambda (,elt) ,@body) ,seq (or ,sep ""))))

;;; anaphora

(defmacro wg-awhen (test &rest body)

  "Anaphoric `when'."

  (declare (indent 1))

(defmacro wg-asetf (&rest places-and-values)

  "Anaphoric `setf'."

  `(progn ,@(mapcar (lambda (pv) `(let ((it ,(car pv))) (setf ,@pv)))

                    (wg-partition places-and-values 2))))

;;; other control structures

(defmacro wg-destructuring-dolist (spec &rest body)

  "Loop over a list.

(defun wg-make-alist (&rest kvps)

  "Return a new alist from KVPS."

  (let (alist)

    (while kvps

      (push (cons (car kvps) (cadr kvps)) alist)

      (setq kvps (cddr kvps)))

    (nreverse alist)))

(defun wg-aget (alist key &optional default)

  "Return the value of KEY in ALIST. Uses `assq'.

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

(defun wg-acopy (alist)

  "Return a copy of ALIST's toplevel list structure."

  (mapcar (lambda (kvp) (cons (car kvp) (cdr kvp))) alist))

(defun wg-aput (alist key value)

  "Return a new alist from ALIST with KEY's value set to VALUE."

  (let* ((found nil)

         (new (wg-docar (kvp alist)

                (if (not (eq key (car kvp))) kvp

                  (setq found (cons key value))))))

    (if found new (cons (cons key value) new))))

  "Non-nil means request confirmation before creating a new

workgroup when `wg-get-workgroup-create' is called with a string

that doesn't name an existing workgroup."

  :type 'boolean

  :group 'workgroups)

(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-current-workgroup (&optional noerror frame)

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

  (or wg-current-workgroup

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

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

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

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

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

(provide 'workgroups-wtree)

;;; workgroups-wtree.el ends here