2012/3/5に晒した物纏め #xyzzy

outline-tree-multiple-frames.lisp

;; -*- mode: lisp; package: outline-tree2; encoding: shift_jis -*-

;; @name        outline-tree-multiple-frames-fix.l
;; @description マルチフレーム版対応
;; @namespace   http://kuonn.mydns.jp/
;; @author      DeaR
;; @timestamp   <2012-04-09 18:05:37 DeaR>

(provide "outline-tree-multiple-frames")

(eval-when (:execute :compile-toplevel :load-toplevel)
  (require "treeview/setup")
  (require "outline-tree/defs"))

(in-package :outline-tree2)


;;--------------------------------------------------------------------------------
;; app-menu
(defmacro merge-app-menu (&body body)
  "*app-menu*をマージして実行"
  `(progn
     (let ((original-app-menu ed::*app-menu*))
       (when (hash-table-p original-app-menu)
         (setf ed::*app-menu* (ed::get-app-menu (ed::selected-frame))))
       ,@body
       (when (hash-table-p original-app-menu)
         (setf ed::*app-menu* original-app-menu)))))



;;--------------------------------------------------------------------------------
;; merge-frame
(defvar *outline-tree-inner-map-frame-p* nil
  "現在実行しているフレーム")

(defvar *outline-tree-app-id-hash* (make-hash-table)
  "全フレームの*outline-tree-app-id*")
(defun get-outline-tree-app-id (&optional (frame (selected-frame)))
  "指定フレームの*outline-tree-app-id*取得"
  (or (gethash frame *outline-tree-app-id-hash*)
      (setf (gethash frame *outline-tree-app-id-hash*) (gensym frame))))
(defun set-outline-tree-app-id (app-id &optional (frame (selected-frame)))
  "指定フレームの*outline-tree-app-id*設定"
  (setf (gethash frame *outline-tree-app-id-hash*) app-id))
(defun rem-outline-tree-app-id (&optional (frame (selected-frame)))
  "指定フレームの*outline-tree-app-id*削除"
  (remhash frame *outline-tree-app-id-hash*))

(defvar *outline-tree-folder-hash-hash* (make-hash-table)
  "全フレームの*outline-tree-folder-hash*")
(defun get-outline-tree-folder-hash (&optional (frame (selected-frame)))
  "指定フレームの*outline-tree-folder-hash*取得"
  (or (gethash frame *outline-tree-folder-hash-hash*)
      (setf (gethash frame *outline-tree-folder-hash-hash*) (make-hash-table :test #'equal))))
(defun set-outline-tree-folder-hash (folder-hash &optional (frame (selected-frame)))
  "指定フレームの*outline-tree-folder-hash*設定"
  (setf (gethash frame *outline-tree-folder-hash-hash*) folder-hash))
(defun rem-outline-tree-folder-hash (&optional (frame (selected-frame)))
  "指定フレームの*outline-tree-folder-hash*削除"
  (remhash frame *outline-tree-folder-hash-hash*))

(defvar *outline-tree-category-hash-hash* (make-hash-table)
  "全フレームの*outline-tree-category-hash*")
(defun get-outline-tree-category-hash (&optional (frame (selected-frame)))
  "指定フレームの*outline-tree-category-hash*取得"
  (or (gethash frame *outline-tree-category-hash-hash*)
      (setf (gethash frame *outline-tree-category-hash-hash*) (make-hash-table :test #'equal))))
(defun set-outline-tree-category-hash (category-hash &optional (frame (selected-frame)))
  "指定フレームの*outline-tree-category-hash*設定"
  (setf (gethash frame *outline-tree-category-hash-hash*) category-hash))
(defun rem-outline-tree-category-hash (&optional (frame (selected-frame)))
  "指定フレームの*outline-tree-category-hash*削除"
  (remhash frame *outline-tree-category-hash-hash*))

(defvar *outline-tree-buffer-hash-hash* (make-hash-table)
  "全フレームの*outline-tree-buffer-hash*")
(defun get-outline-tree-buffer-hash (&optional (frame (selected-frame)))
  "指定フレームの*outline-tree-buffer-hash*取得"
  (or (gethash frame *outline-tree-buffer-hash-hash*)
      (setf (gethash frame *outline-tree-buffer-hash-hash*) (make-hash-table))))
(defun set-outline-tree-buffer-hash (buffer-hash &optional (frame (selected-frame)))
  "指定フレームの*outline-tree-buffer-hash*設定"
  (setf (gethash frame *outline-tree-buffer-hash-hash*) buffer-hash))
(defun rem-outline-tree-buffer-hash (&optional (frame (selected-frame)))
  "指定フレームの*outline-tree-buffer-hash*削除"
  (remhash frame *outline-tree-buffer-hash-hash*))

(defvar *outline-tree-node-hash-hash* (make-hash-table)
  "全フレームの*outline-tree-node-hash*")
(defun get-outline-tree-node-hash (&optional (frame (selected-frame)))
  "指定フレームの*outline-tree-node-hash*取得"
  (or (gethash frame *outline-tree-node-hash-hash*)
      (setf (gethash frame *outline-tree-node-hash-hash*) (make-hash-table))))
(defun set-outline-tree-node-hash (node-hash &optional (frame (selected-frame)))
  "指定フレームの*outline-tree-node-hash*設定"
  (setf (gethash frame *outline-tree-node-hash-hash*) node-hash))
(defun rem-outline-tree-node-hash (&optional (frame (selected-frame)))
  "指定フレームの*outline-tree-node-hash*削除"
  (remhash frame *outline-tree-node-hash-hash*))

(defvar *outline-tree-app-menu-hash* (make-hash-table)
  "全フレームの*outline-tree-app-menu*")
(defun get-outline-tree-app-menu (&optional (frame (selected-frame)))
  "指定フレームの*outline-tree-app-menu*取得"
  (or (gethash frame *outline-tree-app-menu-hash*)
      (setf (gethash frame *outline-tree-app-menu-hash*) nil)))
(defun set-outline-tree-app-menu (menu &optional (frame (selected-frame)))
  "指定フレームの*outline-tree-app-menu*設定"
  (setf (gethash frame *outline-tree-app-menu-hash*) menu))
(defun rem-outline-tree-app-menu (&optional (frame (selected-frame)))
  "指定フレームの*outline-tree-app-menu*削除"
  (remhash frame *outline-tree-app-menu-hash*))

(defmacro merge-frame-0 ((frame) &body body)
  `(let ((frame (or ,frame
                    (selected-frame))))
     (when (and (member frame (frame-list))
                (get-outline-tree-app-id frame))
       (setf *outline-tree-app-id* (get-outline-tree-app-id frame))
       (setf *outline-tree-folder-hash* (get-outline-tree-folder-hash frame))
       (setf *outline-tree-category-hash* (get-outline-tree-category-hash frame))
       (setf *outline-tree-buffer-hash* (get-outline-tree-buffer-hash frame))
       (setf *outline-tree-node-hash* (get-outline-tree-node-hash frame))
       (setf *outline-tree-app-menu* (get-outline-tree-app-menu frame))
       ,@body)))

