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)

(defun wg-auto-associate-buffer-helper (workgroup buffer assoc)

  "Associate BUFFER with WORKGROUP based on ASSOC.

See `wg-buffer-auto-association' for allowable values of ASSOC."

  (cond ((memq assoc '(weak strong))

         (wg-workgroup-associate-bufobj workgroup buffer (eq assoc 'weak)))

        ((functionp assoc)

         (wg-auto-associate-buffer-helper

          workgroup buffer (funcall assoc workgroup buffer)))

        (t nil)))

(defun wg-auto-associate-buffer (buffer &optional frame)

  "Conditionally associate BUFFER with the current workgroup in FRAME.

Frame defaults to `selected-frame'.  See `wg-buffer-auto-association'."

  (when wg-buffer-auto-association-on

      (unless (or (wg-workgroup-bufobj-association-type wg buffer)

                  (member wg wg-deactivation-list)

                  (member (buffer-name b) wg-associate-blacklist)

                  (not (or (buffer-file-name b)

                           (eq (buffer-local-value 'major-mode b) 'dired-mode))))

        (wg-auto-associate-buffer-helper

         wg buffer (wg-local-value 'wg-buffer-auto-association wg))))))

(defadvice switch-to-buffer (after wg-auto-associate-buffer)

  "Automatically associate the buffer with the current workgroup."

  (wg-auto-associate-buffer ad-return-value))

(defadvice set-window-buffer (after wg-auto-associate-buffer)

  "Automatically associate the buffer with the current workgroup."

  (wg-auto-associate-buffer

   (ad-get-arg 1)

   (window-frame (or (ad-get-arg 0) (selected-window)))))

(provide 'workgroups-advice)

;;; workgroups-advice.el ends here

Buffer-local.")

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

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

  "Show this in case everything else fails.

When a buffer can't be restored, when creating a blank wg."

  :type 'string

  :group 'workgroups)

;;; Functions

(defmacro wg-buf-list ()

  "Setf'able `wg-current-session' buf-list slot accessor."

  `(wg-session-buf-list (wg-current-session)))

(defun wg-restore-default-buffer (&optional switch)

  "Return `wg-default-buffer' and maybe SWITCH to it."

  (if switch

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

    (get-buffer-create wg-default-buffer)))

(defun wg-restore-existing-buffer (buf &optional switch)

  "Return existing buffer from BUF and maybe SWITCH to it."

    (if switch (switch-to-buffer b t))

    (with-current-buffer b

      (wg-set-buffer-uid-or-error (wg-buf-uid buf))

      b)))

(defun wg-restore-file-buffer (buf &optional switch)

  "Restore BUF by finding its file and maybe SWITCH to it.

Return the created buffer.

If BUF's file doesn't exist, call `wg-restore-default-buffer'"

  (let ((file-name (wg-buf-file-name buf)))

    (when (and file-name

               (or wg-restore-remote-buffers

                   (not (file-remote-p file-name))))

      (cond ((file-exists-p file-name)

             ;; jit ignore errors

             ;;(ignore-errors

             (condition-case err

                 (let ((b (find-file-noselect file-name nil nil nil)))

                   (with-current-buffer b

                     (rename-buffer (wg-buf-name buf) t)

                     (wg-set-buffer-uid-or-error (wg-buf-uid buf))

                     (when wg-restore-mark

                       (set-mark (wg-buf-mark buf))

                       (deactivate-mark))

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

                     )

                   (if switch (switch-to-buffer b))

                   b)

               (error

                (message "Error while restoring a file %s:\n  %s" file-name (error-message-string err))

                nil)))

            (t

             ;; try directory

             (if (file-directory-p (file-name-directory file-name))

                 (dired (file-name-directory file-name))

               (progn

                 (message "Attempt to restore nonexistent file: %S" file-name)

                 nil))

             )))))

(defun wg-restore-special-buffer (buf &optional switch)

  "Restore a buffer BUF with DESERIALIZER-FN and maybe SWITCH to it."

      ((special-data (wg-buf-special-data buf))

       (buffer (save-window-excursion

                 (condition-case err

                     (funcall (car special-data) buf)

                   (error (message "Error deserializing %S: %S" (wg-buf-name buf) err)

                          nil)))))

    (if switch (switch-to-buffer buffer t))

    (with-current-buffer buffer

      (wg-set-buffer-uid-or-error (wg-buf-uid buf)))

    buffer))

(defun wg-restore-buffer (buf &optional switch)

  "Restore BUF, return it and maybe SWITCH to it."

  (fset 'buffer-list wg-buffer-list-original)

  (prog1

      (or (wg-restore-existing-buffer buf switch)

          (wg-restore-special-buffer buf switch)  ;; non existent dired problem

          (wg-restore-file-buffer buf switch)

          (progn (wg-restore-default-buffer switch) nil))

    (if wg-mess-with-buffer-list

        (fset 'buffer-list wg-buffer-list-function))))

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

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

  (cl-etypecase bufobj

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

  "Return BUFFER.

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

  (with-current-buffer buffer (setq wg-buffer-uid nil)))

;;; buffer-list-filter commands

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

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

BUFFER nil defaults to `current-buffer'."

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

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

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

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

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

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

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

  "Return the BUFFER-LIST display string."

  (wg-display-internal 'wg-buffer-display buffer-list))

;; buffer-list filters

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

  "Return all buffers in INITIAL."

  initial)

;; buffer-list-filter context

(defmacro wg-prior-mapping (mode command)

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

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

(provide 'workgroups-buf)

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

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

  `(cl-destructuring-bind ,args ,expr ,@body))

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

  "Take LIST, return a list of N length sublists, offset by STEP.

N defaults to 2, and STEP defaults to N.

Iterative to prevent stack overflow."

  (let* ((n (or n 2)) (step (or step n)) acc)

    (while list

      (push (-take n list) acc)

      (setq list (nthcdr step list)))

    (nreverse acc)))

;;; bindings

(defmacro wg-when-boundp (symbols &rest body)

  "When all SYMBOLS are bound, `eval' BODY."

  (declare (indent 1))

  `(when (and ,@(mapcar (lambda (sym) `(boundp ',sym)) symbols))

     ,@body))

;;; do-style wrappers

(defmacro wg-docar (spec &rest body)

  "do-style wrapper for `mapcar'.

\(fn (VAR LIST) BODY...)"

  (declare (indent 1))

  `(mapcar (lambda (,(car spec)) ,@body) ,(cadr spec)))

(defmacro wg-dohash (spec &rest body)

  "do-style wrapper for `maphash'.

\(fn (KEY VALUE TABLE [RESULT]) BODY...)"

  (declare (indent 1))

  (wg-dbind (key val table &optional result) spec

    `(progn (maphash (lambda (,key ,val) ,@body) ,table) ,result)))

    result))

;;; lists

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

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

      (length (setf ,seq-place (cl-remove ,item ,seq-place ,@keys)))))

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

      (length (cl-pushnew ,item ,seq-place ,@keys))))

(defun wg-range (start end)

  "Return a list of integers from START up to but not including END."

  (let (accum)

    (dotimes (i (- end start) (nreverse accum))

      (push (+ start i) accum))))

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

  "Insert ELT into LIST after INDEX."

  (let ((new-list (cl-copy-list list)))

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

    new-list))

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

  "Insert ELT into LIST before INDEX."

  (if (zerop index) (cons elt list)

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

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

  "Move ELT before INDEX in LIST.

KEYS is passed to `remove*'."

  (wg-insert-before elt (apply 'cl-remove elt list keys) index))

(defun wg-cyclic-nth (list n)

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

  (nth (mod n (length list)) 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)

  "Return non-nil when LIST contains duplicate elements.

Keywords supported: :test :key

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

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

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

    (cl-loop for (elt . rest) on list

             for elt = (funcall key elt)

             when (cl-find elt rest :test test :key key) return elt)))

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

  (cl-union list1 list2 :test 'string=))

;;; alists

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

;;; base wconfig updating

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

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

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

  (with-selected-frame frame

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

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

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

  (if (not (wg-wconfig-wtree wconfig))

      (error "WTREE is nil in `wg-wconfig-buf-uids'!"))

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

(defun wg-wconfig-restore-frame-position (wconfig &optional frame)

  "Use WCONFIG to restore FRAME's position.

If frame is nil then `selected-frame'."

    ;; Check that arguments are integers

    ;; Problem: https://github.com/pashinin/workgroups2/issues/15

    (if (and (integerp left)

             (integerp top))

        (set-frame-position frame left top))))

(defun wg-wconfig-restore-scroll-bars (wconfig)

  "Restore `selected-frame's scroll-bar settings from WCONFIG."

  (set-frame-parameter

   nil 'vertical-scroll-bars (wg-wconfig-vertical-scroll-bars wconfig))

  (set-frame-parameter

   nil 'scroll-bar-width (wg-wconfig-scroll-bar-width wconfig)))

;;(defun wg-wconfig-restore-fullscreen (wconfig)

;;  "Restore `selected-frame's fullscreen settings from WCONFIG."

;;  (set-frame-parameter

;;   nil 'fullscreen (wg-wconfig-parameters wconfig))

;;  )

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

;;; workgroups-workgroup.el --- workgroup functions

;;; Commentary:

;;; Code:

(require 'ring)

(require 'workgroups-wconfig)

(require 'workgroups-minibuffer)

;;

;; Variables

;;

(defvar wg-deactivation-list nil

  "A stack of workgroups that are currently being switched away from.

Used to avoid associating the old workgroup's buffers with the

new workgroup during a switch.")

(defcustom wg-confirm-on-get-workgroup-create nil

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

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

Otherwise return nil."

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

    (cl-etypecase wconfig-or-name

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

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

                       :key 'wg-wconfig-name

                       :test 'string=)))))

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

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

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

WORKGROUP's saved wconfigs, replace it."

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

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

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

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

              (cons wconfig (cl-remove name it

                                       :key 'wg-wconfig-name

                                       :test 'string=)))))

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

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

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

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

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

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

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

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

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

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

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

             (wg-workgroup-saved-wconfigs workgroup)

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

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

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

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

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

            :test 'string=))

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

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

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

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

Skip undo when NOUNDO."

  (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

         wg-window-configuration-changed         ;; When the window config has changed,

         wg-undoify-window-configuration-change  ;; and undoification is still on for the current command

         (wg-minibuffer-inactive-p))             ;; and the change didn't occur while the minibuffer is active,

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

        wg-already-updated-working-wconfig nil))

(defun wg-update-working-wconfig-hook ()

  "Used in before advice on all functions that trigger `window-configuration-change-hook'.

To save up to date undo info before the change."

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

             (wg-minibuffer-inactive-p))

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

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

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

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

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

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

(defun wg-gc-buf-uids ()