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

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

  "Return a new list of the buf uids of all wins in WTREE."

  (if (not wtree)

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

  (wg-flatten-wtree wtree 'wg-win-buf-uid))

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

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

  (cl-remove-duplicates (wg-wtree-buf-uids wtree) :test 'string=))

(defun wg-reset-window-tree ()

  "Delete all but one window in `selected-frame', and reset

various parameters of that window in preparation for restoring

a wtree."

  (delete-other-windows)

  (set-window-dedicated-p nil nil))

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

  (if (wg-wtree-p w)

      (cl-loop with dir = (wg-wtree-dir w)

               for (win . rest) on (wg-wtree-wlist w)

               do (when rest (split-window nil (wg-w-size win dir) (not dir)))

               do (wg-restore-window-tree-helper win))

    (wg-restore-window w)

    (when (wg-win-selected w)

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

    (when (wg-win-minibuffer-scroll w)

      (setq minibuffer-scroll-window (selected-window)))

    (other-window 1)))

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

  "Restore WTREE in `selected-frame'."

  (let ((window-min-width wg-window-min-width)

        (window-min-height wg-window-min-height)

        (wg-window-tree-selected-window nil))

    (wg-reset-window-tree)

    (wg-restore-window-tree-helper wtree)

    (awhen wg-window-tree-selected-window (select-window it))))

(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-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-read-workgroup-index ()

  "Prompt for the index of a workgroup."

  (let ((max (1- (length (wg-workgroup-list-or-error)))))

    (wg-read-object

     (format "%s\n\nEnter [0-%d]: " (wg-workgroup-list-display) max)

     (lambda (obj) (and (integerp obj) (wg-within obj 0 max t)))

     (format "Please enter an integer [%d-%d]" 0 max)

     nil nil t)))

(defun wg-minibuffer-inactive-p ()

  "Return t when `minibuffer-depth' is zero, nil otherwise."

  (zerop (minibuffer-depth)))

(defun wg-barf-on-active-minibuffer ()

  "Throw an error when the minibuffer is active."

  (when (not (wg-minibuffer-inactive-p))

    (error "Exit minibuffer to use workgroups functions!")))

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

(defun wg-flag-session-modified (&optional session)

  "Set SESSION's modified flag."

  (when wg-flag-modified

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

  "Return current workgroup in frame.

Error unless NOERROR, in FRAME if specified."

  (or wg-current-workgroup

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

  (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 in FRAME.

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 in FRAME.

WORKGROUP should be a workgroup or nil."

                     (not current-prefix-arg)))

  (when (and confirm (file-exists-p filename))

    (unless (y-or-n-p (format "File `%s' exists; overwrite? " filename))

      (error "Cancelled")))

  (unless (file-writable-p filename)

    (error "File %s can't be written to" filename))

  (wg-perform-session-maintenance)

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

  (setf (wg-session-version (wg-current-session)) wg-version)

  ;; Save opened frames as a session parameter "frame-list".

  ;; Exclude `selected-frame' and daemon one (if any).

  ;; http://stackoverflow.com/questions/21151992/why-emacs-as-daemon-gives-1-more-frame-than-is-opened

  (if wg-control-frames

      (let ((fl (frame-list)))

        ;; TODO: remove using dash

        (mapc (lambda (frame)

                (if (string-equal "initial_terminal" (terminal-name frame))

                    (delete frame fl))) fl)

        (setq fl (delete (selected-frame) fl))

        (let (wg-flag-modified)

          (if (wg-current-session t)

              (wg-set-session-parameter 'frame-list (mapcar 'wg-frame-to-wconfig fl))))))

  (wg-write-sexp-to-file (wg-pickel-all-session-parameters) filename)

(defalias 'wg-write-session-file 'wg-save-session-as)

(defun wg-get-session-file ()

  "Return the filename in which to save the session."

  (or (aif (wg-current-session t) (wg-session-file-name it))

      wg-session-file))

;;(read-file-name (format "Save session as [%s]: " wg-session-file))

(defun wg-save-session (&optional force)

  "Save the current Workgroups session if it's been modified.

When FORCE - save session regardless of whether it's been modified."

  (interactive "P")

  (if (and (not (wg-modified-p)) (not force))

      (wg-message "(The session is unmodified)")

    (wg-save-session-as (wg-get-session-file))))

(defun wg-reset-internal (&optional session)

  "Reset Workgroups, setting `wg-current-session' to SESSION.

Resets all frame parameters, buffer-local vars, current session

object, etc.  SESSION nil defaults to a new, blank session."

  (mapc 'wg-reset-frame (frame-list))

  (mapc 'wg-reset-buffer (wg-buffer-list-emacs))

  (setq wg-wconfig-kill-ring nil)

  (setq wg-current-session (or session (wg-make-session))))

  "Mark the session and all workgroups as unmodified."

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

  (dolist (workgroup (wg-workgroup-list))

    (setf (wg-workgroup-modified workgroup) nil)))

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

  "Return session's value for PARAMETER.

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

SESSION nil defaults to the current session."

  (wg-aget (wg-session-parameters (or session (wg-current-session)))

           parameter default))

(defun wg-set-session-parameter (parameter value &optional session)

  "Set PARAMETER to VALUE in SESSION.

SESSION nil means use the current session.  Return value."

  (let ((session (or session (wg-current-session))))

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

    (wg-flag-session-modified session)

    value))

(defun wg-remove-session-parameter (parameter &optional session)

  "Remove parameter PARAMETER from SESSION's parameters."

  (let ((session (or session (wg-current-session))))

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

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

  "Return the value of VARIABLE in SESSION.

SESSION nil defaults to the current session.  If VARIABLE does

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

resolved by Emacs."

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

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

    (if (not (eq value undefined)) value

      (symbol-value variable))))

(defun wg-reset-frame (frame)

  "Reset Workgroups' `frame-parameters' in FRAME to nil."

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

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

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

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

  "Perform session-saving operations based on BEHAVIOR."

  (cl-case behavior

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

    (save (wg-save-session))))

(defun wg-reload-session ()