;ELC
|
;;; Compiled
|
;;; in Emacs version 26.1
|
;;; with all optimizations.
|
|
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
|
|
;;; This file does not contain utf-8 non-ASCII characters,
|
;;; and so can be loaded in Emacs versions earlier than 23.
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
(byte-code "\300\301!\210\300\302!\207" [require subr-x ztree-util] 2)
|
#@60 If set forces ztree to draw lines with unicode characters.
|
(defvar ztree-draw-unicode-lines nil (#$ . 479))
|
#@65 If set forces ztree show number of child entries in the braces.
|
(defvar ztree-show-number-of-children nil (#$ . 593))
|
#@54 A list of Expanded nodes (i.e. directories) entries.
|
(defvar ztree-expanded-nodes-list nil (#$ . 717))
|
(make-variable-buffer-local 'ztree-expanded-nodes-list)
|
#@44 Start node(i.e. directory) for the window.
|
(defvar ztree-start-node nil (#$ . 882))
|
(make-variable-buffer-local 'ztree-start-node)
|
#@70 List of tuples with full node(i.e. file/directory name and the line.
|
(defvar ztree-line-to-node-table nil (#$ . 1019))
|
(make-variable-buffer-local 'ztree-line-to-node-table)
|
#@37 Index of the start line - the root.
|
(defvar ztree-start-line nil (#$ . 1199))
|
(make-variable-buffer-local 'ztree-start-line)
|
#@122 Array of parent lines.
|
The ith value of the array is the parent line for line i.
|
If ith value is i - it is the root line
|
(defvar ztree-parent-lines-array nil (#$ . 1331))
|
(make-variable-buffer-local 'ztree-parent-lines-array)
|
#@118 Counter for the subsequest BS keys (to identify double BS).
|
Used in order to not to use cl package and `lexical-let'
|
(defvar ztree-count-subsequent-bs nil (#$ . 1564))
|
(make-variable-buffer-local 'ztree-count-subsequent-bs)
|
#@279 Hash table, with key - line number, value - property list of the line.
|
The property list has the following keys:
|
- side (`left', `right', `both').
|
Used for 2-side trees, to determine if the node exists on left or right
|
or both sides
|
- offset - the column there the text starts
|
(defvar ztree-line-tree-properties nil (#$ . 1795))
|
(make-variable-buffer-local 'ztree-line-tree-properties)
|
#@94 The cons pair of the previous line and column. Used
|
to restore cursor position after refresh
|
(defvar ztree-prev-position nil (#$ . 2188))
|
(make-variable-buffer-local 'ztree-prev-position)
|
#@85 Function inserting the header into the tree buffer.
|
MUST inster newline at the end!
|
(defvar ztree-tree-header-fun nil (#$ . 2382))
|
(make-variable-buffer-local 'ztree-tree-header-fun)
|
#@71 Function which creates a pretty-printable short string from the node.
|
(defvar ztree-node-short-name-fun nil (#$ . 2571))
|
(make-variable-buffer-local 'ztree-node-short-name-fun)
|
#@93 Function which determines if the node is expandable.
|
For example if the node is a directory
|
(defvar ztree-node-is-expandable-fun nil (#$ . 2754))
|
(make-variable-buffer-local 'ztree-node-is-expandable-fun)
|
#@53 Function which determines if the 2 nodes are equal.
|
(defvar ztree-node-equal-fun nil (#$ . 2965))
|
(make-variable-buffer-local 'ztree-node-equal-fun)
|
#@43 Function returning list of node contents.
|
(defvar ztree-node-contents-fun nil (#$ . 3120))
|
(make-variable-buffer-local 'ztree-node-contents-fun)
|
#@166 Function returning position of the node: `left', `right' or `both'.
|
If not defined (by default) - using single screen tree, otherwise
|
the buffer is split to 2 trees
|
(defvar ztree-node-side-fun nil (#$ . 3272))
|
(make-variable-buffer-local 'ztree-node-side-fun)
|
#@39 Function returning face for the node.
|
(defvar ztree-node-face-fun nil (#$ . 3538))
|
(make-variable-buffer-local 'ztree-node-face-fun)
|
#@55 Function called when Enter/Space pressed on the node.
|
(defvar ztree-node-action-fun nil (#$ . 3677))
|
(make-variable-buffer-local 'ztree-node-action-fun)
|
#@58 Function called to decide if the node should be visible.
|
(defvar ztree-node-showp-fun nil (#$ . 3836))
|
(make-variable-buffer-local 'ztree-node-showp-fun)
|
#@26 Keymap for `ztree-mode'.
|
(defvar ztree-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\304#\210\302\310\311#\210\302\312\313#\210\302\314\315#\210\302\316\317#\210\302\320\321#\210\203? \302\322\323#\210\202E \302\324\323#\210\211\207" [window-system make-sparse-keymap define-key " " ztree-perform-action " " ztree-perform-soft-action [double-mouse-1] " " ztree-jump-side "g" ztree-refresh-buffer "x" ztree-toggle-expand-subtree [remap next-line] ztree-next-line [remap previous-line] ztree-previous-line [backspace] ztree-move-up-in-tree ""] 5) (#$ . 3996))
|
(custom-declare-face 'ztreep-node-face '((((background dark)) (:foreground "#ffffff")) (((type nil)) (:inherit 'font-lock-function-name-face)) (t (:foreground "Blue"))) "*Face used for expandable entries(directories etc) in Ztree buffer." :group 'Ztree :group 'font-lock-highlighting-faces)
|
(defvar ztreep-node-face 'ztreep-node-face)
|
(custom-declare-face 'ztreep-leaf-face '((((background dark)) (:foreground "cyan1")) (((type nil)) (:inherit 'font-lock-variable-name-face)) (t (:foreground "darkblue"))) "*Face used for not expandable nodes(leafs, i.e. files) in Ztree buffer." :group 'Ztree :group 'font-lock-highlighting-faces)
|
(defvar ztreep-leaf-face 'ztreep-leaf-face)
|
(custom-declare-face 'ztreep-arrow-face '((((background dark)) (:foreground "#7f7f7f")) (t (:foreground "#8d8d8d"))) "*Face used for arrows in Ztree buffer." :group 'Ztree :group 'font-lock-highlighting-faces)
|
(defvar ztreep-arrow-face 'ztreep-arrow-face)
|
(custom-declare-face 'ztreep-expand-sign-face '((((background dark)) (:foreground "#7f7fff")) (t (:foreground "#8d8d8d"))) "*Face used for expand sign [+] in Ztree buffer." :group 'Ztree :group 'font-lock-highlighting-faces)
|
(defvar ztreep-expand-sign-face 'ztreep-expand-sign-face)
|
(custom-declare-face 'ztreep-node-count-children-face '((t (:inherit 'font-lock-comment-face :slant italic))) "*Face used for count of number of child entries in Ztree buffer." :group 'Ztree :group 'font-lock-highlighting-faces)
|
(defvar ztreep-node-count-children-face 'ztreep-node-count-children-face)
|
(defvar ztree-mode-hook nil)
|
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [ztree-mode-hook variable-documentation put "Hook run after entering Ztree mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp ztree-mode-map definition-name ztree-mode] 4)
|
(defvar ztree-mode-map (make-sparse-keymap))
|
(byte-code "\301\302N\204 \303\301\302\304\305!#\210\306\307!\204 \303\307\310\311#\210\312\313 !\210\307\302N\204- \303\307\302\304\314!#\210\306\300!\204B \303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P \303\300\302\304\320!#\210\303\311\321\322#\207" [ztree-mode-abbrev-table ztree-mode-map variable-documentation put purecopy "Keymap for `ztree-mode'." boundp ztree-mode-syntax-table definition-name ztree-mode (lambda (#1=#:def-tmp-var) (defvar ztree-mode-syntax-table #1#)) make-syntax-table "Syntax table for `ztree-mode'." (lambda (#1#) (defvar ztree-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `ztree-mode'." derived-mode-parent special-mode] 5)
|
#@253 A major mode for displaying the directory tree in text mode.
|
|
In addition to any hooks its parent mode `special-mode' might have run,
|
this mode runs the hook `ztree-mode-hook', as the final or penultimate step
|
during initialization.
|
|
\{ztree-mode-map}
|
(defalias 'ztree-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203 \314\311\313\310\313N#\210\315 !\204' \316 \317 \"\210\320\f!\211\2035 \211\321 =\203; \322\f\323 \"\210\210\324 \325\"\204R =\204R \326 \325 C#\210\327 !\210\330\f!\210 \331 \307 )\332\333!\207" [delay-mode-hooks major-mode mode-name ztree-mode-map ztree-mode-syntax-table ztree-mode-abbrev-table make-local-variable t special-mode ztree-mode "Ztree" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table nil run-mode-hooks ztree-mode-hook local-abbrev-table indent-tabs-mode buffer-read-only] 5 (#$ . 7240) nil])
|
#@83 Set the cursor to specified LINE and to the text offset (if possible).
|
|
(fn LINE)
|
(defalias 'ztree-scroll-to-line #[257 "\304 \305\245\306 \307\211\310Z\311\"\210\312\313\306 \n\"\314\"\211\2054 \203- iY\203- \211T\\\262\315 \210`\\b\262*\207" [goal-column line-move-visual ztree-line-tree-properties ztree-node-side-fun window-width 2 line-number-at-pos nil line-move t plist-get gethash offset beginning-of-line] 7 (#$ . 8260)])
|
#@97 Return the node for the LINE specified.
|
Search through the array of node-line pairs.
|
|
(fn LINE)
|
(defalias 'ztree-find-node-in-line #[257 "\301\"\207" [ztree-line-to-node-table gethash] 4 (#$ . 8707)])
|
#@105 Find the node at point.
|
Returns cons pair (node, side) for the current point
|
or nil if there is no node
|
(defalias 'ztree-find-node-at-point #[0 "\300 \301\245\302\303 !\211\205 \211iV\203 \304\202 \305B\207" [window-width 2 ztree-find-node-in-line line-number-at-pos right left] 5 (#$ . 8917)])
|
#@63 Find if the NODE is in the list of expanded nodes.
|
|
(fn NODE)
|
(defalias 'ztree-is-expanded-node #[257 "\301\302\303\304\305\306!\307\"\310\311%\"\207" [ztree-expanded-nodes-list ztree-find make-byte-code 257 " \300\"\207" vconcat vector [ztree-node-equal-fun] 4 "\n\n(fn X)"] 9 (#$ . 9222)])
|
#@70 For given LINE set the PARENT in the global array.
|
|
(fn LINE PARENT)
|
(defalias 'ztree-set-parent-for-line #[514 " ZI\207" [ztree-parent-lines-array ztree-start-line] 5 (#$ . 9524)])
|
#@44 For given LINE return a parent.
|
|
(fn LINE)
|
(defalias 'ztree-get-parent-for-line #[257 "\211Y\205 \211 G\\W\205 ZH\207" [ztree-start-line ztree-parent-lines-array] 4 (#$ . 9715)])
|
#@105 Iteration in expanding subtree.
|
Argument NODE current node.
|
Argument STATE node state.
|
|
(fn NODE STATE)
|
(defalias 'ztree-do-toggle-expand-subtree-iter #[514 "!\205% !\302\"\210\211\211\205! \211@\303\"\210A\266\202\202 \262\262\207" [ztree-node-is-expandable-fun ztree-node-contents-fun ztree-do-toggle-expand-state ztree-do-toggle-expand-subtree-iter] 8 (#$ . 9908)])
|
#@32 Implements the subtree expand.
|
(defalias 'ztree-do-toggle-expand-subtree #[0 "\301 \302!\303 !\205 \304!?\305\"\266\306!\210\307\310 \"\207" [ztree-node-is-expandable-fun line-number-at-pos ztree-find-node-in-line window-start ztree-is-expanded-node ztree-do-toggle-expand-subtree-iter ztree-refresh-buffer set-window-start selected-window] 7 (#$ . 10295)])
|
#@164 Toggle expand/collapsed state for nodes or perform an action.
|
HARD specifies (t or nil) if the hard action, binded on RET,
|
should be performed on node.
|
|
(fn HARD)
|
(defalias 'ztree-do-perform-action #[257 "\302 \303!\211\205, !\203 \304!\210\202 \203 \"\210\305 \306!\210\307\310 \"\262\207" [ztree-node-is-expandable-fun ztree-node-action-fun line-number-at-pos ztree-find-node-in-line ztree-toggle-expand-state window-start ztree-refresh-buffer set-window-start selected-window] 7 (#$ . 10670)])
|
#@114 Toggle expand/collapsed state for nodes or perform the action.
|
Performs the hard action, binded on RET, on node.
|
(defalias 'ztree-perform-action #[0 "\300\301!\207" [ztree-do-perform-action t] 2 (#$ . 11188) nil])
|
#@116 Toggle expand/collapsed state for nodes or perform the action.
|
Performs the soft action, binded on Space, on node.
|
(defalias 'ztree-perform-soft-action #[0 "\300\301!\207" [ztree-do-perform-action nil] 2 (#$ . 11409) nil])
|
#@61 Toggle Expanded/Collapsed state on all nodes of the subtree
|
(defalias 'ztree-toggle-expand-subtree #[0 "\300 \207" [ztree-do-toggle-expand-subtree] 1 (#$ . 11638) nil])
|
#@71 Set the expanded state of the NODE to DO-EXPAND.
|
|
(fn NODE DO-EXPAND)
|
(defalias 'ztree-do-toggle-expand-state #[514 "\211\204 \301\302\303\304\305\306!\307\"\310\311%\"\211\207B\211\207" [ztree-expanded-nodes-list ztree-filter make-byte-code 257 " \300\"?\207" vconcat vector [ztree-node-equal-fun] 4 "\n\n(fn X)"] 9 (#$ . 11813)])
|
#@54 Toggle expanded/collapsed state for NODE.
|
|
(fn NODE)
|
(defalias 'ztree-toggle-expand-state #[257 "\300\301!?\"\207" [ztree-do-toggle-expand-state ztree-is-expanded-node] 5 (#$ . 12160)])
|
#@113 Action on Backspace key.
|
Jump to the line of a parent node. If previous key was Backspace
|
then close the node.
|
(defalias 'ztree-move-up-in-tree #[0 "\2056 \303`!\304!\211\2054 \305\232\203/ \n\204/ \306!\307!\203% \310!\210\311\312!\262\2024 \313\314!\266\202\207" [ztree-parent-lines-array last-command ztree-count-subsequent-bs line-number-at-pos ztree-get-parent-for-line ztree-move-up-in-tree ztree-find-node-in-line ztree-is-expanded-node ztree-toggle-expand-state t ztree-refresh-buffer nil ztree-scroll-to-line] 5 (#$ . 12355) nil])
|
#@135 Return pair of 2 elements: list of expandable nodes and list of leafs.
|
Argument NODE node which contents will be returned.
|
|
(fn NODE)
|
(defalias 'ztree-get-splitted-node-contens #[257 "!\301\302\303\304\"\"\302\303\305\"\"B\207" [ztree-node-contents-fun #[514 "!!\231\207" [ztree-node-short-name-fun] 5 "\n\n(fn X Y)"] sort ztree-filter #[257 "!\207" [ztree-node-is-expandable-fun] 3 "\n\n(fn F)"] #[257 "!?\207" [ztree-node-is-expandable-fun] 3 "\n\n(fn F)"]] 8 (#$ . 12914)])
|
#@129 Draw char C at the position (1-based) (X Y).
|
Optional argument FACE face to use to draw a character.
|
|
(fn C X Y &optional FACE)
|
(defalias 'ztree-draw-char #[1027 "\212eb\210Sy\210\300 \210`S\\b\210\301\302!\210\303\302\"\210\304`S`\305\203' \202( \306$)\207" [beginning-of-line delete-char 1 insert-char put-text-property font-lock-face ztreep-arrow-face] 9 (#$ . 13412)])
|
#@50 Return the character used to draw vertical line.
|
(defalias 'ztree-vertical-line-char #[0 "\203 \301\207\302\207" [ztree-draw-unicode-lines 9474 124] 1 (#$ . 13796)])
|
#@50 Return the character used to draw vertical line.
|
(defalias 'ztree-horizontal-line-char #[0 "\203 \301\207\302\207" [ztree-draw-unicode-lines 9472 45] 1 (#$ . 13970)])
|
#@50 Return the character used to draw vertical line.
|
(defalias 'ztree-left-bottom-corner-char #[0 "\203 \301\207\302\207" [ztree-draw-unicode-lines 9492 96] 1 (#$ . 14145)])
|
#@83 Return left intersection character.
|
It is just vertical bar when unicode disabled
|
(defalias 'ztree-left-intersection-char #[0 "\203 \301\207\302\207" [ztree-draw-unicode-lines 9500 124] 1 (#$ . 14323)])
|
#@147 Draw a vertical line of `|' characters from Y1 row to Y2 in X column.
|
Optional argument FACE face to draw line with.
|
|
(fn Y1 Y2 X &optional FACE)
|
(defalias 'ztree-draw-vertical-line #[1027 "\300 \301Z!V\2039 \211\302\211W\203* \211\303\n\\ $\266\211T\262\202 \266\303\\$\202b \211\302\211W\203V \211\303 \\ $\266\211T\262\202; \266\303\\$\207" [ztree-vertical-line-char abs 0 ztree-draw-char] 14 (#$ . 14535)])
|
#@199 Draw a vertical line of `|' characters finishing with `\=`' character.
|
Draws the line from Y1 row to Y2 in X column.
|
Optional argument FACE facet to draw the line with.
|
|
(fn Y1 Y2 X &optional FACE)
|
(defalias 'ztree-draw-vertical-rounded-line #[1027 "\300 \301 \302Z!V\203A \211\303\211W\2031 \211\304 \\\n$\266\211T\262\202 \266\304\\$\202l \211\303\211W\203_ \211\304 \f\\\n$\266\211T\262\202C \266\304 \\$\207" [ztree-vertical-line-char ztree-left-bottom-corner-char abs 0 ztree-draw-char] 15 (#$ . 14992)])
|
#@75 Draw the horizontal line from column X1 to X2 in the row Y.
|
|
(fn X1 X2 Y)
|
(defalias 'ztree-draw-horizontal-line #[771 "\300 V\203+ ZT\301\211W\205& \211\302\\#\266\211T\262\202 \266\202\202K ZT\301\211W\205I \211\302\\#\266\211T\262\2020 \266\202\207" [ztree-horizontal-line-char 0 ztree-draw-char] 11 (#$ . 15553)])
|
#@150 Draw the TREE of lines with parents.
|
Argument DEPTH current depth.
|
Argument START-OFFSET column to start drawing from.
|
|
(fn TREE DEPTH START-OFFSET)
|
(defalias 'ztree-draw-tree #[771 ":\205\242 @A\300_\\\301\\\302\\\300\\\303 \304 \305\306\307\310\311 !\312\"\313\314%\205\240 \315\305\306\316\310\311!\317\"\300\320%\"\321\\\203P \322 T\323!#\210 \211\203\222 \211@\324T#\210\211<\203k \202m \323!\323!!\203\211 \325 S#\210\326\f#\210\266A\266\202\202R \210\205\236 \325\323!#\266\202\266\211\207" [4 3 7 ztree-left-bottom-corner-char ztree-left-intersection-char make-byte-code 257 " \204 \303\207\304\305\n\"\306\"\211\307\267\202 \300\310U\202 \300\310V\202 \303\207" vconcat vector [ztree-node-side-fun ztree-line-tree-properties t plist-get gethash side #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (left 19 right 25)) 0] 5 "\n\n(fn LINE)" ztree-find "\300\301!!\207" [ztree-car-atom] "\n\n(fn X)" 2 ztree-draw-vertical-line ztree-car-atom ztree-draw-tree ztree-draw-char ztree-draw-horizontal-line] 22 (#$ . 15902)])
|
#@97 Set the root lines array.
|
Argument TREE nodes tree to create an array of lines from.
|
|
(fn TREE)
|
(defalias 'ztree-fill-parent-array #[257 "\211@A\211\211\205\" \211@\300\301!\"\210\211<\203 \302!\210A\266\202\202 \262\207" [ztree-set-parent-for-line ztree-car-atom ztree-fill-parent-array] 8 (#$ . 17025)])
|
#@238 Insert node contents with initial depth 0.
|
`ztree-insert-node-contents-1' return the tree of line
|
numbers to determine who is parent line of the
|
particular line. This tree is used to draw the
|
graph.
|
Argument PATH start node.
|
|
(fn PATH)
|
(defalias 'ztree-insert-node-contents #[257 "\303\304\"\305`!Z\306\304\"\307\211\"\210\310!\210\311\304\211#\210\n\2059 \312 \313\\S\314\245\315$\210\311\304\314\245T#\262\207" [ztree-start-line ztree-parent-lines-array ztree-node-side-fun ztree-insert-node-contents-1 0 line-number-at-pos make-vector ztree-set-parent-for-line ztree-fill-parent-array ztree-draw-tree window-width ztree-draw-vertical-line 2 vertical-border] 9 (#$ . 17346)])
|
#@78 Recursively insert contents of the NODE with current DEPTH.
|
|
(fn NODE DEPTH)
|
(defalias 'ztree-insert-node-contents-1 #[514 "\301!\302#\303\203V \304!\211@A\211\2033 \211@!\203, \305\nT\"B\262A\266\202\202 \210\211\211\203T \211@!\203M \302\nT\303#B\262A\266\202\2025 \266B\207" [ztree-node-showp-fun ztree-is-expanded-node ztree-insert-entry nil ztree-get-splitted-node-contens ztree-insert-node-contents-1] 14 (#$ . 18045)])
|
#@104 Inselt the NODE to the current line with specified DEPTH and EXPANDED state.
|
|
(fn NODE DEPTH EXPANDED)
|
(defalias 'ztree-insert-entry #[771 "\306 \307\" !\n!\205' \205' \3101% \311\312\f !\"G0\202' \210\313\205A \205A \3141? \311\315\f\n!\"G0\202A \210\313 \203\251 \n \316\" \n!\317 \320=\203Y \321\262\322=\203b \321\262\323\324\325 \f\326 \205| !&#\262\325\f \327\245T \205\231 !&\210\323\330#\262\266\202\302 \323\324\325\f \326\f\205\275 \n&#\262\331\n #\210\331#\210\332c\210\207" [ztree-line-tree-properties ztree-node-is-expandable-fun ztree-node-short-name-fun ztree-show-number-of-children ztree-node-contents-fun ztree-node-side-fun line-number-at-pos gethash (error) cl-remove-if #[257 "\205\n \301!\302\"\207" [ztree-node-side-fun eql right] 4 "\n\n(fn N)"] nil (error) #[257 "\205\n \301!\302\"\207" [ztree-node-side-fun eql left] 4 "\n\n(fn N)"] t window-width left "" right plist-put offset ztree-insert-single-entry 0 2 side puthash "\n" ztree-node-face-fun ztree-line-to-node-table] 24 (#$ . 18506)])
|
#@594 Writes a SHORT-NAME in a proper position with the type given.
|
Writes a string with given DEPTH, prefixed with [ ] if EXPANDABLE
|
and [-] or [+] depending on if it is EXPANDED from the specified OFFSET.
|
If `ztree-show-number-of-children' is set to t the COUNT-CHILDREN
|
argument is used to present number of entries in the expandable item.
|
COUNT-CHILDREN might be null if the contents of expandable node are
|
not accessible.
|
Optional argument FACE face to write text with.
|
Returns the position where the text starts.
|
|
(fn SHORT-NAME DEPTH EXPANDABLE EXPANDED OFFSET COUNT-CHILDREN &optional FACE)
|
(defalias 'ztree-insert-single-entry #[1798 "\303\304\203\n \202 \203 \305\202 `\306\307\"\210\310`\311#\266`\312 |\210\303V\2036 \313\314\n\315_\"\210 G\303V\203 `\203I !\210\313\314\315`ZZ\"\266i\262\316\n\317#c\210 \203 \203 \320\321\203u \322!\202v \323\"\316\317\n#c\266\207" [ztreep-leaf-face ztree-show-number-of-children ztreep-node-count-children-face 0 #[257 "\301\203 \302\202\n \303\304Q\305\306#c\207" [ztreep-expand-sign-face "[" "-" "+" "]" propertize font-lock-face] 6 "\n\n(fn EXP)"] ztreep-node-face move-to-column t remove-text-properties (font-lock-face nil) line-end-position insert-char 32 4 propertize font-lock-face format " [%s]" number-to-string "N/A"] 16 (#$ . 19611)])
|
#@41 Jump to another side for 2-sided trees.
|
(defalias 'ztree-jump-side #[0 "\205 \301 \302\245iW\203 \303T!\210\202 \303\304!\210\305\306 !\262\207" [ztree-node-side-fun window-width 2 move-to-column 1 ztree-scroll-to-line line-number-at-pos] 3 (#$ . 20949) nil])
|
#@53 Save the current position into the global variable.
|
(defalias 'ztree-save-current-position #[0 "\301`!iB\211\207" [ztree-prev-position line-number-at-pos] 2 (#$ . 21222)])
|
#@91 Refresh the buffer.
|
Optional argument LINE scroll to the line given.
|
|
(fn &optional LINE)
|
(defalias 'ztree-refresh-buffer #[256 "\306\232\205j \307\310!\205j \311 \311 \312 \313 \210\314 \210 \210\315`!\316!\210\203? \317!\210\211\205g \320 \210 A`\\b\202g \204Q \211\204Q \317!\210\313 \202g ?\205g \211\205g \317 @!\210\320 \210 A`\\b)\262\207" [major-mode ztree-prev-position ztree-line-to-node-table ztree-line-tree-properties inhibit-read-only ztree-tree-header-fun ztree-mode boundp ztree-start-node make-hash-table t ztree-save-current-position erase-buffer line-number-at-pos ztree-insert-node-contents ztree-scroll-to-line beginning-of-line ztree-start-line] 4 (#$ . 21401) nil])
|
#@171 Refresh the buffer setting the new root NODE.
|
This will reuse all other settings for the current ztree buffer, but
|
change the root node to the node specified.
|
|
(fn NODE)
|
(defalias 'ztree-change-start-node #[257 "\211\211C\303\304 \207" [ztree-start-node ztree-expanded-nodes-list ztree-prev-position nil ztree-refresh-buffer] 2 (#$ . 22113)])
|
#@42 Move the point to ARG lines up
|
|
(fn ARG)
|
(defalias 'ztree-previous-line #[257 "\300\206 \301[!\207" [ztree-next-line 1] 3 (#$ . 22465) "^p"])
|
#@44 Move the point to ARG lines down
|
|
(fn ARG)
|
(defalias 'ztree-next-line #[257 "\300!\207" [ztree-move-line] 3 (#$ . 22615) "^p"])
|
#@80 Move the point COUNT lines and place at the beginning of the node.
|
|
(fn COUNT)
|
(defalias 'ztree-move-line #[257 "\300\301 \\!\207" [ztree-scroll-to-line line-number-at-pos] 4 (#$ . 22750)])
|
#@75 Hook called then window configuration changed to resize buffer's contents
|
(defalias 'ztree-view-on-window-configuration-changed #[0 "\300\301\302\303#\207" [walk-windows #[257 "r\300!q\210\301\302!\205 \303 )\207" [window-buffer derived-mode-p ztree-mode ztree-refresh-buffer] 3 "\n\n(fn WIN)"] nil visible] 4 (#$ . 22947)])
|
#@947 Create a ztree view buffer configured with parameters given.
|
Argument BUFFER-NAME Name of the buffer created.
|
Argument START-NODE Starting node - the root of the tree.
|
Argument FILTER-FUN Function which will define if the node should not be
|
visible.
|
Argument HEADER-FUN Function which inserts the header into the buffer
|
before drawing the tree.
|
Argument SHORT-NAME-FUN Function which return the short name for a node given.
|
Argument EXPANDABLE-P Function to determine if the node is expandable.
|
Argument EQUAL-FUN An equality function for nodes.
|
Argument CHILDREN-FUN Function to get children from the node.
|
Argument FACE-FUN Function to determine face of the node.
|
Argument ACTION-FUN an action to perform when the Return is pressed.
|
Optional argument NODE-SIDE-FUN Determines the side of the node.
|
|
(fn BUFFER-NAME START-NODE FILTER-FUN HEADER-FUN SHORT-NAME-FUN EXPANDABLE-P EQUAL-FUN CHILDREN-FUN FACE-FUN ACTION-FUN &optional NODE-SIDE-FUN)
|
(defalias 'ztree-view #[2826 "\306 !\307!\210\310 \210\n\211C \311\312\313\"\210\314 \207" [ztree-start-node ztree-expanded-nodes-list ztree-node-showp-fun ztree-tree-header-fun ztree-node-short-name-fun ztree-node-is-expandable-fun get-buffer-create switch-to-buffer ztree-mode add-hook window-configuration-change-hook ztree-view-on-window-configuration-changed ztree-refresh-buffer ztree-node-equal-fun ztree-node-contents-fun ztree-node-face-fun ztree-node-action-fun ztree-node-side-fun] 16 (#$ . 23281)])
|
(provide 'ztree-view)
|