(defmacro merge-frame ((&optional frame) &body body)
  "指定フレームでマージして実行"
  `(let ((frame (or ,frame
                    (selected-frame))))
     (if *outline-tree-inner-map-frame-p*
         (progn
           ,@body)
       (outline-tree2::merge-frame-0 (frame)
         ,@body))))

(defmacro map-frame ((&optional frame) &body body)
  "全フレームをマージして実行"
  `(let ((frame (or ,frame
                    (selected-frame)))
         (ret))
     (if *outline-tree-inner-map-frame-p*
         (progn
           ,@body)
       (progn
         (get-outline-tree-app-id frame)
         (setf *outline-tree-inner-map-frame-p* t)
         (maphash #'(lambda (k v)
                      (if (eq k frame)
                          (setf ret (outline-tree2::merge-frame-0 (k)
                                      ,@body))
                        (outline-tree2::merge-frame-0 (k)
                          ,@body)))
                  *outline-tree-app-id-hash*)
         (setf *outline-tree-inner-map-frame-p* nil)
         ret))))



;;--------------------------------------------------------------------------------
;; require
(outline-tree2::merge-frame ()
  (merge-app-menu
    (require "outline-tree/outline-tree")))



;;--------------------------------------------------------------------------------
;; function
(defvar *original-outline-tree-create-buffer-node-by-buffer* #'outline-tree-create-buffer-node-by-buffer)
(defun outline-tree-create-buffer-node-by-buffer (&optional buffer)
  "バッファに対応するノードの作成/更新"
  (interactive)
  (outline-tree2::map-frame ()
    (funcall *original-outline-tree-create-buffer-node-by-buffer* buffer)))

(defvar *original-outline-tree-delete-buffer-node-by-buffer* #'outline-tree-delete-buffer-node-by-buffer)
(defun outline-tree-delete-buffer-node-by-buffer (&optional buffer)
  "バッファに対応するノードを削除"
  (interactive)
  (outline-tree2::map-frame ()
    (funcall *original-outline-tree-delete-buffer-node-by-buffer* buffer)))



(defvar *original-outline-tree-insert-category-node* #'outline-tree-insert-category-node)
(defun outline-tree-insert-category-node (category-name parent-node &key (insertafter winapi:TVI_SORT) implicit-func explicit-func)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-insert-category-node* category-name parent-node :insertafter insertafter :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-insert-folder-node* #'outline-tree-insert-folder-node)
(defun outline-tree-insert-folder-node (folder-name parent-node &key (insertafter winapi:TVI_SORT)  implicit-func explicit-func)
  "フォルダノードを追加する。
insertafter 引数はインターフェース統一のために存在するが無効。"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-insert-folder-node* folder-name parent-node :insertafter insertafter :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-insert-buffer-node* #'outline-tree-insert-buffer-node)
(defun outline-tree-insert-buffer-node (buffer parent-node &key (insertafter winapi:TVI_SORT) implicit-func explicit-func)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-insert-buffer-node* buffer parent-node :insertafter insertafter :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-insert-range-node* #'outline-tree-insert-range-node)
(defun outline-tree-insert-range-node (range-name parent-node &key (insertafter winapi:TVI_LAST) title-range whole-range sub-type implicit-func explicit-func)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-insert-range-node* range-name parent-node :insertafter insertafter :title-range title-range :whole-range whole-range :sub-type sub-type :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-insert-point-node* #'outline-tree-insert-point-node)
(defun outline-tree-insert-point-node (point-name parent-node &key (insertafter winapi:TVI_LAST) point implicit-func explicit-func)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-insert-point-node* point-name parent-node :insertafter insertafter :point point :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-insert-info-node* #'outline-tree-insert-info-node)
(defun outline-tree-insert-info-node (info-name parent-node &key (insertafter winapi:TVI_LAST) implicit-func explicit-func)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-insert-info-node* info-name parent-node :insertafter insertafter :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-insert-section-node* #'outline-tree-insert-section-node)
(defun outline-tree-insert-section-node (section-name parent-node &key (insertafter winapi:TVI_LAST) implicit-func explicit-func)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-insert-section-node* section-name parent-node :insertafter insertafter :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-remove-range-node* #'outline-tree-remove-range-node)
(defun outline-tree-remove-range-node (node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-remove-range-node* node)))

(defvar *original-outline-tree-remove-point-node* #'outline-tree-remove-point-node)
(defun outline-tree-remove-point-node (node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-remove-point-node* node)))

(defvar *original-outline-tree-remove-buffer-node* #'outline-tree-remove-buffer-node)
(defun outline-tree-remove-buffer-node (node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-remove-buffer-node* node)))

(defvar *original-outline-tree-remove-folder-node* #'outline-tree-remove-folder-node)
(defun outline-tree-remove-folder-node (node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-remove-folder-node* node)))

(defvar *original-outline-tree-remove-category-node* #'outline-tree-remove-category-node)
(defun outline-tree-remove-category-node (node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-remove-category-node* node)))

(defvar *original-outline-tree-remove-info-node* #'outline-tree-remove-info-node)
(defun outline-tree-remove-info-node (node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-remove-info-node* node)))

(defvar *original-outline-tree-remove-section-node* #'outline-tree-remove-section-node)
(defun outline-tree-remove-section-node (node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-remove-section-node* node)))



(defvar *original-outline-tree-create-outline-ctags* #'outline-tree-create-outline-ctags)
(defun outline-tree-create-outline-ctags (root-node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-create-outline-ctags* root-node)))

(defvar *original-outline-tree-create-outline-global* #'outline-tree-create-outline-global)
(defun outline-tree-create-outline-global (root-node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-create-outline-global* root-node)))

(defvar *original-outline-tree-create-outline-XTAGS* #'outline-tree-create-outline-XTAGS)
(defun outline-tree-create-outline-XTAGS (root-node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-create-outline-XTAGS* root-node)))

(defvar *original-outline-tree-expand-expand-subtree* #'outline-tree-expand-expand-subtree)
(defun outline-tree-expand-expand-subtree (node &optional (depth t))
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-expand-expand-subtree* node depth)))

(defvar *original-outline-tree-expand-collapse-subtree* #'outline-tree-expand-collapse-subtree)
(defun outline-tree-expand-collapse-subtree (node &optional (depth t))
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-expand-collapse-subtree* node depth)))

(defvar *original-outline-tree-expand-expand-if-has-heading-node* #'outline-tree-expand-expand-if-has-heading-node)
(defun outline-tree-expand-expand-if-has-heading-node (node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-expand-expand-if-has-heading-node* node)))

(defvar *original-outline-tree-expand-expand-subtree-show-heading-node* #'outline-tree-expand-expand-subtree-show-heading-node)
(defun outline-tree-expand-expand-subtree-show-heading-node (node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-expand-expand-subtree-show-heading-node* node)))

(defvar *original-outline-tree-node-implicit-func-gen* #'outline-tree-node-implicit-func-gen)
(defun outline-tree-node-implicit-func-gen (&optional node)
  "outline-tree: 暗黙的にノードに対して行う処理用関数を生成"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-node-implicit-func-gen* node)))

(defvar *original-outline-tree-node-explicit-func-gen* #'outline-tree-node-explicit-func-gen)
(defun outline-tree-node-explicit-func-gen (&optional node)
  "outline-tree: 明示的にノードに対して行う処理用関数を生成"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-node-explicit-func-gen* node)))

(defvar *original-outline-tree-initialize-icons* #'outline-tree-initialize-icons)
(defun outline-tree-initialize-icons ()
  "treeview の icon を設定"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-initialize-icons*)))

(defvar *original-outline-tree-initialize-treeview* #'outline-tree-initialize-treeview)
(defun outline-tree-initialize-treeview ()
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-initialize-treeview*)))

(defvar *original-outline-tree-exist-p* #'outline-tree-exist-p)
(defun outline-tree-exist-p ()
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-exist-p*)))

(defvar *original-outline-tree-open* #'outline-tree-open)
(defun outline-tree-open ()
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-open*)))

(defvar *original-outline-tree-close* #'outline-tree-close)
(defun outline-tree-close ()
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-close*)))

