From 0d342f0aee3f2f800e486c0051dabe718a7b2841 Mon Sep 17 00:00:00 2001
From: Tom Willemsen
Date: Wed, 23 Mar 2011 11:14:27 +0100
Subject: I don't like nxhtml

---
 emacs.d/nxhtml/util/org-panel.el | 745 ---------------------------------------
 1 file changed, 745 deletions(-)
 delete mode 100644 emacs.d/nxhtml/util/org-panel.el

(limited to 'emacs.d/nxhtml/util/org-panel.el')

diff --git a/emacs.d/nxhtml/util/org-panel.el b/emacs.d/nxhtml/util/org-panel.el
deleted file mode 100644
index a8dfec0..0000000
--- a/emacs.d/nxhtml/util/org-panel.el
+++ /dev/null
@@ -1,745 +0,0 @@
-;;; org-panel.el --- Simple routines for us with bad memory
-;;
-;; Author: Lennart Borgman (lennart O borgman A gmail O com)
-;; Created: Thu Nov 15 15:35:03 2007
-;; Version: 0.21
-;; Lxast-Updated: Wed Nov 21 03:06:03 2007 (3600 +0100)
-;; URL:
-;; Keywords:
-;; Compatibility:
-;;
-;; Fxeatures that might be required by this library:
-;;
-;;   `easymenu', `font-lock', `noutline', `org', `outline', `syntax',
-;;   `time-date'.
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;;; Commentary:
-;;
-;; This defines a kind of control panel for `org-mode'. This control
-;; panel should make it fast to move around and edit structure etc.
-;;
-;; To bring up the control panel type
-;;
-;;   M-x orgpan-panel
-;;
-;; Type ? there for help.
-;;
-;; I suggest you add the following to your .emacs for quick access of
-;; the panel:
-;;
-;;   (eval-after-load 'org-mode
-;;     (define-key org-mode-map [(control ?c) ?p] 'orgpan-panel))
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;;; Change log:
-;;
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;; This program is free software; you can redistribute it and/or
-;; modify it under the terms of the GNU General Public License as
-;; published by the Free Software Foundation; either version 2, or
-;; (at your option) any later version.
-;;
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-;; General Public License for more details.
-;;
-;; You should have received a copy of the GNU General Public License
-;; along with this program; see the file COPYING.  If not, write to
-;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
-;; Floor, Boston, MA 02110-1301, USA.
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;;; Code:
-
-(require 'org)
-(require 'outline)
-
-;; Fix-me: this is for testing. A minor mode version interferes badly
-;; with emulation minor modes.
-(defconst orgpan-minor-mode-version nil)
-
-(defface orgpan-field
-  '((t (:inherit widget-field)))
-  "Face for fields."
-  :group 'orgpan)
-(defvar orgpan-field-face 'orgpan-field)
-
-(defface orgpan-active-field
-  '((t (:inherit highlight)))
-  "Face for fields."
-  :group 'orgpan)
-(defvar orgpan-active-field-face 'orgpan-active-field)
-
-(defface orgpan-spaceline
-  '((t (:height 0.2)))
-  "Face for spacing lines."
-  :group 'orgpan)
-
-(defcustom orgpan-panel-at-top nil
-  "Put org panel at top if non-nil."
-  :type 'boolean
-  :group 'orgpan)
-
-(defcustom orgpan-panel-buttons nil
-  "Panel style, if non-nil use buttons.
-If there are buttons in the panel they are used to change the way
-the arrow keys work.  The panel looks something like this, with
-the first button chosen:
-
-  [Navigate] [Restructure] [TODO/Priority]
-  ----------
-  up/down, left: Go to, right: Visibility
-
-The line below the buttons try to give a short hint about what
-the arrow keys does.  \(Personally I prefer the version without
-buttons since I then do not have to remember which button is
-active.)"
-  :type 'boolean
-  :group 'orgpan)
-
-;; Fix-me: add org-mode-map
-;; (memq 'org-self-insert-command orgpan-org-mode-commands)
-;; (memq 'org-self-insert-command orgpan-org-commands)
-(defvar orgpan-org-mode-commands nil)
-(setq orgpan-org-mode-commands nil)
-
-(defconst orgpan-org-commands
-  '(
-    orgpan-copy-subtree
-    orgpan-cut-subtree
-    orgpan-paste-subtree
-    undo
-    save-buffer
-    ;;
-    ;orgpan-occur
-    orgpan-find-org-file
-    ;;
-    org-cycle
-    org-global-cycle
-    outline-up-heading
-    outline-next-visible-heading
-    outline-previous-visible-heading
-    outline-forward-same-level
-    outline-backward-same-level
-    org-todo
-    org-show-todo-tree
-    org-priority-up
-    org-priority-down
-    org-move-subtree-up
-    org-move-subtree-down
-    org-do-promote
-    org-do-demote
-    org-promote-subtree
-    org-demote-subtree))
-
-
-(defvar orgpan-panel-window nil
-  "The window showing `orgpan-panel-buffer'.")
-
-(defvar orgpan-panel-buffer nil
-  "The panel buffer.
-There can be only one such buffer at any time.")
-
-(defvar orgpan-org-window nil)
-;;(make-variable-buffer-local 'orgpan-org-window)
-
-;; Fix-me: used?
-(defvar orgpan-org-buffer nil)
-;;(make-variable-buffer-local 'orgpan-org-buffer)
-
-(defvar orgpan-last-org-buffer nil)
-;;(make-variable-buffer-local 'orgpan-last-org-buffer)
-
-(defvar orgpan-point nil)
-;;(make-variable-buffer-local 'orgpan-point)
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; Hook functions etc
-
-(defun orgpan-delete-panel ()
-  "Remove the panel."
-  (interactive)
-  (let ((was-in-panel (and (window-live-p orgpan-panel-window)
-                           (eq (selected-window) orgpan-panel-window))))
-    (when (buffer-live-p orgpan-panel-buffer)
-      (delete-windows-on orgpan-panel-buffer)
-      (kill-buffer orgpan-panel-buffer))
-    (when was-in-panel
-      (select-window orgpan-org-window)))
-  (setq orgpan-panel-buffer nil)
-  (setq orgpan-panel-window nil)
-  (orgpan-panel-minor-mode 0)
-  (remove-hook 'post-command-hook 'orgpan-minor-post-command)
-  (remove-hook 'post-command-hook 'orgpan-mode-post-command)
-  ;;(remove-hook 'window-configuration-change-hook 'orgpan-window-config-change)
-  )
-
-(defvar orgpan-from-panel 0)
-(defun orgpan-mode-pre-command ()
-  ;;(setq orgpan-from-panel nil)
-  (condition-case err
-      (if (not (and (windowp orgpan-org-window)
-                    (window-live-p orgpan-org-window)))
-          (progn
-            (setq this-command 'ignore)
-            (orgpan-delete-panel)
-            (message "The window belonging to the panel had disappeared, removed panel."))
-        (let ((buf (window-buffer orgpan-org-window)))
-          (when (with-current-buffer buf
-                  (derived-mode-p 'org-mode))
-            (setq orgpan-last-org-buffer buf))
-          ;; Fix me: add a list of those commands that are not
-          ;; meaningful from the panel (for example org-time-stamp)
-          (when (or (memq this-command orgpan-org-commands)
-                    (memq this-command orgpan-org-mode-commands)
-                    ;; For some reason not all org commands are found above:
-                    (unless (eq this-command 'org-self-insert-command)
-                      (let ((this-name (format "%s" this-command)))
-                        (when (< 4 (length this-name))
-                          (string= "org-" (substring this-name 0 4))))))
-            (if (not (with-current-buffer buf
-                       (derived-mode-p 'org-mode)))
-                (progn
-                  (if (buffer-live-p orgpan-org-buffer)
-                      (set-window-buffer orgpan-org-window orgpan-org-buffer)
-                    (message "Please use `l' or `b' to choose an org-mode buffer"))
-                  (setq this-command 'ignore))
-              (setq orgpan-org-buffer (window-buffer orgpan-org-window))
-              (setq orgpan-from-panel 1)
-              (select-window orgpan-org-window)
-              ))))
-    (error (lwarn 't :warning "orgpan-pre: %S" err))))
-
-(defun orgpan-mode-post-command ()
-  (condition-case err
-      (progn
-        ;;(message "post %s" (current-time-string))(sit-for 1)
-        (unless (and (windowp orgpan-panel-window)
-                     (window-live-p orgpan-panel-window)
-                     (bufferp orgpan-panel-buffer)
-                     (buffer-live-p orgpan-panel-buffer))
-          (orgpan-delete-panel))
-        (unless (active-minibuffer-window)
-          (when (and (= 1 orgpan-from-panel)
-                     (windowp orgpan-panel-window)
-                     (window-live-p orgpan-panel-window))
-            (select-window orgpan-panel-window)
-            (when (derived-mode-p 'orgpan-mode)
-              (setq deactivate-mark t)
-              (when orgpan-panel-buttons
-                (unless (and orgpan-point
-                             (= (point) orgpan-point))
-                  ;; Go backward so it is possible to click on a "button":
-                  (orgpan-backward-field)))))
-          (when (< 0 orgpan-from-panel)
-            (setq orgpan-from-panel (1- orgpan-from-panel)))
-          (unless (eq (selected-window) orgpan-panel-window)
-            (orgpan-delete-panel))))
-    (error (lwarn 't :warning "orgpan-post: %S" err))))
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; Commands
-
-(defun orgpan-last-buffer ()
-  "Open last org-mode buffer in panels org window."
-  (interactive)
-  (let ((buf (window-buffer orgpan-org-window))
-        (last-buf orgpan-last-org-buffer))
-;;     (when (with-current-buffer buf
-;;             (derived-mode-p 'org-mode))
-;;       (setq orgpan-last-org-buffer buf))
-    (when (eq last-buf buf)
-      (setq last-buf nil))
-    (if (not last-buf)
-        (orgpan-switch-buffer)
-      (set-window-buffer orgpan-org-window last-buf))))
-
-(defun orgpan-switch-buffer ()
-  "Switch to next org-mode buffer in panels org window."
-  (interactive)
-  (let ((buf (window-buffer orgpan-org-window))
-        (org-buffers nil))
-    (with-current-buffer buf
-      (when (derived-mode-p 'org-mode)
-        (bury-buffer buf)
-        ;;(setq orgpan-last-org-buffer buf)
-        ))
-    (setq org-buffers (delq nil (mapcar (lambda (buf)
-                                          (when (with-current-buffer buf
-                                                  (derived-mode-p 'org-mode))
-                                            buf))
-                                        (buffer-list))))
-    (setq org-buffers (delq buf org-buffers))
-    (if (not org-buffers)
-        (message "No other org-mode buffers")
-      (set-window-buffer orgpan-org-window (car org-buffers))
-      (setq orgpan-org-buffer (car org-buffers)))))
-
-(defcustom orgpan-cautious-cut-copy-paste nil
-  "Ask the user about panel cut, paste and copy before doing them.
-This refers to the functions `orgpan-paste-subtree',
-`orgpan-cut-subtree' and `orgpan-copy-subtree'."
-  :type 'boolean
-  :group 'orgpan)
-
-(defun orgpan-paste-subtree ()
-  (interactive)
-  (if orgpan-cautious-cut-copy-paste
-      (if (y-or-n-p "Paste subtree here? ")
-          (org-paste-subtree)
-        (message "Nothing was pasted"))
-    (org-paste-subtree)))
-
-(defun orgpan-cut-subtree ()
-  (interactive)
-  (let ((heading (progn
-                   (org-back-to-heading)
-                   (buffer-substring (point) (line-end-position))
-                   )))
-    (if orgpan-cautious-cut-copy-paste
-        (if (y-or-n-p (format "Do you want to cut the subtree\n%s\n? " heading))
-            (org-cut-subtree)
-          (message "Nothing was cut"))
-      (org-cut-subtree))))
-
-(defun orgpan-copy-subtree ()
-  (interactive)
-  (let ((heading (progn
-                   (org-back-to-heading)
-                   (buffer-substring (point) (line-end-position))
-                   )))
-    (if orgpan-cautious-cut-copy-paste
-        (if (y-or-n-p (format "Do you want to copy the subtree\n%s\n? " heading))
-            (org-copy-subtree)
-          (message "Nothing was copied"))
-      (org-copy-subtree))))
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; Buttons
-
-(defvar orgpan-ovl-help nil)
-
-(defun orgpan-check-panel-mode ()
-  (unless (derived-mode-p 'orgpan-mode)
-    (error "Not orgpan-mode in buffer: %s" major-mode)))
-
-(defun orgpan-display-bindings-help ()
-  ;;(orgpan-check-panel-mode)
-  (setq orgpan-point (point-marker))
-  (let* ((ovls (overlays-at orgpan-point))
-         (ovl (car ovls))
-         (help (when ovl (overlay-get ovl 'orgpan-explain))))
-    (dolist (o (overlays-in (point-min) (point-max)))
-      (unless ovl (setq ovl o))
-      (overlay-put o 'face orgpan-field-face))
-    (overlay-put ovl 'face orgpan-active-field-face)
-    (unless orgpan-ovl-help
-      (setq orgpan-ovl-help (make-overlay orgpan-point orgpan-point)))
-    (overlay-put orgpan-ovl-help 'before-string help)))
-
-(defun orgpan-forward-field ()
-  (interactive)
-  (orgpan-check-panel-mode)
-  (let ((pos (next-overlay-change (point))))
-    (unless (overlays-at pos)
-      (setq pos (next-overlay-change pos)))
-    (when (= pos (point-max))
-      (setq pos (point-min))
-      (unless (overlays-at pos)
-        (setq pos (next-overlay-change pos))))
-    (goto-char pos))
-  (orgpan-display-bindings-help))
-
-(defun orgpan-backward-field ()
-  (interactive)
-  (orgpan-check-panel-mode)
-  (when (= (point) (point-min))
-    (goto-char (point-max)))
-  (let ((pos (previous-overlay-change (point))))
-    (unless (overlays-at pos)
-      (setq pos (previous-overlay-change pos)))
-    (goto-char pos))
-  (orgpan-display-bindings-help))
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; Mode
-(defun orgpan-agenda ()
-  "Start agenda"
-  (interactive)
-  (orgpan-delete-panel)
-  (call-interactively 'org-agenda))
-
-(defun orgpan-outline-up-heading (arg &optional invisible-ok)
-  (interactive "p")
-  (outline-back-to-heading invisible-ok)
-  (let ((start-level (funcall outline-level)))
-    (if (<= start-level 1)
-        (message "Already at top level of the outline")
-      (outline-up-heading arg invisible-ok))))
-
-(defvar orgpan-mode-map
-  ;; Fix-me: clean up here!
-  ;; Fix-me: viper support
-  (let ((map (make-sparse-keymap)))
-    (define-key map [?q] 'orgpan-delete-panel)
-    (define-key map [??] 'orgpan-help)
-    (define-key map [?a] 'orgpan-agenda)
-    ;; Copying etc
-    (define-key map [?c] 'orgpan-copy-subtree)
-    (define-key map [?x] 'orgpan-cut-subtree)
-    (define-key map [?v] 'orgpan-paste-subtree)
-    (define-key map [?z] 'undo)
-    (define-key map [(control ?c)] 'orgpan-copy-subtree)
-    (define-key map [(control ?x)] 'orgpan-cut-subtree)
-    (define-key map [(control ?v)] 'orgpan-paste-subtree)
-    (define-key map [(control ?z)] 'undo)
-    ;; Buffers:
-    (define-key map [?b] 'orgpan-switch-buffer)
-    (define-key map [?l] 'orgpan-last-buffer)
-    (define-key map [?o] 'orgpan-find-org-file)
-    (define-key map [?w] 'save-buffer)
-    ;; Some keys for moving between headings. Emacs keys for next/prev
-    ;; line seems ok:
-    (define-key map [(control ?p)] 'outline-previous-visible-heading)
-    (define-key map [(control ?n)] 'outline-next-visible-heading)
-    (define-key map [(shift control ?p)] 'outline-backward-same-level)
-    (define-key map [(shift control ?n)] 'outline-forward-same-level)
-    ;; A mnemunic for up:
-    (define-key map [(control ?u)] 'orgpan-outline-up-heading)
-    ;; Search sparse tree:
-    (define-key map [?s] 'org-sparse-tree)
-    ;;(define-key map [?s] 'orgpan-occur)
-    ;;(define-key map [?s] 'org-occur)
-    ;; Same as in org-mode:
-    ;;(define-key map [(control ?c)(control ?v)] 'org-show-todo-tree)
-    ;; Fix-me: This leads to strange problems:
-    ;;(define-key map [t] 'ignore)
-    map))
-
-(defun orgpan-find-org-file ()
-  "Prompt for an .org file and open it."
-  (interactive)
-  (let ((file-name
-         (read-file-name
-          "Find .org file: " nil nil t nil
-          (lambda (fn)
-            (unless (backup-file-name-p fn)
-              (let ((ext (file-name-extension fn)))
-                (when ext
-                  (string= "org" ext))))))))
-    (find-file file-name)))
-
-(defun orgpan-occur ()
-  "Replacement for `org-occur'.
-Technical reasons."
-  (interactive)
-  (let ((rgx (read-from-minibuffer "(panel) Regexp: ")))
-    (setq orgpan-from-panel 1)
-    (select-window orgpan-org-window)
-    (org-occur rgx)))
-
-(defun orgpan-sparse-tree (&optional arg)
-  "Create a sparse tree, prompt for the details.
-This command can create sparse trees.  You first need to select the type
-of match used to create the tree:
-
-t      Show entries with a specific TODO keyword.
-T      Show entries selected by a tags match.
-p      Enter a property name and its value (both with completion on existing
-       names/values) and show entries with that property.
-r      Show entries matching a regular expression"
-  (interactive "P")
-  (let (ans kwd value)
-    (message "Sparse tree: [r]egexp   [t]odo-kwd   [T]ag   [p]roperty")
-    (setq ans (read-char-exclusive))
-    (cond
-     ((equal ans ?t)
-      (org-show-todo-tree '(4)))
-     ((equal ans ?T)
-      (call-interactively 'org-tags-sparse-tree))
-     ((member ans '(?p ?P))
-      (setq kwd (completing-read "Property: "
-                                 (mapcar 'list (org-buffer-property-keys))))
-      (setq value (completing-read "Value: "
-                                   (mapcar 'list (org-property-values kwd))))
-      (unless (string-match "\\`{.*}\\'" value)
-        (setq value (concat "\"" value "\"")))
-      (org-tags-sparse-tree arg (concat kwd "=" value)))
-     ((member ans '(?r ?R))
-      (call-interactively 'org-occur))
-     (t (error "No such sparse tree command \"%c\"" ans)))))
-
-;; (defun orgpan-avoid-viper-in-buffer ()
-;;   ;; Fix-me: This is ugly. However see `this-major-mode-requires-vi-state':
-;;   (set (make-local-variable 'viper-emacs-state-mode-list) '(orgpan-mode))
-;;   (set (make-local-variable 'viper-new-major-mode-buffer-list) nil)
-;;   (local-set-key [?\ ] 'ignore))
-
-(define-derived-mode orgpan-mode nil "Org-Panel"
-  "Mode for org-simple.el control panel."
-  (set (make-local-variable 'buffer-read-only) t)
-  (unless orgpan-minor-mode-version
-    (add-hook 'pre-command-hook 'orgpan-mode-pre-command nil t)
-    (add-hook 'post-command-hook 'orgpan-mode-post-command t))
-  (set (make-local-variable 'cursor-type) nil)
-  (when (boundp 'yas/dont-activate) (setq yas/dont-activate t))
-  ;; Avoid emulation modes here (cua, viper):
-  (set (make-local-variable 'emulation-mode-map-alists) nil))
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; Panel layout
-
-(defun orgpan-insert-field (text keymap explain)
-  (insert text)
-  (let* ((end (point))
-         (len (length text))
-         (beg (- end len))
-         (ovl (make-overlay beg end)))
-    (overlay-put ovl 'face orgpan-field-face)
-    (overlay-put ovl 'keymap keymap)
-    (overlay-put ovl 'orgpan-explain explain)))
-
-(defconst orgpan-with-keymap
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map org-mode-map)
-    ;; Users are used to tabbing between fields:
-    (define-key map [(tab)]       'orgpan-forward-field)
-    (define-key map [(shift tab)] 'orgpan-backward-field)
-    (define-key map [backtab]     'orgpan-backward-field)
-    ;; Now we must use something else for visibility (first does not
-    ;; work if Viper):
-    (define-key map [(meta tab)]  'org-cycle)
-    (define-key map [(control meta tab)] 'org-global-cycle)
-    map))
-
-(defconst orgpan-without-keymap
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map org-mode-map)
-    ;; Visibility (those are in org-mode-map):
-    ;;(define-key map [tab] 'org-cycle)
-    ;;(define-key map [(shift tab)] 'org-global-cycle)
-    ;; Navigate:
-    (define-key map [left] 'orgpan-outline-up-heading)
-    (define-key map [right] 'org-cycle)
-    (define-key map [up] 'outline-previous-visible-heading)
-    (define-key map [down] 'outline-next-visible-heading)
-    (define-key map [(shift down)] 'outline-forward-same-level)
-    (define-key map [(shift up)] 'outline-backward-same-level)
-    ;; Restructure:
-    (define-key map [(control up)] 'org-move-subtree-up)
-    (define-key map [(control down)] 'org-move-subtree-down)
-    (define-key map [(control left)] 'org-do-promote)
-    (define-key map [(control right)] 'org-do-demote)
-    (define-key map [(control shift left)] 'org-promote-subtree)
-    (define-key map [(control shift right)] 'org-demote-subtree)
-    ;; Todo etc
-    (define-key map [?+] 'org-priority-up)
-    (define-key map [?-] 'org-priority-down)
-    (define-key map [?t] 'org-todo)
-    map))
-
-(defun orgpan-make-panel-without-buttons (buf)
-  (with-current-buffer buf
-    (insert (propertize "*Org Panel*" 'face 'orgpan-active-field))
-    (let ((ovl (make-overlay (point-min) (point-max))))
-      (overlay-put ovl 'priority 10)
-      (overlay-put ovl 'face 'orgpan-active-field))
-    (insert "  ? for help, q quit\n")
-    (insert (propertize "arrows" 'face 'font-lock-keyword-face)
-            ": Go to, "
-            (propertize "C-arrows" 'face 'font-lock-keyword-face)
-            ": Edit tree\n"
-            (propertize "C-cxvz" 'face 'font-lock-keyword-face)
-            ": copy cut paste undo, "
-            (propertize "tT+-" 'face 'font-lock-keyword-face)
-            ": todo priority, "
-            (propertize "s" 'face 'font-lock-keyword-face)
-            ": search, "
-            (propertize "o" 'face 'font-lock-keyword-face)
-            ": open file\n"
-            (propertize "w" 'face 'font-lock-keyword-face)
-            ": write, "
-            (propertize "a" 'face 'font-lock-keyword-face)
-            ": agenda"
-            "\n"
-            )
-    (set-keymap-parent orgpan-mode-map orgpan-without-keymap)
-    (let ((ovl (make-overlay (point-min) (point-max))))
-      (overlay-put ovl 'face 'secondary-selection))
-    ))
-
-(defun orgpan-make-panel-with-buttons (buf)
-  (with-current-buffer buf
-    (let* ((base-map (make-sparse-keymap))
-           (space-line (propertize "\n\n" 'face 'orgpan-spaceline))
-           (arrow-face 'font-lock-keyword-face)
-           (L (propertize "left" 'face arrow-face))
-           (R (propertize "right" 'face arrow-face))
-           (U (propertize "up" 'face arrow-face))
-           (D (propertize "down" 'face arrow-face)))
-      ;;(message D)(sit-for 2)
-      (define-key base-map [left] 'ignore)
-      (define-key base-map [right] 'ignore)
-      (define-key base-map [up] 'ignore)
-      (define-key base-map [down] 'ignore)
-      (define-key base-map [?q] 'delete-window)
-      (define-key base-map [??] 'orgpan-help)
-      ;; Navigating
-      (let ((map (copy-keymap base-map)))
-        (define-key map [left] 'outline-up-heading)
-        (define-key map [right] 'org-cycle)
-        (define-key map [up] 'outline-previous-visible-heading)
-        (define-key map [down] 'outline-next-visible-heading)
-        (define-key map [(shift down)] 'outline-forward-same-level)
-        (define-key map [(shift up)] 'outline-backward-same-level)
-        (orgpan-insert-field "Navigate" map (concat U "/" D ", " L ": Go to, " R ": Visibility")))
-      (insert "  ")
-      (let ((map (copy-keymap base-map)))
-        (define-key map [up] 'org-move-subtree-up)
-        (define-key map [down] 'org-move-subtree-down)
-        (define-key map [left] 'org-do-promote)
-        (define-key map [right] 'org-do-demote)
-        (define-key map [(shift left)] 'org-promote-subtree)
-        (define-key map [(shift right)] 'org-demote-subtree)
-        (orgpan-insert-field
-         "Restructure" map
-         (concat U "/" D ": "
-                 (propertize "Move" 'face 'font-lock-warning-face)
-                 ", " L "/" R ": "
-                 (propertize "Level (w S: Subtree Level)" 'face 'font-lock-warning-face))))
-      (insert "  ")
-      (let ((map (copy-keymap base-map)))
-        (define-key map [up] 'org-priority-up)
-        (define-key map [down] 'org-priority-down)
-        (define-key map [right] 'org-todo)
-        (orgpan-insert-field "TODO/priority" map
-                             (concat R ": TODO, " U "/" D ": Priority")))
-      )
-    (insert "   ? for help, q quit\n")
-    (orgpan-display-bindings-help)
-    (set-keymap-parent orgpan-mode-map orgpan-with-keymap)
-    ))
-
-(defun orgpan-make-panel-buffer ()
-  "Make the panel buffer."
-  (let* ((buf-name "*Org Panel*"))
-    (when orgpan-panel-buffer (kill-buffer orgpan-panel-buffer))
-    ;;(with-current-buffer orgpan-panel-buffer (orgpan-mode))
-    (setq orgpan-panel-buffer (get-buffer-create buf-name))
-    (if orgpan-panel-buttons
-        (orgpan-make-panel-with-buttons orgpan-panel-buffer)
-      (orgpan-make-panel-without-buttons orgpan-panel-buffer))
-    (with-current-buffer orgpan-panel-buffer
-      (orgpan-mode)
-      (goto-char (point-min)))
-    orgpan-panel-buffer))
-
-(defun orgpan-help ()
-  (interactive)
-  (set-keymap-parent orgpan-with-keymap nil)
-  (set-keymap-parent orgpan-without-keymap nil)
-  (describe-function 'orgpan-panel)
-  (set-keymap-parent orgpan-with-keymap org-mode-map)
-  (set-keymap-parent orgpan-without-keymap org-mode-map)
-  (message "Use 'l' to get back to last viewed org file"))
-
-(defcustom orgpan-panel-height 5
-  "Panel height"
-  :type '(choice (integer :tag "One line" 2)
-                 (integer :tag "All lines" 5))
-  :group 'orgpan)
-
-(defun orgpan-panel ()
-  "Create a control panel for current `org-mode' buffer.
-The control panel may be used to quickly move around and change
-the headings. The idea is that when you want to to a lot of this
-kind of editing you should be able to do that with few
-keystrokes (and without having to remember the complicated
-keystrokes). A typical situation when this perhaps can be useful
-is when you are looking at your notes file \(usually ~/.notes,
-see `remember-data-file') where you have saved quick notes with
-`remember'.
-
-The keys below are defined in the panel. Note that the commands
-are carried out in the `org-mode' buffer that belongs to the
-panel.
-
-\\{orgpan-mode-map}
-
-In addition to the keys above most of the keys in `org-mode' can
-also be used from the panel.
-
-Note: There are two forms of the control panel, one with buttons
-and one without. The default is without, see
-`orgpan-panel-buttons'.  If buttons are used choosing a different
-button changes the binding of the arrow keys."
-  (interactive)
-  (unless (derived-mode-p 'org-mode)
-    (error "Buffer is not in org-mode"))
-  (orgpan-delete-panel)
-  (unless orgpan-org-mode-commands
-    (map-keymap (lambda (ev def)
-                  (when (and def
-                             (symbolp def)
-                             (fboundp def))
-                    (setq orgpan-org-mode-commands
-                          (cons def orgpan-org-mode-commands))))
-                org-mode-map))
-  (remq 'org-self-insert-command orgpan-org-mode-commands)
-  ;;(org-back-to-heading)
-  ;;(remove-hook 'window-configuration-change-hook 'orgpan-window-config-change)
-  (split-window)
-  (if orgpan-panel-at-top
-      (setq orgpan-org-window (next-window))
-    (setq orgpan-org-window (selected-window))
-    (select-window (next-window)))
-  (set-window-buffer (selected-window) (orgpan-make-panel-buffer))
-  (setq orgpan-panel-window (selected-window))
-  (set-window-dedicated-p orgpan-panel-window t)
-  (adjust-window-trailing-edge orgpan-org-window
-                               (- (window-height) orgpan-panel-height)  nil)
-  ;; The minor mode version starts here:
-  (when orgpan-minor-mode-version
-    (select-window orgpan-org-window)
-    (orgpan-panel-minor-mode 1)
-    (add-hook 'post-command-hook 'orgpan-minor-post-command t)))
-
-(define-minor-mode orgpan-panel-minor-mode
-  "Minor mode used in `org-mode' buffer when showing panel."
-  :keymap orgpan-mode-map
-  :lighter " PANEL"
-  :group 'orgpan
-  )
-
-(defun orgpan-minor-post-command ()
-  ;; Check org window and buffer
-  (if (and (windowp orgpan-org-window)
-           (window-live-p orgpan-org-window)
-           (eq orgpan-org-window (selected-window))
-           (derived-mode-p 'org-mode)
-           ;; Check panel window and buffer
-           (windowp orgpan-panel-window)
-           (window-live-p orgpan-panel-window)
-           (bufferp orgpan-panel-buffer)
-           (buffer-live-p orgpan-panel-buffer)
-           (eq (window-buffer orgpan-panel-window) orgpan-panel-buffer)
-           ;; Check minor mode
-           orgpan-panel-minor-mode)
-      (setq cursor-type nil)
-    (orgpan-delete-panel)))
-
-
-(provide 'org-panel)
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; org-panel.el ends here
-- 
cgit v1.2.3-54-g00ecf