"Run commands F in Agenda buffer.

You can get these commands using `wg-get-org-agenda-view-commands'."

  (when (and (boundp 'org-agenda-buffer-name)

             (fboundp 'org-current-line)

             (fboundp 'org-goto-line))

    (if (get-buffer org-agenda-buffer-name)

        (save-window-excursion

          (with-current-buffer org-agenda-buffer-name

            (let* ((line (org-current-line)))

              (if f (eval f))

              (org-goto-line line)))))))

(wg-support 'org-agenda-mode 'org-agenda

            '((serialize . (lambda (buffer)

                             (wg-get-org-agenda-view-commands)))

              (deserialize . (lambda (buffer vars)

                               (org-agenda-list)

                               (wg-awhen (get-buffer org-agenda-buffer-name)

                                 (set-buffer it)

                                 (wg-run-agenda-cmd vars))

                               ))))

;; eshell

(wg-support 'eshell-mode 'esh-mode

            '((deserialize . (lambda (buffer vars)

                               (prog1 (eshell t)

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

;; term-mode

;;

;; This should work for `ansi-term's, too, as there doesn't seem to

;; be any difference between the two except how the name of the

;; buffer is generated.

;;

(wg-support 'term-mode 'term

            `((serialize . ,(lambda (buffer)

                              (if (get-buffer-process buffer)

                                  (wg-last1 (process-command (get-buffer-process buffer)))

                                "/bin/bash")))

              (deserialize . ,(lambda (buffer vars)

                                (cl-labels ((term-window-width () 80)

                                            (window-height () 24))

                                  (prog1 (term vars)

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

;; Python

(wg-support 'inferior-python-mode 'python

            `((save . (python-shell-interpreter python-shell-interpreter-args))

              (deserialize . ,(lambda (buffer vars)

                                (wg-dbind (pythoncmd pythonargs) vars

                                  (save-window-excursion

                                    (run-python (concat pythoncmd " " pythonargs)))

                                  (wg-awhen (get-buffer (process-buffer (python-shell-get-or-create-process)))

                                    (set-buffer it)

                                    (switch-to-buffer (process-buffer (python-shell-get-or-create-process)))

                                    (goto-char (point-max)))

                                  )))))

;; Sage shell

(wg-support 'inferior-sage-mode 'sage-mode

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

                                (save-window-excursion

                                  (if (boundp' sage-command)

                                      (run-sage t sage-command t)))

                                (if (boundp 'sage-buffer)

                                    (wg-awhen (and

                                               sage-buffer)

                                      (set-buffer it)

                                      (switch-to-buffer sage-buffer)

                                      (goto-char (point-max))))))))

;; inferior-ess-mode   (ess-inf.el)

;; R shell, M-x R

(wg-support 'inferior-ess-mode 'ess-inf

            `((save . (inferior-ess-program))

              (deserialize . ,(lambda (buffer vars)

                                (wg-dbind (cmd) vars

                                  (let ((ess-ask-about-transfile nil)

                                        (ess-ask-for-ess-directory nil)

                                        (ess-history-file nil))

                                    (R)))))))

;; inferior-octave-mode

(wg-support 'inferior-octave-mode 'octave

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

                                (prog1 (run-octave)

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

;; Prolog shell

(wg-support 'prolog-inferior-mode 'prolog

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

                                (save-window-excursion

                                  (run-prolog nil))

                                (switch-to-buffer "*prolog*")

                                (goto-char (point-max))))))

;; compilation-mode

;;

;; I think it's not a good idea to compile a program just to switch

;; workgroups. So just restoring a buffer name.

(wg-support 'compilation-mode 'compile

            `((serialize . ,(lambda (buffer)

                              (if (boundp' compilation-arguments) compilation-arguments)))

              (deserialize . ,(lambda (buffer vars)

                                (save-window-excursion

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

                                (with-current-buffer (wg-buf-name buffer)

                                  (when (boundp' compilation-arguments)

                                    (make-local-variable 'compilation-arguments)

                                    (setq compilation-arguments vars)))

                                (switch-to-buffer (wg-buf-name buffer))

                                (goto-char (point-max))))))

;; grep-mode

;; see grep.el - `compilation-start' - it is just a compilation buffer

;; local variables:

;; `compilation-arguments' == (cmd mode nil nil)

(wg-support 'grep-mode 'grep

            `((serialize . ,(lambda (buffer)

                              (if (boundp' compilation-arguments) compilation-arguments)))

              (deserialize . ,(lambda (buffer vars)

                                (compilation-start (car vars) (nth 1 vars))

                                (switch-to-buffer "*grep*")))))

;; speedbar-mode

(defun wg-deserialize-speedbar-buffer (buf)

  "Deserialize speedbar-buffer BUF."

  (when (and (require 'speedbar nil 'noerror)

             (require 'dframe nil 'noerror))

    (wg-dbind (this-function args) (wg-buf-special-data buf)

      (let ((default-directory (car args))

            bufname)

        (if (boundp 'sr-speedbar-buffer-name)

            (setq bufname sr-speedbar-buffer-name)

          (setq bufname "*SPEEDBAR*"))

        (when (and (fboundp 'speedbar-mode)

                   (fboundp 'speedbar-reconfigure-keymaps)

                   (fboundp 'speedbar-update-contents)

                   (fboundp 'speedbar-set-timer))

          (with-no-warnings

            (setq speedbar-buffer (get-buffer-create bufname))

            (setq speedbar-frame (selected-frame)

                  dframe-attached-frame (selected-frame)

                  speedbar-select-frame-method 'attached

                  speedbar-verbosity-level 0

                  speedbar-last-selected-file nil)

            (set-buffer speedbar-buffer)

            (speedbar-mode)

            (speedbar-reconfigure-keymaps)

            (speedbar-update-contents)

            (speedbar-set-timer 1)

            (set-window-dedicated-p (get-buffer-window bufname) t)

            (switch-to-buffer bufname)))

        (current-buffer)

        ))))

(defun wg-serialize-speedbar-buffer (buffer)

  "Serialize speedbar BUFFER."

  (with-current-buffer buffer

    (if (fboundp 'speedbar-mode)

        (when (eq major-mode 'speedbar-mode)

          (list 'wg-deserialize-speedbar-buffer

                (wg-take-until-unreadable (list default-directory))

                )))))

(defun wg-deserialize-slime-buffer (buf)

  "Deserialize `slime' buffer BUF."

  (when (require 'slime nil 'noerror)

    (wg-dbind (this-function args) (wg-buf-special-data buf)

      (let ((default-directory (car args))

            (arguments (nth 1 args)))

        (when (and (fboundp 'slime-start*)

                   (fboundp 'slime-process))

          (save-window-excursion

            (slime-start* arguments))

          (switch-to-buffer (process-buffer (slime-process)))

          (current-buffer))))))

;; `comint-mode'  (general mode for all shells)

;;

;; It may have different shells. So we need to determine which shell is

;; now in `comint-mode' and how to restore it.

;;

;; Just executing `comint-exec' may be not enough because we can miss

;; some hooks or any other stuff that is executed when you run a

;; specific shell.

(defun wg-serialize-comint-buffer (buffer)

  "Serialize comint BUFFER."

  (with-current-buffer buffer