(defvar *original-outline-tree-open-p* #'outline-tree-open-p)
(defun outline-tree-open-p ()
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-open-p*)))

(defvar *original-outline-tree-close-p* #'outline-tree-close-p)
(defun outline-tree-close-p ()
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-close-p*)))

(defvar *original-outline-tree-node-has-children-p* #'outline-tree-node-has-children-p)
(defun outline-tree-node-has-children-p (node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-node-has-children-p* node)))

(defvar *original-outline-tree-get-selected-node* #'outline-tree-get-selected-node)
(defun outline-tree-get-selected-node ()
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-get-selected-node*)))

(defvar *original-outline-tree-create* #'outline-tree-create)
(defun outline-tree-create (&optional frame)
  "outline-tree: アウトラインツリー作成"
  (interactive)
  (outline-tree2::merge-frame (frame)
    (funcall *original-outline-tree-create*)))

(defvar *original-outline-tree-delete* #'outline-tree-delete)
(defun outline-tree-delete (&optional frame)
  "outline-tree: アウトラインツリー削除"
  (interactive)
  (outline-tree2::merge-frame (frame)
    (funcall *original-outline-tree-delete*)))

(defvar *original-outline-tree-revdata-set-category-node* #'outline-tree-revdata-set-category-node)
(defun outline-tree-revdata-set-category-node (category-name node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-revdata-set-category-node* category-name node)))

(defvar *original-outline-tree-revdata-del-category-node* #'outline-tree-revdata-del-category-node)
(defun outline-tree-revdata-del-category-node (node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-revdata-del-category-node* node)))

(defvar *original-outline-tree-update-folder-node* #'outline-tree-update-folder-node)
(defun outline-tree-update-folder-node (node &key (folder-name nil folder-name-sv) (implicit-func nil implicit-func-sv) (explicit-func nil explicit-func-sv))
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-update-folder-node* node :folder-name folder-name :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-update-category-node* #'outline-tree-update-category-node)
(defun outline-tree-update-category-node (node &key (category-name nil category-name-sv) (implicit-func nil implicit-func-sv) (explicit-func nil explicit-func-sv))
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-update-category-node* node :category-name category-name :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-update-buffer-node* #'outline-tree-update-buffer-node)
(defun outline-tree-update-buffer-node (node &key (buffer nil buffer-sv) (implicit-func nil implicit-func-sv) (explicit-func nil explicit-func-sv))
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-update-buffer-node* node :buffer buffer :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-update-range-node* #'outline-tree-update-range-node)
(defun outline-tree-update-range-node (node &key (range-name nil range-name-sv) (title-range nil title-range-sv) (contents-range nil contents-range-sv) (whole-range nil whole-range-sv) (implicit-func nil implicit-func-sv) (explicit-func nil plicit-func-sv))
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-update-range-node* node :range-name range-name :title-range title-range :contents-range contents-range :whole-range whole-range :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-update-point-node* #'outline-tree-update-point-node)
(defun outline-tree-update-point-node (node &key (point-name nil point-name-sv) (point nil point-sv) (implicit-func nil implicit-func-sv) (explicit-func nil explicit-func-sv))
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-update-point-node* node :point-name point-name :point point :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-update-info-node* #'outline-tree-update-info-node)
(defun outline-tree-update-info-node (node &key (info-name nil info-name-sv) (implicit-func nil implicit-func-sv) (explicit-func nil explicit-func-sv))
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-update-info-node* node :info-name info-name :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-update-section-node* #'outline-tree-update-section-node)
(defun outline-tree-update-section-node (node &key (section-name nil section-name-sv) (implicit-func nil implicit-func-sv) (explicit-func nil explicit-func-sv))
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-update-section-node* node :section-name section-name :implicit-func implicit-func :explicit-func explicit-func)))

(defvar *original-outline-tree-abbreviate-display-folder-name* #'outline-tree-abbreviate-display-folder-name)
(defun outline-tree-abbreviate-display-folder-name (&optional length)
  "フォルダノード名の表示幅を変更する。"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-abbreviate-display-folder-name* length)))

(defvar *original-outline-tree-sort-folder-node* #'outline-tree-sort-folder-node)
(defun outline-tree-sort-folder-node ()
  "フォルダノードをフォルダノード名でソートする。
outline-tree-insert-folder-node 関数内で使用される。"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-sort-folder-node*)))

(defvar *original-outline-tree-update-modified-buffer-node-name-view* #'outline-tree-update-modified-buffer-node-name-view)
(defun outline-tree-update-modified-buffer-node-name-view ()
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-update-modified-buffer-node-name-view*)))

(defvar *original-outline-tree-sort-node* #'outline-tree-sort-node)
(defun outline-tree-sort-node (parent-node)
  "指定した parent-node の子ノードをノード名でソートする。
outline-tree-insert-buffer-node 関数内で使用される。"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-sort-node* parent-node)))

(defvar *original-outline-tree-funcall-buffer-by-node* #'outline-tree-funcall-buffer-by-node)
(defun outline-tree-funcall-buffer-by-node (func node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-funcall-buffer-by-node* func node)))

(defvar *original-outline-tree-set-data-contents-range-tree-by-node* #'outline-tree-set-data-contents-range-tree-by-node)
(defun outline-tree-set-data-contents-range-tree-by-node (&optional node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-set-data-contents-range-tree-by-node* node)))

(defvar *original-outline-tree-set-data-output-range-tree-by-node* #'outline-tree-set-data-output-range-tree-by-node)
(defun outline-tree-set-data-output-range-tree-by-node (&optional node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-set-data-output-range-tree-by-node* node)))

(defvar *original-outline-tree-get-create-outline-function-by-buffer* #'outline-tree-get-create-outline-function-by-buffer)
(defun outline-tree-get-create-outline-function-by-buffer (&optional buffer)
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-get-create-outline-function-by-buffer* buffer)))

(defvar *original-outline-tree-create-outline-by-buffer* #'outline-tree-create-outline-by-buffer)
(defun outline-tree-create-outline-by-buffer (&optional buffer)
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-create-outline-by-buffer* buffer)))

(defvar *original-outline-tree-delete-outline-by-buffer* #'outline-tree-delete-outline-by-buffer)
(defun outline-tree-delete-outline-by-buffer (&optional buffer)
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-delete-outline-by-buffer* buffer)))

(defvar *original-outline-tree-exist-outline-p-by-buffer* #'outline-tree-exist-outline-p-by-buffer)
(defun outline-tree-exist-outline-p-by-buffer (&optional buffer)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-exist-outline-p-by-buffer* buffer)))

(defvar *original-outline-tree-initialize-expand-node* #'outline-tree-initialize-expand-node)
(defun outline-tree-initialize-expand-node ()
  "ノードの開閉状態を初期状態にする
初期状態：フォルダノードを展開
非表示バッファカテゴリノード以外のカテゴリノードを展開
outline-tree-create 内で用いられる補助関数"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-initialize-expand-node*)))

(defvar *original-outline-tree-get-buffer-by-node* #'outline-tree-get-buffer-by-node)
(defun outline-tree-get-buffer-by-node (&optional node)
  "node が属する buffer を返す"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-get-buffer-by-node* node)))

(defvar *original-outline-tree-get-buffer-node-by-node* #'outline-tree-get-buffer-node-by-node)
(defun outline-tree-get-buffer-node-by-node (&optional node)
  "node が属する buffer-node を返す"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-get-buffer-node-by-node* node)))

(defvar *original-outline-tree-get-folder-node-by-node* #'outline-tree-get-folder-node-by-node)
(defun outline-tree-get-folder-node-by-node (&optional node)
  "node が属する folder-node を返す"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-get-folder-node-by-node* node)))

(defvar *original-outline-tree-get-category-node-by-node* #'outline-tree-get-category-node-by-node)
(defun outline-tree-get-category-node-by-node (&optional node)
  "node が属する category-node を返す"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-get-category-node-by-node* node)))

(defvar *original-outline-tree-get-node-by-buffer* #'outline-tree-get-node-by-buffer)
(defun outline-tree-get-node-by-buffer (&optional buffer)
  "buffer と point に対応する node を返す"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-get-node-by-buffer* buffer)))

(defvar *original-outline-tree-select-node-by-node* #'outline-tree-select-node-by-node)
(defun outline-tree-select-node-by-node (&optional node select-only)
  "渡された node を選択する"
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-select-node-by-node* node select-only)))

(defvar *original-outline-tree-select-up-key-node* #'outline-tree-select-up-key-node)
(defun outline-tree-select-up-key-node (&optional node select-only)
  "node を基準とし、Up キーを押した際の移動先となる node を選択する"
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-select-up-key-node* node select-only)))

