mirror of https://github.com/Chizi123/.emacs.d.git

Chizi123
2018-11-18 434b46beff1c5ec01cbefd5273d89971a82d6bab
commit | author | age
5cb5f7 1 ;ELC
C 2 ;;; Compiled
3 ;;; in Emacs version 26.1
4 ;;; with all optimizations.
5
6 ;;; This file uses dynamic docstrings, first added in Emacs 19.29.
7
8 ;;; This file does not contain utf-8 non-ASCII characters,
9 ;;; and so can be loaded in Emacs versions earlier than 23.
10
11 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
12 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
13
14
15 (byte-code "\300\301!\210\300\302!\207" [require subr-x ztree-util] 2)
16 #@60 If set forces ztree to draw lines with unicode characters.
17 (defvar ztree-draw-unicode-lines nil (#$ . 479))
18 #@65 If set forces ztree show number of child entries in the braces.
19 (defvar ztree-show-number-of-children nil (#$ . 593))
20 #@54 A list of Expanded nodes (i.e. directories) entries.
21 (defvar ztree-expanded-nodes-list nil (#$ . 717))
22 (make-variable-buffer-local 'ztree-expanded-nodes-list)
23 #@44 Start node(i.e. directory) for the window.
24 (defvar ztree-start-node nil (#$ . 882))
25 (make-variable-buffer-local 'ztree-start-node)
26 #@70 List of tuples with full node(i.e. file/directory name and the line.
27 (defvar ztree-line-to-node-table nil (#$ . 1019))
28 (make-variable-buffer-local 'ztree-line-to-node-table)
29 #@37 Index of the start line - the root.
30 (defvar ztree-start-line nil (#$ . 1199))
31 (make-variable-buffer-local 'ztree-start-line)
32 #@122 Array of parent lines.
33 The ith value of the array is the parent line for line i.
34 If ith value is i - it is the root line
35 (defvar ztree-parent-lines-array nil (#$ . 1331))
36 (make-variable-buffer-local 'ztree-parent-lines-array)
37 #@118 Counter for the subsequest BS keys (to identify double BS).
38 Used in order to not to use cl package and `lexical-let'
39 (defvar ztree-count-subsequent-bs nil (#$ . 1564))
40 (make-variable-buffer-local 'ztree-count-subsequent-bs)
41 #@279 Hash table, with key - line number, value - property list of the line.
42 The property list has the following keys:
43 - side (`left', `right', `both').
44 Used for 2-side trees, to determine if the node exists on left or right
45 or both sides
46 - offset - the column there the text starts 
47 (defvar ztree-line-tree-properties nil (#$ . 1795))
48 (make-variable-buffer-local 'ztree-line-tree-properties)
49 #@94 The cons pair of the previous line and column. Used
50 to restore cursor position after refresh
51 (defvar ztree-prev-position nil (#$ . 2188))
52 (make-variable-buffer-local 'ztree-prev-position)
53 #@85 Function inserting the header into the tree buffer.
54 MUST inster newline at the end!
55 (defvar ztree-tree-header-fun nil (#$ . 2382))
56 (make-variable-buffer-local 'ztree-tree-header-fun)
57 #@71 Function which creates a pretty-printable short string from the node.
58 (defvar ztree-node-short-name-fun nil (#$ . 2571))
59 (make-variable-buffer-local 'ztree-node-short-name-fun)
60 #@93 Function which determines if the node is expandable.
61 For example if the node is a directory
62 (defvar ztree-node-is-expandable-fun nil (#$ . 2754))
63 (make-variable-buffer-local 'ztree-node-is-expandable-fun)
64 #@53 Function which determines if the 2 nodes are equal.
65 (defvar ztree-node-equal-fun nil (#$ . 2965))
66 (make-variable-buffer-local 'ztree-node-equal-fun)
67 #@43 Function returning list of node contents.
68 (defvar ztree-node-contents-fun nil (#$ . 3120))
69 (make-variable-buffer-local 'ztree-node-contents-fun)
70 #@166 Function returning position of the node: `left', `right' or `both'.
71 If not defined (by default) - using single screen tree, otherwise
72 the buffer is split to 2 trees
73 (defvar ztree-node-side-fun nil (#$ . 3272))
74 (make-variable-buffer-local 'ztree-node-side-fun)
75 #@39 Function returning face for the node.
76 (defvar ztree-node-face-fun nil (#$ . 3538))
77 (make-variable-buffer-local 'ztree-node-face-fun)
78 #@55 Function called when Enter/Space pressed on the node.
79 (defvar ztree-node-action-fun nil (#$ . 3677))
80 (make-variable-buffer-local 'ztree-node-action-fun)
81 #@58 Function called to decide if the node should be visible.
82 (defvar ztree-node-showp-fun nil (#$ . 3836))
83 (make-variable-buffer-local 'ztree-node-showp-fun)
84 #@26 Keymap for `ztree-mode'.
85 (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))
86 (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)
87 (defvar ztreep-node-face 'ztreep-node-face)
88 (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)
89 (defvar ztreep-leaf-face 'ztreep-leaf-face)
90 (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)
91 (defvar ztreep-arrow-face 'ztreep-arrow-face)
92 (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)
93 (defvar ztreep-expand-sign-face 'ztreep-expand-sign-face)
94 (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)
95 (defvar ztreep-node-count-children-face 'ztreep-node-count-children-face)
96 (defvar ztree-mode-hook nil)
97 (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)
98 (defvar ztree-mode-map (make-sparse-keymap))
99 (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)
100 #@253 A major mode for displaying the directory tree in text mode.
101
102 In addition to any hooks its parent mode `special-mode' might have run,
103 this mode runs the hook `ztree-mode-hook', as the final or penultimate step
104 during initialization.
105
106 \{ztree-mode-map}
107 (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 \325C#\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])
108 #@83 Set the cursor to specified LINE and to the text offset (if possible).
109
110 (fn LINE)
111 (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)])
112 #@97 Return the node for the LINE specified.
113 Search through the array of node-line pairs.
114
115 (fn LINE)
116 (defalias 'ztree-find-node-in-line #[257 "\301\"\207" [ztree-line-to-node-table gethash] 4 (#$ . 8707)])
117 #@105 Find the node at point.
118 Returns cons pair (node, side) for the current point
119 or nil if there is no node
120 (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)])
121 #@63 Find if the NODE is in the list of expanded nodes.
122
123 (fn NODE)
124 (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)])
125 #@70 For given LINE set the PARENT in the global array.
126
127 (fn LINE PARENT)
128 (defalias 'ztree-set-parent-for-line #[514 "    ZI\207" [ztree-parent-lines-array ztree-start-line] 5 (#$ . 9524)])
129 #@44 For given LINE return a parent.
130
131 (fn LINE)
132 (defalias 'ztree-get-parent-for-line #[257 "\211Y\205\211    G\\W\205    ZH\207" [ztree-start-line ztree-parent-lines-array] 4 (#$ . 9715)])
133 #@105 Iteration in expanding subtree.
134 Argument NODE current node.
135 Argument STATE node state.
136
137 (fn NODE STATE)
138 (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)])
139 #@32 Implements the subtree expand.
140 (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)])
141 #@164 Toggle expand/collapsed state for nodes or perform an action.
142 HARD specifies (t or nil) if the hard action, binded on RET,
143 should be performed on node.
144
145 (fn HARD)
146 (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)])
147 #@114 Toggle expand/collapsed state for nodes or perform the action.
148 Performs the hard action, binded on RET, on node.
149 (defalias 'ztree-perform-action #[0 "\300\301!\207" [ztree-do-perform-action t] 2 (#$ . 11188) nil])
150 #@116 Toggle expand/collapsed state for nodes or perform the action.
151 Performs the soft action, binded on Space, on node.
152 (defalias 'ztree-perform-soft-action #[0 "\300\301!\207" [ztree-do-perform-action nil] 2 (#$ . 11409) nil])
153 #@61 Toggle Expanded/Collapsed state on all nodes of the subtree
154 (defalias 'ztree-toggle-expand-subtree #[0 "\300 \207" [ztree-do-toggle-expand-subtree] 1 (#$ . 11638) nil])
155 #@71 Set the expanded state of the NODE to DO-EXPAND.
156
157 (fn NODE DO-EXPAND)
158 (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)])
159 #@54 Toggle expanded/collapsed state for NODE.
160
161 (fn NODE)
162 (defalias 'ztree-toggle-expand-state #[257 "\300\301!?\"\207" [ztree-do-toggle-expand-state ztree-is-expanded-node] 5 (#$ . 12160)])
163 #@113 Action on Backspace key.
164 Jump to the line of a parent node.  If previous key was Backspace
165 then close the node.
166 (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])
167 #@135 Return pair of 2 elements: list of expandable nodes and list of leafs.
168 Argument NODE node which contents will be returned.
169
170 (fn NODE)
171 (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)])
172 #@129 Draw char C at the position (1-based) (X Y).
173 Optional argument FACE face to use to draw a character.
174
175 (fn C X Y &optional FACE)
176 (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)])
177 #@50 Return the character used to draw vertical line.
178 (defalias 'ztree-vertical-line-char #[0 "\203\301\207\302\207" [ztree-draw-unicode-lines 9474 124] 1 (#$ . 13796)])
179 #@50 Return the character used to draw vertical line.
180 (defalias 'ztree-horizontal-line-char #[0 "\203\301\207\302\207" [ztree-draw-unicode-lines 9472 45] 1 (#$ . 13970)])
181 #@50 Return the character used to draw vertical line.
182 (defalias 'ztree-left-bottom-corner-char #[0 "\203\301\207\302\207" [ztree-draw-unicode-lines 9492 96] 1 (#$ . 14145)])
183 #@83 Return left intersection character.
184 It is just vertical bar when unicode disabled
185 (defalias 'ztree-left-intersection-char #[0 "\203\301\207\302\207" [ztree-draw-unicode-lines 9500 124] 1 (#$ . 14323)])
186 #@147 Draw a vertical line of `|' characters from Y1 row to Y2 in X column.
187 Optional argument FACE face to draw line with.
188
189 (fn Y1 Y2 X &optional FACE)
190 (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)])
191 #@199 Draw a vertical line of `|' characters finishing with `\=`' character.
192 Draws the line from Y1 row to Y2 in X column.
193 Optional argument FACE facet to draw the line with.
194
195 (fn Y1 Y2 X &optional FACE)
196 (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)])
197 #@75 Draw the horizontal line from column X1 to X2 in the row Y.
198
199 (fn X1 X2 Y)
200 (defalias 'ztree-draw-horizontal-line #[771 "\300 V\203+ZT\301\211W\205&\211\302\\#\266\211T\262\202 \266\202\202KZT\301\211W\205I\211\302\\#\266\211T\262\2020\266\202\207" [ztree-horizontal-line-char 0 ztree-draw-char] 11 (#$ . 15553)])
201 #@150 Draw the TREE of lines with parents.
202 Argument DEPTH current depth.
203 Argument START-OFFSET column to start drawing from.
204
205 (fn TREE DEPTH START-OFFSET)
206 (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)])
207 #@97 Set the root lines array.
208 Argument TREE nodes tree to create an array of lines from.
209
210 (fn TREE)
211 (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)])
212 #@238 Insert node contents with initial depth 0.
213 `ztree-insert-node-contents-1' return the tree of line
214 numbers to determine who is parent line of the
215 particular line.  This tree is used to draw the
216 graph.
217 Argument PATH start node.
218
219 (fn PATH)
220 (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)])
221 #@78 Recursively insert contents of the NODE with current DEPTH.
222
223 (fn NODE DEPTH)
224 (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)])
225 #@104 Inselt the NODE to the current line with specified DEPTH and EXPANDED state.
226
227 (fn NODE DEPTH EXPANDED)
228 (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)])
229 #@594 Writes a SHORT-NAME in a proper position with the type given.
230 Writes a string with given DEPTH, prefixed with [ ] if EXPANDABLE
231 and [-] or [+] depending on if it is EXPANDED from the specified OFFSET.
232 If `ztree-show-number-of-children' is set to t the COUNT-CHILDREN
233 argument is used to present number of entries in the expandable item.
234 COUNT-CHILDREN might be null if the contents of expandable node are
235 not accessible.
236 Optional argument FACE face to write text with.
237 Returns the position where the text starts.
238
239 (fn SHORT-NAME DEPTH EXPANDABLE EXPANDED OFFSET COUNT-CHILDREN &optional FACE)
240 (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)])
241 #@41 Jump to another side for 2-sided trees.
242 (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])
243 #@53 Save the current position into the global variable.
244 (defalias 'ztree-save-current-position #[0 "\301`!iB\211\207" [ztree-prev-position line-number-at-pos] 2 (#$ . 21222)])
245 #@91 Refresh the buffer.
246 Optional argument LINE scroll to the line given.
247
248 (fn &optional LINE)
249 (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])
250 #@171 Refresh the buffer setting the new root NODE.
251 This will reuse all other settings for the current ztree buffer, but
252 change the root node to the node specified.
253
254 (fn NODE)
255 (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)])
256 #@42 Move the point to ARG lines up
257
258 (fn ARG)
259 (defalias 'ztree-previous-line #[257 "\300\206\301[!\207" [ztree-next-line 1] 3 (#$ . 22465) "^p"])
260 #@44 Move the point to ARG lines down
261
262 (fn ARG)
263 (defalias 'ztree-next-line #[257 "\300!\207" [ztree-move-line] 3 (#$ . 22615) "^p"])
264 #@80 Move the point COUNT lines and place at the beginning of the node.
265
266 (fn COUNT)
267 (defalias 'ztree-move-line #[257 "\300\301 \\!\207" [ztree-scroll-to-line line-number-at-pos] 4 (#$ . 22750)])
268 #@75 Hook called then window configuration changed to resize buffer's contents
269 (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)])
270 #@947 Create a ztree view buffer configured with parameters given.
271 Argument BUFFER-NAME Name of the buffer created.
272 Argument START-NODE Starting node - the root of the tree.
273 Argument FILTER-FUN Function which will define if the node should not be
274 visible.
275 Argument HEADER-FUN Function which inserts the header into the buffer
276 before drawing the tree.
277 Argument SHORT-NAME-FUN Function which return the short name for a node given.
278 Argument EXPANDABLE-P Function to determine if the node is expandable.
279 Argument EQUAL-FUN An equality function for nodes.
280 Argument CHILDREN-FUN Function to get children from the node.
281 Argument FACE-FUN Function to determine face of the node.
282 Argument ACTION-FUN an action to perform when the Return is pressed.
283 Optional argument NODE-SIDE-FUN Determines the side of the node.
284
285 (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)
286 (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)])
287 (provide 'ztree-view)