(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

  (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

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

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

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

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

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

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

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

;;; Commentary:

;;; Code:

(require 'ring)

(require 'workgroups-wconfig)

(require 'workgroups-minibuffer)

;;

;; Variables

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

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