(defvar *original-outline-tree-select-down-key-node* #'outline-tree-select-down-key-node)
(defun outline-tree-select-down-key-node (&optional node select-only)
  "node を基準とし、Down キーを押した際の移動先となる node を選択する"
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-select-down-key-node* node select-only)))

(defvar *original-outline-tree-select-left-key-node* #'outline-tree-select-left-key-node)
(defun outline-tree-select-left-key-node (&optional node select-only)
  "node を基準とし、Left キーを押した際の移動先となる node を選択する"
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-select-left-key-node* node select-only)))

(defvar *original-outline-tree-select-right-key-node* #'outline-tree-select-right-key-node)
(defun outline-tree-select-right-key-node (&optional node select-only)
  "node を基準とし、Right キーを押した際の移動先となる node を選択する"
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-select-right-key-node* node select-only)))

(defvar *original-outline-tree-select-pageup-key-node* #'outline-tree-select-pageup-key-node)
(defun outline-tree-select-pageup-key-node (&optional node select-only)
  "node を基準とし、PageUp キーを押した際の移動先となる node を選択する"
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-select-pageup-key-node* node select-only)))

(defvar *original-outline-tree-select-pagedown-key-node* #'outline-tree-select-pagedown-key-node)
(defun outline-tree-select-pagedown-key-node (&optional node select-only)
  "node を基準とし、PageDown キーを押した際の移動先となる node を選択する"
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-select-pagedown-key-node* node select-only)))

