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

Chizi123
2018-11-18 8f6f2705a38e2515b6c57fda12c5be29fb9a798f
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
;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 \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])
#@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\202KZT\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)