| 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 \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]) | |
| 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\202K ZT\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) | |