(defvar *original-outline-tree-select-ancestor-node* #'outline-tree-select-ancestor-node)
(defun outline-tree-select-ancestor-node (&optional node select-only)
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-select-ancestor-node* node select-only)))

(defvar *original-outline-tree-select-eldest-descendants-node* #'outline-tree-select-eldest-descendants-node)
(defun outline-tree-select-eldest-descendants-node (&optional node select-only)
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-select-eldest-descendants-node* node select-only)))

(defvar *original-outline-tree-select-youngest-descendants-node* #'outline-tree-select-youngest-descendants-node)
(defun outline-tree-select-youngest-descendants-node (&optional node select-only)
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-select-youngest-descendants-node* node select-only)))

(defvar *original-outline-tree-select-node-delay* #'outline-tree-select-node-delay)
(defun outline-tree-select-node-delay ()
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-select-node-delay*)))

(defvar *original-outline-tree-has-heading-node-p-by-buffer* #'outline-tree-has-heading-node-p-by-buffer)
(defun outline-tree-has-heading-node-p-by-buffer (&optional buffer)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-has-heading-node-p-by-buffer* buffer)))

(defvar *original-outline-tree-select-node-by-window-for-hook* #'outline-tree-select-node-by-window-for-hook)
(defun outline-tree-select-node-by-window-for-hook ()
  "対象ウィンドウに関連付いたバッファのポイントに対応するノードを選択する。
アウトラインが最新で、常にハイライトの設定がなされていれば、範囲の
ハイライトも行う。
大抵のコマンドの後では hook 動作を行うが、基本的に treeview、outline-tree を
明示的に操作しているコマンドの場合は安全のため、動作を行わない。"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-select-node-by-window-for-hook*)))

(defvar *original-outline-tree-isearch-forward* #'outline-tree-isearch-forward)
(defun outline-tree-isearch-forward (&optional reverse)
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-isearch-forward* reverse)))

(defvar *original-outline-tree-buffer-list* #'outline-tree-buffer-list)
(defun outline-tree-buffer-list (&optional top-node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-buffer-list* top-node)))

(defvar *original-outline-tree-set-buffer-by-node* #'outline-tree-set-buffer-by-node)
(defun outline-tree-set-buffer-by-node (&optional node)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-set-buffer-by-node* node)))

