|
167
|
1 ;;; speedbar --- quick access to files and tags -*-byte-compile-warnings:nil;-*-
|
|
|
2
|
|
|
3 ;; Copyright (C) 1996, 1997 Eric M. Ludlam
|
|
|
4 ;;
|
|
|
5 ;; Author: Eric M. Ludlam <zappo@gnu.ai.mit.edu>
|
|
|
6 ;; Version: 0.5
|
|
|
7 ;; Keywords: file, tags, tools
|
|
|
8 ;; X-RCS: $Id: speedbar.el,v 1.2 1997/06/29 23:13:33 steve Exp $
|
|
|
9 ;;
|
|
|
10 ;; This program is free software; you can redistribute it and/or modify
|
|
|
11 ;; it under the terms of the GNU General Public License as published by
|
|
|
12 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
13 ;; any later version.
|
|
|
14 ;;
|
|
|
15 ;; This program is distributed in the hope that it will be useful,
|
|
|
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
18 ;; GNU General Public License for more details.
|
|
|
19 ;;
|
|
|
20 ;; You should have received a copy of the GNU General Public License
|
|
|
21 ;; along with this program; if not, you can either send email to this
|
|
|
22 ;; program's author (see below) or write to:
|
|
|
23 ;;
|
|
|
24 ;; The Free Software Foundation, Inc.
|
|
|
25 ;; 675 Mass Ave.
|
|
|
26 ;; Cambridge, MA 02139, USA.
|
|
|
27 ;;
|
|
|
28 ;; Please send bug reports, etc. to zappo@gnu.ai.mit.edu.
|
|
|
29 ;;
|
|
100
|
30
|
|
167
|
31 ;;; Commentary:
|
|
|
32 ;;
|
|
|
33 ;; The speedbar provides a frame in which files, and locations in
|
|
|
34 ;; files are displayed. These items can be clicked on with mouse-2
|
|
|
35 ;; in order to make the last active frame display that file location.
|
|
|
36 ;;
|
|
|
37 ;; To use speedbar, add this to your .emacs file:
|
|
|
38 ;;
|
|
|
39 ;; (autoload 'speedbar-frame-mode "speedbar" "Popup a speedbar frame" t)
|
|
|
40 ;; (autoload 'speedbar-get-focus "speedbar" "Jump to speedbar frame" t)
|
|
|
41 ;;
|
|
|
42 ;; If you want to choose it from a menu or something, do this:
|
|
|
43 ;;
|
|
|
44 ;; (define-key-after (lookup-key global-map [menu-bar tools])
|
|
|
45 ;; [speedbar] '("Speedbar" . speedbar-frame-mode) [calendar])
|
|
|
46 ;;
|
|
|
47 ;; If you want to access speedbar using only the keyboard, do this:
|
|
|
48 ;;
|
|
|
49 ;; (define-key global-map [f4] 'speedbar-get-focus)
|
|
|
50 ;;
|
|
|
51 ;; This will let you hit f4 (or whatever key you choose) to jump
|
|
|
52 ;; focus to the speedbar frame. Pressing RET or e to jump to a file
|
|
|
53 ;; or tag will move you back to the attached frame. The command
|
|
|
54 ;; `speedbar-get-fucus' will also create a speedbar frame if it does
|
|
|
55 ;; not exist.
|
|
|
56 ;;
|
|
|
57 ;; Once a speedbar frame is active, it takes advantage of idle time
|
|
|
58 ;; to keep it's contents updated. The contents is usually a list of
|
|
|
59 ;; files in the directory of the currently active buffer. When
|
|
|
60 ;; applicable, tags in the active file can be expanded.
|
|
|
61 ;;
|
|
|
62 ;; To add new supported files types into speedbar, use the function
|
|
|
63 ;; `speedbar-add-supported-extension' If speedbar complains that the
|
|
|
64 ;; file type is not supported, that means there is no built in
|
|
|
65 ;; support from imenu, and the etags part wasn't set up correctly. You
|
|
|
66 ;; may add elements to `speedbar-supported-extension-expressions' as long
|
|
|
67 ;; as it is done before speedbar is loaded.
|
|
|
68 ;;
|
|
|
69 ;; To prevent speedbar from following you into certain directories
|
|
|
70 ;; use the function `speedbar-add-ignored-path-regexp' too add a new
|
|
|
71 ;; regular expression matching a type of path. You may add list
|
|
|
72 ;; elements to `speedbar-ignored-path-expressions' as long as it is
|
|
|
73 ;; done before speedbar is loaded.
|
|
|
74 ;;
|
|
|
75 ;; To add new file types to imenu, see the documentation in the
|
|
|
76 ;; file imenu.el that comes with emacs. To add new file types which
|
|
|
77 ;; etags supports, you need to modify the variable
|
|
|
78 ;; `speedbar-fetch-etags-parse-list'.
|
|
|
79 ;;
|
|
|
80 ;; If the updates are going too slow for you, modify the variable
|
|
|
81 ;; `speedbar-update-speed' to a longer idle time before updates.
|
|
|
82 ;;
|
|
|
83 ;; If you navigate directories, you will probably notice that you
|
|
|
84 ;; will navigate to a directory which is eventually replaced after
|
|
|
85 ;; you go back to editing a file (unless you pull up a new file.)
|
|
|
86 ;; The delay time before this happens is in
|
|
|
87 ;; `speedbar-navigating-speed', and defaults to 10 seconds.
|
|
|
88 ;;
|
|
|
89 ;; XEmacs users may want to change the default timeouts for
|
|
|
90 ;; `speedbar-update-speed' to something longer as XEmacs doesn't have
|
|
|
91 ;; idle timers, the speedbar timer keeps going off arbitrarilly while
|
|
|
92 ;; you're typing. It's quite pesky.
|
|
|
93 ;;
|
|
|
94 ;; Users of emacs previous to to v 19.31 (when idle timers
|
|
|
95 ;; where introduced) will not have speedbar updating automatically.
|
|
|
96 ;; Use "r" to refresh the display after changing directories.
|
|
|
97 ;; Remember, do not interrupt the stealthy updates or you display may
|
|
|
98 ;; not be completely refreshed.
|
|
|
99 ;;
|
|
|
100 ;; See optional file `speedbspec.el' for additional configurations
|
|
|
101 ;; which allow speedbar to create specialized lists for special modes
|
|
|
102 ;; that are not file-related.
|
|
|
103 ;;
|
|
|
104 ;; See optional file `speedbcfg.el' for interactive buffers
|
|
|
105 ;; allowing simple configuration of colors and features of speedbar.
|
|
|
106 ;;
|
|
|
107 ;; AUC-TEX users: The imenu tags for AUC-TEX mode don't work very
|
|
|
108 ;; well. Use the imenu keywords from tex-mode.el for better results.
|
|
|
109 ;;
|
|
|
110 ;; This file requires the library package assoc (association lists)
|
|
100
|
111
|
|
|
112 ;;; Speedbar updates can be found at:
|
|
167
|
113 ;; ftp://ftp.ultranet.com/pub/zappo/speedbar*.tar.gz
|
|
|
114 ;;
|
|
100
|
115
|
|
167
|
116 ;;; Change log:
|
|
|
117 ;; 0.1 Initial Revision
|
|
|
118 ;; 0.2 Fixed problem with x-pointer-shape causing future frames not
|
|
|
119 ;; to be created.
|
|
|
120 ;; Fixed annoying habit of `speedbar-update-contents' to make
|
|
|
121 ;; it possible to accidentally kill the speedbar buffer.
|
|
|
122 ;; Clicking directory names now only changes the contents of
|
|
|
123 ;; the speedbar, and does not cause a dired mode to appear.
|
|
|
124 ;; Clicking the <+> next to the directory does cause dired to
|
|
|
125 ;; be run.
|
|
|
126 ;; Added XEmacs support, which means timer support moved to a
|
|
|
127 ;; platform independant call.
|
|
|
128 ;; Added imenu support. Now modes are supported by imenu
|
|
|
129 ;; first, and etags only if the imenu call doesn't work.
|
|
|
130 ;; Imenu is a little faster than etags, and is more emacs
|
|
|
131 ;; friendly.
|
|
|
132 ;; Added more user control variables described in the commentary.
|
|
|
133 ;; Added smart recentering when nodes are opened and closed.
|
|
|
134 ;; 0.3 x-pointer-shape fixed for emacs 19.35, so I put that check in.
|
|
|
135 ;; Added invisible codes to the beginning of each line.
|
|
|
136 ;; Added list aproach to node expansion for easier addition of new
|
|
|
137 ;; types of things to expand by
|
|
|
138 ;; Added multi-level path name support
|
|
|
139 ;; Added multi-level tag name support.
|
|
|
140 ;; Only mouse-2 is now used for node expansion
|
|
|
141 ;; Added keys e + - to edit expand, and contract node lines
|
|
|
142 ;; Added longer legal file regexp for all those modes which support
|
|
|
143 ;; imenu. (pascal, fortran90, ada, pearl)
|
|
|
144 ;; Added pascal support to etags from Dave Penkler <dave_penkler@grenoble.hp.com>
|
|
|
145 ;; Fixed centering algorithm
|
|
|
146 ;; Tried to choose background independent colors. Made more robust.
|
|
|
147 ;; Rearranged code into a more logical order
|
|
|
148 ;; 0.3.1 Fixed doc & broken keybindings
|
|
|
149 ;; Added mode hooks.
|
|
|
150 ;; Improved color selection to be background mode smart
|
|
|
151 ;; `nil' passed to `speedbar-frame-mode' now toggles the frame as
|
|
|
152 ;; advertised in the doc string
|
|
|
153 ;; 0.4a Added modified patch from Dan Schmidt <dfan@lglass.com> allowing a
|
|
|
154 ;; directory cache to be maintained speeding up revisiting of files.
|
|
|
155 ;; Default raise-lower behavior is now off by default.
|
|
|
156 ;; Added some menu items for edit expand and contract.
|
|
|
157 ;; Pre 19.31 emacsen can run without idle timers.
|
|
|
158 ;; Added some patch information from Farzin Guilak <farzin@protocol.com>
|
|
|
159 ;; adding xemacs specifics, and some etags upgrades.
|
|
|
160 ;; Added ability to set a faces symbol-value to a string
|
|
|
161 ;; representing the desired foreground color. (idea from
|
|
|
162 ;; Farzin Guilak, but implemented differently)
|
|
|
163 ;; Fixed problem with 1 character buttons.
|
|
|
164 ;; Added support for new Imenu marker technique.
|
|
|
165 ;; Added `speedbar-load-hooks' for things to run only once on
|
|
|
166 ;; load such as updating one of the many lists.
|
|
|
167 ;; Added `speedbar-supported-extension-expressions' which is a
|
|
|
168 ;; list of extensions that speedbar will tag. This variable
|
|
|
169 ;; should only be updated with `speedbar-add-supported-extension'
|
|
|
170 ;; Moved configure dialog support to a separate file so
|
|
|
171 ;; speedbar is not dependant on eieio to run
|
|
|
172 ;; Fixed list-contraction problem when the item was at the end
|
|
|
173 ;; of a sublist.
|
|
|
174 ;; Fixed XEmacs multi-frame timer selecting bug problem.
|
|
|
175 ;; Added `speedbar-ignored-modes' which is a list of major modes
|
|
|
176 ;; speedbar will not follow when it is displayed in the selected frame
|
|
|
177 ;; 0.4 When the file being edited is not in the list, and is a file
|
|
|
178 ;; that should be in the list, the speedbar cache is replaced.
|
|
|
179 ;; Temp buffers are now shown in the attached frame not the
|
|
|
180 ;; speedbar frame
|
|
|
181 ;; New variables `speedbar-vc-*' and `speedbar-stealthy-function-list'
|
|
|
182 ;; added. `speedbar-update-current-file' is now a member of
|
|
|
183 ;; the stealthy list. New function `speedbar-check-vc' will
|
|
|
184 ;; examine each file and mark it if it is checked out. To
|
|
|
185 ;; add new version control types, override the function
|
|
|
186 ;; `speedbar-this-file-in-vc' and `speedbar-vc-check-dir-p'.
|
|
|
187 ;; The stealth list is interruptible so that long operations
|
|
|
188 ;; do not interrupt someones editing flow. Other long
|
|
|
189 ;; speedbar updates will be added to the stealthy list in the
|
|
|
190 ;; future should interesting ones be needed.
|
|
|
191 ;; Added many new functions including:
|
|
|
192 ;; `speedbar-item-byte-compile' `speedbar-item-load'
|
|
|
193 ;; `speedbar-item-copy' `speedbar-item-rename' `speedbar-item-delete'
|
|
|
194 ;; and `speedbar-item-info'
|
|
|
195 ;; If the user kills the speedbar buffer in some way, the frame will
|
|
|
196 ;; be removed.
|
|
|
197 ;; 0.4.1 Bug fixes
|
|
|
198 ;; <mark.jeffries@nomura.co.uk> added `speedbar-update-flag',
|
|
|
199 ;; XEmacs fixes for menus, and tag sorting, and quit key.
|
|
|
200 ;; Modeline now updates itself based on window-width.
|
|
|
201 ;; Frame is cached when closed to make pulling it up again faster.
|
|
|
202 ;; Speedbars window is now marked as dedicated.
|
|
|
203 ;; Added bindings: <grossjoh@charly.informatik.uni-dortmund.de>
|
|
|
204 ;; Long directories are now span multiple lines autmoatically
|
|
|
205 ;; Added `speedbar-directory-button-trim-method' to specify how to
|
|
|
206 ;; sorten the directory button to fit on the screen.
|
|
|
207 ;; 0.4.2 Add one level of full-text cache.
|
|
|
208 ;; Add `speedbar-get-focus' to switchto/raise the speedbar frame.
|
|
|
209 ;; Editing thing-on-line will auto-raise the attached frame.
|
|
|
210 ;; Bound `U' to `speedbar-up-directory' command.
|
|
|
211 ;; Refresh will now maintain all subdirectories that were open
|
|
|
212 ;; when the refresh was requested. (This does not include the
|
|
|
213 ;; tags, only the directories)
|
|
|
214 ;; 0.4.3 Bug fixes
|
|
|
215 ;; 0.4.4 Added `speedbar-ignored-path-expressions' and friends.
|
|
|
216 ;; Configuration menu items not displayed if dialog-mode not present
|
|
|
217 ;; Speedbar buffer now starts with a space, and is not deleted
|
|
|
218 ;; ewhen the speedbar frame is closed. This prevents the invisible
|
|
|
219 ;; frame from preventing buffer switches with other buffers.
|
|
|
220 ;; Fixed very bad bug in the -add-[extension|path] functions.
|
|
|
221 ;; Added `speedbar-find-file-in-frame' which will always pop up a frame
|
|
|
222 ;; that is already display a buffer selected in the speedbar buffer.
|
|
|
223 ;; Added S-mouse2 as "power click" for always poping up a new frame.
|
|
|
224 ;; and always rescanning with imenu (ditching the imenu cache), and
|
|
|
225 ;; always rescanning directories.
|
|
|
226 ;; 0.4.5 XEmacs bugfixes and enhancements.
|
|
|
227 ;; Window Title simplified.
|
|
|
228 ;; 0.4.6 Fixed problems w/ dedicated minibuffer frame.
|
|
|
229 ;; Fixed errors reported by checkdoc.
|
|
|
230 ;; 0.5 Mode-specific contents added. Controlled w/ the variable
|
|
|
231 ;; `speedbar-mode-specific-contents-flag'. See speedbspec
|
|
|
232 ;; for info on enabling this feature.
|
|
|
233 ;; `speedbar-load-hook' name change and pointer check against
|
|
|
234 ;; major-mode. Suggested by Sam Steingold <sds@ptc.com>
|
|
|
235 ;; Quit auto-selects the attached frame.
|
|
|
236 ;; Ranamed `speedbar-do-updates' to `speedbar-update-flag'
|
|
|
237 ;; Passes checkdoc.
|
|
|
238
|
|
100
|
239 ;;; TODO:
|
|
167
|
240 ;; 1) More functions to create buttons and options
|
|
|
241 ;; 2) filtering algoritms to reduce the number of tags/files displayed.
|
|
|
242 ;; 3) Timeout directories we haven't visited in a while.
|
|
|
243 ;; 4) Remeber tags when refreshing the display. (Refresh tags too?)
|
|
|
244 ;; 5) More 'special mode support.
|
|
|
245 ;; 6) Smart way to auto-expand instead of directory switch
|
|
100
|
246
|
|
167
|
247 ;;; Code:
|
|
|
248 (require 'assoc)
|
|
|
249 (require 'easymenu)
|
|
|
250
|
|
|
251 (defvar speedbar-xemacsp (string-match "XEmacs" emacs-version)
|
|
|
252 "Non-nil if we are running in the XEmacs environment.")
|
|
100
|
253
|
|
|
254 (defvar speedbar-initial-expansion-list
|
|
|
255 '(speedbar-directory-buttons speedbar-default-directory-list)
|
|
167
|
256 "List of functions to call to fill in the speedbar buffer.
|
|
|
257 Whenever a top level update is issued all functions in this list are
|
|
|
258 run. These functions will always get the default directory to use
|
|
|
259 passed in as the first parameter, and a 0 as the second parameter.
|
|
|
260 The 0 indicates the uppermost indentation level. They must assume
|
|
|
261 that the cursor is at the position where they start inserting
|
|
|
262 buttons.")
|
|
|
263
|
|
|
264 (defvar speedbar-stealthy-function-list
|
|
|
265 '(speedbar-update-current-file speedbar-check-vc)
|
|
|
266 "List of functions to periodically call stealthily.
|
|
|
267 Each function must return nil if interrupted, or t if completed.
|
|
|
268 Stealthy functions which have a single operation should always return
|
|
|
269 t. Functions which take a long time should maintain a state (where
|
|
|
270 they are in their speedbar related calculations) and permit
|
|
|
271 interruption. See `speedbar-check-vc' as a good example.")
|
|
|
272
|
|
|
273 (defvar speedbar-mode-specific-contents-flag t
|
|
|
274 "*Non-nil means speedbar will show specail-mode contents.
|
|
|
275 This permits some modes to create customized contents for the speedbar
|
|
|
276 frame.")
|
|
|
277
|
|
|
278 (defvar speedbar-special-mode-expansion-list nil
|
|
|
279 "Mode specific list of functions to call to fill in speedbar.
|
|
|
280 Some modes, such as Info or RMAIL, do not relate quite as easily into
|
|
|
281 a simple list of files. When this variable is non-nil and buffer-local,
|
|
|
282 then these functions are used, creating specialized contents. These
|
|
|
283 functions are called each time the speedbar timer is called. This
|
|
|
284 allows a mode to update it's contents regularly.
|
|
|
285
|
|
|
286 Each function is called with the default and frame belonging to
|
|
|
287 speedbar, and with one parameter; the buffer requesting
|
|
|
288 the speedbar display.")
|
|
|
289
|
|
|
290 (defvar speedbar-load-hook nil
|
|
|
291 "Hooks run when speedbar is loaded.")
|
|
|
292
|
|
|
293 (defvar speedbar-desired-buffer nil
|
|
|
294 "Non-nil when speedbar is showing buttons specific a special mode.
|
|
|
295 In this case it is the originating buffer.")
|
|
100
|
296
|
|
|
297 (defvar speedbar-show-unknown-files nil
|
|
167
|
298 "*Non-nil show files we can't expand with a ? in the expand button.
|
|
|
299 nil means don't show the file in the list.")
|
|
100
|
300
|
|
|
301 ;; Xemacs timers aren't based on idleness. Therefore tune it down a little
|
|
|
302 ;; or suffer mightilly!
|
|
|
303 (defvar speedbar-update-speed (if speedbar-xemacsp 5 1)
|
|
167
|
304 "*Idle time in seconds needed before speedbar will update itself.
|
|
|
305 Updates occur to allow speedbar to display directory information
|
|
|
306 relevant to the buffer you are currently editing.")
|
|
100
|
307 (defvar speedbar-navigating-speed 10
|
|
167
|
308 "*Idle time to wait after navigation commands in speedbar are executed.
|
|
|
309 Navigation commands included expanding/contracting nodes, and moving
|
|
|
310 between different directories.")
|
|
100
|
311
|
|
167
|
312 (defvar speedbar-frame-parameters (list
|
|
|
313 ;; Xemacs fails to delete speedbar
|
|
|
314 ;; if minibuffer is off.
|
|
|
315 ;(cons 'minibuffer
|
|
|
316 ; (if speedbar-xemacsp t nil))
|
|
|
317 ;; The above behavior seems to have fixed
|
|
|
318 ;; itself somewhere along the line.
|
|
|
319 ;; let me know if any problems arise.
|
|
|
320 '(minibuffer . nil)
|
|
|
321 '(width . 20)
|
|
|
322 '(scroll-bar-width . 10)
|
|
|
323 '(border-width . 0)
|
|
|
324 '(unsplittable . t) )
|
|
|
325 "*Parameters to use when creating the speedbar frame.
|
|
|
326 Parameters not listed here which will be added automatically are
|
|
|
327 `height' which will be initialized to the height of the frame speedbar
|
|
|
328 is attached to. To add more frame defaults, `cons' new alist members
|
|
|
329 onto this variable through the `speedbar-load-hook'")
|
|
100
|
330
|
|
167
|
331 (defvar speedbar-use-imenu-flag (stringp (locate-library "imenu"))
|
|
|
332 "*Non-nil means use imenu for file parsing. nil to use etags.
|
|
|
333 XEmacs doesn't support imenu, therefore the default is to use etags
|
|
|
334 instead. Etags support is not as robust as imenu support.")
|
|
100
|
335
|
|
167
|
336 (defvar speedbar-sort-tags nil
|
|
|
337 "*If Non-nil, sort tags in the speedbar display. (Etags only)
|
|
|
338 See imenu.el source for how imenu does sorting.")
|
|
|
339
|
|
|
340 (defvar speedbar-directory-button-trim-method 'span
|
|
|
341 "*Indicates how the directory button will be displayed.
|
|
|
342 Possible values are:
|
|
|
343 'span - span large directories over multiple lines.
|
|
|
344 'trim - trim large directories to only show the last few.
|
|
|
345 nil - no trimming.")
|
|
100
|
346
|
|
|
347 (defvar speedbar-before-delete-hook nil
|
|
167
|
348 "*Hooks called before deleting the speedbar frame.")
|
|
100
|
349
|
|
|
350 (defvar speedbar-mode-hook nil
|
|
167
|
351 "*Hooks called after creating a speedbar buffer.")
|
|
100
|
352
|
|
|
353 (defvar speedbar-timer-hook nil
|
|
167
|
354 "*Hooks called after running the speedbar timer function.")
|
|
|
355
|
|
|
356 (defvar speedbar-verbosity-level 1
|
|
|
357 "*Verbosity level of the speedbar. 0 means say nothing.
|
|
|
358 1 means medium level verbosity. 2 and higher are higher levels of
|
|
|
359 verbosity.")
|
|
|
360
|
|
|
361 (defvar speedbar-vc-indicator " *"
|
|
|
362 "*Text used to mark files which are currently checked out.
|
|
|
363 Currently only RCS is supported. Other version control systems can be
|
|
|
364 added by examining the function `speedbar-this-file-in-vc' and
|
|
|
365 `speedbar-vc-check-dir-p'")
|
|
|
366
|
|
|
367 (defvar speedbar-vc-do-check t
|
|
|
368 "*Non-nil check all files in speedbar to see if they have been checked out.
|
|
|
369 Any file checked out is marked with `speedbar-vc-indicator'")
|
|
|
370
|
|
|
371 (defvar speedbar-vc-to-do-point nil
|
|
|
372 "Local variable maintaining the current version control check position.")
|
|
|
373
|
|
|
374 (defvar speedbar-ignored-modes nil
|
|
|
375 "*List of major modes which speedbar will not switch directories for.")
|
|
|
376
|
|
|
377 (defvar speedbar-ignored-path-expressions
|
|
|
378 '("/log/$")
|
|
|
379 "*List of regular expressions matching directories speedbar will ignore.
|
|
|
380 They should included paths to directories which are notoriously very
|
|
|
381 large and take a long time to load in. Use the function
|
|
|
382 `speedbar-add-ignored-path-regexp' to add new items to this list after
|
|
|
383 speedbar is loaded. You may place anything you like in this list
|
|
|
384 before speedbar has been loaded.")
|
|
100
|
385
|
|
|
386 (defvar speedbar-file-unshown-regexp
|
|
|
387 (let ((nstr "") (noext completion-ignored-extensions))
|
|
|
388 (while noext
|
|
|
389 (setq nstr (concat nstr (regexp-quote (car noext)) "$"
|
|
|
390 (if (cdr noext) "\\|" ""))
|
|
|
391 noext (cdr noext)))
|
|
|
392 (concat nstr "\\|#[^#]+#$\\|\\.\\.?$"))
|
|
167
|
393 "*Regexp matching files we don't want displayed in a speedbar buffer.
|
|
|
394 It is generated from the variable `completion-ignored-extensions'")
|
|
|
395
|
|
|
396 (defvar speedbar-supported-extension-expressions
|
|
|
397 (append '(".[CcHh]\\(++\\|pp\\|c\\|h\\)?" ".tex\\(i\\(nfo\\)?\\)?"
|
|
|
398 ".el" ".emacs" ".p" ".java")
|
|
|
399 (if speedbar-use-imenu-flag
|
|
|
400 '(".f90" ".ada" ".pl" ".tcl" ".m"
|
|
|
401 "Makefile\\(\\.in\\)?")))
|
|
|
402 "*List of regular expressions which will match files supported by tagging.
|
|
|
403 Do not prefix the `.' char with a double \\ to quote it, as the period
|
|
|
404 will be stripped by a simplified optimizer when compiled into a
|
|
|
405 singular expression. This variable will be turned into
|
|
|
406 `speedbar-file-regexp' for use with speedbar. You should use the
|
|
|
407 function `speedbar-add-supported-extension' to add a new extension at
|
|
|
408 runtime, or use the configuration dialog to set it in your .emacs
|
|
|
409 file.")
|
|
|
410
|
|
|
411 (defun speedbar-extension-list-to-regex (extlist)
|
|
|
412 "Takes EXTLIST, a list of extensions and transforms it into regexp.
|
|
|
413 All the preceding . are stripped for an optimized expression starting
|
|
|
414 with . followed by extensions, followed by full-filenames."
|
|
|
415 (let ((regex1 nil) (regex2 nil))
|
|
|
416 (while extlist
|
|
|
417 (if (= (string-to-char (car extlist)) ?.)
|
|
|
418 (setq regex1 (concat regex1 (if regex1 "\\|" "")
|
|
|
419 (substring (car extlist) 1)))
|
|
|
420 (setq regex2 (concat regex2 (if regex2 "\\|" "") (car extlist))))
|
|
|
421 (setq extlist (cdr extlist)))
|
|
|
422 ;; concat all the sub-exressions together, making sure all types
|
|
|
423 ;; of parts exist during concatination.
|
|
|
424 (concat "\\("
|
|
|
425 (if regex1 (concat "\\(\\.\\(" regex1 "\\)\\)") "")
|
|
|
426 (if (and regex1 regex2) "\\|" "")
|
|
|
427 (if regex2 (concat "\\(" regex2 "\\)") "")
|
|
|
428 "\\)$")))
|
|
|
429
|
|
|
430 (defvar speedbar-ignored-path-regexp
|
|
|
431 (speedbar-extension-list-to-regex speedbar-ignored-path-expressions)
|
|
|
432 "Regular expression matching paths speedbar will not switch to.
|
|
|
433 Created from `speedbar-ignored-path-expressions' with the function
|
|
|
434 `speedbar-extension-list-to-regex' (A misnamed function in this case.)
|
|
|
435 Use the function `speedbar-add-ignored-path-regexp' to modify this
|
|
|
436 variable.")
|
|
100
|
437
|
|
167
|
438 (defvar speedbar-file-regexp
|
|
|
439 (speedbar-extension-list-to-regex speedbar-supported-extension-expressions)
|
|
|
440 "Regular expression matching files we know how to expand.
|
|
|
441 Created from `speedbar-supported-extension-expression' with the
|
|
|
442 function `speedbar-extension-list-to-regex'")
|
|
|
443
|
|
|
444 (defun speedbar-add-supported-extension (extension)
|
|
|
445 "Add EXTENSION as a new supported extension for speedbar tagging.
|
|
|
446 This should start with a `.' if it is not a complete file name, and
|
|
|
447 the dot should NOT be quoted in with \\. Other regular expression
|
|
|
448 matchers are allowed however. EXTENSION may be a single string or a
|
|
|
449 list of strings."
|
|
|
450 (if (not (listp extension)) (setq extension (list extension)))
|
|
|
451 (while extension
|
|
|
452 (if (member (car extension) speedbar-supported-extension-expressions)
|
|
|
453 nil
|
|
|
454 (setq speedbar-supported-extension-expressions
|
|
|
455 (cons (car extension) speedbar-supported-extension-expressions)))
|
|
|
456 (setq extension (cdr extension)))
|
|
|
457 (setq speedbar-file-regexp (speedbar-extension-list-to-regex
|
|
|
458 speedbar-supported-extension-expressions)))
|
|
|
459
|
|
|
460 (defun speedbar-add-ignored-path-regexp (path-expression)
|
|
|
461 "Add PATH-EXPRESSION as a new ignored path for speedbar tracking.
|
|
|
462 This function will modify `speedbar-ignored-path-regexp' and add
|
|
|
463 PATH-EXPRESSION to `speedbar-ignored-path-expressions'."
|
|
|
464 (if (not (listp path-expression))
|
|
|
465 (setq path-expression (list path-expression)))
|
|
|
466 (while path-expression
|
|
|
467 (if (member (car path-expression) speedbar-ignored-path-expressions)
|
|
|
468 nil
|
|
|
469 (setq speedbar-ignored-path-expressions
|
|
|
470 (cons (car path-expression) speedbar-ignored-path-expressions)))
|
|
|
471 (setq path-expression (cdr path-expression)))
|
|
|
472 (setq speedbar-ignored-path-regexp (speedbar-extension-list-to-regex
|
|
|
473 speedbar-ignored-path-expressions)))
|
|
|
474
|
|
|
475 (defvar speedbar-update-flag (or (not (fboundp 'run-with-idle-timer))
|
|
|
476 (not (fboundp 'start-itimer)))
|
|
|
477 "*Non-nil means to automatically update the display.
|
|
|
478 When this is nil then speedbar will not follow the attached frame's path.
|
|
|
479 When speedbar is active, use:
|
|
|
480
|
|
|
481 \\<speedbar-key-map> `\\[speedbar-toggle-updates]'
|
|
|
482
|
|
|
483 to toggle this value.")
|
|
100
|
484
|
|
|
485 (defvar speedbar-syntax-table nil
|
|
167
|
486 "Syntax-table used on the speedbar.")
|
|
100
|
487
|
|
|
488 (if speedbar-syntax-table
|
|
|
489 nil
|
|
|
490 (setq speedbar-syntax-table (make-syntax-table))
|
|
|
491 ;; turn off paren matching around here.
|
|
|
492 (modify-syntax-entry ?\' " " speedbar-syntax-table)
|
|
|
493 (modify-syntax-entry ?\" " " speedbar-syntax-table)
|
|
|
494 (modify-syntax-entry ?( " " speedbar-syntax-table)
|
|
|
495 (modify-syntax-entry ?) " " speedbar-syntax-table)
|
|
|
496 (modify-syntax-entry ?[ " " speedbar-syntax-table)
|
|
|
497 (modify-syntax-entry ?] " " speedbar-syntax-table))
|
|
167
|
498
|
|
100
|
499
|
|
|
500 (defvar speedbar-key-map nil
|
|
|
501 "Keymap used in speedbar buffer.")
|
|
167
|
502
|
|
|
503 (autoload 'speedbar-configure-options "speedbcfg" "Configure speedbar variables" t)
|
|
|
504 (autoload 'speedbar-configure-faces "speedbcfg" "Configure speedbar faces" t)
|
|
100
|
505
|
|
|
506 (if speedbar-key-map
|
|
|
507 nil
|
|
|
508 (setq speedbar-key-map (make-keymap))
|
|
|
509 (suppress-keymap speedbar-key-map t)
|
|
|
510
|
|
167
|
511 ;; control
|
|
100
|
512 (define-key speedbar-key-map "e" 'speedbar-edit-line)
|
|
167
|
513 (define-key speedbar-key-map "\C-m" 'speedbar-edit-line)
|
|
100
|
514 (define-key speedbar-key-map "+" 'speedbar-expand-line)
|
|
|
515 (define-key speedbar-key-map "-" 'speedbar-contract-line)
|
|
167
|
516 (define-key speedbar-key-map "g" 'speedbar-refresh)
|
|
|
517 (define-key speedbar-key-map "t" 'speedbar-toggle-updates)
|
|
|
518 (define-key speedbar-key-map "q" 'speedbar-close-frame)
|
|
|
519 (define-key speedbar-key-map "U" 'speedbar-up-directory)
|
|
|
520
|
|
|
521 ;; navigation
|
|
|
522 (define-key speedbar-key-map "n" 'speedbar-next)
|
|
|
523 (define-key speedbar-key-map "p" 'speedbar-prev)
|
|
|
524 (define-key speedbar-key-map " " 'speedbar-scroll-up)
|
|
|
525 (define-key speedbar-key-map "\C-?" 'speedbar-scroll-down)
|
|
|
526
|
|
|
527 ;; After much use, I suddenly desired in my heart to perform dired
|
|
|
528 ;; style operations since the directory was RIGHT THERE!
|
|
|
529 (define-key speedbar-key-map "I" 'speedbar-item-info)
|
|
|
530 (define-key speedbar-key-map "B" 'speedbar-item-byte-compile)
|
|
|
531 (define-key speedbar-key-map "L" 'speedbar-item-load)
|
|
|
532 (define-key speedbar-key-map "C" 'speedbar-item-copy)
|
|
|
533 (define-key speedbar-key-map "D" 'speedbar-item-delete)
|
|
|
534 (define-key speedbar-key-map "R" 'speedbar-item-rename)
|
|
100
|
535
|
|
|
536 (if (string-match "XEmacs" emacs-version)
|
|
|
537 (progn
|
|
|
538 ;; bind mouse bindings so we can manipulate the items on each line
|
|
|
539 (define-key speedbar-key-map 'button2 'speedbar-click)
|
|
167
|
540 (define-key speedbar-key-map '(shift button2) 'speedbar-power-click)
|
|
|
541 (define-key speedbar-key-map '(meta button3) 'speedbar-mouse-item-info)
|
|
100
|
542
|
|
167
|
543 ;; Setup XEmacs Menubar w/ etags specific items
|
|
|
544 (defvar speedbar-menu
|
|
|
545 '("Speed Bar"
|
|
|
546 ["Run Speedbar" (speedbar-frame-mode 1) t]
|
|
|
547 ["Refresh" speedbar-refresh t]
|
|
|
548 ["Allow Auto Updates"
|
|
|
549 speedbar-toggle-updates
|
|
|
550 :style toggle
|
|
|
551 :selected speedbar-update-flag]
|
|
|
552 "-----"
|
|
|
553 ["Sort etags in Speedbar"
|
|
|
554 (speedbar-toggle-etags "sort")
|
|
|
555 :style toggle
|
|
|
556 :selected speedbar-sort-tags]
|
|
|
557 ["Show unknown files"
|
|
|
558 (speedbar-toggle-etags "show")
|
|
|
559 :style toggle
|
|
|
560 :selected speedbar-show-unknown-files]
|
|
|
561 "-----"
|
|
|
562 ["Use C++ Tagging"
|
|
|
563 (speedbar-toggle-etags "-C")
|
|
|
564 :style toggle
|
|
|
565 :selected (member "-C" speedbar-fetch-etags-arguments)]
|
|
|
566 ["Tag preprocessor defs"
|
|
|
567 (speedbar-toggle-etags "-D")
|
|
|
568 :style toggle
|
|
|
569 :selected (not (member "-D" speedbar-fetch-etags-arguments))]
|
|
|
570 ["Use indentation"
|
|
|
571 (speedbar-toggle-etags "-S")
|
|
|
572 :style toggle
|
|
|
573 :selected (not (member "-S" speedbar-fetch-etags-arguments))]))
|
|
|
574
|
|
|
575 (add-submenu '("Tools") speedbar-menu nil)
|
|
|
576
|
|
100
|
577 )
|
|
|
578 ;; bind mouse bindings so we can manipulate the items on each line
|
|
|
579 (define-key speedbar-key-map [mouse-2] 'speedbar-click)
|
|
167
|
580 ;; This is the power click for poping up new frames
|
|
|
581 (define-key speedbar-key-map [S-mouse-2] 'speedbar-power-click)
|
|
|
582 ;; This adds a small unecessary visual effect
|
|
|
583 ;;(define-key speedbar-key-map [down-mouse-2] 'speedbar-quick-mouse)
|
|
|
584 (define-key speedbar-key-map [M-mouse-2] 'speedbar-mouse-item-info)
|
|
100
|
585
|
|
|
586 ;; disable all menus - we don't have a lot of space to play with
|
|
167
|
587 ;; in such a skinny frame. This will cleverly find and nuke some
|
|
|
588 ;; user-defined menus as well if they are there. Too bad it
|
|
|
589 ;; rely's on the structure of a keymap to work.
|
|
|
590 (let ((k (lookup-key global-map [menu-bar])))
|
|
|
591 (while k
|
|
|
592 (if (and (listp (car k)) (listp (cdr (car k))))
|
|
|
593 (define-key speedbar-key-map (vector 'menu-bar (car (car k)))
|
|
|
594 'undefined))
|
|
|
595 (setq k (cdr k))))
|
|
100
|
596
|
|
|
597 ;; This lets the user scroll as if we had a scrollbar... well maybe not
|
|
|
598 (define-key speedbar-key-map [mode-line mouse-2] 'speedbar-mouse-hscroll)
|
|
|
599 ))
|
|
|
600
|
|
167
|
601 (defvar speedbar-easymenu-definition-base
|
|
|
602 '("Speedbar"
|
|
|
603 ["Update" speedbar-refresh t]
|
|
|
604 ["Auto Update" speedbar-toggle-updates
|
|
|
605 :style toggle :selected speedbar-update-flag]
|
|
|
606 )
|
|
|
607 "Base part of the speedbar menu.")
|
|
|
608
|
|
|
609 (defvar speedbar-easymenu-definition-special
|
|
|
610 '(["Edit Item On Line" speedbar-edit-line t]
|
|
|
611 ["Show All Files" speedbar-toggle-show-all-files
|
|
|
612 :style toggle :selected speedbar-show-unknown-files]
|
|
|
613 ["Expand Item" speedbar-expand-line
|
|
|
614 (save-excursion (beginning-of-line)
|
|
|
615 (looking-at "[0-9]+: *.\\+. "))]
|
|
|
616 ["Contract Item" speedbar-contract-line
|
|
|
617 (save-excursion (beginning-of-line)
|
|
|
618 (looking-at "[0-9]+: *.-. "))]
|
|
|
619 "----"
|
|
|
620 ["Item Information" speedbar-item-info t]
|
|
|
621 ["Load Lisp File" speedbar-item-load
|
|
|
622 (save-excursion
|
|
|
623 (beginning-of-line)
|
|
|
624 (looking-at "[0-9]+: *\\[[+-]\\] .+\\(\\.el\\)\\( \\*\\)?$"))]
|
|
|
625 ["Byte Compile File" speedbar-item-byte-compile
|
|
|
626 (save-excursion
|
|
|
627 (beginning-of-line)
|
|
|
628 (looking-at "[0-9]+: *\\[[+-]\\] .+\\(\\.el\\)\\( \\*\\)?$"))]
|
|
|
629 ["Copy Item" speedbar-item-copy
|
|
|
630 (save-excursion (beginning-of-line) (looking-at "[0-9]+: *\\["))]
|
|
|
631 ["Rename Item" speedbar-item-rename
|
|
|
632 (save-excursion (beginning-of-line) (looking-at "[0-9]+: *[[<]"))]
|
|
|
633 ["Delete Item" speedbar-item-delete
|
|
|
634 (save-excursion (beginning-of-line) (looking-at "[0-9]+: *[[<]"))])
|
|
|
635 "Additional menu items while in file-mode.")
|
|
|
636
|
|
|
637 (defvar speedbar-easymenu-definition-trailer
|
|
|
638 '("----"
|
|
|
639 ["Close" speedbar-close-frame t])
|
|
|
640 "Menu items appearing at the end of the speedbar menu.")
|
|
100
|
641
|
|
|
642 (defvar speedbar-buffer nil
|
|
|
643 "The buffer displaying the speedbar.")
|
|
|
644 (defvar speedbar-frame nil
|
|
|
645 "The frame displaying speedbar.")
|
|
167
|
646 (defvar speedbar-cached-frame nil
|
|
|
647 "The frame that was last created, then removed from the display.")
|
|
|
648 (defvar speedbar-full-text-cache nil
|
|
|
649 "The last open directory is saved in it's entirety for ultra-fast switching.")
|
|
100
|
650 (defvar speedbar-timer nil
|
|
|
651 "The speedbar timer used for updating the buffer.")
|
|
|
652 (defvar speedbar-attached-frame nil
|
|
167
|
653 "The frame which started speedbar mode.
|
|
|
654 This is the frame from which all data displayed in the speedbar is
|
|
|
655 gathered, and in which files and such are displayed.")
|
|
100
|
656
|
|
|
657 (defvar speedbar-last-selected-file nil
|
|
167
|
658 "The last file which was selected in speedbar buffer.")
|
|
100
|
659
|
|
|
660 (defvar speedbar-shown-directories nil
|
|
167
|
661 "Maintain list of directories simultaneously open in the current speedbar.")
|
|
|
662
|
|
|
663 (defvar speedbar-directory-contents-alist nil
|
|
|
664 "An association list of directories and their contents.
|
|
|
665 Each sublist was returned by `speedbar-file-lists'. This list is
|
|
|
666 maintained to speed up the refresh rate when switching between
|
|
|
667 directories.")
|
|
|
668
|
|
|
669 (defvar speedbar-power-click nil
|
|
|
670 "Never set this by hand. Value is t when S-mouse activity occurs.")
|
|
100
|
671
|
|
|
672
|
|
|
673 ;;; Mode definitions/ user commands
|
|
167
|
674 ;;
|
|
|
675 ;;###autoload
|
|
|
676 (defalias 'speedbar 'speedbar-frame-mode)
|
|
100
|
677 (defun speedbar-frame-mode (&optional arg)
|
|
167
|
678 "Enable or disable speedbar. Positive ARG means turn on, negative turn off.
|
|
|
679 nil means toggle. Once the speedbar frame is activated, a buffer in
|
|
|
680 `speedbar-mode' will be displayed. Currently, only one speedbar is
|
|
|
681 supported at a time."
|
|
100
|
682 (interactive "P")
|
|
|
683 (if (not window-system)
|
|
167
|
684 (error "Speedbar is not useful outside of a windowing environment"))
|
|
100
|
685 ;; toggle frame on and off.
|
|
|
686 (if (not arg) (if speedbar-frame (setq arg -1) (setq arg 1)))
|
|
|
687 ;; turn the frame off on neg number
|
|
|
688 (if (and (numberp arg) (< arg 0))
|
|
|
689 (progn
|
|
|
690 (run-hooks 'speedbar-before-delete-hook)
|
|
|
691 (if (and speedbar-frame (frame-live-p speedbar-frame))
|
|
167
|
692 (if speedbar-xemacsp
|
|
|
693 (delete-frame speedbar-frame)
|
|
|
694 (setq speedbar-cached-frame speedbar-frame)
|
|
|
695 (modify-frame-parameters speedbar-frame '((visibility . nil)))))
|
|
100
|
696 (setq speedbar-frame nil)
|
|
167
|
697 (speedbar-set-timer nil)
|
|
|
698 ;; Used to delete the buffer. This has the annoying affect of
|
|
|
699 ;; preventing whatever took it's place from ever appearing
|
|
|
700 ;; as the default after a C-x b was typed
|
|
|
701 ;;(if (bufferp speedbar-buffer)
|
|
|
702 ;; (kill-buffer speedbar-buffer))
|
|
|
703 )
|
|
100
|
704 ;; Set this as our currently attached frame
|
|
|
705 (setq speedbar-attached-frame (selected-frame))
|
|
|
706 ;; Get the frame to work in
|
|
167
|
707 (if (frame-live-p speedbar-cached-frame)
|
|
|
708 (progn
|
|
|
709 (setq speedbar-frame speedbar-cached-frame)
|
|
|
710 (modify-frame-parameters speedbar-frame '((visibility . t)))
|
|
|
711 ;; Get the buffer to play with
|
|
|
712 (speedbar-mode)
|
|
|
713 (select-frame speedbar-frame)
|
|
|
714 (if (not (eq (current-buffer) speedbar-buffer))
|
|
|
715 (switch-to-buffer speedbar-buffer))
|
|
|
716 (set-window-dedicated-p (selected-window) t)
|
|
|
717 (raise-frame speedbar-frame)
|
|
|
718 (speedbar-set-timer speedbar-update-speed)
|
|
|
719 )
|
|
|
720 (if (frame-live-p speedbar-frame)
|
|
|
721 (raise-frame speedbar-frame)
|
|
|
722 (let ((params (cons (cons 'height (frame-height))
|
|
|
723 speedbar-frame-parameters)))
|
|
|
724 (setq speedbar-frame
|
|
|
725 (if (< emacs-major-version 20) ;a bug is fixed in v20 & later
|
|
|
726 (make-frame params)
|
|
|
727 (let ((x-pointer-shape x-pointer-top-left-arrow)
|
|
|
728 (x-sensitive-text-pointer-shape x-pointer-hand2))
|
|
|
729 (make-frame params)))))
|
|
|
730 ;; reset the selection variable
|
|
|
731 (setq speedbar-last-selected-file nil)
|
|
|
732 ;; Put the buffer into the frame
|
|
|
733 (save-window-excursion
|
|
|
734 ;; Get the buffer to play with
|
|
|
735 (speedbar-mode)
|
|
|
736 (select-frame speedbar-frame)
|
|
|
737 (switch-to-buffer speedbar-buffer)
|
|
|
738 (set-window-dedicated-p (selected-window) t)
|
|
|
739 ;; Turn off toolbar and menubar under XEmacs
|
|
|
740 (if speedbar-xemacsp
|
|
|
741 (progn
|
|
|
742 (set-specifier default-toolbar-visible-p
|
|
|
743 (cons (selected-frame) nil))
|
|
|
744 ;; These lines make the menu-bar go away nicely, but
|
|
|
745 ;; they also cause xemacs much heartache.
|
|
|
746 ;;(set-specifier menubar-visible-p (cons (selected-frame) nil))
|
|
|
747 ;;(make-local-variable 'current-menubar)
|
|
|
748 ;;(setq current-menubar speedbar-menu)
|
|
|
749 ;;(add-submenu nil speedbar-menu nil)
|
|
|
750 )))
|
|
|
751 (speedbar-set-timer speedbar-update-speed)
|
|
|
752 ))))
|
|
100
|
753
|
|
|
754 (defun speedbar-close-frame ()
|
|
167
|
755 "Turn off a currently active speedbar."
|
|
100
|
756 (interactive)
|
|
167
|
757 (speedbar-frame-mode -1)
|
|
|
758 (select-frame speedbar-attached-frame)
|
|
|
759 (other-frame 0))
|
|
|
760
|
|
|
761 (defun speedbar-frame-width ()
|
|
|
762 "Return the width of the speedbar frame in characters.
|
|
|
763 nil if it doesn't exist."
|
|
|
764 (and speedbar-frame (cdr (assoc 'width (frame-parameters speedbar-frame)))))
|
|
100
|
765
|
|
|
766 (defun speedbar-mode ()
|
|
167
|
767 "Major mode for managing a display of directories and tags.
|
|
|
768 \\<speedbar-key-map>
|
|
|
769 The first line represents the default path of the speedbar frame.
|
|
|
770 Each directory segment is a button which jumps speedbar's default
|
|
|
771 directory to that path. Buttons are activated by clicking `\\[speedbar-click]'.
|
|
|
772 In some situations using `\\[speedbar-power-click]' is a `power click' which will
|
|
|
773 rescan cached items, or pop up new frames.
|
|
100
|
774
|
|
|
775 Each line starting with <+> represents a directory. Click on the <+>
|
|
|
776 to insert the directory listing into the current tree. Click on the
|
|
|
777 <-> to retract that list. Click on the directory name to go to that
|
|
|
778 directory as the default.
|
|
|
779
|
|
|
780 Each line starting with [+] is a file. If the variable
|
|
|
781 `speedbar-show-unknown-files' is t, the lines starting with [?] are
|
|
|
782 files which don't have imenu support, but are not expressly ignored.
|
|
|
783 Files are completely ignored if they match `speedbar-file-unshown-regexp'
|
|
|
784 which is generated from `completion-ignored-extensions'.
|
|
|
785
|
|
167
|
786 Files with a `*' character after their name are files checked out of a
|
|
|
787 version control system. (currently only RCS is supported.) New
|
|
|
788 version control systems can be added by examining the documentation
|
|
|
789 for `speedbar-this-file-in-vc' and `speedbar-vc-check-dir-p'
|
|
|
790
|
|
100
|
791 Click on the [+] to display a list of tags from that file. Click on
|
|
|
792 the [-] to retract the list. Click on the file name to edit the file
|
|
|
793 in the attached frame.
|
|
|
794
|
|
|
795 If you open tags, you might find a node starting with {+}, which is a
|
|
167
|
796 category of tags. Click the {+} to expand the category. Jump-able
|
|
100
|
797 tags start with >. Click the name of the tag to go to that position
|
|
|
798 in the selected file.
|
|
|
799
|
|
167
|
800 \\{speedbar-key-map}"
|
|
|
801 ;; NOT interactive
|
|
|
802 (save-excursion
|
|
|
803 (setq speedbar-buffer (set-buffer (get-buffer-create " SPEEDBAR")))
|
|
|
804 (kill-all-local-variables)
|
|
|
805 (setq major-mode 'speedbar-mode)
|
|
|
806 (setq mode-name "Speedbar")
|
|
|
807 (use-local-map speedbar-key-map)
|
|
|
808 (set-syntax-table speedbar-syntax-table)
|
|
|
809 (setq font-lock-keywords nil) ;; no font-locking please
|
|
|
810 (setq truncate-lines t)
|
|
|
811 (make-local-variable 'frame-title-format)
|
|
|
812 (setq frame-title-format "Speedbar")
|
|
|
813 ;; Set this up special just for the speedbar buffer
|
|
|
814 (if (null default-minibuffer-frame)
|
|
|
815 (progn
|
|
|
816 (make-local-variable 'default-minibuffer-frame)
|
|
|
817 (setq default-minibuffer-frame speedbar-attached-frame)))
|
|
|
818 (make-local-variable 'temp-buffer-show-function)
|
|
|
819 (setq temp-buffer-show-function 'speedbar-temp-buffer-show-function)
|
|
|
820 (setq kill-buffer-hook '(lambda () (let ((skilling (boundp 'skilling)))
|
|
|
821 (if skilling
|
|
|
822 nil
|
|
|
823 (if (eq (current-buffer)
|
|
|
824 speedbar-buffer)
|
|
|
825 (speedbar-frame-mode -1))))))
|
|
|
826 (speedbar-set-mode-line-format)
|
|
|
827 (if (not speedbar-xemacsp)
|
|
|
828 (setq auto-show-mode nil)) ;no auto-show for Emacs
|
|
|
829 (run-hooks 'speedbar-mode-hook))
|
|
100
|
830 (speedbar-update-contents)
|
|
167
|
831 speedbar-buffer)
|
|
|
832
|
|
|
833 (defun speedbar-set-mode-line-format ()
|
|
|
834 "Set the format of the mode line based on the current speedbar environment.
|
|
|
835 This gives visual indications of what is up. It EXPECTS the speedbar
|
|
|
836 frame and window to be the currently active frame and window."
|
|
|
837 (if (frame-live-p speedbar-frame)
|
|
|
838 (save-excursion
|
|
|
839 (set-buffer speedbar-buffer)
|
|
|
840 (let* ((w (or (speedbar-frame-width) 20))
|
|
|
841 (p1 "<<")
|
|
|
842 (p5 ">>")
|
|
|
843 (p3 (if speedbar-update-flag "SPEEDBAR" "SLOWBAR"))
|
|
|
844 (blank (- w (length p1) (length p3) (length p5)
|
|
|
845 (if line-number-mode 4 0)))
|
|
|
846 (p2 (if (> blank 0)
|
|
|
847 (make-string (/ blank 2) ? )
|
|
|
848 ""))
|
|
|
849 (p4 (if (> blank 0)
|
|
|
850 (make-string (+ (/ blank 2) (% blank 2)) ? )
|
|
|
851 ""))
|
|
|
852 (tf
|
|
|
853 (if line-number-mode
|
|
|
854 (list (concat p1 p2 p3) '(line-number-mode " %3l")
|
|
|
855 (concat p4 p5))
|
|
|
856 (list (concat p1 p2 p3 p4 p5)))))
|
|
|
857 (if (not (equal mode-line-format tf))
|
|
|
858 (progn
|
|
|
859 (setq mode-line-format tf)
|
|
|
860 (force-mode-line-update)))))))
|
|
100
|
861
|
|
167
|
862 (defun speedbar-temp-buffer-show-function (buffer)
|
|
|
863 "Placed in the variable `temp-buffer-show-function' in `speedbar-mode'.
|
|
|
864 If a user requests help using \\[help-command] <Key> the temp BUFFER will be
|
|
|
865 redirected into a window on the attached frame."
|
|
|
866 (if speedbar-attached-frame (select-frame speedbar-attached-frame))
|
|
|
867 (pop-to-buffer buffer nil)
|
|
|
868 (other-window -1)
|
|
|
869 (run-hooks 'temp-buffer-show-hook))
|
|
|
870
|
|
|
871 (defun speedbar-reconfigure-menubar ()
|
|
|
872 "Reconfigure the menu-bar in a speedbar frame.
|
|
|
873 Different menu items are displayed depending on the current display mode
|
|
|
874 and the existence of packages."
|
|
|
875 (let ((km (make-sparse-keymap))
|
|
|
876 (cf (selected-frame))
|
|
|
877 (md (append speedbar-easymenu-definition-base
|
|
|
878 (if speedbar-shown-directories
|
|
|
879 ;; file display mode version
|
|
|
880 speedbar-easymenu-definition-special
|
|
|
881 (save-excursion
|
|
|
882 (select-frame speedbar-attached-frame)
|
|
|
883 (if (local-variable-p
|
|
|
884 'speedbar-easymenu-definition-special)
|
|
|
885 ;; If bound locally, we can use it
|
|
|
886 speedbar-easymenu-definition-special)))
|
|
|
887 ;; The trailer
|
|
|
888 speedbar-easymenu-definition-trailer)))
|
|
|
889 (easy-menu-define speedbar-menu-map speedbar-key-map "Speedbar menu" md)
|
|
|
890 (if speedbar-xemacsp (set-buffer-menubar (list km)))))
|
|
|
891
|
|
|
892
|
|
|
893 ;;; User Input stuff
|
|
|
894 ;;
|
|
100
|
895 (defun speedbar-mouse-hscroll (e)
|
|
167
|
896 "Read a mouse event E from the mode line, and horizontally scroll.
|
|
|
897 If the mouse is being clicked on the far left, or far right of the
|
|
|
898 mode-line. This is only useful for non-XEmacs"
|
|
100
|
899 (interactive "e")
|
|
|
900 (let* ((xp (car (nth 2 (car (cdr e)))))
|
|
|
901 (cpw (/ (frame-pixel-width)
|
|
|
902 (frame-width)))
|
|
|
903 (oc (1+ (/ xp cpw)))
|
|
|
904 )
|
|
|
905 (cond ((< oc 3)
|
|
|
906 (scroll-left 2))
|
|
|
907 ((> oc (- (window-width) 3))
|
|
|
908 (scroll-right 2))
|
|
|
909 (t (message "Click on the edge of the modeline to scroll left/right")))
|
|
|
910 ;;(message "X: Pixel %d Char Pixels %d On char %d" xp cpw oc)
|
|
|
911 ))
|
|
|
912
|
|
167
|
913 (defun speedbar-get-focus ()
|
|
|
914 "Change frame focus to or from the speedbar frame.
|
|
|
915 If the selected frame is not speedbar, then speedbar frame is
|
|
|
916 selected. If the speedbar frame is active, then select the attached frame."
|
|
|
917 (interactive)
|
|
|
918 (if (eq (selected-frame) speedbar-frame)
|
|
|
919 (if (frame-live-p speedbar-attached-frame)
|
|
|
920 (select-frame speedbar-attached-frame))
|
|
|
921 ;; make sure we have a frame
|
|
|
922 (if (not (frame-live-p speedbar-frame)) (speedbar-frame-mode 1))
|
|
|
923 ;; go there
|
|
|
924 (select-frame speedbar-frame))
|
|
|
925 (other-frame 0))
|
|
|
926
|
|
|
927 (defun speedbar-next (arg)
|
|
|
928 "Move to the next ARGth line in a speedbar buffer."
|
|
|
929 (interactive "p")
|
|
|
930 (forward-line (or arg 1))
|
|
|
931 (speedbar-item-info)
|
|
|
932 (speedbar-position-cursor-on-line))
|
|
|
933
|
|
|
934 (defun speedbar-prev (arg)
|
|
|
935 "Move to the previous ARGth line in a speedbar buffer."
|
|
|
936 (interactive "p")
|
|
|
937 (speedbar-next (if arg (- arg) -1)))
|
|
|
938
|
|
|
939 (defun speedbar-scroll-up (&optional arg)
|
|
|
940 "Page down one screen-full of the speedbar, or ARG lines."
|
|
|
941 (interactive "P")
|
|
|
942 (scroll-up arg)
|
|
|
943 (speedbar-position-cursor-on-line))
|
|
|
944
|
|
|
945 (defun speedbar-scroll-down (&optional arg)
|
|
|
946 "Page up one screen-full of the speedbar, or ARG lines."
|
|
|
947 (interactive "P")
|
|
|
948 (scroll-down arg)
|
|
|
949 (speedbar-position-cursor-on-line))
|
|
|
950
|
|
|
951 (defun speedbar-up-directory ()
|
|
|
952 "Keyboard accelerator for moving the default directory up one.
|
|
|
953 Assumes that the current buffer is the speedbar buffer"
|
|
|
954 (interactive)
|
|
|
955 (setq default-directory (expand-file-name (concat default-directory "../")))
|
|
|
956 (speedbar-update-contents))
|
|
100
|
957
|
|
167
|
958 ;;; Speedbar file activity
|
|
|
959 ;;
|
|
|
960 (defun speedbar-refresh ()
|
|
|
961 "Refresh the current speedbar display, disposing of any cached data."
|
|
|
962 (interactive)
|
|
|
963 (let ((dl speedbar-shown-directories))
|
|
|
964 (while dl
|
|
|
965 (adelete 'speedbar-directory-contents-alist (car dl))
|
|
|
966 (setq dl (cdr dl))))
|
|
|
967 (if (<= 1 speedbar-verbosity-level) (message "Refreshing speedbar..."))
|
|
|
968 (speedbar-update-contents)
|
|
|
969 (speedbar-stealthy-updates)
|
|
|
970 ;; Reset the timer in case it got really hosed for some reason...
|
|
|
971 (speedbar-set-timer speedbar-update-speed)
|
|
|
972 (if (<= 1 speedbar-verbosity-level) (message "Refreshing speedbar...done")))
|
|
|
973
|
|
|
974 (defun speedbar-item-load ()
|
|
|
975 "Byte compile the item under the cursor or mouse if it is a lisp file."
|
|
|
976 (interactive)
|
|
|
977 (let ((f (speedbar-line-file)))
|
|
|
978 (if (and (file-exists-p f) (string-match "\\.el$" f))
|
|
|
979 (if (and (file-exists-p (concat f "c"))
|
|
|
980 (y-or-n-p (format "Load %sc? " f)))
|
|
|
981 ;; If the compiled version exists, load that instead...
|
|
|
982 (load-file (concat f "c"))
|
|
|
983 (load-file f))
|
|
|
984 (error "Not a loadable file..."))))
|
|
|
985
|
|
|
986 (defun speedbar-item-byte-compile ()
|
|
|
987 "Byte compile the item under the cursor or mouse if it is a lisp file."
|
|
|
988 (interactive)
|
|
|
989 (let ((f (speedbar-line-file))
|
|
|
990 (sf (selected-frame)))
|
|
|
991 (if (and (file-exists-p f) (string-match "\\.el$" f))
|
|
|
992 (progn
|
|
|
993 (select-frame speedbar-attached-frame)
|
|
|
994 (byte-compile-file f nil)
|
|
|
995 (select-frame sf)))
|
|
|
996 ))
|
|
|
997
|
|
|
998 (defun speedbar-mouse-item-info (event)
|
|
|
999 "Provide information about what the user clicked on.
|
|
|
1000 This should be bound to a mouse EVENT."
|
|
|
1001 (interactive "e")
|
|
|
1002 (mouse-set-point event)
|
|
|
1003 (speedbar-item-info))
|
|
|
1004
|
|
|
1005 (defun speedbar-item-info ()
|
|
|
1006 "Display info in the mini-buffer about the button the mouse is over."
|
|
|
1007 (interactive)
|
|
|
1008 (if (not speedbar-shown-directories)
|
|
|
1009 nil
|
|
|
1010 (let* ((item (speedbar-line-file))
|
|
|
1011 (attr (if item (file-attributes item) nil)))
|
|
|
1012 (if item (message "%s %d %s" (nth 8 attr) (nth 7 attr) item)
|
|
|
1013 (save-excursion
|
|
|
1014 (beginning-of-line)
|
|
|
1015 (looking-at "\\([0-9]+\\):")
|
|
|
1016 (setq item (speedbar-line-path (string-to-int (match-string 1))))
|
|
|
1017 (if (re-search-forward "> \\([^ ]+\\)$"
|
|
|
1018 (save-excursion(end-of-line)(point)) t)
|
|
|
1019 (progn
|
|
|
1020 (setq attr (get-text-property (match-beginning 1)
|
|
|
1021 'speedbar-token))
|
|
|
1022 (message "Tag %s in %s at position %s"
|
|
|
1023 (match-string 1) item (if attr attr 0)))
|
|
|
1024 (message "No special info for this line.")))
|
|
|
1025 ))))
|
|
|
1026
|
|
|
1027 (defun speedbar-item-copy ()
|
|
|
1028 "Copy the item under the cursor.
|
|
|
1029 Files can be copied to new names or places."
|
|
|
1030 (interactive)
|
|
|
1031 (let ((f (speedbar-line-file)))
|
|
|
1032 (if (not f) (error "Not a file."))
|
|
|
1033 (if (file-directory-p f)
|
|
|
1034 (error "Cannot copy directory.")
|
|
|
1035 (let* ((rt (read-file-name (format "Copy %s to: "
|
|
|
1036 (file-name-nondirectory f))
|
|
|
1037 (file-name-directory f)))
|
|
|
1038 (refresh (member (expand-file-name (file-name-directory rt))
|
|
|
1039 speedbar-shown-directories)))
|
|
|
1040 ;; Create the right file name part
|
|
|
1041 (if (file-directory-p rt)
|
|
|
1042 (setq rt
|
|
|
1043 (concat (expand-file-name rt)
|
|
|
1044 (if (string-match "/$" rt) "" "/")
|
|
|
1045 (file-name-nondirectory f))))
|
|
|
1046 (if (or (not (file-exists-p rt))
|
|
|
1047 (y-or-n-p (format "Overwrite %s with %s? " rt f)))
|
|
|
1048 (progn
|
|
|
1049 (copy-file f rt t t)
|
|
|
1050 ;; refresh display if the new place is currently displayed.
|
|
|
1051 (if refresh
|
|
|
1052 (progn
|
|
|
1053 (speedbar-refresh)
|
|
|
1054 (if (not (speedbar-goto-this-file rt))
|
|
|
1055 (speedbar-goto-this-file f))))
|
|
|
1056 ))))))
|
|
|
1057
|
|
|
1058 (defun speedbar-item-rename ()
|
|
|
1059 "Rename the item under the cursor or mouse.
|
|
|
1060 Files can be renamed to new names or moved to new directories."
|
|
|
1061 (interactive)
|
|
|
1062 (let ((f (speedbar-line-file)))
|
|
|
1063 (if f
|
|
|
1064 (let* ((rt (read-file-name (format "Rename %s to: "
|
|
|
1065 (file-name-nondirectory f))
|
|
|
1066 (file-name-directory f)))
|
|
|
1067 (refresh (member (expand-file-name (file-name-directory rt))
|
|
|
1068 speedbar-shown-directories)))
|
|
|
1069 ;; Create the right file name part
|
|
|
1070 (if (file-directory-p rt)
|
|
|
1071 (setq rt
|
|
|
1072 (concat (expand-file-name rt)
|
|
|
1073 (if (string-match "/$" rt) "" "/")
|
|
|
1074 (file-name-nondirectory f))))
|
|
|
1075 (if (or (not (file-exists-p rt))
|
|
|
1076 (y-or-n-p (format "Overwrite %s with %s? " rt f)))
|
|
|
1077 (progn
|
|
|
1078 (rename-file f rt t)
|
|
|
1079 ;; refresh display if the new place is currently displayed.
|
|
|
1080 (if refresh
|
|
|
1081 (progn
|
|
|
1082 (speedbar-refresh)
|
|
|
1083 (speedbar-goto-this-file rt)
|
|
|
1084 )))))
|
|
|
1085 (error "Not a file."))))
|
|
|
1086
|
|
|
1087 (defun speedbar-item-delete ()
|
|
|
1088 "Delete the item under the cursor. Files are removed from disk."
|
|
|
1089 (interactive)
|
|
|
1090 (let ((f (speedbar-line-file)))
|
|
|
1091 (if (not f) (error "Not a file."))
|
|
|
1092 (if (y-or-n-p (format "Delete %s? " f))
|
|
|
1093 (progn
|
|
|
1094 (if (file-directory-p f)
|
|
|
1095 (delete-directory f)
|
|
|
1096 (delete-file f))
|
|
|
1097 (message "Okie dokie..")
|
|
|
1098 (let ((p (point)))
|
|
|
1099 (speedbar-refresh)
|
|
|
1100 (goto-char p))
|
|
|
1101 ))
|
|
|
1102 ))
|
|
|
1103
|
|
|
1104 (defun speedbar-enable-update ()
|
|
|
1105 "Enable automatic updating in speedbar via timers."
|
|
|
1106 (interactive)
|
|
|
1107 (setq speedbar-update-flag t)
|
|
|
1108 (speedbar-set-mode-line-format)
|
|
|
1109 (speedbar-set-timer speedbar-update-speed))
|
|
|
1110
|
|
|
1111 (defun speedbar-disable-update ()
|
|
|
1112 "Disable automatic updating and stop consuming resources."
|
|
|
1113 (interactive)
|
|
|
1114 (setq speedbar-update-flag nil)
|
|
|
1115 (speedbar-set-mode-line-format)
|
|
|
1116 (speedbar-set-timer nil))
|
|
|
1117
|
|
|
1118 (defun speedbar-toggle-updates ()
|
|
|
1119 "Toggle automatic update for the speedbar frame."
|
|
|
1120 (interactive)
|
|
|
1121 (if speedbar-update-flag
|
|
|
1122 (speedbar-disable-update)
|
|
|
1123 (speedbar-enable-update)))
|
|
|
1124
|
|
|
1125 (defun speedbar-toggle-show-all-files ()
|
|
|
1126 "Toggle display of files speedbar can not tag."
|
|
|
1127 (interactive)
|
|
|
1128 (setq speedbar-show-unknown-files (not speedbar-show-unknown-files))
|
|
|
1129 (speedbar-refresh))
|
|
|
1130
|
|
100
|
1131 ;;; Utility functions
|
|
167
|
1132 ;;
|
|
100
|
1133 (defun speedbar-set-timer (timeout)
|
|
167
|
1134 "Unset an old timer (if there is one) and activate a new timer with TIMEOUT.
|
|
|
1135 TIMEOUT is the number of seconds until the speedbar timer is called
|
|
|
1136 again."
|
|
|
1137 (cond
|
|
100
|
1138 ;; Xemacs
|
|
|
1139 (speedbar-xemacsp
|
|
167
|
1140 (if speedbar-timer
|
|
100
|
1141 (progn (delete-itimer speedbar-timer)
|
|
|
1142 (setq speedbar-timer nil)))
|
|
|
1143 (if timeout
|
|
|
1144 (setq speedbar-timer (start-itimer "speedbar"
|
|
|
1145 'speedbar-timer-fn
|
|
|
1146 timeout
|
|
|
1147 nil))))
|
|
167
|
1148 ;; Post 19.31 Emacs
|
|
|
1149 ((fboundp 'run-with-idle-timer)
|
|
|
1150 (if speedbar-timer
|
|
100
|
1151 (progn (cancel-timer speedbar-timer)
|
|
|
1152 (setq speedbar-timer nil)))
|
|
|
1153 (if timeout
|
|
167
|
1154 (setq speedbar-timer
|
|
100
|
1155 (run-with-idle-timer timeout nil 'speedbar-timer-fn))))
|
|
167
|
1156 ;; Older or other Emacsen with no timers. Set up so that it's
|
|
|
1157 ;; obvious this emacs can't handle the updates
|
|
|
1158 (t
|
|
|
1159 (setq speedbar-update-flag nil)))
|
|
|
1160 ;; change this if it changed for some reason
|
|
|
1161 (speedbar-set-mode-line-format))
|
|
100
|
1162
|
|
|
1163 (defmacro speedbar-with-writable (&rest forms)
|
|
167
|
1164 "Allow the buffer to be writable and evaluate FORMS.
|
|
|
1165 Turn read only back on when done."
|
|
100
|
1166 (list 'let '((speedbar-with-writable-buff (current-buffer)))
|
|
|
1167 '(toggle-read-only -1)
|
|
|
1168 (cons 'progn forms)
|
|
|
1169 '(save-excursion (set-buffer speedbar-with-writable-buff)
|
|
|
1170 (toggle-read-only 1))))
|
|
|
1171 (put 'speedbar-with-writable 'lisp-indent-function 0)
|
|
|
1172
|
|
167
|
1173 (defun speedbar-select-window (buffer)
|
|
|
1174 "Select a window in which BUFFER is show.
|
|
|
1175 If it is not shown, force it to appear in the default window."
|
|
|
1176 (let ((win (get-buffer-window buffer speedbar-attached-frame)))
|
|
|
1177 (if win
|
|
|
1178 (select-window win)
|
|
|
1179 (show-buffer (selected-window) buffer))))
|
|
|
1180
|
|
|
1181 (defmacro speedbar-with-attached-buffer (&rest forms)
|
|
|
1182 "Execute FORMS in the attached frame's special buffer.
|
|
|
1183 Optionally select that frame if necessary."
|
|
|
1184 ;; Reset the timer with a new timeout when cliking a file
|
|
|
1185 ;; in case the user was navigating directories, we can cancel
|
|
|
1186 ;; that other timer.
|
|
|
1187 (list
|
|
|
1188 'progn
|
|
|
1189 '(speedbar-set-timer speedbar-update-speed)
|
|
|
1190 (list
|
|
|
1191 'let '((cf (selected-frame)))
|
|
|
1192 '(select-frame speedbar-attached-frame)
|
|
|
1193 '(speedbar-select-window speedbar-desired-buffer)
|
|
|
1194 (cons 'progn forms)
|
|
|
1195 '(select-frame cf)
|
|
|
1196 '(speedbar-maybee-jump-to-attached-frame)
|
|
|
1197 )))
|
|
|
1198
|
|
|
1199 (defun speedbar-insert-button (text face mouse function
|
|
|
1200 &optional token prevline)
|
|
|
1201 "Insert TEXT as the next logical speedbar button.
|
|
|
1202 FACE is the face to put on the button, MOUSE is the highlight face to use.
|
|
|
1203 When the user clicks on TEXT, FUNCTION is called with the TOKEN parameter.
|
|
|
1204 This function assumes that the current buffer is the speedbar buffer.
|
|
|
1205 If PREVLINE, then put this button on the previous line.
|
|
|
1206
|
|
|
1207 This is a convenience function for special mode that create their own
|
|
|
1208 specialized speedbar displays."
|
|
|
1209 (goto-char (point-max))
|
|
|
1210 (if (/= (current-column) 0) (insert "\n"))
|
|
|
1211 (if prevline (progn (delete-char -1) (insert " "))) ;back up if desired...
|
|
|
1212 (let ((start (point)))
|
|
|
1213 (insert text)
|
|
|
1214 (speedbar-make-button start (point) face mouse function token))
|
|
|
1215 (let ((start (point)))
|
|
|
1216 (insert "\n")
|
|
|
1217 (put-text-property start (point) 'face nil)
|
|
|
1218 (put-text-property start (point) 'mouse-face nil)))
|
|
|
1219
|
|
100
|
1220 (defun speedbar-make-button (start end face mouse function &optional token)
|
|
167
|
1221 "Create a button from START to END, with FACE as the display face.
|
|
|
1222 MOUSE is the mouse face. When this button is clicked on FUNCTION
|
|
|
1223 will be run with the TOKEN parameter (any lisp object)"
|
|
100
|
1224 (put-text-property start end 'face face)
|
|
|
1225 (put-text-property start end 'mouse-face mouse)
|
|
|
1226 (put-text-property start end 'invisible nil)
|
|
|
1227 (if function (put-text-property start end 'speedbar-function function))
|
|
|
1228 (if token (put-text-property start end 'speedbar-token token))
|
|
|
1229 )
|
|
167
|
1230
|
|
|
1231 ;;; File button management
|
|
|
1232 ;;
|
|
100
|
1233 (defun speedbar-file-lists (directory)
|
|
167
|
1234 "Create file lists for DIRECTORY.
|
|
|
1235 The car is the list of directories, the cdr is list of files not
|
|
|
1236 matching ignored headers. Cache any directory files found in
|
|
|
1237 `speedbar-directory-contents-alist' and use that cache before scanning
|
|
|
1238 the file-system"
|
|
|
1239 (setq directory (expand-file-name directory))
|
|
|
1240 ;; If in powerclick mode, then the directory we are getting
|
|
|
1241 ;; should be rescanned.
|
|
|
1242 (if speedbar-power-click
|
|
|
1243 (adelete 'speedbar-directory-contents-alist directory))
|
|
|
1244 ;; find the directory, either in the cache, or build it.
|
|
|
1245 (or (cdr-safe (assoc directory speedbar-directory-contents-alist))
|
|
|
1246 (let ((default-directory directory)
|
|
|
1247 (dir (directory-files directory nil))
|
|
|
1248 (dirs nil)
|
|
|
1249 (files nil))
|
|
|
1250 (while dir
|
|
|
1251 (if (not (string-match speedbar-file-unshown-regexp (car dir)))
|
|
|
1252 (if (file-directory-p (car dir))
|
|
|
1253 (setq dirs (cons (car dir) dirs))
|
|
|
1254 (setq files (cons (car dir) files))))
|
|
|
1255 (setq dir (cdr dir)))
|
|
|
1256 (let ((nl (cons (nreverse dirs) (list (nreverse files)))))
|
|
|
1257 (aput 'speedbar-directory-contents-alist directory nl)
|
|
|
1258 nl))
|
|
|
1259 ))
|
|
100
|
1260
|
|
|
1261 (defun speedbar-directory-buttons (directory index)
|
|
167
|
1262 "Insert a single button group at point for DIRECTORY.
|
|
|
1263 Each directory path part is a different button. If part of the path
|
|
|
1264 matches the user directory ~, then it is replaced with a ~.
|
|
|
1265 INDEX is not used, but is required by the caller."
|
|
100
|
1266 (let* ((tilde (expand-file-name "~"))
|
|
|
1267 (dd (expand-file-name directory))
|
|
|
1268 (junk (string-match (regexp-quote tilde) dd))
|
|
|
1269 (displayme (if junk
|
|
|
1270 (concat "~" (substring dd (match-end 0)))
|
|
|
1271 dd))
|
|
|
1272 (p (point)))
|
|
|
1273 (if (string-match "^~/?$" displayme) (setq displayme (concat tilde "/")))
|
|
|
1274 (insert displayme)
|
|
|
1275 (save-excursion
|
|
|
1276 (goto-char p)
|
|
|
1277 (while (re-search-forward "\\([^/]+\\)/" nil t)
|
|
|
1278 (speedbar-make-button (match-beginning 1) (match-end 1)
|
|
|
1279 'speedbar-directory-face
|
|
|
1280 'speedbar-highlight-face
|
|
|
1281 'speedbar-directory-buttons-follow
|
|
|
1282 (if (= (match-beginning 1) p)
|
|
|
1283 (expand-file-name "~/") ;the tilde
|
|
|
1284 (buffer-substring-no-properties
|
|
167
|
1285 p (match-end 0)))))
|
|
|
1286 ;; Nuke the beginning of the directory if it's too long...
|
|
|
1287 (cond ((eq speedbar-directory-button-trim-method 'span)
|
|
|
1288 (beginning-of-line)
|
|
|
1289 (let ((ww (or (speedbar-frame-width) 20)))
|
|
|
1290 (move-to-column ww nil)
|
|
|
1291 (while (>= (current-column) ww)
|
|
|
1292 (re-search-backward "/" nil t)
|
|
|
1293 (if (<= (current-column) 2)
|
|
|
1294 (progn
|
|
|
1295 (re-search-forward "/" nil t)
|
|
|
1296 (if (< (current-column) 4)
|
|
|
1297 (re-search-forward "/" nil t))
|
|
|
1298 (forward-char -1)))
|
|
|
1299 (if (looking-at "/?$")
|
|
|
1300 (beginning-of-line)
|
|
|
1301 (insert "/...\n ")
|
|
|
1302 (move-to-column ww nil)))))
|
|
|
1303 ((eq speedbar-directory-button-trim-method 'trim)
|
|
|
1304 (end-of-line)
|
|
|
1305 (let ((ww (or (speedbar-frame-width) 20))
|
|
|
1306 (tl (current-column)))
|
|
|
1307 (if (< ww tl)
|
|
|
1308 (progn
|
|
|
1309 (move-to-column (- tl ww))
|
|
|
1310 (if (re-search-backward "/" nil t)
|
|
|
1311 (progn
|
|
|
1312 (delete-region (point-min) (point))
|
|
|
1313 (insert "$")
|
|
|
1314 )))))))
|
|
|
1315 )
|
|
100
|
1316 (if (string-match "^/[^/]+/$" displayme)
|
|
|
1317 (progn
|
|
|
1318 (insert " ")
|
|
|
1319 (let ((p (point)))
|
|
|
1320 (insert "<root>")
|
|
|
1321 (speedbar-make-button p (point)
|
|
|
1322 'speedbar-directory-face
|
|
|
1323 'speedbar-highlight-face
|
|
|
1324 'speedbar-directory-buttons-follow
|
|
|
1325 "/"))))
|
|
167
|
1326 (end-of-line)
|
|
100
|
1327 (insert-char ?\n 1 nil)))
|
|
|
1328
|
|
|
1329 (defun speedbar-make-tag-line (exp-button-type
|
|
|
1330 exp-button-char exp-button-function
|
|
|
1331 exp-button-data
|
|
|
1332 tag-button tag-button-function tag-button-data
|
|
|
1333 tag-button-face depth)
|
|
167
|
1334 "Create a tag line with EXP-BUTTON-TYPE for the small expansion button.
|
|
|
1335 This is the button that expands or contracts a node (if applicable),
|
|
|
1336 and EXP-BUTTON-CHAR the character in it (+, -, ?, etc). EXP-BUTTON-FUNCTION
|
|
|
1337 is the function to call if it's clicked on. Button types are
|
|
|
1338 'bracket, 'angle, 'curly, or nil. EXP-BUTTON-DATA is extra data
|
|
|
1339 attached to the text forming the expansion button.
|
|
100
|
1340
|
|
167
|
1341 Next, TAG-BUTTON is the text of the tag. TAG-BUTTON-FUNCTION is the
|
|
|
1342 function to call if clicked on, and TAG-BUTTON-DATA is the data to
|
|
|
1343 attach to the text field (such a tag positioning, etc).
|
|
|
1344 TAG-BUTTON-FACE is a face used for this type of tag.
|
|
100
|
1345
|
|
|
1346 Lastly, DEPTH shows the depth of expansion.
|
|
|
1347
|
|
167
|
1348 This function assumes that the cursor is in the speedbar window at the
|
|
100
|
1349 position to insert a new item, and that the new item will end with a CR"
|
|
|
1350 (let ((start (point))
|
|
|
1351 (end (progn
|
|
|
1352 (insert (int-to-string depth) ":")
|
|
|
1353 (point))))
|
|
|
1354 (put-text-property start end 'invisible t)
|
|
|
1355 )
|
|
|
1356 (insert-char ? depth nil)
|
|
|
1357 (put-text-property (- (point) depth) (point) 'invisible nil)
|
|
|
1358 (let* ((exp-button (cond ((eq exp-button-type 'bracket) "[%c]")
|
|
|
1359 ((eq exp-button-type 'angle) "<%c>")
|
|
|
1360 ((eq exp-button-type 'curly) "{%c}")
|
|
|
1361 (t ">")))
|
|
|
1362 (buttxt (format exp-button exp-button-char))
|
|
|
1363 (start (point))
|
|
|
1364 (end (progn (insert buttxt) (point)))
|
|
|
1365 (bf (if exp-button-type 'speedbar-button-face nil))
|
|
|
1366 (mf (if exp-button-function 'speedbar-highlight-face nil))
|
|
|
1367 )
|
|
|
1368 (speedbar-make-button start end bf mf exp-button-function exp-button-data)
|
|
|
1369 )
|
|
|
1370 (insert-char ? 1 nil)
|
|
|
1371 (put-text-property (1- (point)) (point) 'invisible nil)
|
|
|
1372 (let ((start (point))
|
|
|
1373 (end (progn (insert tag-button) (point))))
|
|
|
1374 (insert-char ?\n 1 nil)
|
|
|
1375 (put-text-property (1- (point)) (point) 'invisible nil)
|
|
167
|
1376 (speedbar-make-button start end tag-button-face
|
|
100
|
1377 (if tag-button-function 'speedbar-highlight-face nil)
|
|
|
1378 tag-button-function tag-button-data))
|
|
|
1379 )
|
|
|
1380
|
|
|
1381 (defun speedbar-change-expand-button-char (char)
|
|
167
|
1382 "Change the expansion button character to CHAR for the current line."
|
|
100
|
1383 (save-excursion
|
|
|
1384 (beginning-of-line)
|
|
167
|
1385 (if (re-search-forward ":\\s-*.\\([-+?]\\)" (save-excursion (end-of-line)
|
|
100
|
1386 (point)) t)
|
|
|
1387 (speedbar-with-writable
|
|
|
1388 (goto-char (match-beginning 1))
|
|
|
1389 (delete-char 1)
|
|
|
1390 (insert-char char 1 t)))))
|
|
|
1391
|
|
|
1392
|
|
|
1393 ;;; Build button lists
|
|
167
|
1394 ;;
|
|
100
|
1395 (defun speedbar-insert-files-at-point (files level)
|
|
167
|
1396 "Insert list of FILES starting at point, and indenting all files to LEVEL.
|
|
|
1397 Tag expandable items with a +, otherwise a ?. Don't highlight ? as we
|
|
|
1398 don't know how to manage them. The input parameter FILES is a cons
|
|
|
1399 cell of the form ( 'DIRLIST . 'FILELIST )"
|
|
100
|
1400 ;; Start inserting all the directories
|
|
|
1401 (let ((dirs (car files)))
|
|
|
1402 (while dirs
|
|
|
1403 (speedbar-make-tag-line 'angle ?+ 'speedbar-dired (car dirs)
|
|
|
1404 (car dirs) 'speedbar-dir-follow nil
|
|
|
1405 'speedbar-directory-face level)
|
|
|
1406 (setq dirs (cdr dirs))))
|
|
|
1407 (let ((lst (car (cdr files))))
|
|
|
1408 (while lst
|
|
|
1409 (let* ((known (string-match speedbar-file-regexp (car lst)))
|
|
|
1410 (expchar (if known ?+ ??))
|
|
|
1411 (fn (if known 'speedbar-tag-file nil)))
|
|
|
1412 (if (or speedbar-show-unknown-files (/= expchar ??))
|
|
|
1413 (speedbar-make-tag-line 'bracket expchar fn (car lst)
|
|
|
1414 (car lst) 'speedbar-find-file nil
|
|
|
1415 'speedbar-file-face level)))
|
|
|
1416 (setq lst (cdr lst)))))
|
|
|
1417
|
|
|
1418 (defun speedbar-default-directory-list (directory index)
|
|
167
|
1419 "Insert files for DIRECTORY with level INDEX at point."
|
|
100
|
1420 (speedbar-insert-files-at-point
|
|
|
1421 (speedbar-file-lists directory) index)
|
|
167
|
1422 (speedbar-reset-scanners)
|
|
|
1423 (if (= index 0)
|
|
|
1424 ;; If the shown files variable has extra directories, then
|
|
|
1425 ;; it is our responsibility to redraw them all
|
|
|
1426 ;; Luckilly, the nature of inserting items into this list means
|
|
|
1427 ;; that by reversing it, we can easilly go in the right order
|
|
|
1428 (let ((sf (cdr (reverse speedbar-shown-directories))))
|
|
|
1429 (setq speedbar-shown-directories
|
|
|
1430 (list (expand-file-name default-directory)))
|
|
|
1431 ;; exand them all as we find them
|
|
|
1432 (while sf
|
|
|
1433 (if (speedbar-goto-this-file (car sf))
|
|
|
1434 (progn
|
|
|
1435 (beginning-of-line)
|
|
|
1436 (if (looking-at "[0-9]+:[ ]*<")
|
|
|
1437 (progn
|
|
|
1438 (goto-char (match-end 0))
|
|
|
1439 (speedbar-do-function-pointer)))
|
|
|
1440 (setq sf (cdr sf)))))
|
|
|
1441 )))
|
|
100
|
1442
|
|
|
1443 (defun speedbar-insert-generic-list (level lst expand-fun find-fun)
|
|
167
|
1444 "At LEVEL, insert a generic multi-level alist LST.
|
|
|
1445 Associations with lists get {+} tags (to expand into more nodes) and
|
|
|
1446 those with positions just get a > as the indicator. {+} buttons will
|
|
|
1447 have the function EXPAND-FUN and the token is the CDR list. The token
|
|
|
1448 name will have the function FIND-FUN and not token."
|
|
100
|
1449 ;; Remove imenu rescan button
|
|
|
1450 (if (string= (car (car lst)) "*Rescan*")
|
|
|
1451 (setq lst (cdr lst)))
|
|
|
1452 ;; insert the parts
|
|
|
1453 (while lst
|
|
|
1454 (cond ((null (car-safe lst)) nil) ;this would be a separator
|
|
167
|
1455 ((or (numberp (cdr-safe (car-safe lst)))
|
|
|
1456 (markerp (cdr-safe (car-safe lst))))
|
|
100
|
1457 (speedbar-make-tag-line nil nil nil nil ;no expand button data
|
|
|
1458 (car (car lst)) ;button name
|
|
167
|
1459 find-fun ;function
|
|
100
|
1460 (cdr (car lst)) ;token is position
|
|
167
|
1461 'speedbar-tag-face
|
|
100
|
1462 (1+ level)))
|
|
|
1463 ((listp (cdr-safe (car-safe lst)))
|
|
|
1464 (speedbar-make-tag-line 'curly ?+ expand-fun (cdr (car lst))
|
|
|
1465 (car (car lst)) ;button name
|
|
167
|
1466 nil nil 'speedbar-tag-face
|
|
100
|
1467 (1+ level)))
|
|
|
1468 (t (message "Ooops!")))
|
|
|
1469 (setq lst (cdr lst))))
|
|
|
1470
|
|
|
1471 ;;; Timed functions
|
|
167
|
1472 ;;
|
|
100
|
1473 (defun speedbar-update-contents ()
|
|
167
|
1474 "Generically update the contents of the speedbar buffer."
|
|
100
|
1475 (interactive)
|
|
167
|
1476 ;; Set the current special buffer
|
|
|
1477 (setq speedbar-desired-buffer nil)
|
|
|
1478 (if (and speedbar-mode-specific-contents-flag
|
|
|
1479 speedbar-special-mode-expansion-list
|
|
|
1480 (local-variable-p
|
|
|
1481 'speedbar-special-mode-expansion-list))
|
|
|
1482 ;(eq (get major-mode 'mode-class 'special)))
|
|
|
1483 (speedbar-update-special-contents)
|
|
|
1484 (speedbar-update-directory-contents)))
|
|
|
1485
|
|
|
1486 (defun speedbar-update-directory-contents ()
|
|
|
1487 "Update the contents of the speedbar buffer based on the current directory."
|
|
|
1488 (let ((cbd (expand-file-name default-directory))
|
|
|
1489 (funclst speedbar-initial-expansion-list)
|
|
|
1490 (cache speedbar-full-text-cache)
|
|
|
1491 ;; disable stealth during update
|
|
|
1492 (speedbar-stealthy-function-list nil)
|
|
|
1493 (use-cache nil)
|
|
|
1494 ;; Because there is a bug I can't find just yet
|
|
|
1495 (inhibit-quit nil))
|
|
100
|
1496 (save-excursion
|
|
|
1497 (set-buffer speedbar-buffer)
|
|
167
|
1498 ;; If we are updating contents to a where we are, then this is
|
|
|
1499 ;; really a request to update existing contents, so we must be
|
|
|
1500 ;; careful with our text cache!
|
|
|
1501 (if (member cbd speedbar-shown-directories)
|
|
|
1502 (setq cache nil)
|
|
|
1503 ;; If this directory is NOT in the current list of available
|
|
|
1504 ;; paths, then use the cache, and set the cache to our new
|
|
|
1505 ;; value. Make sure to unhighlight the current file, or if we
|
|
|
1506 ;; come back to this directory, it might be a different file
|
|
|
1507 ;; and then we get a mess!
|
|
|
1508 (if (> (point-max) 1)
|
|
|
1509 (progn
|
|
|
1510 (speedbar-clear-current-file)
|
|
|
1511 (setq speedbar-full-text-cache
|
|
|
1512 (cons speedbar-shown-directories (buffer-string)))))
|
|
|
1513
|
|
|
1514 ;; Check if our new directory is in the list of directories
|
|
|
1515 ;; show in the text-cahce
|
|
|
1516 (if (member cbd (car cache))
|
|
|
1517 (setq speedbar-shown-directories (car cache)
|
|
|
1518 use-cache t)
|
|
|
1519 ;; default the shown directories to this list...
|
|
|
1520 (setq speedbar-shown-directories (list cbd)))
|
|
|
1521 )
|
|
|
1522 (setq speedbar-last-selected-file nil)
|
|
100
|
1523 (speedbar-with-writable
|
|
|
1524 (setq default-directory cbd)
|
|
167
|
1525 (erase-buffer)
|
|
|
1526 (if use-cache
|
|
|
1527 (insert (cdr cache))
|
|
|
1528 (while funclst
|
|
|
1529 (funcall (car funclst) cbd 0)
|
|
|
1530 (setq funclst (cdr funclst)))))
|
|
|
1531 (goto-char (point-min))))
|
|
|
1532 (speedbar-reconfigure-menubar))
|
|
|
1533
|
|
|
1534 (defun speedbar-update-special-contents ()
|
|
|
1535 "Used the mode-specific variable to fill in the speedbar buffer.
|
|
|
1536 This should only be used by modes classified as special."
|
|
|
1537 (let ((funclst speedbar-special-mode-expansion-list)
|
|
|
1538 (specialbuff (current-buffer)))
|
|
|
1539 (save-excursion
|
|
|
1540 (setq speedbar-desired-buffer specialbuff)
|
|
|
1541 (set-buffer speedbar-buffer)
|
|
|
1542 ;; If we are leaving a directory, cache it.
|
|
|
1543 (if (not speedbar-shown-directories)
|
|
|
1544 ;; Do nothing
|
|
|
1545 nil
|
|
|
1546 ;; Clean up directory maintenance stuff
|
|
|
1547 (speedbar-clear-current-file)
|
|
|
1548 (setq speedbar-full-text-cache
|
|
|
1549 (cons speedbar-shown-directories (buffer-string))
|
|
|
1550 speedbar-shown-directories nil))
|
|
|
1551 ;; Now fill in the buffer with our newly found specialized list.
|
|
|
1552 (speedbar-with-writable
|
|
100
|
1553 (while funclst
|
|
167
|
1554 ;; We do not erase the buffer because these functions may
|
|
|
1555 ;; decide NOT to update themselves.
|
|
|
1556 (funcall (car funclst) specialbuff)
|
|
|
1557 (setq funclst (cdr funclst))))
|
|
|
1558 (goto-char (point-min))))
|
|
|
1559 (speedbar-reconfigure-menubar))
|
|
100
|
1560
|
|
|
1561 (defun speedbar-timer-fn ()
|
|
167
|
1562 "Run whenever emacs is idle to update the speedbar item."
|
|
|
1563 (if (not (and (frame-live-p speedbar-frame)
|
|
100
|
1564 (frame-live-p speedbar-attached-frame)))
|
|
|
1565 (speedbar-set-timer nil)
|
|
167
|
1566 (condition-case nil
|
|
|
1567 ;; Save all the match data so that we don't mess up executing fns
|
|
|
1568 (save-match-data
|
|
|
1569 (if (and (frame-visible-p speedbar-frame) speedbar-update-flag)
|
|
|
1570 (let ((af (selected-frame)))
|
|
|
1571 (save-window-excursion
|
|
|
1572 (select-frame speedbar-attached-frame)
|
|
|
1573 ;; make sure we at least choose a window to
|
|
|
1574 ;; get a good directory from
|
|
|
1575 (if (string-match "\\*Minibuf-[0-9]+\\*" (buffer-name))
|
|
|
1576 (other-window 1))
|
|
|
1577 ;; Update for special mode all the time!
|
|
|
1578 (if (and speedbar-mode-specific-contents-flag
|
|
|
1579 speedbar-special-mode-expansion-list
|
|
|
1580 (local-variable-p
|
|
|
1581 'speedbar-special-mode-expansion-list))
|
|
|
1582 ;(eq (get major-mode 'mode-class 'special)))
|
|
|
1583 (speedbar-update-special-contents)
|
|
|
1584 ;; Update all the contents if directories change!
|
|
|
1585 (if (or (member (expand-file-name default-directory)
|
|
|
1586 speedbar-shown-directories)
|
|
|
1587 (string-match speedbar-ignored-path-regexp
|
|
|
1588 (expand-file-name default-directory))
|
|
|
1589 (member major-mode speedbar-ignored-modes)
|
|
|
1590 (eq af speedbar-frame)
|
|
|
1591 (not (buffer-file-name)))
|
|
|
1592 nil
|
|
|
1593 (if (<= 1 speedbar-verbosity-level)
|
|
|
1594 (message "Updating speedbar to: %s..."
|
|
|
1595 default-directory))
|
|
|
1596 (speedbar-update-directory-contents)
|
|
|
1597 (if (<= 1 speedbar-verbosity-level)
|
|
|
1598 (message "Updating speedbar to: %s...done"
|
|
|
1599 default-directory))))
|
|
|
1600 (select-frame af))
|
|
|
1601 ;; Now run stealthy updates of time-consuming items
|
|
|
1602 (speedbar-stealthy-updates))))
|
|
|
1603 ;; errors that might occur
|
|
|
1604 (error (message "Speedbar error!")))
|
|
|
1605 ;; Reset the timer
|
|
|
1606 (speedbar-set-timer speedbar-update-speed))
|
|
100
|
1607 (run-hooks 'speedbar-timer-hook)
|
|
|
1608 )
|
|
|
1609
|
|
167
|
1610
|
|
|
1611 ;;; Stealthy activities
|
|
|
1612 ;;
|
|
|
1613 (defun speedbar-stealthy-updates ()
|
|
|
1614 "For a given speedbar, run all items in the stealthy function list.
|
|
|
1615 Each item returns t if it completes successfully, or nil if
|
|
|
1616 interrupted by the user."
|
|
|
1617 (let ((l speedbar-stealthy-function-list))
|
|
|
1618 (unwind-protect
|
|
|
1619 (while (and l (funcall (car l)))
|
|
|
1620 (sit-for 0)
|
|
|
1621 (setq l (cdr l)))
|
|
|
1622 ;(message "Exit with %S" (car l))
|
|
|
1623 )))
|
|
|
1624
|
|
|
1625 (defun speedbar-reset-scanners ()
|
|
|
1626 "Reset any variables used by functions in the stealthy list as state.
|
|
|
1627 If new functions are added, their state needs to be updated here."
|
|
|
1628 (setq speedbar-vc-to-do-point t)
|
|
|
1629 )
|
|
|
1630
|
|
|
1631 (defun speedbar-clear-current-file ()
|
|
|
1632 "Locate the file thought to be current, and unhighlight it."
|
|
|
1633 (save-excursion
|
|
|
1634 (set-buffer speedbar-buffer)
|
|
|
1635 (if speedbar-last-selected-file
|
|
|
1636 (speedbar-with-writable
|
|
|
1637 (goto-char (point-min))
|
|
|
1638 (if (and
|
|
|
1639 speedbar-last-selected-file
|
|
|
1640 (re-search-forward
|
|
|
1641 (concat " \\(" (regexp-quote speedbar-last-selected-file)
|
|
|
1642 "\\)\\(" (regexp-quote speedbar-vc-indicator)
|
|
|
1643 "\\)?\n")
|
|
|
1644 nil t))
|
|
|
1645 (put-text-property (match-beginning 1)
|
|
|
1646 (match-end 1)
|
|
|
1647 'face
|
|
|
1648 'speedbar-file-face))))))
|
|
|
1649
|
|
100
|
1650 (defun speedbar-update-current-file ()
|
|
167
|
1651 "Find the current file is, and update our visuals to indicate its name.
|
|
|
1652 This is specific to file names. If the file name doesn't show up, but
|
|
|
1653 it should be in the list, then the directory cache needs to be
|
|
|
1654 updated."
|
|
100
|
1655 (let* ((lastf (selected-frame))
|
|
167
|
1656 (newcfd (save-excursion
|
|
|
1657 (select-frame speedbar-attached-frame)
|
|
|
1658 (let ((rf (if (buffer-file-name)
|
|
|
1659 (buffer-file-name)
|
|
|
1660 nil)))
|
|
|
1661 (select-frame lastf)
|
|
|
1662 rf)))
|
|
|
1663 (newcf (if newcfd (file-name-nondirectory newcfd)))
|
|
|
1664 (lastb (current-buffer))
|
|
|
1665 (sucf-recursive (boundp 'sucf-recursive)))
|
|
|
1666 (if (and newcf
|
|
|
1667 ;; check here, that way we won't refresh to newcf until
|
|
|
1668 ;; its been written, thus saving ourselves some time
|
|
|
1669 (file-exists-p newcf)
|
|
|
1670 (not (string= newcf speedbar-last-selected-file)))
|
|
100
|
1671 (progn
|
|
167
|
1672 ;; It is important to select the frame, otherwise the window
|
|
|
1673 ;; we want the cursor to move in will not be updated by the
|
|
|
1674 ;; search-forward command.
|
|
100
|
1675 (select-frame speedbar-frame)
|
|
167
|
1676 ;; Remove the old file...
|
|
|
1677 (speedbar-clear-current-file)
|
|
|
1678 ;; now highlight the new one.
|
|
100
|
1679 (set-buffer speedbar-buffer)
|
|
|
1680 (speedbar-with-writable
|
|
|
1681 (goto-char (point-min))
|
|
167
|
1682 (if (re-search-forward
|
|
|
1683 (concat " \\(" (regexp-quote newcf) "\\)\\("
|
|
|
1684 (regexp-quote speedbar-vc-indicator)
|
|
|
1685 "\\)?\n") nil t)
|
|
|
1686 ;; put the property on it
|
|
|
1687 (put-text-property (match-beginning 1)
|
|
|
1688 (match-end 1)
|
|
|
1689 'face
|
|
|
1690 'speedbar-selected-face)
|
|
|
1691 ;; Oops, it's not in the list. Should it be?
|
|
|
1692 (if (and (string-match speedbar-file-regexp newcf)
|
|
|
1693 (string= (file-name-directory newcfd)
|
|
|
1694 (expand-file-name default-directory)))
|
|
|
1695 ;; yes, it is (we will ignore unknowns for now...)
|
|
|
1696 (progn
|
|
|
1697 (speedbar-refresh)
|
|
|
1698 (if (re-search-forward
|
|
|
1699 (concat " \\(" (regexp-quote newcf) "\\)\n") nil t)
|
|
|
1700 ;; put the property on it
|
|
|
1701 (put-text-property (match-beginning 1)
|
|
|
1702 (match-end 1)
|
|
|
1703 'face
|
|
|
1704 'speedbar-selected-face)))
|
|
|
1705 ;; if it's not in there now, whatever...
|
|
|
1706 ))
|
|
100
|
1707 (setq speedbar-last-selected-file newcf))
|
|
167
|
1708 (if (not sucf-recursive)
|
|
|
1709 (progn
|
|
|
1710 (forward-line -1)
|
|
|
1711 (speedbar-position-cursor-on-line)))
|
|
100
|
1712 (set-buffer lastb)
|
|
167
|
1713 (select-frame lastf)
|
|
|
1714 )))
|
|
|
1715 ;; return that we are done with this activity.
|
|
|
1716 t)
|
|
|
1717
|
|
|
1718 ;; If it's being used, check for it
|
|
|
1719 (eval-when-compile (or (featurep 'xemacs) (require 'ange-ftp)))
|
|
|
1720
|
|
|
1721 (defun speedbar-check-vc ()
|
|
|
1722 "Scan all files in a directory, and for each see if it's checked out.
|
|
|
1723 See `speedbar-this-file-in-vc' and `speedbar-vc-check-dir-p' for how
|
|
|
1724 to add more types of version control systems."
|
|
|
1725 ;; Check for to-do to be reset. If reset but no RCS is available
|
|
|
1726 ;; then set to nil (do nothing) otherwise, start at the beginning
|
|
|
1727 (save-excursion
|
|
|
1728 (set-buffer speedbar-buffer)
|
|
|
1729 (if (and speedbar-vc-do-check (eq speedbar-vc-to-do-point t)
|
|
|
1730 (speedbar-vc-check-dir-p default-directory)
|
|
|
1731 (not (and (featurep 'ange-ftp)
|
|
|
1732 (string-match (car
|
|
|
1733 (if speedbar-xemacsp
|
|
|
1734 ange-ftp-path-format
|
|
|
1735 ange-ftp-name-format))
|
|
|
1736 (expand-file-name default-directory)))))
|
|
|
1737 (setq speedbar-vc-to-do-point 0))
|
|
|
1738 (if (numberp speedbar-vc-to-do-point)
|
|
|
1739 (progn
|
|
|
1740 (goto-char speedbar-vc-to-do-point)
|
|
|
1741 (while (and (not (input-pending-p))
|
|
|
1742 (re-search-forward "^\\([0-9]+\\):\\s-*\\[[+-]\\] " nil t))
|
|
|
1743 (setq speedbar-vc-to-do-point (point))
|
|
|
1744 (if (speedbar-check-vc-this-line)
|
|
|
1745 (speedbar-with-writable
|
|
|
1746 (insert speedbar-vc-indicator))))
|
|
|
1747 (if (input-pending-p)
|
|
|
1748 ;; return that we are incomplete
|
|
|
1749 nil
|
|
|
1750 ;; we are done, set to-do to nil
|
|
|
1751 (setq speedbar-vc-to-do-point nil)
|
|
|
1752 ;; and return t
|
|
|
1753 t))
|
|
|
1754 t)))
|
|
|
1755
|
|
|
1756 (defun speedbar-check-vc-this-line ()
|
|
|
1757 "Return t if the file on this line is check of of a version control system.
|
|
|
1758 The one caller-requirement is that the last regexp matching operation
|
|
|
1759 has the current depth stored in (MATCHSTRING 1), and that the cursor
|
|
|
1760 is right in front of the file name."
|
|
|
1761 (let* ((d (string-to-int (match-string 1)))
|
|
|
1762 (f (speedbar-line-path d))
|
|
|
1763 (fn (buffer-substring-no-properties
|
|
|
1764 (point) (progn (end-of-line) (point))))
|
|
|
1765 (fulln (concat f fn)))
|
|
|
1766 (if (<= 2 speedbar-verbosity-level)
|
|
|
1767 (message "Speedbar vc check...%s" fulln))
|
|
|
1768 (and (file-writable-p fulln)
|
|
|
1769 (speedbar-this-file-in-vc f fn))))
|
|
|
1770
|
|
|
1771 (defun speedbar-vc-check-dir-p (path)
|
|
|
1772 "Return t if we should bother checking PATH for version control files.
|
|
|
1773 This can be overloaded to add new types of version control systems."
|
|
|
1774 (or
|
|
|
1775 (file-exists-p (concat path "RCS/"))
|
|
|
1776 ;; If SCCS is added in `speedbar-this-file-in-vc'
|
|
|
1777 ;; (file-exists-p (concat path "SCCS/"))
|
|
|
1778 ;; (file-exists-p (getenv "SCCSPATHTHINGIDONTREMEMBER"))
|
|
|
1779 ))
|
|
|
1780
|
|
|
1781 (defun speedbar-this-file-in-vc (path name)
|
|
|
1782 "Check to see if the file in PATH with NAME is in a version control system.
|
|
|
1783 You can add new VC systems by overriding this function. You can
|
|
|
1784 optimize this function by overriding it and only doing those checks
|
|
|
1785 that will occur on your system."
|
|
|
1786 (or
|
|
|
1787 (file-exists-p (concat path "RCS/" name ",v"))
|
|
|
1788 ;; Is this right? I don't recall
|
|
|
1789 ;;(file-exists-p (concat path "SCCS/," fn))
|
|
|
1790 ;;(file-exists-p (concat (getenv "SCCSPATHTHING") "/SCCS/," fn))
|
|
|
1791 ))
|
|
100
|
1792
|
|
|
1793 ;;; Clicking Activity
|
|
167
|
1794 ;;
|
|
100
|
1795 (defun speedbar-quick-mouse (e)
|
|
167
|
1796 "Since mouse events are strange, this will keep the mouse nicely positioned.
|
|
|
1797 This should be bound to mouse event E."
|
|
100
|
1798 (interactive "e")
|
|
|
1799 (mouse-set-point e)
|
|
167
|
1800 (speedbar-position-cursor-on-line)
|
|
100
|
1801 )
|
|
|
1802
|
|
|
1803 (defun speedbar-position-cursor-on-line ()
|
|
|
1804 "Position the cursor on a line."
|
|
167
|
1805 (let ((oldpos (point)))
|
|
|
1806 (beginning-of-line)
|
|
|
1807 (if (looking-at "[0-9]+:\\s-*..?.? ")
|
|
|
1808 (goto-char (1- (match-end 0)))
|
|
|
1809 (goto-char oldpos))))
|
|
|
1810
|
|
|
1811 (defun speedbar-power-click (e)
|
|
|
1812 "Activate any speedbar button as a power click.
|
|
|
1813 This should be bound to mouse event E."
|
|
|
1814 (interactive "e")
|
|
|
1815 (let ((speedbar-power-click t))
|
|
|
1816 (speedbar-click e)))
|
|
|
1817
|
|
|
1818 (defun speedbar-click (e)
|
|
|
1819 "Activate any speedbar buttons where the mouse is clicked.
|
|
|
1820 This must be bound to a mouse event. A button is any location of text
|
|
|
1821 with a mouse face that has a text property called `speedbar-function'.
|
|
|
1822 This should be bound to mouse event E."
|
|
|
1823 (interactive "e")
|
|
|
1824 (mouse-set-point e)
|
|
|
1825 (speedbar-do-function-pointer)
|
|
|
1826 (speedbar-quick-mouse e))
|
|
|
1827
|
|
|
1828 (defun speedbar-do-function-pointer ()
|
|
|
1829 "Look under the cursor and examine the text properties.
|
|
|
1830 From this extract the file/tag name, token, indentation level and call
|
|
|
1831 a function if appropriate"
|
|
|
1832 (let* ((fn (get-text-property (point) 'speedbar-function))
|
|
|
1833 (tok (get-text-property (point) 'speedbar-token))
|
|
|
1834 ;; The 1-,+ is safe because scaning starts AFTER the point
|
|
|
1835 ;; specified. This lets the search include the character the
|
|
|
1836 ;; cursor is on.
|
|
|
1837 (tp (previous-single-property-change
|
|
|
1838 (1+ (point)) 'speedbar-function))
|
|
|
1839 (np (next-single-property-change
|
|
|
1840 (point) 'speedbar-function))
|
|
|
1841 (txt (buffer-substring-no-properties (or tp (point-min))
|
|
|
1842 (or np (point-max))))
|
|
|
1843 (dent (save-excursion (beginning-of-line)
|
|
|
1844 (string-to-number
|
|
|
1845 (if (looking-at "[0-9]+")
|
|
|
1846 (buffer-substring-no-properties
|
|
|
1847 (match-beginning 0) (match-end 0))
|
|
|
1848 "0")))))
|
|
|
1849 ;;(message "%S:%S:%S:%s" fn tok txt dent)
|
|
|
1850 (and fn (funcall fn txt tok dent)))
|
|
|
1851 (speedbar-position-cursor-on-line))
|
|
|
1852
|
|
|
1853 ;;; Reading info from the speedbar buffer
|
|
|
1854 ;;
|
|
|
1855 (defun speedbar-line-file (&optional p)
|
|
|
1856 "Retrieve the file or whatever from the line at P point.
|
|
|
1857 The return value is a string representing the file. If it is a
|
|
|
1858 directory, then it is the directory name."
|
|
|
1859 (save-excursion
|
|
|
1860 (save-match-data
|
|
|
1861 (beginning-of-line)
|
|
|
1862 (if (looking-at (concat
|
|
|
1863 "\\([0-9]+\\): *[[<][-+][]>] \\([^ \n]+\\)\\("
|
|
|
1864 (regexp-quote speedbar-vc-indicator)
|
|
|
1865 "\\)?"))
|
|
|
1866 (let* ((depth (string-to-int (match-string 1)))
|
|
|
1867 (path (speedbar-line-path depth))
|
|
|
1868 (f (match-string 2)))
|
|
|
1869 (concat path f))
|
|
|
1870 nil))))
|
|
|
1871
|
|
|
1872 (defun speedbar-goto-this-file (file)
|
|
|
1873 "If FILE is displayed, goto this line and return t.
|
|
|
1874 Otherwise do not move and return nil."
|
|
|
1875 (let ((path (substring (file-name-directory (expand-file-name file))
|
|
|
1876 (length (expand-file-name default-directory))))
|
|
|
1877 (dest (point)))
|
|
|
1878 (save-match-data
|
|
|
1879 (goto-char (point-min))
|
|
|
1880 ;; scan all the directories
|
|
|
1881 (while (and path (not (eq path t)))
|
|
|
1882 (if (string-match "^/?\\([^/]+\\)" path)
|
|
|
1883 (let ((pp (match-string 1 path)))
|
|
|
1884 (if (save-match-data
|
|
|
1885 (re-search-forward (concat "> " (regexp-quote pp) "$")
|
|
|
1886 nil t))
|
|
|
1887 (setq path (substring path (match-end 1)))
|
|
|
1888 (setq path nil)))
|
|
|
1889 (setq path t)))
|
|
|
1890 ;; find the file part
|
|
|
1891 (if (or (not path) (string= (file-name-nondirectory file) ""))
|
|
|
1892 ;; only had a dir part
|
|
|
1893 (if path
|
|
|
1894 (progn
|
|
|
1895 (speedbar-position-cursor-on-line)
|
|
|
1896 t)
|
|
|
1897 (goto-char dest) nil)
|
|
|
1898 ;; find the file part
|
|
|
1899 (let ((nd (file-name-nondirectory file)))
|
|
|
1900 (if (re-search-forward
|
|
|
1901 (concat "] \\(" (regexp-quote nd)
|
|
|
1902 "\\)\\(" (regexp-quote speedbar-vc-indicator) "\\)?$")
|
|
|
1903 nil t)
|
|
|
1904 (progn
|
|
|
1905 (speedbar-position-cursor-on-line)
|
|
|
1906 t)
|
|
|
1907 (goto-char dest)
|
|
|
1908 nil))))))
|
|
100
|
1909
|
|
|
1910 (defun speedbar-line-path (depth)
|
|
167
|
1911 "Retrieve the pathname associated with the current line.
|
|
|
1912 This may require traversing backwards from DEPTH and combining the default
|
|
|
1913 directory with these items."
|
|
100
|
1914 (save-excursion
|
|
167
|
1915 (save-match-data
|
|
|
1916 (let ((path nil))
|
|
|
1917 (setq depth (1- depth))
|
|
|
1918 (while (/= depth -1)
|
|
|
1919 (if (not (re-search-backward (format "^%d:" depth) nil t))
|
|
|
1920 (error "Error building path of tag")
|
|
|
1921 (cond ((looking-at "[0-9]+:\\s-*<->\\s-+\\([^\n]+\\)$")
|
|
|
1922 (setq path (concat (buffer-substring-no-properties
|
|
|
1923 (match-beginning 1) (match-end 1))
|
|
|
1924 "/"
|
|
|
1925 path)))
|
|
|
1926 ((looking-at "[0-9]+:\\s-*[-]\\s-+\\([^\n]+\\)$")
|
|
|
1927 ;; This is the start of our path.
|
|
|
1928 (setq path (buffer-substring-no-properties
|
|
|
1929 (match-beginning 1) (match-end 1))))))
|
|
|
1930 (setq depth (1- depth)))
|
|
|
1931 (if (and path
|
|
|
1932 (string-match (concat (regexp-quote speedbar-vc-indicator) "$")
|
|
|
1933 path))
|
|
|
1934 (setq path (substring path 0 (match-beginning 0))))
|
|
|
1935 (concat default-directory path)))))
|
|
100
|
1936
|
|
|
1937 (defun speedbar-edit-line ()
|
|
|
1938 "Edit whatever tag or file is on the current speedbar line."
|
|
|
1939 (interactive)
|
|
167
|
1940 (save-excursion
|
|
|
1941 (beginning-of-line)
|
|
|
1942 ;; If this fails, then it is a non-standard click, and as such,
|
|
|
1943 ;; perfectly allowed.
|
|
|
1944 (re-search-forward "[]>}] [a-zA-Z0-9]"
|
|
|
1945 (save-excursion (end-of-line) (point)) t)
|
|
|
1946 (speedbar-do-function-pointer)))
|
|
100
|
1947
|
|
|
1948 (defun speedbar-expand-line ()
|
|
|
1949 "Expand the line under the cursor."
|
|
|
1950 (interactive)
|
|
|
1951 (beginning-of-line)
|
|
|
1952 (re-search-forward ":\\s-*.\\+. " (save-excursion (end-of-line) (point)))
|
|
|
1953 (forward-char -2)
|
|
|
1954 (speedbar-do-function-pointer))
|
|
|
1955
|
|
|
1956 (defun speedbar-contract-line ()
|
|
167
|
1957 "Contract the line under the cursor."
|
|
100
|
1958 (interactive)
|
|
|
1959 (beginning-of-line)
|
|
|
1960 (re-search-forward ":\\s-*.-. " (save-excursion (end-of-line) (point)))
|
|
|
1961 (forward-char -2)
|
|
|
1962 (speedbar-do-function-pointer))
|
|
|
1963
|
|
167
|
1964 (defun speedbar-maybee-jump-to-attached-frame ()
|
|
|
1965 "Jump to the attached frame ONLY if this was not a mouse event."
|
|
|
1966 (if (numberp last-input-char)
|
|
|
1967 (progn
|
|
|
1968 (select-frame speedbar-attached-frame)
|
|
|
1969 (other-frame 0))))
|
|
100
|
1970
|
|
|
1971 (defun speedbar-find-file (text token indent)
|
|
167
|
1972 "Speedbar click handler for filenames.
|
|
|
1973 TEXT, the file will be displayed in the attached frame.
|
|
|
1974 TOKEN is unused, but required by the click handler. INDENT is the
|
|
|
1975 current indentation level."
|
|
100
|
1976 (let ((cdd (speedbar-line-path indent)))
|
|
167
|
1977 (speedbar-find-file-in-frame (concat cdd text))
|
|
|
1978 (speedbar-stealthy-updates)
|
|
100
|
1979 ;; Reset the timer with a new timeout when cliking a file
|
|
|
1980 ;; in case the user was navigating directories, we can cancel
|
|
|
1981 ;; that other timer.
|
|
167
|
1982 (speedbar-set-timer speedbar-update-speed))
|
|
|
1983 (speedbar-maybee-jump-to-attached-frame))
|
|
100
|
1984
|
|
|
1985 (defun speedbar-dir-follow (text token indent)
|
|
167
|
1986 "Speedbar click handler for directory names.
|
|
|
1987 Clicking a directory will cause the speedbar to list files in the
|
|
|
1988 the subdirectory TEXT. TOKEN is an unused requirement. The
|
|
|
1989 subdirectory chosen will be at INDENT level."
|
|
|
1990 (setq default-directory
|
|
100
|
1991 (concat (expand-file-name (concat (speedbar-line-path indent) text))
|
|
|
1992 "/"))
|
|
|
1993 ;; Because we leave speedbar as the current buffer,
|
|
|
1994 ;; update contents will change directory without
|
|
|
1995 ;; having to touch the attached frame.
|
|
|
1996 (speedbar-update-contents)
|
|
|
1997 (speedbar-set-timer speedbar-navigating-speed)
|
|
|
1998 (setq speedbar-last-selected-file nil)
|
|
167
|
1999 (speedbar-stealthy-updates))
|
|
100
|
2000
|
|
167
|
2001 (defun speedbar-delete-subblock (indent)
|
|
|
2002 "Delete text from point to indentation level INDENT or greater.
|
|
|
2003 Handles end-of-sublist smartly."
|
|
|
2004 (speedbar-with-writable
|
|
|
2005 (save-excursion
|
|
|
2006 (end-of-line) (forward-char 1)
|
|
|
2007 (while (and (not (save-excursion
|
|
|
2008 (re-search-forward (format "^%d:" indent)
|
|
|
2009 nil t)))
|
|
|
2010 (>= indent 0))
|
|
|
2011 (setq indent (1- indent)))
|
|
|
2012 (delete-region (point) (if (>= indent 0)
|
|
|
2013 (match-beginning 0)
|
|
|
2014 (point-max))))))
|
|
100
|
2015
|
|
|
2016 (defun speedbar-dired (text token indent)
|
|
167
|
2017 "Speedbar click handler for directory expand button.
|
|
|
2018 Clicking this button expands or contracts a directory. TEXT is the
|
|
|
2019 button clicked which has either a + or -. TOKEN is the directory to be
|
|
|
2020 expanded. INDENT is the current indentation level."
|
|
|
2021 (cond ((string-match "+" text) ;we have to expand this dir
|
|
|
2022 (setq speedbar-shown-directories
|
|
|
2023 (cons (expand-file-name
|
|
100
|
2024 (concat (speedbar-line-path indent) token "/"))
|
|
|
2025 speedbar-shown-directories))
|
|
|
2026 (speedbar-change-expand-button-char ?-)
|
|
167
|
2027 (speedbar-reset-scanners)
|
|
100
|
2028 (save-excursion
|
|
|
2029 (end-of-line) (forward-char 1)
|
|
|
2030 (speedbar-with-writable
|
|
167
|
2031 (speedbar-default-directory-list
|
|
100
|
2032 (concat (speedbar-line-path indent) token "/")
|
|
|
2033 (1+ indent)))))
|
|
|
2034 ((string-match "-" text) ;we have to contract this node
|
|
167
|
2035 (speedbar-reset-scanners)
|
|
100
|
2036 (let ((oldl speedbar-shown-directories)
|
|
|
2037 (newl nil)
|
|
167
|
2038 (td (expand-file-name
|
|
100
|
2039 (concat (speedbar-line-path indent) token))))
|
|
|
2040 (while oldl
|
|
|
2041 (if (not (string-match (concat "^" (regexp-quote td)) (car oldl)))
|
|
|
2042 (setq newl (cons (car oldl) newl)))
|
|
|
2043 (setq oldl (cdr oldl)))
|
|
|
2044 (setq speedbar-shown-directories newl))
|
|
|
2045 (speedbar-change-expand-button-char ?+)
|
|
167
|
2046 (speedbar-delete-subblock indent)
|
|
100
|
2047 )
|
|
|
2048 (t (error "Ooops... not sure what to do.")))
|
|
|
2049 (speedbar-center-buffer-smartly)
|
|
|
2050 (setq speedbar-last-selected-file nil)
|
|
167
|
2051 (save-excursion (speedbar-stealthy-updates)))
|
|
100
|
2052
|
|
167
|
2053 (defun speedbar-directory-buttons-follow (text token indent)
|
|
|
2054 "Speedbar click handler for default directory buttons.
|
|
|
2055 TEXT is the button clicked on. TOKEN is the directory to follow.
|
|
|
2056 INDENT is the current indentation level and is unused."
|
|
100
|
2057 (setq default-directory token)
|
|
|
2058 ;; Because we leave speedbar as the current buffer,
|
|
|
2059 ;; update contents will change directory without
|
|
|
2060 ;; having to touch the attached frame.
|
|
|
2061 (speedbar-update-contents)
|
|
|
2062 (speedbar-set-timer speedbar-navigating-speed))
|
|
|
2063
|
|
|
2064 (defun speedbar-tag-file (text token indent)
|
|
167
|
2065 "The cursor is on a selected line. Expand the tags in the specified file.
|
|
|
2066 The parameter TEXT and TOKEN are required, where TEXT is the button
|
|
|
2067 clicked, and TOKEN is the file to expand. INDENT is the current
|
|
|
2068 indentation level."
|
|
100
|
2069 (cond ((string-match "+" text) ;we have to expand this file
|
|
|
2070 (let* ((fn (expand-file-name (concat (speedbar-line-path indent)
|
|
|
2071 token)))
|
|
167
|
2072 (lst (if speedbar-use-imenu-flag
|
|
100
|
2073 (let ((tim (speedbar-fetch-dynamic-imenu fn)))
|
|
|
2074 (if (eq tim t)
|
|
|
2075 (speedbar-fetch-dynamic-etags fn)
|
|
|
2076 tim))
|
|
|
2077 (speedbar-fetch-dynamic-etags fn))))
|
|
|
2078 ;; if no list, then remove expando button
|
|
|
2079 (if (not lst)
|
|
|
2080 (speedbar-change-expand-button-char ??)
|
|
|
2081 (speedbar-change-expand-button-char ?-)
|
|
|
2082 (speedbar-with-writable
|
|
|
2083 (save-excursion
|
|
|
2084 (end-of-line) (forward-char 1)
|
|
|
2085 (speedbar-insert-generic-list indent
|
|
|
2086 lst 'speedbar-tag-expand
|
|
|
2087 'speedbar-tag-find))))))
|
|
|
2088 ((string-match "-" text) ;we have to contract this node
|
|
|
2089 (speedbar-change-expand-button-char ?+)
|
|
167
|
2090 (speedbar-delete-subblock indent))
|
|
100
|
2091 (t (error "Ooops... not sure what to do.")))
|
|
|
2092 (speedbar-center-buffer-smartly))
|
|
|
2093
|
|
|
2094 (defun speedbar-tag-find (text token indent)
|
|
167
|
2095 "For the tag TEXT in a file TOKEN, goto that position.
|
|
|
2096 INDENT is the current indentation level."
|
|
100
|
2097 (let ((file (speedbar-line-path indent)))
|
|
167
|
2098 (speedbar-find-file-in-frame file)
|
|
|
2099 (save-excursion (speedbar-stealthy-updates))
|
|
100
|
2100 ;; Reset the timer with a new timeout when cliking a file
|
|
|
2101 ;; in case the user was navigating directories, we can cancel
|
|
|
2102 ;; that other timer.
|
|
|
2103 (speedbar-set-timer speedbar-update-speed)
|
|
167
|
2104 (goto-char token)
|
|
|
2105 ;;(recenter)
|
|
|
2106 (speedbar-maybee-jump-to-attached-frame)
|
|
|
2107 ))
|
|
100
|
2108
|
|
|
2109 (defun speedbar-tag-expand (text token indent)
|
|
167
|
2110 "Expand a tag sublist. Imenu will return sub-lists of specialized tag types.
|
|
|
2111 Etags does not support this feature. TEXT will be the button
|
|
|
2112 string. TOKEN will be the list, and INDENT is the current indentation
|
|
|
2113 level."
|
|
100
|
2114 (cond ((string-match "+" text) ;we have to expand this file
|
|
|
2115 (speedbar-change-expand-button-char ?-)
|
|
|
2116 (speedbar-with-writable
|
|
|
2117 (save-excursion
|
|
|
2118 (end-of-line) (forward-char 1)
|
|
|
2119 (speedbar-insert-generic-list indent
|
|
|
2120 token 'speedbar-tag-expand
|
|
|
2121 'speedbar-tag-find))))
|
|
|
2122 ((string-match "-" text) ;we have to contract this node
|
|
|
2123 (speedbar-change-expand-button-char ?+)
|
|
167
|
2124 (speedbar-delete-subblock indent))
|
|
100
|
2125 (t (error "Ooops... not sure what to do.")))
|
|
|
2126 (speedbar-center-buffer-smartly))
|
|
167
|
2127
|
|
|
2128 ;;; Loading files into the attached frame.
|
|
|
2129 ;;
|
|
|
2130 (defun speedbar-find-file-in-frame (file)
|
|
|
2131 "This will load FILE into the speedbar attached frame.
|
|
|
2132 If the file is being displayed in a different frame already, then raise that
|
|
|
2133 frame instead."
|
|
|
2134 (let* ((buff (find-file-noselect file))
|
|
|
2135 (bwin (get-buffer-window buff 0)))
|
|
|
2136 (if bwin
|
|
|
2137 (progn
|
|
|
2138 (select-window bwin)
|
|
|
2139 (raise-frame (window-frame bwin)))
|
|
|
2140 (if speedbar-power-click
|
|
|
2141 (let ((pop-up-frames t)) (select-window (display-buffer buff)))
|
|
|
2142 (select-frame speedbar-attached-frame)
|
|
|
2143 (switch-to-buffer buff))))
|
|
|
2144 )
|
|
100
|
2145
|
|
|
2146 ;;; Centering Utility
|
|
167
|
2147 ;;
|
|
100
|
2148 (defun speedbar-center-buffer-smartly ()
|
|
167
|
2149 "Recenter a speedbar buffer so the current indentation level is all visible.
|
|
|
2150 This assumes that the cursor is on a file, or tag of a file which the user is
|
|
100
|
2151 interested in."
|
|
167
|
2152 (if (<= (count-lines (point-min) (point-max))
|
|
100
|
2153 (window-height (selected-window)))
|
|
|
2154 ;; whole buffer fits
|
|
|
2155 (let ((cp (point)))
|
|
|
2156 (goto-char (point-min))
|
|
|
2157 (recenter 0)
|
|
|
2158 (goto-char cp))
|
|
|
2159 ;; too big
|
|
|
2160 (let (depth start end exp p)
|
|
|
2161 (save-excursion
|
|
|
2162 (beginning-of-line)
|
|
|
2163 (setq depth (if (looking-at "[0-9]+")
|
|
|
2164 (string-to-int (buffer-substring-no-properties
|
|
|
2165 (match-beginning 0) (match-end 0)))
|
|
|
2166 0))
|
|
|
2167 (setq exp (format "^%d:\\s-*[[{<]\\([?+-]\\)[]>}]" depth)))
|
|
|
2168 (save-excursion
|
|
|
2169 (end-of-line)
|
|
|
2170 (if (re-search-backward exp nil t)
|
|
|
2171 (setq start (point))
|
|
|
2172 (error "Center error"))
|
|
|
2173 (save-excursion ;Not sure about this part.
|
|
|
2174 (end-of-line)
|
|
|
2175 (setq p (point))
|
|
|
2176 (while (and (not (re-search-forward exp nil t))
|
|
|
2177 (>= depth 0))
|
|
|
2178 (setq depth (1- depth))
|
|
|
2179 (setq exp (format "^%d:\\s-*[[{<]\\([?+-]\\)[]>}]" depth)))
|
|
|
2180 (if (/= (point) p)
|
|
|
2181 (setq end (point))
|
|
|
2182 (setq end (point-max)))))
|
|
|
2183 ;; Now work out the details of centering
|
|
|
2184 (let ((nl (count-lines start end))
|
|
|
2185 (cp (point)))
|
|
|
2186 (if (> nl (window-height (selected-window)))
|
|
|
2187 ;; We can't fit it all, so just center on cursor
|
|
|
2188 (progn (goto-char start)
|
|
|
2189 (recenter 1))
|
|
|
2190 ;; we can fit everything on the screen, but...
|
|
|
2191 (if (and (pos-visible-in-window-p start (selected-window))
|
|
|
2192 (pos-visible-in-window-p end (selected-window)))
|
|
|
2193 ;; we are all set!
|
|
|
2194 nil
|
|
|
2195 ;; we need to do something...
|
|
|
2196 (goto-char start)
|
|
|
2197 (let ((newcent (/ (- (window-height (selected-window)) nl) 2))
|
|
|
2198 (lte (count-lines start (point-max))))
|
|
|
2199 (if (and (< (+ newcent lte) (window-height (selected-window)))
|
|
|
2200 (> (- (window-height (selected-window)) lte 1)
|
|
|
2201 newcent))
|
|
|
2202 (setq newcent (- (window-height (selected-window))
|
|
|
2203 lte 1)))
|
|
|
2204 (recenter newcent))))
|
|
|
2205 (goto-char cp)))))
|
|
|
2206
|
|
|
2207
|
|
|
2208 ;;; Tag Management -- Imenu
|
|
167
|
2209 ;;
|
|
|
2210 (if (string-match "XEmacs" emacs-version)
|
|
|
2211
|
|
|
2212 nil
|
|
|
2213
|
|
|
2214 (eval-when-compile (if (locate-library "imenu") (require 'imenu)))
|
|
|
2215
|
|
100
|
2216 (defun speedbar-fetch-dynamic-imenu (file)
|
|
167
|
2217 "Load FILE into a buffer, and generate tags using Imenu.
|
|
|
2218 Returns the tag list, or t for an error."
|
|
|
2219 ;; Load this AND compile it in
|
|
|
2220 (require 'imenu)
|
|
100
|
2221 (save-excursion
|
|
|
2222 (set-buffer (find-file-noselect file))
|
|
|
2223 (condition-case nil
|
|
167
|
2224 (progn
|
|
|
2225 (if speedbar-power-click (setq imenu--index-alist nil))
|
|
|
2226 (imenu--make-index-alist t))
|
|
100
|
2227 (error t))))
|
|
167
|
2228 )
|
|
100
|
2229
|
|
167
|
2230 ;;; Tag Management -- etags (XEmacs compatibility part)
|
|
|
2231 ;;
|
|
100
|
2232 (defvar speedbar-fetch-etags-parse-list
|
|
167
|
2233 '(;; Note that java has the same parse-group as c
|
|
|
2234 ("\\.\\([cChH]\\|c++\\|cpp\\|cc\\|hh\\|java\\)$" . speedbar-parse-c-or-c++tag)
|
|
|
2235 ("\\.el\\|\\.emacs" . "defun\\s-+\\(\\(\\w\\|[-_]\\)+\\)\\s-*\C-?")
|
|
100
|
2236 ("\\.tex$" . speedbar-parse-tex-string)
|
|
|
2237 ("\\.p" .
|
|
|
2238 "\\(\\(FUNCTION\\|function\\|PROCEDURE\\|procedure\\)\\s-+\\([a-zA-Z0-9_.:]+\\)\\)\\s-*(?^?")
|
|
|
2239
|
|
|
2240 )
|
|
167
|
2241 "Associations of file extensions and expressions for extracting tags.
|
|
|
2242 To add a new file type, you would want to add a new association to the
|
|
|
2243 list, where the car is the file match, and the cdr is the way to
|
|
|
2244 extract an element from the tags output. If the output is complex,
|
|
|
2245 use a function symbol instead of regexp. The function should expect
|
|
|
2246 to be at the beginning of a line in the etags buffer.
|
|
100
|
2247
|
|
167
|
2248 This variable is ignored if `speedbar-use-imenu-flag' is t")
|
|
100
|
2249
|
|
|
2250 (defvar speedbar-fetch-etags-command "etags"
|
|
|
2251 "*Command used to create an etags file.
|
|
|
2252
|
|
167
|
2253 This variable is ignored if `speedbar-use-imenu-flag' is t")
|
|
100
|
2254
|
|
|
2255 (defvar speedbar-fetch-etags-arguments '("-D" "-I" "-o" "-")
|
|
167
|
2256 "*List of arguments to use with `speedbar-fetch-etags-command'.
|
|
|
2257 This creates an etags output buffer. Use `speedbar-toggle-etags' to
|
|
|
2258 modify this list conveniently.
|
|
|
2259
|
|
|
2260 This variable is ignored if `speedbar-use-imenu-flag' is t")
|
|
|
2261
|
|
|
2262 (defun speedbar-toggle-etags (flag)
|
|
|
2263 "Toggle FLAG in `speedbar-fetch-etags-arguments'.
|
|
|
2264 FLAG then becomes a member of etags command line arguments. If flag
|
|
|
2265 is \"sort\", then toggle the value of `speedbar-sort-tags'. If it's
|
|
|
2266 value is \"show\" then toggle the value of
|
|
|
2267 `speedbar-show-unknown-files'.
|
|
100
|
2268
|
|
167
|
2269 This function is a convenience function for XEmacs menu created by
|
|
|
2270 Farzin Guilak <farzin@protocol.com>"
|
|
|
2271 (interactive)
|
|
|
2272 (cond
|
|
|
2273 ((equal flag "sort")
|
|
|
2274 (setq speedbar-sort-tags (not speedbar-sort-tags)))
|
|
|
2275 ((equal flag "show")
|
|
|
2276 (setq speedbar-show-unknown-files (not speedbar-show-unknown-files)))
|
|
|
2277 ((or (equal flag "-C")
|
|
|
2278 (equal flag "-S")
|
|
|
2279 (equal flag "-D"))
|
|
|
2280 (if (member flag speedbar-fetch-etags-arguments)
|
|
|
2281 (setq speedbar-fetch-etags-arguments
|
|
|
2282 (delete flag speedbar-fetch-etags-arguments))
|
|
|
2283 (add-to-list 'speedbar-fetch-etags-arguments flag)))
|
|
|
2284 (t nil)))
|
|
100
|
2285
|
|
|
2286 (defun speedbar-fetch-dynamic-etags (file)
|
|
167
|
2287 "For FILE, run etags and create a list of symbols extracted.
|
|
|
2288 Each symbol will be associated with it's line position in FILE."
|
|
100
|
2289 (let ((newlist nil))
|
|
|
2290 (unwind-protect
|
|
|
2291 (save-excursion
|
|
|
2292 (if (get-buffer "*etags tmp*")
|
|
|
2293 (kill-buffer "*etags tmp*")) ;kill to clean it up
|
|
167
|
2294 (if (<= 1 speedbar-verbosity-level) (message "Fetching etags..."))
|
|
100
|
2295 (set-buffer (get-buffer-create "*etags tmp*"))
|
|
167
|
2296 (apply 'call-process speedbar-fetch-etags-command nil
|
|
|
2297 (current-buffer) nil
|
|
100
|
2298 (append speedbar-fetch-etags-arguments (list file)))
|
|
|
2299 (goto-char (point-min))
|
|
167
|
2300 (if (<= 1 speedbar-verbosity-level) (message "Fetching etags..."))
|
|
|
2301 (let ((expr
|
|
100
|
2302 (let ((exprlst speedbar-fetch-etags-parse-list)
|
|
|
2303 (ans nil))
|
|
|
2304 (while (and (not ans) exprlst)
|
|
|
2305 (if (string-match (car (car exprlst)) file)
|
|
|
2306 (setq ans (car exprlst)))
|
|
|
2307 (setq exprlst (cdr exprlst)))
|
|
|
2308 (cdr ans))))
|
|
|
2309 (if expr
|
|
|
2310 (let (tnl)
|
|
|
2311 (while (not (save-excursion (end-of-line) (eobp)))
|
|
|
2312 (save-excursion
|
|
|
2313 (setq tnl (speedbar-extract-one-symbol expr)))
|
|
|
2314 (if tnl (setq newlist (cons tnl newlist)))
|
|
|
2315 (forward-line 1)))
|
|
|
2316 (message "Sorry, no support for a file of that extension"))))
|
|
|
2317 )
|
|
167
|
2318 (if speedbar-sort-tags
|
|
|
2319 (sort newlist (lambda (a b) (string< (car a) (car b))))
|
|
|
2320 (reverse newlist))))
|
|
|
2321
|
|
|
2322 ;; This bit donated by Farzin Guilak <farzin@protocol.com> but I'm not
|
|
|
2323 ;; sure it's needed with the different sorting method.
|
|
|
2324 ;;
|
|
|
2325 ;(defun speedbar-clean-etags()
|
|
|
2326 ; "Removes spaces before the ^? character, and removes `#define',
|
|
|
2327 ;return types, etc. preceding tags. This ensures that the sort operation
|
|
|
2328 ;works on the tags, not the return types."
|
|
|
2329 ; (save-excursion
|
|
|
2330 ; (goto-char (point-min))
|
|
|
2331 ; (while
|
|
|
2332 ; (re-search-forward "(?[ \t](?\C-?" nil t)
|
|
|
2333 ; (replace-match "\C-?" nil nil))
|
|
|
2334 ; (goto-char (point-min))
|
|
|
2335 ; (while
|
|
|
2336 ; (re-search-forward "\\(.*[ \t]+\\)\\([^ \t\n]+.*\C-?\\)" nil t)
|
|
|
2337 ; (delete-region (match-beginning 1) (match-end 1)))))
|
|
100
|
2338
|
|
|
2339 (defun speedbar-extract-one-symbol (expr)
|
|
167
|
2340 "At point, return nil, or one alist in the form: ( symbol . position )
|
|
|
2341 The line should contain output from etags. Parse the output using the
|
|
|
2342 regular expression EXPR"
|
|
100
|
2343 (let* ((sym (if (stringp expr)
|
|
|
2344 (if (save-excursion
|
|
167
|
2345 (re-search-forward expr (save-excursion
|
|
100
|
2346 (end-of-line)
|
|
|
2347 (point)) t))
|
|
|
2348 (buffer-substring-no-properties (match-beginning 1)
|
|
|
2349 (match-end 1)))
|
|
|
2350 (funcall expr)))
|
|
|
2351 (pos (let ((j (re-search-forward "[\C-?\C-a]\\([0-9]+\\),\\([0-9]+\\)"
|
|
|
2352 (save-excursion
|
|
|
2353 (end-of-line)
|
|
|
2354 (point))
|
|
|
2355 t)))
|
|
|
2356 (if (and j sym)
|
|
|
2357 (1+ (string-to-int (buffer-substring-no-properties
|
|
167
|
2358 (match-beginning 2)
|
|
100
|
2359 (match-end 2))))
|
|
|
2360 0))))
|
|
|
2361 (if (/= pos 0)
|
|
|
2362 (cons sym pos)
|
|
|
2363 nil)))
|
|
|
2364
|
|
|
2365 (defun speedbar-parse-c-or-c++tag ()
|
|
|
2366 "Parse a c or c++ tag, which tends to be a little complex."
|
|
|
2367 (save-excursion
|
|
|
2368 (let ((bound (save-excursion (end-of-line) (point))))
|
|
|
2369 (cond ((re-search-forward "\C-?\\([^\C-a]+\\)\C-a" bound t)
|
|
|
2370 (buffer-substring-no-properties (match-beginning 1)
|
|
|
2371 (match-end 1)))
|
|
|
2372 ((re-search-forward "\\<\\([^ \t]+\\)\\s-+new(" bound t)
|
|
|
2373 (buffer-substring-no-properties (match-beginning 1)
|
|
|
2374 (match-end 1)))
|
|
|
2375 ((re-search-forward "\\<\\([^ \t(]+\\)\\s-*(\C-?" bound t)
|
|
|
2376 (buffer-substring-no-properties (match-beginning 1)
|
|
|
2377 (match-end 1)))
|
|
|
2378 (t nil))
|
|
|
2379 )))
|
|
|
2380
|
|
|
2381 (defun speedbar-parse-tex-string ()
|
|
167
|
2382 "Parse a Tex string. Only find data which is relevant."
|
|
100
|
2383 (save-excursion
|
|
|
2384 (let ((bound (save-excursion (end-of-line) (point))))
|
|
|
2385 (cond ((re-search-forward "\\(section\\|chapter\\|cite\\)\\s-*{[^\C-?}]*}?" bound t)
|
|
|
2386 (buffer-substring-no-properties (match-beginning 0)
|
|
|
2387 (match-end 0)))
|
|
|
2388 (t nil)))))
|
|
|
2389
|
|
|
2390
|
|
167
|
2391 ;;; Color loading section This is messy *Blech!*
|
|
|
2392 ;;
|
|
100
|
2393 (defun speedbar-load-color (sym l-fg l-bg d-fg d-bg &optional bold italic underline)
|
|
167
|
2394 "Create a color for SYM with a L-FG and L-BG color, or D-FG and D-BG.
|
|
|
2395 Optionally make BOLD, ITALIC, or UNDERLINE if applicable. If the background
|
|
|
2396 attribute of the current frame is determined to be light (white, for example)
|
|
|
2397 then L-FG and L-BG is used. If not, then D-FG and D-BG is used. This will
|
|
|
2398 allocate the colors in the best possible manor. This will allow me to store
|
|
|
2399 multiple defaults and dynamically determine which colors to use."
|
|
100
|
2400 (let* ((params (frame-parameters))
|
|
|
2401 (disp-res (if (fboundp 'x-get-resource)
|
|
|
2402 (if speedbar-xemacsp
|
|
|
2403 (x-get-resource ".displayType" "DisplayType" 'string)
|
|
|
2404 (x-get-resource ".displayType" "DisplayType"))
|
|
|
2405 nil))
|
|
|
2406 (display-type
|
|
|
2407 (cond (disp-res (intern (downcase disp-res)))
|
|
|
2408 ((and (fboundp 'x-display-color-p) (x-display-color-p)) 'color)
|
|
|
2409 (t 'mono)))
|
|
|
2410 (bg-res (if (fboundp 'x-get-resource)
|
|
|
2411 (if speedbar-xemacsp
|
|
|
2412 (x-get-resource ".backgroundMode" "BackgroundMode" 'string)
|
|
|
2413 (x-get-resource ".backgroundMode" "BackgroundMode"))
|
|
|
2414 nil))
|
|
|
2415 (bgmode
|
|
|
2416 (cond (bg-res (intern (downcase bg-res)))
|
|
167
|
2417 ((let* ((bgc (or (cdr (assq 'background-color params))
|
|
|
2418 (if speedbar-xemacsp
|
|
|
2419 (x-get-resource ".background"
|
|
|
2420 "Background" 'string)
|
|
|
2421 (x-get-resource ".background"
|
|
|
2422 "Background"))
|
|
|
2423 ;; if no other options, default is white
|
|
|
2424 "white"))
|
|
|
2425 (bgcr (if speedbar-xemacsp
|
|
|
2426 (color-instance-rgb-components
|
|
|
2427 (make-color-instance bgc))
|
|
|
2428 (x-color-values bgc)))
|
|
|
2429 (wcr (if speedbar-xemacsp
|
|
|
2430 (color-instance-rgb-components
|
|
|
2431 (make-color-instance "white"))
|
|
|
2432 (x-color-values "white"))))
|
|
|
2433 (< (apply '+ bgcr) (/ (apply '+ wcr) 3)))
|
|
100
|
2434 'dark)
|
|
|
2435 (t 'light))) ;our default
|
|
|
2436 (set-p (function (lambda (face-name resource)
|
|
|
2437 (if speedbar-xemacsp
|
|
167
|
2438 (x-get-resource
|
|
100
|
2439 (concat face-name ".attribute" resource)
|
|
|
2440 (concat "Face.Attribute" resource)
|
|
|
2441 'string)
|
|
167
|
2442 (x-get-resource
|
|
100
|
2443 (concat face-name ".attribute" resource)
|
|
|
2444 (concat "Face.Attribute" resource)))
|
|
|
2445 )))
|
|
167
|
2446 (nbg (cond ((eq bgmode 'dark) d-bg)
|
|
100
|
2447 (t l-bg)))
|
|
|
2448 (nfg (cond ((eq bgmode 'dark) d-fg)
|
|
|
2449 (t l-fg))))
|
|
|
2450
|
|
|
2451 (if (not (eq display-type 'color))
|
|
|
2452 ;; we need a face of some sort, so just make due with default
|
|
|
2453 (progn
|
|
|
2454 (copy-face 'default sym)
|
|
|
2455 (if bold (condition-case nil
|
|
|
2456 (make-face-bold sym)
|
|
167
|
2457 (error (message "Cannot make face %s bold!"
|
|
100
|
2458 (symbol-name sym)))))
|
|
|
2459 (if italic (condition-case nil
|
|
|
2460 (make-face-italic sym)
|
|
|
2461 (error (message "Cannot make face %s italic!"
|
|
|
2462 (symbol-name sym)))))
|
|
|
2463 (set-face-underline-p sym underline)
|
|
|
2464 )
|
|
|
2465 ;; make a colorized version of a face. Be sure to check Xdefaults
|
|
|
2466 ;; for possible overrides first!
|
|
|
2467 (let ((newface (make-face sym)))
|
|
|
2468 ;; For each attribute, check if it might already be set by Xdefaults
|
|
|
2469 (if (and nfg (not (funcall set-p (symbol-name sym) "Foreground")))
|
|
167
|
2470 (set-face-foreground newface nfg))
|
|
100
|
2471 (if (and nbg (not (funcall set-p (symbol-name sym) "Background")))
|
|
167
|
2472 (set-face-background newface nbg))
|
|
|
2473
|
|
100
|
2474 (if bold (condition-case nil
|
|
167
|
2475 (make-face-bold newface)
|
|
100
|
2476 (error (message "Cannot make face %s bold!"
|
|
|
2477 (symbol-name sym)))))
|
|
|
2478 (if italic (condition-case nil
|
|
167
|
2479 (make-face-italic newface)
|
|
100
|
2480 (error (message "Cannot make face %s italic!"
|
|
167
|
2481 (symbol-name newface)))))
|
|
|
2482 (set-face-underline-p newface underline)
|
|
100
|
2483 ))))
|
|
|
2484
|
|
167
|
2485 (if (x-display-color-p)
|
|
100
|
2486 (progn
|
|
167
|
2487 (speedbar-load-color 'speedbar-button-face "green4" nil "green3" nil nil nil nil)
|
|
100
|
2488 (speedbar-load-color 'speedbar-file-face "cyan4" nil "cyan" nil nil nil nil)
|
|
|
2489 (speedbar-load-color 'speedbar-directory-face "blue4" nil "light blue" nil nil nil nil)
|
|
|
2490 (speedbar-load-color 'speedbar-tag-face "brown" nil "yellow" nil nil nil nil)
|
|
|
2491 (speedbar-load-color 'speedbar-selected-face "red" nil "red" nil nil nil t)
|
|
|
2492 (speedbar-load-color 'speedbar-highlight-face nil "green" nil "sea green" nil nil nil)
|
|
|
2493 ) ; color
|
|
|
2494 (make-face 'speedbar-button-face)
|
|
|
2495 ;;(make-face 'speedbar-file-face)
|
|
|
2496 (copy-face 'bold 'speedbar-file-face)
|
|
|
2497 (make-face 'speedbar-directory-face)
|
|
|
2498 (make-face 'speedbar-tag-face)
|
|
|
2499 ;;(make-face 'speedbar-selected-face)
|
|
|
2500 (copy-face 'underline 'speedbar-selected-face)
|
|
|
2501 ;;(make-face 'speedbar-highlight-face)
|
|
|
2502 (copy-face 'highlight 'speedbar-highlight-face)
|
|
|
2503
|
|
|
2504 ) ;; monochrome
|
|
|
2505
|
|
167
|
2506 ;; some edebug hooks
|
|
|
2507 (add-hook 'edebug-setup-hook
|
|
|
2508 (lambda ()
|
|
|
2509 (def-edebug-spec speedbar-with-writable def-body)))
|
|
|
2510
|
|
|
2511 ;; run load-time hooks
|
|
|
2512 (run-hooks 'speedbar-load-hook)
|
|
|
2513
|
|
100
|
2514 (provide 'speedbar)
|
|
167
|
2515 ;;; speedbar ends here
|