(defvar *original-outline-tree-delete-region-by-range-node* #'outline-tree-delete-region-by-range-node)
(defun outline-tree-delete-region-by-range-node (&optional range-node)
  "range-node とともに、リージョンを削除"
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-delete-region-by-range-node* range-node)))

(defvar *original-outline-tree-get-swap-target-range-node* #'outline-tree-get-swap-target-range-node)
(defun outline-tree-get-swap-target-range-node (range-node &optional prev)
  "入替え可能な range-node を返す"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-get-swap-target-range-node* range-node prev)))

(defvar *original-outline-tree-swap-region-by-next-range-node* #'outline-tree-swap-region-by-next-range-node)
(defun outline-tree-swap-region-by-next-range-node (&optional range-node prev)
  "range-node を次の range-node と入替え、リージョンの内容も入替える"
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-swap-region-by-next-range-node* range-node prev)))

(defvar *original-outline-tree-create-outline-and-select-node* #'outline-tree-create-outline-and-select-node)
(defun outline-tree-create-outline-and-select-node ()
  (interactive)
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-create-outline-and-select-node*)))

(defvar *original-outline-tree-output-html* #'outline-tree-output-html)
(defun outline-tree-output-html (&optional (type :range) root-node output-depth frame-p (header 'outline-tree-output-html-header) (footer 'outline-tree-output-html-footer) (frame 'outline-tree-output-html-frame) (css 'outline-tree-output-html-css))
  "HTML 出力
type への指定        : :range, :heading
output-depth への指定: nil, :expand"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-output-html* type root-node output-depth frame-p header footer frame css)))



;;--------------------------------------------------------------------------------
;; menu
(defvar *original-outline-tree-startup-app-menu* #'outline-tree-startup-app-menu)
(defun outline-tree-startup-app-menu ()
  (merge-app-menu
    (funcall *original-outline-tree-startup-app-menu*)))

(defvar *original-outline-tree-insert-menu-items* #'outline-tree-insert-menu-items)
(defun outline-tree-insert-menu-items (&key menu position head-sep tail-sep)
  "outline-tree: メニューへ登録"
  (outline-tree2::merge-frame ()
    (merge-app-menu
      (funcall *original-outline-tree-insert-menu-items* :menu menu :position position :head-sep head-sep :tail-sep tail-sep))))

(defvar *original-outline-tree-delete-menu* #'outline-tree-delete-menu)
(defun outline-tree-delete-menu (&optional menu)
  "outline-tree: メニューから削除"
  (merge-app-menu
    (funcall *original-outline-tree-delete-menu* menu)))
(defvar *original-outline-tree-insert-app-menu* #'outline-tree-insert-app-menu)

(defun outline-tree-insert-app-menu (&key (menu (current-menu)) (position *outline-tree-app-menu-position*) (menu-name *outline-tree-app-menu-name*))
  (unless menu
    (if (menup ed::*app-menu*)
        (setf menu ed::*app-menu*)
      (setf menu (ed::get-app-menu (ed::selected-frame)))))
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-insert-app-menu* :menu menu :position position :menu-name menu-name)))

(defvar *original-outline-tree-create-app-menu* #'outline-tree-create-app-menu)
(defun outline-tree-create-app-menu ()
  "メニューを作成"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-create-app-menu*)
    (set-outline-tree-app-menu *outline-tree-app-menu*)))

(defvar *original-outline-tree-menu-gen* #'outline-tree-menu-gen)
(defun outline-tree-menu-gen (node)
  "outline-tree: node に対応するメニューを生成
※実装上の注意: 選択しているノードのバッファとカレントバッファは異なる
場合がありえるので注意。"
  (outline-tree2::merge-frame ()
    (funcall *original-outline-tree-menu-gen* node)))



;;--------------------------------------------------------------------------------
;; hook
(defun outline-tree-init-app-menus-hook (&optional (frame (selected-frame)))
  (outline-tree2::merge-frame (frame)
    (tv::treeview-app-id-register *outline-tree-app-id*)
    (when (eq *outline-tree-use* t)
      (outline-tree-create frame)))
  (outline-tree-insert-app-menu))
(add-hook '*init-app-menus-hook* 'outline-tree-init-app-menus-hook)

(defun outline-tree-delete-frame-functions (frame)
  (outline-tree2::merge-frame (frame)
    (tv::treeview-app-id-unregister *outline-tree-app-id*)
    (rem-outline-tree-app-id frame)
    (rem-outline-tree-folder-hash frame)
    (rem-outline-tree-category-hash frame)
    (rem-outline-tree-buffer-hash frame)
    (rem-outline-tree-node-hash frame)
    (rem-outline-tree-app-menu frame)))
(add-hook '*delete-frame-functions* 'outline-tree-delete-frame-functions)

outline-treeのマルチフレーム対応 - こんなに月も紅いのに