1 ;;; speedbar.el --- quick access to files and tags in a frame
3 ;;; Copyright (C) 1996, 97, 98, 99, 2000, 01 Free Software Foundation
5 ;; Author: Eric M. Ludlam <zappo@gnu.org>
7 ;; Keywords: file, tags, tools
9 ;; This file is part of GNU Emacs.
11 ;; GNU Emacs is free software; you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation; either version 2, or (at your option)
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs; see the file COPYING. If not, write to the
23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 ;; Boston, MA 02111-1307, USA.
28 ;; The speedbar provides a frame in which files, and locations in
29 ;; files are displayed. These items can be clicked on with mouse-2
30 ;; in order to make the last active frame display that file location.
34 ;; Simply type `M-x speedbar', and it will be autoloaded for you.
36 ;; If you want to choose it from a menu, such as "Tools", you can do this:
38 ;; (define-key-after (lookup-key global-map [menu-bar tools])
39 ;; [speedbar] '("Speedbar" . speedbar-frame-mode) [calendar])
41 ;; If you want to access speedbar using only the keyboard, do this:
43 ;; (global-set-key [f4] 'speedbar-get-focus)
45 ;; This will let you hit f4 (or whatever key you choose) to jump
46 ;; focus to the speedbar frame. Pressing it again will bring you back
47 ;; to the attached frame. Pressing RET or e to jump to a file
48 ;; or tag will move you back to the attached frame. The command
49 ;; `speedbar-get-focus' will also create a speedbar frame if it does
52 ;; Customizing Speedbar:
54 ;; Once a speedbar frame is active, it takes advantage of idle time
55 ;; to keep its contents updated. The contents is usually a list of
56 ;; files in the directory of the currently active buffer. When
57 ;; applicable, tags in the active file can be expanded.
59 ;; To add new supported files types into speedbar, use the function
60 ;; `speedbar-add-supported-extension'. If speedbar complains that the
61 ;; file type is not supported, that means there is no built in
62 ;; support from imenu, and the etags part wasn't set up correctly. You
63 ;; may add elements to `speedbar-supported-extension-expressions' as long
64 ;; as it is done before speedbar is loaded.
66 ;; To prevent speedbar from following you into certain directories
67 ;; use the function `speedbar-add-ignored-path-regexp' to add a new
68 ;; regular expression matching a type of path. You may add list
69 ;; elements to `speedbar-ignored-path-expressions' as long as it is
70 ;; done before speedbar is loaded.
72 ;; To add new file types to imenu, see the documentation in the
73 ;; file imenu.el that comes with Emacs. To add new file types which
74 ;; etags supports, you need to modify the variable
75 ;; `speedbar-fetch-etags-parse-list'.
77 ;; If the updates are going too slow for you, modify the variable
78 ;; `speedbar-update-speed' to a longer idle time before updates.
80 ;; If you navigate directories, you will probably notice that you
81 ;; will navigate to a directory which is eventually replaced after
82 ;; you go back to editing a file (unless you pull up a new file.)
83 ;; The delay time before this happens is in
84 ;; `speedbar-navigating-speed', and defaults to 10 seconds.
86 ;; To enable mouse tracking with information in the minibuffer of
87 ;; the attached frame, use the variable `speedbar-track-mouse-flag'.
89 ;; Tag layout can be modified through `speedbar-tag-hierarchy-method',
90 ;; which controls how tags are layed out. It is actually a list of
91 ;; functions that filter the data. The default groups large tag lists
92 ;; into sub-lists. A long flat list can be used instead if needed.
93 ;; Other filters can be easily added.
95 ;; AUCTEX users: The imenu tags for AUCTEX mode doesn't work very
96 ;; well. Use the imenu keywords from tex-mode.el for better results.
98 ;; This file requires the library package assoc (association lists)
100 ;;; Developing for speedbar
102 ;; Adding a speedbar specialized display mode:
104 ;; Speedbar can be configured to create a special display for certain
105 ;; modes that do not display traditional file/tag data. Rmail, Info,
106 ;; and the debugger are examples. These modes can, however, benefit
107 ;; from a speedbar style display in their own way.
109 ;; If your `major-mode' is `foo-mode', the only requirement is to
110 ;; create a function called `foo-speedbar-buttons' which takes one
111 ;; argument, BUFFER. BUFFER will be the buffer speedbar wants filled.
112 ;; In `foo-speedbar-buttons' there are several functions that make
113 ;; building a speedbar display easy. See the documentation for
114 ;; `speedbar-with-writable' (needed because the buffer is usually
115 ;; read-only) `speedbar-make-tag-line', `speedbar-insert-button', and
116 ;; `speedbar-insert-generic-list'. If you use
117 ;; `speedbar-insert-generic-list', also read the doc for
118 ;; `speedbar-tag-hierarchy-method' in case you wish to override it.
119 ;; The macro `speedbar-with-attached-buffer' brings you back to the
120 ;; buffer speedbar is displaying for.
122 ;; For those functions that make buttons, the "function" should be a
123 ;; symbol that is the function to call when clicked on. The "token"
124 ;; is extra data you can pass along. The "function" must take three
125 ;; parameters. They are (TEXT TOKEN INDENT). TEXT is the text of the
126 ;; button clicked on. TOKEN is the data passed in when you create the
127 ;; button. INDENT is an indentation level, or 0. You can store
128 ;; indentation levels with `speedbar-make-tag-line' which creates a
129 ;; line with an expander (eg. [+]) and a text button.
131 ;; Some useful functions when writing expand functions, and click
132 ;; functions are `speedbar-change-expand-button-char',
133 ;; `speedbar-delete-subblock', and `speedbar-center-buffer-smartly'.
134 ;; The variable `speedbar-power-click' is set to t in your functions
135 ;; when the user shift-clicks. This is an indication of anything from
136 ;; refreshing cached data to making a buffer appear in a new frame.
138 ;; If you wish to add to the default speedbar menu for the case of
139 ;; `foo-mode', create a variable `foo-speedbar-menu-items'. This
140 ;; should be a list compatible with the `easymenu' package. It will
141 ;; be spliced into the main menu. (Available with click-mouse-3). If
142 ;; you wish to have extra key bindings in your special mode, create a
143 ;; variable `foo-speedbar-key-map'. Instead of using `make-keymap',
144 ;; or `make-sparse-keymap', use the function
145 ;; `speedbar-make-specialized-keymap'. This lets you inherit all of
146 ;; speedbar's default bindings with low overhead.
148 ;; Adding a speedbar top-level display mode:
150 ;; Unlike the specialized modes, there are no name requirements,
151 ;; however the methods for writing a button display, menu, and keymap
152 ;; are the same. Once you create these items, you can call the
153 ;; function `speedbar-add-expansion-list'. It takes one parameter
154 ;; which is a list element of the form (NAME MENU KEYMAP &rest
155 ;; BUTTON-FUNCTIONS). NAME is a string that will show up in the
156 ;; Displays menu item. MENU is a symbol containing the menu items to
157 ;; splice in. KEYMAP is a symbol holding the keymap to use, and
158 ;; BUTTON-FUNCTIONS are the function names to call, in order, to create
160 ;; Another tweakable variable is `speedbar-stealthy-function-list'
161 ;; which is of the form (NAME &rest FUNCTION ...). NAME is the string
162 ;; name matching `speedbar-add-expansion-list'. (It does not need to
163 ;; exist.). This provides additional display info which might be
164 ;; time-consuming to calculate.
165 ;; Lastly, `speedbar-mode-functions-list' allows you to set special
166 ;; function overrides. At the moment very few functions may be
167 ;; overridden, but more will be added as the need is discovered.
170 ;; - More functions to create buttons and options
171 ;; - Timeout directories we haven't visited in a while.
180 (defvar speedbar-xemacsp
(string-match "XEmacs" emacs-version
)
181 "Non-nil if we are running in the XEmacs environment.")
182 (defvar speedbar-xemacs20p
(and speedbar-xemacsp
183 (>= emacs-major-version
20)))
185 ;; customization stuff
186 (defgroup speedbar nil
187 "File and tag browser frame."
193 (defgroup speedbar-faces nil
194 "Faces used in speedbar."
199 (defgroup speedbar-vc nil
200 "Version control display in speedbar."
205 (defvar speedbar-initial-expansion-mode-alist
206 '(("buffers" speedbar-buffer-easymenu-definition speedbar-buffers-key-map
207 speedbar-buffer-buttons
)
208 ("quick buffers" speedbar-buffer-easymenu-definition speedbar-buffers-key-map
209 speedbar-buffer-buttons-temp
)
210 ;; Files last, means first in the Displays menu
211 ("files" speedbar-easymenu-definition-special speedbar-file-key-map
212 speedbar-directory-buttons speedbar-default-directory-list
)
214 "List of named expansion elements for filling the speedbar frame.
215 These expansion lists are only valid for regular files. Special modes
216 still get to override this list on a mode-by-mode basis. This list of
217 lists is of the form (NAME MENU KEYMAP FN1 FN2 ...). NAME is a string
218 representing the types of things to be displayed. MENU is an easymenu
219 structure used when in this mode. KEYMAP is a local keymap to install
220 over the regular speedbar keymap. FN1 ... are functions that will be
221 called in order. These functions will always get the default
222 directory to use passed in as the first parameter, and a 0 as the
223 second parameter. The 0 indicates the uppermost indentation level.
224 They must assume that the cursor is at the position where they start
227 (defvar speedbar-initial-expansion-list-name
"files"
228 "A symbol name representing the expansion list to use.
229 The expansion list `speedbar-initial-expansion-mode-alist' contains
230 the names and associated functions to use for buttons in speedbar.")
232 (defvar speedbar-previously-used-expansion-list-name
"files"
233 "Save the last expansion list method.
234 This is used for returning to a previous expansion list method when
235 the user is done with the current expansion list.")
237 (defvar speedbar-stealthy-function-list
239 speedbar-update-current-file speedbar-check-vc speedbar-check-objects
)
241 "List of functions to periodically call stealthily.
242 This list is of the form:
243 '( (\"NAME\" FUNCTION ...)
245 where NAME is the name of the major display mode these functions are
246 for, and the remaining elements FUNCTION are functions to call in order.
247 Each function must return nil if interrupted, or t if completed.
248 Stealthy functions which have a single operation should always return
249 t. Functions which take a long time should maintain a state (where
250 they are in their speedbar related calculations) and permit
251 interruption. See `speedbar-check-vc' as a good example.")
253 (defvar speedbar-mode-functions-list
254 '(("files" (speedbar-item-info . speedbar-files-item-info
)
255 (speedbar-line-path . speedbar-files-line-path
))
256 ("buffers" (speedbar-item-info . speedbar-buffers-item-info
)
257 (speedbar-line-path . speedbar-buffers-line-path
))
258 ("quick buffers" (speedbar-item-info . speedbar-buffers-item-info
)
259 (speedbar-line-path . speedbar-buffers-line-path
))
261 "List of function tables to use for different major display modes.
262 It is not necessary to define any functions for a specialized mode.
263 This just provides a simple way of adding lots of customizations.
264 Each sublist is of the form:
265 (\"NAME\" (FUNCTIONSYMBOL . REPLACEMENTFUNCTION) ...)
266 Where NAME is the name of the specialized mode. The rest of the list
267 is a set of dotted pairs of the form FUNCTIONSYMBOL, which is the name
268 of a function you would like to replace, and REPLACEMENTFUNCTION,
269 which is a function you can call instead. Not all functions can be
270 replaced this way. Replaceable functions must provide that
271 functionality individually.")
273 (defcustom speedbar-mode-specific-contents-flag t
274 "*Non-nil means speedbar will show special mode contents.
275 This permits some modes to create customized contents for the speedbar
280 (defvar speedbar-special-mode-expansion-list nil
281 "Default function list for creating specialized button lists.
282 This list is set by modes that wish to have special speedbar displays.
283 The list is of function names. Each function is called with one
284 parameter BUFFER, the originating buffer. The current buffer is the
287 (defvar speedbar-special-mode-key-map nil
288 "Default keymap used when identifying a specialized display mode.
289 This keymap is local to each buffer that wants to define special keybindings
290 effective when its display is shown.")
292 (defcustom speedbar-visiting-file-hook nil
293 "Hooks run when speedbar visits a file in the selected frame."
297 (defcustom speedbar-visiting-tag-hook
'(speedbar-highlight-one-tag-line)
298 "Hooks run when speedbar visits a tag in the selected frame."
302 :options
'(speedbar-highlight-one-tag-line
303 speedbar-recenter-to-top
307 (defcustom speedbar-load-hook nil
308 "Hooks run when speedbar is loaded."
312 (defcustom speedbar-reconfigure-keymaps-hook nil
313 "Hooks run when the keymaps are regenerated."
318 (defcustom speedbar-show-unknown-files nil
319 "*Non-nil show files we can't expand with a ? in the expand button.
320 nil means don't show the file in the list."
324 (defcustom speedbar-update-speed
326 (if speedbar-xemacs20p
327 2 ; 1 is too obrusive in XEmacs
328 5) ; when no idleness, need long delay
330 "*Idle time in seconds needed before speedbar will update itself.
331 Updates occur to allow speedbar to display directory information
332 relevant to the buffer you are currently editing."
336 ;; When I moved to a repeating timer, I had the horrible missfortune
337 ;; of loosing the ability for adaptive speed choice. This update
338 ;; speed currently causes long delays when it should have been turned off.
339 (defcustom speedbar-navigating-speed speedbar-update-speed
340 "*Idle time to wait after navigation commands in speedbar are executed.
341 Navigation commands included expanding/contracting nodes, and moving
342 between different directories."
346 (defcustom speedbar-frame-parameters
'((minibuffer . nil
)
352 "*Parameters to use when creating the speedbar frame in Emacs.
353 Any parameter supported by a frame may be added. The parameter `height'
354 will be initialized to the height of the frame speedbar is
355 attached to and added to this list before the new frame is initialized."
357 :type
'(repeat (sexp :tag
"Parameter:")))
359 ;; These values by Hrvoje Niksic <hniksic@srce.hr>
360 (defcustom speedbar-frame-plist
361 '(minibuffer nil width
20 border-width
0
362 internal-border-width
0 unsplittable t
363 default-toolbar-visible-p nil has-modeline-p nil
364 menubar-visible-p nil
)
365 "*Parameters to use when creating the speedbar frame in XEmacs.
366 Parameters not listed here which will be added automatically are
367 `height' which will be initialized to the height of the frame speedbar
370 :type
'(repeat (group :inline t
371 (symbol :tag
"Property")
372 (sexp :tag
"Value"))))
374 (defcustom speedbar-use-imenu-flag
(stringp (locate-library "imenu"))
375 "*Non-nil means use imenu for file parsing. nil to use etags.
376 XEmacs prior to 20.4 doesn't support imenu, therefore the default is to
377 use etags instead. Etags support is not as robust as imenu support."
378 :tag
"Use Imenu for tags"
382 (defvar speedbar-dynamic-tags-function-list
383 '((speedbar-fetch-dynamic-imenu . speedbar-insert-imenu-list
)
384 (speedbar-fetch-dynamic-etags . speedbar-insert-etags-list
))
385 "Set to a list of functions which will return and insert a list of tags.
386 Each element is of the form ( FETCH . INSERT ) where FETCH
387 is a function which takes one parameter (the file to tag) and returns a
388 list of tags. The tag list can be of any form as long as the
389 corresponding insert method can handle it. If it returns t, then an
390 error occurred, and the next fetch routine is tried.
391 INSERT is a function which takes an INDENTation level, and a LIST of
392 tags to insert. It will then create the speedbar buttons.")
394 (defcustom speedbar-track-mouse-flag t
395 "*Non-nil means to display info about the line under the mouse."
399 (defcustom speedbar-sort-tags nil
400 "*If non-nil, sort tags in the speedbar display. *Obsolete*."
404 (defcustom speedbar-tag-hierarchy-method
405 '(speedbar-prefix-group-tag-hierarchy
406 speedbar-trim-words-tag-hierarchy
)
407 "*List of hooks which speedbar will use to organize tags into groups.
408 Groups are defined as expandable meta-tags. Imenu supports
409 such things in some languages, such as separating variables from
410 functions. Each hook takes one argument LST, and may destructively
411 create a new list of the same form. LST is a list of elements of the
414 where each ELT is of the form
415 (TAG-NAME-STRING . NUMBER-OR-MARKER)
417 (GROUP-NAME-STRING ELT1 ELT2... ELTn)"
420 :options
'(speedbar-sort-tag-hierarchy
421 speedbar-trim-words-tag-hierarchy
422 speedbar-prefix-group-tag-hierarchy
423 speedbar-simple-group-tag-hierarchy
)
426 (defcustom speedbar-tag-group-name-minimum-length
4
427 "*The minimum length of a prefix group name before expanding.
428 Thus, if the `speedbar-tag-hierarchy-method' includes `prefix-group'
429 and one such groups common characters is less than this number of
430 characters, then the group name will be changed to the form of:
434 This way we won't get silly looking listings."
438 (defcustom speedbar-tag-split-minimum-length
20
439 "*Minimum length before we stop trying to create sub-lists in tags.
440 This is used by all tag-hierarchy methods that break large lists into
445 (defcustom speedbar-tag-regroup-maximum-length
10
446 "*Maximum length of submenus that are regrouped.
447 If the regrouping option is used, then if two or more short subgroups
448 are next to each other, then they are combined until this number of
453 (defcustom speedbar-activity-change-focus-flag nil
454 "*Non-nil means the selected frame will change based on activity.
455 Thus, if a file is selected for edit, the buffer will appear in the
456 selected frame and the focus will change to that frame."
460 (defcustom speedbar-directory-button-trim-method
'span
461 "*Indicates how the directory button will be displayed.
463 'span - span large directories over multiple lines.
464 'trim - trim large directories to only show the last few.
467 :type
'(radio (const :tag
"Span large directories over mutiple lines."
469 (const :tag
"Trim large directories to only show the last few."
471 (const :tag
"No trimming." nil
)))
473 (defcustom speedbar-smart-directory-expand-flag t
474 "*Non-nil means speedbar should use smart expansion.
475 Smart expansion only affects when speedbar wants to display a
476 directory for a file in the attached frame. When smart expansion is
477 enabled, new directories which are children of a displayed directory
478 are expanded in the current framework. If nil, then the current
479 hierarchy would be replaced with the new directory."
483 (defcustom speedbar-indentation-width
1
484 "*When sub-nodes are expanded, the number of spaces used for indentation."
489 (defcustom speedbar-hide-button-brackets-flag nil
490 "*Non-nil means speedbar will hide the brackets around the + or -."
495 (defcustom speedbar-use-images
(and (or (fboundp 'defimage
)
496 (fboundp 'make-image-specifier
))
497 (if (fboundp 'display-graphic-p
)
500 "*Non-nil if speedbar should display icons."
505 (defcustom speedbar-before-popup-hook nil
506 "*Hooks called before popping up the speedbar frame."
510 (defcustom speedbar-before-delete-hook nil
511 "*Hooks called before deleting the speedbar frame."
515 (defcustom speedbar-mode-hook nil
516 "*Hooks called after creating a speedbar buffer."
520 (defcustom speedbar-timer-hook nil
521 "*Hooks called after running the speedbar timer function."
525 (defcustom speedbar-verbosity-level
1
526 "*Verbosity level of the speedbar. 0 means say nothing.
527 1 means medium level verbosity. 2 and higher are higher levels of
532 (defvar speedbar-indicator-separator
" "
533 "String separating file text from indicator characters.")
535 (defcustom speedbar-vc-do-check t
536 "*Non-nil check all files in speedbar to see if they have been checked out.
537 Any file checked out is marked with `speedbar-vc-indicator'."
541 (defvar speedbar-vc-indicator
"*"
542 "Text used to mark files which are currently checked out.
543 Other version control systems can be added by examining the function
544 `speedbar-vc-path-enable-hook' and `speedbar-vc-in-control-hook'.")
546 (defcustom speedbar-vc-path-enable-hook nil
547 "*Return non-nil if the current path should be checked for Version Control.
548 Functions in this hook must accept one parameter which is the path
553 (defcustom speedbar-vc-in-control-hook nil
554 "*Return non-nil if the specified file is under Version Control.
555 Functions in this hook must accept two parameters. The PATH of the
556 current file, and the FILENAME of the file being checked."
560 (defvar speedbar-vc-to-do-point nil
561 "Local variable maintaining the current version control check position.")
563 (defcustom speedbar-obj-do-check t
564 "*Non-nil check all files in speedbar to see if they have an object file.
565 Any file checked out is marked with `speedbar-obj-indicator', and the
566 marking is based on `speedbar-obj-alist'."
570 (defvar speedbar-obj-to-do-point nil
571 "Local variable maintaining the current version control check position.")
573 (defvar speedbar-obj-indicator
'("#" .
"!")
574 "Text used to mark files that have a corresponding hidden object file.
575 The car is for an up-to-date object. The cdr is for an out of date object.
576 The expression `speedbar-obj-alist' defines who gets tagged.")
578 (defvar speedbar-obj-alist
579 '(("\\.\\([cpC]\\|cpp\\|cc\\)$" .
".o")
581 ("\\.java$" .
".class")
582 ("\\.f\\(or\\|90\\|77\\)?$" .
".o")
584 ("\\.texi$" .
".info"))
585 "Alist of file extensions, and their corresponding object file type.")
587 (defvar speedbar-indicator-regex
588 (concat (regexp-quote speedbar-indicator-separator
)
590 (regexp-quote speedbar-vc-indicator
)
592 (regexp-quote (car speedbar-obj-indicator
))
594 (regexp-quote (cdr speedbar-obj-indicator
))
596 "Regular expression used when identifying files.
597 Permits stripping of indicator characters from a line.")
599 (defcustom speedbar-scanner-reset-hook nil
600 "*Hook called whenever generic scanners are reset.
601 Set this to implement your own scanning / rescan safe functions with
606 (defvar speedbar-ignored-modes nil
607 "*List of major modes which speedbar will not switch directories for.")
609 (defun speedbar-extension-list-to-regex (extlist)
610 "Takes EXTLIST, a list of extensions and transforms it into regexp.
611 All the preceding `.' are stripped for an optimized expression starting
612 with `.' followed by extensions, followed by full-filenames."
613 (let ((regex1 nil
) (regex2 nil
))
615 (if (= (string-to-char (car extlist
)) ?.
)
616 (setq regex1
(concat regex1
(if regex1
"\\|" "")
617 (substring (car extlist
) 1)))
618 (setq regex2
(concat regex2
(if regex2
"\\|" "") (car extlist
))))
619 (setq extlist
(cdr extlist
)))
620 ;; concat all the sub-exressions together, making sure all types
621 ;; of parts exist during concatination.
623 (if regex1
(concat "\\(\\.\\(" regex1
"\\)\\)") "")
624 (if (and regex1 regex2
) "\\|" "")
625 (if regex2
(concat "\\(" regex2
"\\)") "")
628 (defvar speedbar-ignored-path-regexp nil
629 "Regular expression matching paths speedbar will not switch to.
630 Created from `speedbar-ignored-path-expressions' with the function
631 `speedbar-extension-list-to-regex' (A misnamed function in this case.)
632 Use the function `speedbar-add-ignored-path-regexp', or customize the
633 variable `speedbar-ignored-path-expressions' to modify this variable.")
635 (defcustom speedbar-ignored-path-expressions
636 '("[/\\]logs?[/\\]\\'")
637 "*List of regular expressions matching directories speedbar will ignore.
638 They should included paths to directories which are notoriously very
639 large and take a long time to load in. Use the function
640 `speedbar-add-ignored-path-regexp' to add new items to this list after
641 speedbar is loaded. You may place anything you like in this list
642 before speedbar has been loaded."
644 :type
'(repeat (regexp :tag
"Path Regexp"))
645 :set
(lambda (sym val
)
646 (setq speedbar-ignored-path-expressions val
647 speedbar-ignored-path-regexp
648 (speedbar-extension-list-to-regex val
))))
650 (defcustom speedbar-directory-unshown-regexp
"^\\(CVS\\|RCS\\|SCCS\\)\\'"
651 "*Regular expression matching directories not to show in speedbar.
652 They should include commonly existing directories which are not
653 useful, such as version control."
657 (defvar speedbar-file-unshown-regexp
658 (let ((nstr "") (noext completion-ignored-extensions
))
660 (setq nstr
(concat nstr
(regexp-quote (car noext
)) "\\'"
661 (if (cdr noext
) "\\|" ""))
663 ;; backup refdir lockfile
664 (concat nstr
"\\|#[^#]+#$\\|\\.\\.?\\'\\|\\.#"))
665 "*Regexp matching files we don't want displayed in a speedbar buffer.
666 It is generated from the variable `completion-ignored-extensions'")
668 ;; Compiler silencing trick. The real defvar comes later in this file.
669 (defvar speedbar-file-regexp
)
671 ;; this is dangerous to customize, because the defaults will probably
672 ;; change in the future.
673 (defcustom speedbar-supported-extension-expressions
674 (append '(".[ch]\\(\\+\\+\\|pp\\|c\\|h\\|xx\\)?" ".tex\\(i\\(nfo\\)?\\)?"
675 ".el" ".emacs" ".l" ".lsp" ".p" ".java" ".f\\(90\\|77\\|or\\)?")
676 (if speedbar-use-imenu-flag
677 '(".ada" ".p[lm]" ".tcl" ".m" ".scm" ".pm" ".py" ".g"
678 ;; html is not supported by default, but an imenu tags package
679 ;; is available. Also, html files are nice to be able to see.
681 "[Mm]akefile\\(\\.in\\)?")))
682 "*List of regular expressions which will match files supported by tagging.
683 Do not prefix the `.' char with a double \\ to quote it, as the period
684 will be stripped by a simplified optimizer when compiled into a
685 singular expression. This variable will be turned into
686 `speedbar-file-regexp' for use with speedbar. You should use the
687 function `speedbar-add-supported-extension' to add a new extension at
688 runtime, or use the configuration dialog to set it in your .emacs
692 :type
'(repeat (regexp :tag
"Extension Regexp"))
693 :set
(lambda (sym val
)
694 (setq speedbar-supported-extension-expressions val
695 speedbar-file-regexp
(speedbar-extension-list-to-regex val
))))
697 (defvar speedbar-file-regexp
698 (speedbar-extension-list-to-regex speedbar-supported-extension-expressions
)
699 "Regular expression matching files we know how to expand.
700 Created from `speedbar-supported-extension-expression' with the
701 function `speedbar-extension-list-to-regex'")
703 (defcustom speedbar-scan-subdirs nil
704 "*Non-nil means speedbar will check if subdirs are empty.
705 That way you don't have to click on them to find out. But this
706 incurs extra I/O, hence it slows down directory display
707 proportionally to the number of subdirs."
712 (defun speedbar-add-supported-extension (extension)
713 "Add EXTENSION as a new supported extension for speedbar tagging.
714 This should start with a `.' if it is not a complete file name, and
715 the dot should NOT be quoted in with \\. Other regular expression
716 matchers are allowed however. EXTENSION may be a single string or a
718 (interactive "sExtension: ")
719 (if (not (listp extension
)) (setq extension
(list extension
)))
721 (if (member (car extension
) speedbar-supported-extension-expressions
)
723 (setq speedbar-supported-extension-expressions
724 (cons (car extension
) speedbar-supported-extension-expressions
)))
725 (setq extension
(cdr extension
)))
726 (setq speedbar-file-regexp
(speedbar-extension-list-to-regex
727 speedbar-supported-extension-expressions
)))
729 (defun speedbar-add-ignored-path-regexp (path-expression)
730 "Add PATH-EXPRESSION as a new ignored path for speedbar tracking.
731 This function will modify `speedbar-ignored-path-regexp' and add
732 PATH-EXPRESSION to `speedbar-ignored-path-expressions'."
733 (interactive "sPath regex: ")
734 (if (not (listp path-expression
))
735 (setq path-expression
(list path-expression
)))
736 (while path-expression
737 (if (member (car path-expression
) speedbar-ignored-path-expressions
)
739 (setq speedbar-ignored-path-expressions
740 (cons (car path-expression
) speedbar-ignored-path-expressions
)))
741 (setq path-expression
(cdr path-expression
)))
742 (setq speedbar-ignored-path-regexp
(speedbar-extension-list-to-regex
743 speedbar-ignored-path-expressions
)))
745 ;; If we don't have custom, then we set it here by hand.
746 (if (not (fboundp 'custom-declare-variable
))
747 (setq speedbar-file-regexp
(speedbar-extension-list-to-regex
748 speedbar-supported-extension-expressions
)
749 speedbar-ignored-path-regexp
(speedbar-extension-list-to-regex
750 speedbar-ignored-path-expressions
)))
752 (defvar speedbar-update-flag
(and
753 (or (fboundp 'run-with-idle-timer
)
754 (fboundp 'start-itimer
)
755 (boundp 'post-command-idle-hook
))
756 (if (fboundp 'display-graphic-p
)
759 "*Non-nil means to automatically update the display.
760 When this is nil then speedbar will not follow the attached frame's path.
761 When speedbar is active, use:
763 \\<speedbar-key-map> `\\[speedbar-toggle-updates]'
765 to toggle this value.")
767 (defvar speedbar-syntax-table nil
768 "Syntax-table used on the speedbar.")
770 (if speedbar-syntax-table
772 (setq speedbar-syntax-table
(make-syntax-table))
773 ;; turn off paren matching around here.
774 (modify-syntax-entry ?
\' " " speedbar-syntax-table
)
775 (modify-syntax-entry ?
\" " " speedbar-syntax-table
)
776 (modify-syntax-entry ?
( " " speedbar-syntax-table
)
777 (modify-syntax-entry ?
) " " speedbar-syntax-table
)
778 (modify-syntax-entry ?
{ " " speedbar-syntax-table
)
779 (modify-syntax-entry ?
} " " speedbar-syntax-table
)
780 (modify-syntax-entry ?
[ " " speedbar-syntax-table
)
781 (modify-syntax-entry ?
] " " speedbar-syntax-table
))
783 (defvar speedbar-key-map nil
784 "Keymap used in speedbar buffer.")
788 (setq speedbar-key-map
(make-keymap))
789 (suppress-keymap speedbar-key-map t
)
792 (define-key speedbar-key-map
"g" 'speedbar-refresh
)
793 (define-key speedbar-key-map
"t" 'speedbar-toggle-updates
)
794 (define-key speedbar-key-map
"q" 'speedbar-close-frame
)
795 (define-key speedbar-key-map
"Q" 'delete-frame
)
798 (define-key speedbar-key-map
"n" 'speedbar-next
)
799 (define-key speedbar-key-map
"p" 'speedbar-prev
)
800 (define-key speedbar-key-map
"\M-n" 'speedbar-restricted-next
)
801 (define-key speedbar-key-map
"\M-p" 'speedbar-restricted-prev
)
802 (define-key speedbar-key-map
"\C-\M-n" 'speedbar-forward-list
)
803 (define-key speedbar-key-map
"\C-\M-p" 'speedbar-backward-list
)
804 (define-key speedbar-key-map
" " 'speedbar-scroll-up
)
805 (define-key speedbar-key-map
[delete] 'speedbar-scroll-down)
807 ;; Short cuts I happen to find useful
808 (define-key speedbar-key-map "r"
809 (lambda () (interactive)
810 (speedbar-change-initial-expansion-list
811 speedbar-previously-used-expansion-list-name)))
812 (define-key speedbar-key-map "b"
813 (lambda () (interactive)
814 (speedbar-change-initial-expansion-list "quick buffers")))
815 (define-key speedbar-key-map "f"
816 (lambda () (interactive)
817 (speedbar-change-initial-expansion-list "files")))
820 (substitute-key-definition 'switch-to-buffer
821 'speedbar-switch-buffer-attached-frame
822 speedbar-key-map global-map)
826 ;; mouse bindings so we can manipulate the items on each line
827 (define-key speedbar-key-map 'button2 'speedbar-click)
828 (define-key speedbar-key-map '(shift button2) 'speedbar-power-click)
829 ;; Info doc fix from Bob Weiner
830 (if (featurep 'infodoc)
832 (define-key speedbar-key-map 'button3 'speedbar-xemacs-popup-kludge))
833 (define-key speedbar-key-map '(meta button3) 'speedbar-mouse-item-info)
836 ;; mouse bindings so we can manipulate the items on each line
837 (define-key speedbar-key-map [down-mouse-1] 'speedbar-double-click)
838 (define-key speedbar-key-map [mouse-2] 'speedbar-click)
839 ;; This is the power click for new frames, or refreshing a cache
840 (define-key speedbar-key-map [S-mouse-2] 'speedbar-power-click)
841 ;; This adds a small unecessary visual effect
842 ;;(define-key speedbar-key-map [down-mouse-2] 'speedbar-quick-mouse)
843 (define-key speedbar-key-map [M-mouse-2] 'speedbar-mouse-item-info)
845 (define-key speedbar-key-map [down-mouse-3] 'speedbar-emacs-popup-kludge)
847 ;; This lets the user scroll as if we had a scrollbar... well maybe not
848 (define-key speedbar-key-map [mode-line mouse-2] 'speedbar-mouse-hscroll)
849 ;; another handy place users might click to get our menu.
850 (define-key speedbar-key-map [mode-line down-mouse-1]
851 'speedbar-emacs-popup-kludge)
853 ;; We can't switch buffers with the buffer mouse menu. Lets hack it.
854 (define-key speedbar-key-map [C-down-mouse-1] 'speedbar-hack-buffer-menu)
856 ;; Lastly, we want to track the mouse. Play here
857 (define-key speedbar-key-map [mouse-movement] 'speedbar-track-mouse)
860 (defun speedbar-make-specialized-keymap ()
861 "Create a keymap for use with a speedbar major or minor display mode.
862 This basically creates a sparse keymap, and makes it's parent be
864 (let ((k (make-sparse-keymap)))
865 (set-keymap-parent k speedbar-key-map)
868 (defvar speedbar-file-key-map nil
869 "Keymap used in speedbar buffer while files are displayed.")
871 (if speedbar-file-key-map
873 (setq speedbar-file-key-map (speedbar-make-specialized-keymap))
875 ;; Basic tree features
876 (define-key speedbar-file-key-map "e" 'speedbar-edit-line)
877 (define-key speedbar-file-key-map "\C-m" 'speedbar-edit-line)
878 (define-key speedbar-file-key-map "+" 'speedbar-expand-line)
879 (define-key speedbar-file-key-map "=" 'speedbar-expand-line)
880 (define-key speedbar-file-key-map "-" 'speedbar-contract-line)
882 ;; file based commands
883 (define-key speedbar-file-key-map "U" 'speedbar-up-directory)
884 (define-key speedbar-file-key-map "I" 'speedbar-item-info)
885 (define-key speedbar-file-key-map "B" 'speedbar-item-byte-compile)
886 (define-key speedbar-file-key-map "L" 'speedbar-item-load)
887 (define-key speedbar-file-key-map "C" 'speedbar-item-copy)
888 (define-key speedbar-file-key-map "D" 'speedbar-item-delete)
889 (define-key speedbar-file-key-map "O" 'speedbar-item-object-delete)
890 (define-key speedbar-file-key-map "R" 'speedbar-item-rename)
893 (defvar speedbar-easymenu-definition-base
896 ["Update" speedbar-refresh t]
897 ["Auto Update" speedbar-toggle-updates
898 :style toggle :selected speedbar-update-flag])
899 (if (and (or (fboundp 'defimage)
900 (fboundp 'make-image-specifier))
901 (if (fboundp 'display-graphic-p)
905 ["Use Images" speedbar-toggle-images
906 :style toggle :selected speedbar-use-images]))
908 "Base part of the speedbar menu.")
910 (defvar speedbar-easymenu-definition-special
911 '(["Edit Item On Line" speedbar-edit-line t]
912 ["Show All Files" speedbar-toggle-show-all-files
913 :style toggle :selected speedbar-show-unknown-files]
914 ["Expand File Tags" speedbar-expand-line
915 (save-excursion (beginning-of-line)
916 (looking-at "[0-9]+: *.\\+. "))]
917 ["Flush Cache & Expand" speedbar-flush-expand-line
918 (save-excursion (beginning-of-line)
919 (looking-at "[0-9]+: *.\\+. "))]
920 ["Contract File Tags" speedbar-contract-line
921 (save-excursion (beginning-of-line)
922 (looking-at "[0-9]+: *.-. "))]
923 ; ["Sort Tags" speedbar-toggle-sorting
924 ; :style toggle :selected speedbar-sort-tags]
926 ["File/Tag Information" speedbar-item-info t]
927 ["Load Lisp File" speedbar-item-load
930 (looking-at "[0-9]+: *\\[[+-]\\] .+\\(\\.el\\)\\( \\|$\\)"))]
931 ["Byte Compile File" speedbar-item-byte-compile
934 (looking-at "[0-9]+: *\\[[+-]\\] .+\\(\\.el\\)\\( \\|$\\)"))]
935 ["Copy File" speedbar-item-copy
936 (save-excursion (beginning-of-line) (looking-at "[0-9]+: *\\["))]
937 ["Rename File" speedbar-item-rename
938 (save-excursion (beginning-of-line) (looking-at "[0-9]+: *[[<]"))]
939 ["Delete File" speedbar-item-delete
940 (save-excursion (beginning-of-line) (looking-at "[0-9]+: *[[<]"))]
941 ["Delete Object" speedbar-item-object-delete
942 (save-excursion (beginning-of-line)
943 (looking-at "[0-9]+: *\\[[+-]\\] [^ \n]+ \\*?[!#]$"))]
945 "Additional menu items while in file-mode.")
947 (defvar speedbar-easymenu-definition-trailer
949 (if (and (featurep 'custom) (fboundp 'custom-declare-variable))
950 (list ["Customize..." speedbar-customize t]))
952 ["Close" speedbar-close-frame t]
953 ["Quit" delete-frame t] ))
954 "Menu items appearing at the end of the speedbar menu.")
956 (defvar speedbar-desired-buffer nil
957 "Non-nil when speedbar is showing buttons specific to a special mode.
958 In this case it is the originating buffer.")
959 (defvar speedbar-buffer nil
960 "The buffer displaying the speedbar.")
961 (defvar speedbar-frame nil
962 "The frame displaying speedbar.")
963 (defvar speedbar-cached-frame nil
964 "The frame that was last created, then removed from the display.")
965 (defvar speedbar-full-text-cache nil
966 "The last open directory is saved in its entirety for ultra-fast switching.")
967 (defvar speedbar-timer nil
968 "The speedbar timer used for updating the buffer.")
969 (defvar speedbar-attached-frame nil
970 "The frame which started speedbar mode.
971 This is the frame from which all data displayed in the speedbar is
972 gathered, and in which files and such are displayed.")
974 (defvar speedbar-last-selected-file nil
975 "The last file which was selected in speedbar buffer.")
977 (defvar speedbar-shown-directories nil
978 "Maintain list of directories simultaneously open in the current speedbar.")
980 (defvar speedbar-directory-contents-alist nil
981 "An association list of directories and their contents.
982 Each sublist was returned by `speedbar-file-lists'. This list is
983 maintained to speed up the refresh rate when switching between
986 (defvar speedbar-power-click nil
987 "Never set this by hand. Value is t when S-mouse activity occurs.")
992 (if (fboundp 'frame-parameter)
994 (defalias 'speedbar-frame-parameter 'frame-parameter)
996 (defun speedbar-frame-parameter (frame parameter)
997 "Return FRAME's PARAMETER value."
998 (cdr (assoc parameter (frame-parameters frame)))))
1000 (if (fboundp 'make-overlay)
1002 (defalias 'speedbar-make-overlay 'make-overlay)
1003 (defalias 'speedbar-overlay-put 'overlay-put)
1004 (defalias 'speedbar-delete-overlay 'delete-overlay)
1005 (defalias 'speedbar-overlay-start 'overlay-start)
1006 (defalias 'speedbar-overlay-end 'overlay-end)
1007 (defalias 'speedbar-mode-line-update 'force-mode-line-update))
1008 (defalias 'speedbar-make-overlay 'make-extent)
1009 (defalias 'speedbar-overlay-put 'set-extent-property)
1010 (defalias 'speedbar-delete-overlay 'delete-extent)
1011 (defalias 'speedbar-overlay-start 'extent-start)
1012 (defalias 'speedbar-overlay-end 'extent-end)
1013 (defalias 'speedbar-mode-line-update 'redraw-modeline))
1015 ;;; Mode definitions/ user commands
1019 (defalias 'speedbar 'speedbar-frame-mode)
1021 (defun speedbar-frame-mode (&optional arg)
1022 "Enable or disable speedbar. Positive ARG means turn on, negative turn off.
1023 nil means toggle. Once the speedbar frame is activated, a buffer in
1024 `speedbar-mode' will be displayed. Currently, only one speedbar is
1025 supported at a time.
1026 `speedbar-before-popup-hook' is called before popping up the speedbar frame.
1027 `speedbar-before-delete-hook' is called before the frame is deleted."
1029 ;; toggle frame on and off.
1030 (if (not arg) (if (and (frame-live-p speedbar-frame)
1031 (frame-visible-p speedbar-frame))
1032 (setq arg -1) (setq arg 1)))
1033 ;; turn the frame off on neg number
1034 (if (and (numberp arg) (< arg 0))
1036 (run-hooks 'speedbar-before-delete-hook)
1037 (if (and speedbar-frame (frame-live-p speedbar-frame))
1039 (setq speedbar-cached-frame speedbar-frame)
1040 (make-frame-invisible speedbar-frame)))
1041 (setq speedbar-frame nil)
1042 (speedbar-set-timer nil)
1043 ;; Used to delete the buffer. This has the annoying affect of
1044 ;; preventing whatever took its place from ever appearing
1045 ;; as the default after a C-x b was typed
1046 ;;(if (bufferp speedbar-buffer)
1047 ;; (kill-buffer speedbar-buffer))
1049 ;; Set this as our currently attached frame
1050 (setq speedbar-attached-frame (selected-frame))
1051 (run-hooks 'speedbar-before-popup-hook)
1052 ;; Get the frame to work in
1053 (if (frame-live-p speedbar-cached-frame)
1055 (setq speedbar-frame speedbar-cached-frame)
1056 (make-frame-visible speedbar-frame)
1057 ;; Get the buffer to play with
1059 (select-frame speedbar-frame)
1060 (if (not (eq (current-buffer) speedbar-buffer))
1061 (switch-to-buffer speedbar-buffer))
1062 (set-window-dedicated-p (selected-window) t)
1063 (raise-frame speedbar-frame)
1064 (speedbar-set-timer speedbar-update-speed)
1066 (if (frame-live-p speedbar-frame)
1067 (raise-frame speedbar-frame)
1068 (setq speedbar-frame
1069 (if speedbar-xemacsp
1070 ;; Only guess height if it is not specified.
1071 (if (member 'height speedbar-frame-plist)
1072 (make-frame speedbar-frame-plist)
1073 (make-frame (nconc (list 'height
1074 (speedbar-needed-height))
1075 speedbar-frame-plist)))
1076 (let* ((mh (speedbar-frame-parameter nil 'menu-bar-lines))
1077 (cfx (speedbar-frame-parameter nil 'left))
1078 (cfy (speedbar-frame-parameter nil 'top))
1079 (cfw (frame-pixel-width))
1081 ;; Only add a guessed height if one is not specified
1082 ;; in the input parameters.
1083 (if (assoc 'height speedbar-frame-parameters)
1084 speedbar-frame-parameters
1086 speedbar-frame-parameters
1087 (list (cons 'height (+ mh (frame-height)))))))
1089 (if (or (< emacs-major-version 20)
1090 (not (eq window-system 'x)))
1092 (let ((x-pointer-shape x-pointer-top-left-arrow)
1093 (x-sensitive-text-pointer-shape
1095 (make-frame params)))))
1096 ;; Position speedbar frame.
1097 (if (or (not window-system) (eq window-system 'pc)
1098 (assoc 'left speedbar-frame-parameters)
1099 (assoc 'top speedbar-frame-parameters))
1100 ;; Do no positioning if not on a windowing system,
1101 ;; or if left/top were specified in the parameters.
1104 (if (not (consp cfx))
1106 ;; If cfx is a list, that means we grow
1107 ;; from a specific edge of the display.
1108 ;; Convert that to the distance from the
1109 ;; left side of the display.
1110 (if (eq (car cfx) '-)
1111 ;; A - means distance from the right edge
1112 ;; of the display, or DW - cfx - framewidth
1113 (- (x-display-pixel-width) (car (cdr cfx))
1114 (frame-pixel-width))
1116 (modify-frame-parameters
1121 ;; Decide which side to put it
1122 ;; on. 200 is just a buffer
1123 ;; for the left edge of the
1124 ;; screen. The extra 10 is just
1125 ;; dressings for window decorations.
1126 (let ((sfw (frame-pixel-width frame)))
1127 (let ((left-guess (- cfx 10 sfw))
1128 (right-guess (+ cfx cfw 5)))
1129 (let ((left-margin left-guess)
1131 (- (x-display-pixel-width)
1132 right-guess 5 sfw)))
1133 (cond ((>= left-margin 0) left-guess)
1134 ((>= right-margin 0) right-guess)
1135 ;; otherwise choose side we overlap less
1136 ((> left-margin right-margin) 0)
1137 (t (- (x-display-pixel-width) sfw 5)))))))
1140 ;; reset the selection variable
1141 (setq speedbar-last-selected-file nil)
1142 ;; Put the buffer into the frame
1143 (save-window-excursion
1144 ;; Get the buffer to play with
1146 (select-frame speedbar-frame)
1147 (switch-to-buffer speedbar-buffer)
1148 (set-window-dedicated-p (selected-window) t))
1149 (if (and (or (null window-system) (eq window-system 'pc))
1150 (fboundp 'set-frame-name))
1152 (select-frame speedbar-frame)
1153 (set-frame-name "Speedbar")))
1154 (speedbar-set-timer speedbar-update-speed)))))
1157 (defun speedbar-get-focus ()
1158 "Change frame focus to or from the speedbar frame.
1159 If the selected frame is not speedbar, then speedbar frame is
1160 selected. If the speedbar frame is active, then select the attached frame."
1162 (if (eq (selected-frame) speedbar-frame)
1163 (if (frame-live-p speedbar-attached-frame)
1164 (select-frame speedbar-attached-frame))
1165 ;; If updates are off, then refresh the frame (they want it now...)
1166 (if (not speedbar-update-flag)
1167 (let ((speedbar-update-flag t))
1168 (speedbar-timer-fn)))
1169 ;; make sure we have a frame
1170 (if (not (frame-live-p speedbar-frame)) (speedbar-frame-mode 1))
1172 (select-frame speedbar-frame)
1176 (defun speedbar-close-frame ()
1177 "Turn off a currently active speedbar."
1179 (speedbar-frame-mode -1)
1180 (select-frame speedbar-attached-frame)
1183 (defun speedbar-switch-buffer-attached-frame (&optional buffer)
1184 "Switch to BUFFER in speedbar's attached frame, and raise that frame.
1185 This overrides the default behavior of `switch-to-buffer' which is
1186 broken because of the dedicated speedbar frame."
1188 ;; Assume we are in the speedbar frame.
1189 (speedbar-get-focus)
1190 ;; Now switch buffers
1192 (switch-to-buffer buffer)
1193 (call-interactively 'switch-to-buffer nil nil)))
1195 (defmacro speedbar-frame-width ()
1196 "Return the width of the speedbar frame in characters.
1197 nil if it doesn't exist."
1198 '(frame-width speedbar-frame))
1200 ;; XEmacs function only.
1201 (defun speedbar-needed-height (&optional frame)
1202 "The needed height for the tool bar FRAME (in characters)."
1203 (or frame (setq frame (selected-frame)))
1204 ;; The 1 is the missing modeline/minibuffer
1205 (+ 1 (/ (frame-pixel-height frame)
1206 (face-height 'default frame))))
1208 (defun speedbar-mode ()
1209 "Major mode for managing a display of directories and tags.
1210 \\<speedbar-key-map>
1211 The first line represents the default path of the speedbar frame.
1212 Each directory segment is a button which jumps speedbar's default
1213 directory to that path. Buttons are activated by clicking `\\[speedbar-click]'.
1214 In some situations using `\\[speedbar-power-click]' is a `power click' which will
1215 rescan cached items, or pop up new frames.
1217 Each line starting with <+> represents a directory. Click on the <+>
1218 to insert the directory listing into the current tree. Click on the
1219 <-> to retract that list. Click on the directory name to go to that
1220 directory as the default.
1222 Each line starting with [+] is a file. If the variable
1223 `speedbar-show-unknown-files' is t, the lines starting with [?] are
1224 files which don't have imenu support, but are not expressly ignored.
1225 Files are completely ignored if they match `speedbar-file-unshown-regexp'
1226 which is generated from `completion-ignored-extensions'.
1228 Files with a `*' character after their name are files checked out of a
1229 version control system. (Currently only RCS is supported.) New
1230 version control systems can be added by examining the documentation
1231 for `speedbar-this-file-in-vc' and `speedbar-vc-check-dir-p'.
1233 Files with a `#' or `!' character after them are source files that
1234 have an object file associated with them. The `!' indicates that the
1235 files is out of date. You can control what source/object associations
1236 exist through the variable `speedbar-obj-alist'.
1238 Click on the [+] to display a list of tags from that file. Click on
1239 the [-] to retract the list. Click on the file name to edit the file
1240 in the attached frame.
1242 If you open tags, you might find a node starting with {+}, which is a
1243 category of tags. Click the {+} to expand the category. Jump-able
1244 tags start with >. Click the name of the tag to go to that position
1245 in the selected file.
1247 \\{speedbar-key-map}"
1250 (setq speedbar-buffer (set-buffer (get-buffer-create " SPEEDBAR")))
1251 (kill-all-local-variables)
1252 (setq major-mode 'speedbar-mode)
1253 (setq mode-name "Speedbar")
1254 (set-syntax-table speedbar-syntax-table)
1255 (setq font-lock-keywords nil) ;; no font-locking please
1256 (setq truncate-lines t)
1257 (make-local-variable 'frame-title-format)
1258 (setq frame-title-format "Speedbar")
1259 ;; Set this up special just for the speedbar buffer
1260 ;; Terminal minibuffer stuff does not require this.
1261 (if (and window-system (not (eq window-system 'pc))
1262 (null default-minibuffer-frame))
1264 (make-local-variable 'default-minibuffer-frame)
1265 (setq default-minibuffer-frame speedbar-attached-frame)))
1266 ;; Correct use of `temp-buffer-show-function': Bob Weiner
1267 (if (and (boundp 'temp-buffer-show-hook)
1268 (boundp 'temp-buffer-show-function))
1269 (progn (make-local-variable 'temp-buffer-show-hook)
1270 (setq temp-buffer-show-hook temp-buffer-show-function)))
1271 (make-local-variable 'temp-buffer-show-function)
1272 (setq temp-buffer-show-function 'speedbar-temp-buffer-show-function)
1273 (if speedbar-xemacsp
1275 ;; Argh! mouse-track-click-hook doesn't understand the
1276 ;; make-local-hook conventions.
1277 (make-local-variable 'mouse-track-click-hook)
1278 (add-hook 'mouse-track-click-hook
1279 (lambda (event count)
1280 (if (/= (event-button event) 1)
1281 nil ; Do normal operations.
1283 (speedbar-quick-mouse event))
1286 (speedbar-mouse-set-point event)
1287 (speedbar-do-function-pointer)
1288 (speedbar-quick-mouse event)))
1289 ;; Don't do normal operations.
1291 (add-hook 'kill-buffer-hook (lambda () (let ((skilling (boundp 'skilling)))
1294 (if (eq (current-buffer)
1296 (speedbar-frame-mode -1)))))
1298 (toggle-read-only 1)
1299 (speedbar-set-mode-line-format)
1300 (if speedbar-xemacsp
1302 (set (make-local-variable 'mouse-motion-handler)
1303 'speedbar-track-mouse-xemacs))
1304 (if speedbar-track-mouse-flag
1305 (set (make-local-variable 'track-mouse) t)) ;this could be messy.
1306 (setq auto-show-mode nil)) ;no auto-show for Emacs
1307 (run-hooks 'speedbar-mode-hook))
1308 (speedbar-update-contents)
1311 (defmacro speedbar-with-attached-buffer (&rest forms)
1312 "Execute FORMS in the attached frame's special buffer.
1313 Optionally select that frame if necessary."
1314 `(save-selected-window
1315 (speedbar-set-timer speedbar-update-speed)
1316 (select-frame speedbar-attached-frame)
1318 (speedbar-maybee-jump-to-attached-frame)))
1320 (defun speedbar-message (fmt &rest args)
1321 "Like message, but for use in the speedbar frame.
1322 Argument FMT is the format string, and ARGS are the arguments for message."
1323 (save-selected-window
1324 (select-frame speedbar-attached-frame)
1325 (apply 'message fmt args)))
1327 (defun speedbar-y-or-n-p (prompt)
1328 "Like `y-or-n-p', but for use in the speedbar frame.
1329 Argument PROMPT is the prompt to use."
1330 (save-selected-window
1331 (if (and default-minibuffer-frame (not (eq default-minibuffer-frame
1332 speedbar-attached-frame)))
1333 (select-frame speedbar-attached-frame))
1336 (defun speedbar-show-info-under-mouse (&optional event)
1337 "Call the info function for the line under the mouse.
1338 Optional EVENT is currently not used."
1339 (let ((pos (mouse-position))) ; we ignore event until I use it later.
1340 (if (equal (car pos) speedbar-frame)
1342 (save-window-excursion
1343 (apply 'set-mouse-position pos)
1344 (speedbar-item-info))))))
1346 (defun speedbar-set-mode-line-format ()
1347 "Set the format of the mode line based on the current speedbar environment.
1348 This gives visual indications of what is up. It EXPECTS the speedbar
1349 frame and window to be the currently active frame and window."
1350 (if (and (frame-live-p speedbar-frame)
1351 (or (not speedbar-xemacsp)
1353 (specifier-instance has-modeline-p))))
1355 (set-buffer speedbar-buffer)
1356 (let* ((w (or (speedbar-frame-width) 20))
1359 (p3 (if speedbar-update-flag "SPEEDBAR" "SLOWBAR"))
1360 (blank (- w (length p1) (length p3) (length p5)
1361 (if line-number-mode 4 0)))
1363 (make-string (/ blank 2) ? )
1366 (make-string (+ (/ blank 2) (% blank 2)) ? )
1369 (if line-number-mode
1370 (list (concat p1 p2 p3) '(line-number-mode " %3l")
1372 (list (concat p1 p2 p3 p4 p5)))))
1373 (if (not (equal mode-line-format tf))
1375 (setq mode-line-format tf)
1376 (speedbar-mode-line-update)))))))
1378 (defun speedbar-temp-buffer-show-function (buffer)
1379 "Placed in the variable `temp-buffer-show-function' in `speedbar-mode'.
1380 If a user requests help using \\[help-command] <Key> the temp BUFFER will be
1381 redirected into a window on the attached frame."
1382 (if speedbar-attached-frame (select-frame speedbar-attached-frame))
1383 (pop-to-buffer buffer nil)
1385 ;; Fix for using this hook on some platforms: Bob Weiner
1386 (cond ((not speedbar-xemacsp)
1387 (run-hooks 'temp-buffer-show-hook))
1388 ((fboundp 'run-hook-with-args)
1389 (run-hook-with-args 'temp-buffer-show-hook buffer))
1390 ((and (boundp 'temp-buffer-show-hook)
1391 (listp temp-buffer-show-hook))
1392 (mapcar (function (lambda (hook) (funcall hook buffer)))
1393 temp-buffer-show-hook))))
1395 (defvar speedbar-previous-menu nil
1396 "The menu before the last `speedbar-reconfigure-keymaps' was called.")
1398 (defun speedbar-reconfigure-keymaps ()
1399 "Reconfigure the menu-bar in a speedbar frame.
1400 Different menu items are displayed depending on the current display mode
1401 and the existence of packages."
1403 speedbar-easymenu-definition-base
1404 (if speedbar-shown-directories
1405 ;; file display mode version
1406 (speedbar-initial-menu)
1408 (select-frame speedbar-attached-frame)
1409 (if (local-variable-p
1410 'speedbar-easymenu-definition-special
1412 ;; If bound locally, we can use it
1413 speedbar-easymenu-definition-special)))
1414 ;; Dynamic menu stuff
1416 (list (cons "Displays"
1417 (let ((displays nil)
1418 (alist speedbar-initial-expansion-mode-alist))
1423 (capitalize (car (car alist)))
1425 'speedbar-change-initial-expansion-list
1429 (setq alist (cdr alist)))
1432 speedbar-easymenu-definition-trailer))
1433 (localmap (save-excursion
1434 (let ((cf (selected-frame)))
1436 (select-frame speedbar-attached-frame)
1437 (if (local-variable-p
1438 'speedbar-special-mode-key-map
1440 speedbar-special-mode-key-map)
1441 (select-frame cf))))))
1443 (set-buffer speedbar-buffer)
1444 (use-local-map (or localmap
1445 (speedbar-initial-keymap)
1446 ;; This creates a small keymap we can glom the
1447 ;; menu adjustments into.
1448 (speedbar-make-specialized-keymap)))
1449 ;; Delete the old menu if applicable.
1450 (if speedbar-previous-menu (easy-menu-remove speedbar-previous-menu))
1451 (setq speedbar-previous-menu md)
1452 ;; Now add the new menu
1453 (if (not speedbar-xemacsp)
1454 (easy-menu-define speedbar-menu-map (current-local-map)
1456 (easy-menu-add md (current-local-map))
1457 (set-buffer-menubar (list md))))
1458 (run-hooks 'speedbar-reconfigure-keymaps-hook)))
1461 ;;; User Input stuff
1464 ;; XEmacs: this can be implemented using modeline keymaps, but there
1465 ;; is no use, as we have horizontal scrollbar (as the docstring
1467 (defun speedbar-mouse-hscroll (e)
1468 "Read a mouse event E from the mode line, and horizontally scroll.
1469 If the mouse is being clicked on the far left, or far right of the
1470 mode-line. This is only useful for non-XEmacs."
1472 (let* ((xp (car (nth 2 (car (cdr e)))))
1473 (cpw (/ (frame-pixel-width)
1475 (oc (1+ (/ xp cpw)))
1479 ((> oc (- (window-width) 3))
1481 (t (speedbar-message
1482 "Click on the edge of the modeline to scroll left/right")))
1483 ;;(speedbar-message "X: Pixel %d Char Pixels %d On char %d" xp cpw oc)
1486 (defun speedbar-customize ()
1487 "Customize speedbar using the Custom package."
1489 (let ((sf (selected-frame)))
1490 (select-frame speedbar-attached-frame)
1491 (customize-group 'speedbar)
1493 (speedbar-maybee-jump-to-attached-frame))
1495 (defun speedbar-track-mouse (event)
1496 "For motion EVENT, display info about the current line."
1498 (if (not speedbar-track-mouse-flag)
1501 (let ((char (nth 1 (car (cdr event)))))
1502 (if (not (numberp char))
1503 (speedbar-message nil)
1505 ;; (speedbar-message "%S" event)
1506 (speedbar-item-info)
1509 (defun speedbar-track-mouse-xemacs (event)
1510 "For motion EVENT, display info about the current line."
1511 (if (functionp (default-value 'mouse-motion-handler))
1512 (funcall (default-value 'mouse-motion-handler) event))
1513 (if speedbar-track-mouse-flag
1515 (save-window-excursion
1517 (progn (mouse-set-point event)
1518 ;; Prevent focus-related bugs.
1519 (if (eq major-mode 'speedbar-mode)
1520 (speedbar-item-info)))
1523 ;; In XEmacs, we make popup menus work on the item over mouse (as
1524 ;; opposed to where the point happens to be.) We attain this by
1525 ;; temporarily moving the point to that place.
1526 ;; Hrvoje Niksic <hniksic@srce.hr>
1527 (defun speedbar-xemacs-popup-kludge (event)
1528 "Pop up a menu related to the clicked on item.
1529 Must be bound to EVENT."
1531 (select-frame speedbar-frame)
1533 (goto-char (event-closest-point event))
1535 (forward-char (min 5 (- (save-excursion (end-of-line) (point))
1536 (save-excursion (beginning-of-line) (point)))))
1538 ;; Wait for menu to bail out. `popup-mode-menu' (and other popup
1539 ;; menu functions) return immediately.
1541 (while (not (misc-user-event-p (setq new (next-event))))
1542 (dispatch-event new))
1543 (dispatch-event new))))
1545 (defun speedbar-emacs-popup-kludge (e)
1546 "Pop up a menu related to the clicked on item.
1547 Must be bound to event E."
1551 ;; This gets the cursor where the user can see it.
1552 (if (not (bolp)) (forward-char -1))
1554 (mouse-major-mode-menu e nil)))
1556 (defun speedbar-hack-buffer-menu (e)
1557 "Control mouse 1 is buffer menu.
1558 This hack overrides it so that the right thing happens in the main
1559 Emacs frame, not in the speedbar frame.
1560 Argument E is the event causing this activity."
1562 (let ((fn (lookup-key global-map (if speedbar-xemacsp
1568 (set-window-dedicated-p (selected-window) nil)
1569 (call-interactively fn)
1570 (setq newbuff (current-buffer)))
1571 (switch-to-buffer speedbar-buffer)
1572 (set-window-dedicated-p (selected-window) t))
1573 (if (not (eq newbuff speedbar-buffer))
1574 (speedbar-with-attached-buffer
1575 (switch-to-buffer newbuff)))))
1577 (defun speedbar-next (arg)
1578 "Move to the next ARGth line in a speedbar buffer."
1580 (forward-line (or arg 1))
1581 (speedbar-item-info)
1582 (speedbar-position-cursor-on-line))
1584 (defun speedbar-prev (arg)
1585 "Move to the previous ARGth line in a speedbar buffer."
1587 (speedbar-next (if arg (- arg) -1)))
1589 (defun speedbar-restricted-move (arg)
1590 "Move to the next ARGth line in a speedbar buffer at the same depth.
1591 This means that movement is restricted to a subnode, and that siblings
1592 of intermediate nodes are skipped."
1593 (if (not (numberp arg)) (signal 'wrong-type-argument (list arg 'numberp)))
1594 ;; First find the extent for which we are allowed to move.
1595 (let ((depth (save-excursion (beginning-of-line)
1596 (if (looking-at "[0-9]+:")
1597 (string-to-int (match-string 0))
1599 (crement (if (< arg 0) 1 -1)) ; decrement or increment
1600 (lastmatch (point)))
1602 (forward-line (- crement))
1603 (let ((subdepth (save-excursion (beginning-of-line)
1604 (if (looking-at "[0-9]+:")
1605 (string-to-int (match-string 0))
1607 (cond ((or (< subdepth depth)
1608 (progn (end-of-line) (eobp))
1609 (progn (beginning-of-line) (bobp)))
1610 ;; We have reached the end of this block.
1611 (goto-char lastmatch)
1613 (error "End of sub-list"))
1615 (setq lastmatch (point)
1616 arg (+ arg crement))))))
1617 (speedbar-position-cursor-on-line)))
1619 (defun speedbar-restricted-next (arg)
1620 "Move to the next ARGth line in a speedbar buffer at the same depth.
1621 This means that movement is restricted to a subnode, and that siblings
1622 of intermediate nodes are skipped."
1624 (speedbar-restricted-move (or arg 1))
1625 (speedbar-item-info))
1628 (defun speedbar-restricted-prev (arg)
1629 "Move to the previous ARGth line in a speedbar buffer at the same depth.
1630 This means that movement is restricted to a subnode, and that siblings
1631 of intermediate nodes are skipped."
1633 (speedbar-restricted-move (if arg (- arg) -1))
1634 (speedbar-item-info))
1636 (defun speedbar-navigate-list (arg)
1637 "Move across ARG groups of similarly typed items in speedbar.
1638 Stop on the first line of the next type of item, or on the last or first item
1639 if we reach a buffer boundary."
1642 (if (looking-at "[0-9]+: *[[<{][-+?][]>}] ")
1643 (let ((str (regexp-quote (match-string 0))))
1644 (while (looking-at str)
1645 (speedbar-restricted-move arg)
1646 (beginning-of-line))))
1647 (speedbar-position-cursor-on-line))
1649 (defun speedbar-forward-list ()
1650 "Move forward over the current list.
1651 A LIST in speedbar is a group of similarly typed items, such as directories,
1652 files, or the directory button."
1654 (speedbar-navigate-list 1)
1655 (speedbar-item-info))
1657 (defun speedbar-backward-list ()
1658 "Move backward over the current list.
1659 A LIST in speedbar is a group of similarly typed items, such as directories,
1660 files, or the directory button."
1662 (speedbar-navigate-list -1)
1663 (speedbar-item-info))
1665 (defun speedbar-scroll-up (&optional arg)
1666 "Page down one screen-full of the speedbar, or ARG lines."
1669 (speedbar-position-cursor-on-line))
1671 (defun speedbar-scroll-down (&optional arg)
1672 "Page up one screen-full of the speedbar, or ARG lines."
1675 (speedbar-position-cursor-on-line))
1677 (defun speedbar-up-directory ()
1678 "Keyboard accelerator for moving the default directory up one.
1679 Assumes that the current buffer is the speedbar buffer."
1681 (setq default-directory (expand-file-name (concat default-directory "../")))
1682 (speedbar-update-contents))
1684 ;;; Speedbar file activity (aka creeping featurism)
1686 (defun speedbar-refresh ()
1687 "Refresh the current speedbar display, disposing of any cached data."
1689 (let ((dl speedbar-shown-directories)
1692 (adelete 'speedbar-directory-contents-alist (car dl))
1694 (if (<= 1 speedbar-verbosity-level)
1695 (speedbar-message "Refreshing speedbar..."))
1696 (speedbar-update-contents)
1697 (speedbar-stealthy-updates)
1698 ;; Reset the timer in case it got really hosed for some reason...
1699 (speedbar-set-timer speedbar-update-speed)
1700 (if (<= 1 speedbar-verbosity-level)
1701 (speedbar-message "Refreshing speedbar...done"))))
1703 (defun speedbar-item-load ()
1704 "Load the item under the cursor or mouse if it is a Lisp file."
1706 (let ((f (speedbar-line-file)))
1707 (if (and (file-exists-p f) (string-match "\\.el\\'" f))
1708 (if (and (file-exists-p (concat f "c"))
1709 (speedbar-y-or-n-p (format "Load %sc? " f)))
1710 ;; If the compiled version exists, load that instead...
1711 (load-file (concat f "c"))
1713 (error "Not a loadable file"))))
1715 (defun speedbar-item-byte-compile ()
1716 "Byte compile the item under the cursor or mouse if it is a Lisp file."
1718 (let ((f (speedbar-line-file))
1719 (sf (selected-frame)))
1720 (if (and (file-exists-p f) (string-match "\\.el\\'" f))
1722 (select-frame speedbar-attached-frame)
1723 (byte-compile-file f nil)
1725 (speedbar-reset-scanners)))
1728 (defun speedbar-mouse-item-info (event)
1729 "Provide information about what the user clicked on.
1730 This should be bound to a mouse EVENT."
1732 (mouse-set-point event)
1733 (speedbar-item-info))
1735 (defun speedbar-generic-item-info ()
1736 "Attempt to derive, and then display information about this line item.
1737 File style information is displayed with `speedbar-item-info'."
1740 ;; Skip invisible number info.
1741 (if (looking-at "\\([0-9]+\\):") (goto-char (match-end 0)))
1742 ;; Skip items in "folder" type text characters.
1743 (if (looking-at "\\s-*[[<({].[]>)}] ") (goto-char (match-end 0)))
1745 (speedbar-message "Text: %s" (buffer-substring-no-properties
1746 (point) (progn (end-of-line) (point))))))
1748 (defun speedbar-item-info ()
1749 "Display info in the mini-buffer about the button the mouse is over.
1750 This function can be replaced in `speedbar-mode-functions-list' as
1751 `speedbar-item-info'."
1753 (let (message-log-max)
1754 (funcall (or (speedbar-fetch-replacement-function 'speedbar-item-info)
1755 'speedbar-generic-item-info))))
1757 (defun speedbar-item-info-file-helper (&optional filename)
1758 "Display info about a file that is on the current line.
1759 nil if not applicable. If FILENAME, then use that instead of reading
1760 it from the speedbar buffer."
1761 (let* ((item (or filename (speedbar-line-file)))
1762 (attr (if item (file-attributes item) nil)))
1763 (if (and item attr) (speedbar-message "%s %-6d %s" (nth 8 attr)
1767 (defun speedbar-item-info-tag-helper ()
1768 "Display info about a tag that is on the current line.
1769 nil if not applicable."
1772 (if (re-search-forward " [-+=]?> \\([^\n]+\\)"
1773 (save-excursion(end-of-line)(point)) t)
1774 (let ((tag (match-string 1))
1775 (attr (speedbar-line-token))
1777 (if (and (featurep 'semantic) (semantic-token-p attr))
1778 (speedbar-message (semantic-summerize-nonterminal attr))
1779 (looking-at "\\([0-9]+\\):")
1780 (setq item (file-name-nondirectory (speedbar-line-path)))
1781 (speedbar-message "Tag: %s in %s" tag item)))
1782 (if (re-search-forward "{[+-]} \\([^\n]+\\)$"
1783 (save-excursion(end-of-line)(point)) t)
1784 (speedbar-message "Group of tags \"%s\"" (match-string 1))
1785 (if (re-search-forward " [+-]?[()|@] \\([^\n]+\\)$" nil t)
1786 (let* ((detailtext (match-string 1))
1787 (detail (or (speedbar-line-token) detailtext))
1788 (parent (save-excursion
1790 (let ((dep (if (looking-at "[0-9]+:")
1791 (1- (string-to-int (match-string 0)))
1793 (re-search-backward (concat "^"
1797 (if (looking-at "[0-9]+: +[-+=>]> \\([^\n]+\\)$")
1798 (speedbar-line-token)
1800 (if (and (featurep 'semantic) (semantic-token-p detail))
1802 (semantic-summerize-nonterminal detail parent))
1804 (speedbar-message "Detail: %s of tag %s" detail
1805 (if (and (featurep 'semantic)
1806 (semantic-token-p parent))
1807 (semantic-token-name parent)
1809 (speedbar-message "Detail: %s" detail))))
1812 (defun speedbar-files-item-info ()
1813 "Display info in the mini-buffer about the button the mouse is over."
1814 (if (not speedbar-shown-directories)
1815 (speedbar-generic-item-info)
1816 (or (speedbar-item-info-file-helper)
1817 (speedbar-item-info-tag-helper)
1818 (speedbar-generic-item-info))))
1820 (defun speedbar-item-copy ()
1821 "Copy the item under the cursor.
1822 Files can be copied to new names or places."
1824 (let ((f (speedbar-line-file)))
1825 (if (not f) (error "Not a file"))
1826 (if (file-directory-p f)
1827 (error "Cannot copy directory")
1828 (let* ((rt (read-file-name (format "Copy %s to: "
1829 (file-name-nondirectory f))
1830 (file-name-directory f)))
1831 (refresh (member (expand-file-name (file-name-directory rt))
1832 speedbar-shown-directories)))
1833 ;; Create the right file name part
1834 (if (file-directory-p rt)
1836 (concat (expand-file-name rt)
1837 (if (string-match "[/\\]$" rt) "" "/")
1838 (file-name-nondirectory f))))
1839 (if (or (not (file-exists-p rt))
1840 (speedbar-y-or-n-p (format "Overwrite %s with %s? " rt f)))
1842 (copy-file f rt t t)
1843 ;; refresh display if the new place is currently displayed.
1847 (if (not (speedbar-goto-this-file rt))
1848 (speedbar-goto-this-file f))))
1851 (defun speedbar-item-rename ()
1852 "Rename the item under the cursor or mouse.
1853 Files can be renamed to new names or moved to new directories."
1855 (let ((f (speedbar-line-file)))
1857 (let* ((rt (read-file-name (format "Rename %s to: "
1858 (file-name-nondirectory f))
1859 (file-name-directory f)))
1860 (refresh (member (expand-file-name (file-name-directory rt))
1861 speedbar-shown-directories)))
1862 ;; Create the right file name part
1863 (if (file-directory-p rt)
1865 (concat (expand-file-name rt)
1866 (if (string-match "[/\\]\\'" rt) "" "/")
1867 (file-name-nondirectory f))))
1868 (if (or (not (file-exists-p rt))
1869 (speedbar-y-or-n-p (format "Overwrite %s with %s? " rt f)))
1871 (rename-file f rt t)
1872 ;; refresh display if the new place is currently displayed.
1876 (speedbar-goto-this-file rt)
1878 (error "Not a file"))))
1880 (defun speedbar-item-delete ()
1881 "Delete the item under the cursor. Files are removed from disk."
1883 (let ((f (speedbar-line-file)))
1884 (if (not f) (error "Not a file"))
1885 (if (speedbar-y-or-n-p (format "Delete %s? " f))
1887 (if (file-directory-p f)
1888 (delete-directory f)
1890 (speedbar-message "Okie dokie..")
1897 (defun speedbar-item-object-delete ()
1898 "Delete the object associated from the item under the cursor.
1899 The file is removed from disk. The object is determined from the
1900 variable `speedbar-obj-alist'."
1902 (let* ((f (speedbar-line-file))
1904 (oa speedbar-obj-alist))
1905 (if (not f) (error "Not a file"))
1906 (while (and oa (not (string-match (car (car oa)) f)))
1908 (setq obj (concat (file-name-sans-extension f) (cdr (car oa))))
1909 (if (and oa (file-exists-p obj)
1910 (speedbar-y-or-n-p (format "Delete %s? " obj)))
1913 (speedbar-reset-scanners)))))
1915 (defun speedbar-enable-update ()
1916 "Enable automatic updating in speedbar via timers."
1918 (setq speedbar-update-flag t)
1919 (speedbar-set-mode-line-format)
1920 (speedbar-set-timer speedbar-update-speed))
1922 (defun speedbar-disable-update ()
1923 "Disable automatic updating and stop consuming resources."
1925 (setq speedbar-update-flag nil)
1926 (speedbar-set-mode-line-format)
1927 (speedbar-set-timer nil))
1929 (defun speedbar-toggle-updates ()
1930 "Toggle automatic update for the speedbar frame."
1932 (if speedbar-update-flag
1933 (speedbar-disable-update)
1934 (speedbar-enable-update)))
1936 (defun speedbar-toggle-images ()
1937 "Toggle images for the speedbar frame."
1939 (setq speedbar-use-images (not speedbar-use-images))
1942 (defun speedbar-toggle-sorting ()
1943 "Toggle sorting for the speedbar frame."
1945 (setq speedbar-sort-tags (not speedbar-sort-tags)))
1947 (defun speedbar-toggle-show-all-files ()
1948 "Toggle display of files speedbar can not tag."
1950 (setq speedbar-show-unknown-files (not speedbar-show-unknown-files))
1953 ;;; Utility functions
1955 (defun speedbar-set-timer (timeout)
1956 "Apply a timer with TIMEOUT, or remove a timer if TIMEOUT is nil.
1957 TIMEOUT is the number of seconds until the speedbar timer is called
1958 again. When TIMEOUT is nil, turn off all timeouts.
1959 This function will also enable or disable the `vc-checkin-hook' used
1960 to track file check ins, and will change the mode line to match
1961 `speedbar-update-flag'."
1966 (progn (delete-itimer speedbar-timer)
1967 (setq speedbar-timer nil)))
1969 (if (and speedbar-xemacsp
1970 (or (>= emacs-major-version 20)
1971 (>= emacs-minor-version 15)))
1972 (setq speedbar-timer (start-itimer "speedbar"
1977 (setq speedbar-timer (start-itimer "speedbar"
1982 ((fboundp 'run-with-idle-timer)
1984 (progn (cancel-timer speedbar-timer)
1985 (setq speedbar-timer nil)))
1987 (setq speedbar-timer
1988 (run-with-idle-timer timeout t 'speedbar-timer-fn))))
1989 ;; Emacs 19.30 (Thanks twice: ptype@dra.hmg.gb)
1990 ((fboundp 'post-command-idle-hook)
1992 (add-hook 'post-command-idle-hook 'speedbar-timer-fn)
1993 (remove-hook 'post-command-idle-hook 'speedbar-timer-fn)))
1994 ;; Older or other Emacsen with no timers. Set up so that its
1995 ;; obvious this emacs can't handle the updates
1997 (setq speedbar-update-flag nil)))
1998 ;; Apply a revert hook that will reset the scanners. We attach to revert
1999 ;; because most reverts occur during VC state change, and this lets our
2000 ;; VC scanner fix itself.
2002 (add-hook 'after-revert-hook 'speedbar-reset-scanners)
2003 (remove-hook 'after-revert-hook 'speedbar-reset-scanners)
2005 ;; change this if it changed for some reason
2006 (speedbar-set-mode-line-format))
2008 (defmacro speedbar-with-writable (&rest forms)
2009 "Allow the buffer to be writable and evaluate FORMS."
2010 (list 'let '((inhibit-read-only t))
2011 (cons 'progn forms)))
2012 (put 'speedbar-with-writable 'lisp-indent-function 0)
2014 (defun speedbar-select-window (buffer)
2015 "Select a window in which BUFFER is shown.
2016 If it is not shown, force it to appear in the default window."
2017 (let ((win (get-buffer-window buffer speedbar-attached-frame)))
2020 (set-window-buffer (selected-window) buffer))))
2022 (defun speedbar-insert-button (text face mouse function
2023 &optional token prevline)
2024 "Insert TEXT as the next logical speedbar button.
2025 FACE is the face to put on the button, MOUSE is the highlight face to use.
2026 When the user clicks on TEXT, FUNCTION is called with the TOKEN parameter.
2027 This function assumes that the current buffer is the speedbar buffer.
2028 If PREVLINE, then put this button on the previous line.
2030 This is a convenience function for special modes that create their own
2031 specialized speedbar displays."
2032 (goto-char (point-max))
2033 (let ((start (point)))
2034 (if (/= (current-column) 0) (insert "\n"))
2035 (put-text-property start (point) 'invisible nil))
2036 (if prevline (progn (delete-char -1)
2037 (insert " ") ;back up if desired...
2038 (put-text-property (1- (point)) (point) 'invisible nil)))
2039 (let ((start (point)))
2041 (speedbar-make-button start (point) face mouse function token))
2042 (let ((start (point)))
2044 (put-text-property start (point) 'face nil)
2045 (put-text-property start (point) 'invisible nil)
2046 (put-text-property start (point) 'mouse-face nil)))
2048 (defun speedbar-make-button (start end face mouse function &optional token)
2049 "Create a button from START to END, with FACE as the display face.
2050 MOUSE is the mouse face. When this button is clicked on FUNCTION
2051 will be run with the TOKEN parameter (any Lisp object)."
2052 (put-text-property start end 'face face)
2053 (put-text-property start end 'mouse-face mouse)
2054 (put-text-property start end 'invisible nil)
2055 (if function (put-text-property start end 'speedbar-function function))
2056 (if token (put-text-property start end 'speedbar-token token))
2057 ;; So far the only text we have is less that 3 chars.
2058 (if (<= (- end start) 3)
2059 (speedbar-insert-image-button-maybe start (- end start)))
2062 ;;; Initial Expansion list management
2064 (defun speedbar-initial-expansion-list ()
2065 "Return the current default expansion list.
2066 This is based on `speedbar-initial-expansion-list-name' referencing
2067 `speedbar-initial-expansion-mode-alist'."
2068 ;; cdr1 - name, cdr2 - menu
2069 (cdr (cdr (cdr (assoc speedbar-initial-expansion-list-name
2070 speedbar-initial-expansion-mode-alist)))))
2072 (defun speedbar-initial-menu ()
2073 "Return the current default menu data.
2074 This is based on `speedbar-initial-expansion-list-name' referencing
2075 `speedbar-initial-expansion-mode-alist'."
2077 (car (cdr (assoc speedbar-initial-expansion-list-name
2078 speedbar-initial-expansion-mode-alist)))))
2080 (defun speedbar-initial-keymap ()
2081 "Return the current default menu data.
2082 This is based on `speedbar-initial-expansion-list-name' referencing
2083 `speedbar-initial-expansion-mode-alist'."
2085 (car (cdr (cdr (assoc speedbar-initial-expansion-list-name
2086 speedbar-initial-expansion-mode-alist))))))
2088 (defun speedbar-initial-stealthy-functions ()
2089 "Return a list of functions to call stealthily.
2090 This is based on `speedbar-initial-expansion-list-name' referencing
2091 `speedbar-stealthy-function-list'."
2092 (cdr (assoc speedbar-initial-expansion-list-name
2093 speedbar-stealthy-function-list)))
2095 (defun speedbar-add-expansion-list (new-list)
2096 "Add NEW-LIST to the list of expansion lists."
2097 (add-to-list 'speedbar-initial-expansion-mode-alist new-list))
2099 (defun speedbar-change-initial-expansion-list (new-default)
2100 "Change speedbar's default expansion list to NEW-DEFAULT."
2103 (completing-read (format "Speedbar Mode (default %s): "
2104 speedbar-previously-used-expansion-list-name)
2105 speedbar-initial-expansion-mode-alist
2107 speedbar-previously-used-expansion-list-name)))
2108 (setq speedbar-previously-used-expansion-list-name
2109 speedbar-initial-expansion-list-name
2110 speedbar-initial-expansion-list-name new-default)
2112 (speedbar-reconfigure-keymaps))
2114 (defun speedbar-fetch-replacement-function (function)
2115 "Return a current mode specific replacement for function, or nil.
2116 Scans `speedbar-mode-functions-list' first for the current mode, then
2118 (cdr (assoc function
2119 (cdr (assoc speedbar-initial-expansion-list-name
2120 speedbar-mode-functions-list)))))
2122 (defun speedbar-add-mode-functions-list (new-list)
2123 "Add NEW-LIST to the list of mode functions.
2124 See `speedbar-mode-functions-list' for details."
2125 (add-to-list 'speedbar-mode-functions-list new-list))
2128 ;;; Special speedbar display management
2130 (defun speedbar-maybe-add-localized-support (buffer)
2131 "Quick check function called on BUFFERs by the speedbar timer function.
2132 Maintains the value of local variables which control speedbars use
2133 of the special mode functions."
2134 (or speedbar-special-mode-expansion-list
2135 (speedbar-add-localized-speedbar-support buffer)))
2137 (defun speedbar-add-localized-speedbar-support (buffer)
2138 "Add localized speedbar support to BUFFER's mode if it is available."
2139 (interactive "bBuffer: ")
2140 (if (stringp buffer) (setq buffer (get-buffer buffer)))
2141 (if (not (buffer-live-p buffer))
2146 (let ((ms (symbol-name major-mode)) v)
2147 (if (not (string-match "-mode$" ms))
2148 nil ;; do nothing to broken mode
2149 (setq ms (substring ms 0 (match-beginning 0)))
2150 (setq v (intern-soft (concat ms "-speedbar-buttons")))
2151 (make-local-variable 'speedbar-special-mode-expansion-list)
2153 (setq speedbar-special-mode-expansion-list t)
2154 ;; If it is autoloaded, we need to load it now so that
2155 ;; we have access to the varialbe -speedbar-menu-items.
2156 ;; Is this XEmacs safe?
2157 (let ((sf (symbol-function v)))
2158 (if (and (listp sf) (eq (car sf) 'autoload))
2159 (load-library (car (cdr sf)))))
2160 (setq speedbar-special-mode-expansion-list (list v))
2161 (setq v (intern-soft (concat ms "-speedbar-key-map")))
2163 nil ;; don't add special keymap
2164 (make-local-variable 'speedbar-special-mode-key-map)
2165 (setq speedbar-special-mode-key-map
2167 (setq v (intern-soft (concat ms "-speedbar-menu-items")))
2169 nil ;; don't add special menus
2170 (make-local-variable 'speedbar-easymenu-definition-special)
2171 (setq speedbar-easymenu-definition-special
2175 (defun speedbar-remove-localized-speedbar-support (buffer)
2176 "Remove any traces that BUFFER supports speedbar in a specialized way."
2179 (kill-local-variable 'speedbar-special-mode-expansion-list)
2180 (kill-local-variable 'speedbar-special-mode-key-map)
2181 (kill-local-variable 'speedbar-easymenu-definition-special)))
2183 ;;; File button management
2185 (defun speedbar-file-lists (directory)
2186 "Create file lists for DIRECTORY.
2187 The car is the list of directories, the cdr is list of files not
2188 matching ignored headers. Cache any directory files found in
2189 `speedbar-directory-contents-alist' and use that cache before scanning
2191 (setq directory (expand-file-name directory))
2192 ;; If in powerclick mode, then the directory we are getting
2193 ;; should be rescanned.
2194 (if speedbar-power-click
2195 (adelete 'speedbar-directory-contents-alist directory))
2196 ;; find the directory, either in the cache, or build it.
2197 (or (cdr-safe (assoc directory speedbar-directory-contents-alist))
2198 (let ((default-directory directory)
2199 (case-fold-search read-file-name-completion-ignore-case)
2201 (dolist (file (directory-files directory nil))
2202 (or (string-match speedbar-file-unshown-regexp file)
2203 (string-match speedbar-directory-unshown-regexp file)
2204 (if (file-directory-p file)
2205 (setq dirs (cons file dirs))
2206 (setq files (cons file files)))))
2207 (let ((nl `(,(nreverse dirs) ,(nreverse files))))
2208 (aput 'speedbar-directory-contents-alist directory nl)
2211 (defun speedbar-directory-buttons (directory index)
2212 "Insert a single button group at point for DIRECTORY.
2213 Each directory path part is a different button. If part of the path
2214 matches the user directory ~, then it is replaced with a ~.
2215 INDEX is not used, but is required by the caller."
2216 (let* ((tilde (expand-file-name "~/"))
2217 (dd (expand-file-name directory))
2218 (junk (string-match (regexp-quote tilde) dd))
2220 (concat "~/" (substring dd (match-end 0)))
2223 (if (string-match "^~[/\\]?\\'" displayme) (setq displayme tilde))
2227 (while (re-search-forward "\\([^/\\]+\\)[/\\]" nil t)
2228 (speedbar-make-button (match-beginning 1) (match-end 1)
2229 'speedbar-directory-face
2230 'speedbar-highlight-face
2231 'speedbar-directory-buttons-follow
2232 (if (and (= (match-beginning 1) p)
2233 (not (char-equal (char-after (+ p 1)) ?:)))
2234 (expand-file-name "~/") ;the tilde
2235 (buffer-substring-no-properties
2237 ;; Nuke the beginning of the directory if it's too long...
2238 (cond ((eq speedbar-directory-button-trim-method 'span)
2240 (let ((ww (or (speedbar-frame-width) 20)))
2241 (move-to-column ww nil)
2242 (while (>= (current-column) ww)
2243 (re-search-backward "[/\\]" nil t)
2244 (if (<= (current-column) 2)
2246 (re-search-forward "[/\\]" nil t)
2247 (if (< (current-column) 4)
2248 (re-search-forward "[/\\]" nil t))
2250 (if (looking-at "[/\\]?$")
2253 (move-to-column ww nil)))))
2254 ((eq speedbar-directory-button-trim-method 'trim)
2256 (let ((ww (or (speedbar-frame-width) 20))
2257 (tl (current-column)))
2260 (move-to-column (- tl ww))
2261 (if (re-search-backward "[/\\]" nil t)
2263 (delete-region (point-min) (point))
2267 (if (string-match "\\`[/\\][^/\\]+[/\\]\\'" displayme)
2272 (speedbar-make-button p (point)
2273 'speedbar-directory-face
2274 'speedbar-highlight-face
2275 'speedbar-directory-buttons-follow
2278 (insert-char ?\n 1 nil)))
2280 (defun speedbar-make-tag-line (exp-button-type
2281 exp-button-char exp-button-function
2283 tag-button tag-button-function tag-button-data
2284 tag-button-face depth)
2285 "Create a tag line with EXP-BUTTON-TYPE for the small expansion button.
2286 This is the button that expands or contracts a node (if applicable),
2287 and EXP-BUTTON-CHAR the character in it (+, -, ?, etc). EXP-BUTTON-FUNCTION
2288 is the function to call if it's clicked on. Button types are
2289 'bracket, 'angle, 'curly, or nil. EXP-BUTTON-DATA is extra data
2290 attached to the text forming the expansion button.
2292 Next, TAG-BUTTON is the text of the tag. TAG-BUTTON-FUNCTION is the
2293 function to call if clicked on, and TAG-BUTTON-DATA is the data to
2294 attach to the text field (such a tag positioning, etc).
2295 TAG-BUTTON-FACE is a face used for this type of tag.
2297 Lastly, DEPTH shows the depth of expansion.
2299 This function assumes that the cursor is in the speedbar window at the
2300 position to insert a new item, and that the new item will end with a CR."
2301 (let ((start (point))
2303 (insert (int-to-string depth) ":")
2305 (depthspacesize (* depth speedbar-indentation-width)))
2306 (put-text-property start end 'invisible t)
2307 (insert-char ? depthspacesize nil)
2308 (put-text-property (- (point) depthspacesize) (point) 'invisible nil)
2309 (let* ((exp-button (cond ((eq exp-button-type 'bracket) "[%c]")
2310 ((eq exp-button-type 'angle) "<%c>")
2311 ((eq exp-button-type 'curly) "{%c}")
2313 (buttxt (format exp-button exp-button-char))
2315 (end (progn (insert buttxt) (point)))
2316 (bf (if exp-button-type 'speedbar-button-face nil))
2317 (mf (if exp-button-function 'speedbar-highlight-face nil))
2319 (speedbar-make-button start end bf mf exp-button-function exp-button-data)
2320 (if speedbar-hide-button-brackets-flag
2322 (put-text-property start (1+ start) 'invisible t)
2323 (put-text-property end (1- end) 'invisible t)))
2325 (insert-char ? 1 nil)
2326 (put-text-property (1- (point)) (point) 'invisible nil)
2327 (let ((start (point))
2328 (end (progn (insert tag-button) (point))))
2329 (insert-char ?\n 1 nil)
2330 (put-text-property (1- (point)) (point) 'invisible nil)
2331 (speedbar-make-button start end tag-button-face
2332 (if tag-button-function 'speedbar-highlight-face nil)
2333 tag-button-function tag-button-data))
2336 (defun speedbar-change-expand-button-char (char)
2337 "Change the expansion button character to CHAR for the current line."
2340 (if (re-search-forward ":\\s-*.\\([-+?]\\)" (save-excursion (end-of-line)
2342 (speedbar-with-writable
2343 (goto-char (match-beginning 1))
2345 (insert-char char 1 t)
2346 (put-text-property (point) (1- (point)) 'invisible nil)
2347 ;; make sure we fix the image on the text here.
2348 (speedbar-insert-image-button-maybe (- (point) 2) 3)))))
2351 ;;; Build button lists
2353 (defun speedbar-insert-files-at-point (files level directory)
2354 "Insert list of FILES starting at point, and indenting all files to LEVEL.
2355 Tag expandable items with a +, otherwise a ?. Don't highlight ? as we
2356 don't know how to manage them. The input parameter FILES is a cons
2357 cell of the form ( 'DIRLIST . 'FILELIST )."
2358 ;; Start inserting all the directories
2359 (dolist (dir (car files))
2360 (if (if speedbar-scan-subdirs
2362 (let ((l (speedbar-file-lists (concat directory dir))))
2363 (or (car l) (cadr l)))
2365 (file-readable-p (concat directory dir)))
2366 (speedbar-make-tag-line 'angle ?+ 'speedbar-dired dir
2367 dir 'speedbar-dir-follow nil
2368 'speedbar-directory-face level)
2369 (speedbar-make-tag-line 'angle ? nil dir
2370 dir 'speedbar-dir-follow nil
2371 'speedbar-directory-face level)))
2372 (let ((case-fold-search read-file-name-completion-ignore-case))
2373 (dolist (file (cadr files))
2374 (let* ((known (and (file-readable-p (concat directory file))
2375 (string-match speedbar-file-regexp file)))
2376 (expchar (if known ?+ ??))
2377 (fn (if known 'speedbar-tag-file nil)))
2378 (if (or speedbar-show-unknown-files (/= expchar ??))
2379 (speedbar-make-tag-line 'bracket expchar fn file
2380 file 'speedbar-find-file nil
2381 'speedbar-file-face level))))))
2383 (defun speedbar-default-directory-list (directory index)
2384 "Insert files for DIRECTORY with level INDEX at point."
2385 (speedbar-insert-files-at-point
2386 (speedbar-file-lists directory) index directory)
2387 (speedbar-reset-scanners)
2389 ;; If the shown files variable has extra directories, then
2390 ;; it is our responsibility to redraw them all
2391 ;; Luckilly, the nature of inserting items into this list means
2392 ;; that by reversing it, we can easilly go in the right order
2393 (let ((sf (cdr (reverse speedbar-shown-directories))))
2394 (setq speedbar-shown-directories
2395 (list (expand-file-name default-directory)))
2396 ;; exand them all as we find them
2398 (if (speedbar-goto-this-file (car sf))
2401 (if (looking-at "[0-9]+:[ ]*<")
2403 (goto-char (match-end 0))
2404 (speedbar-do-function-pointer)))))
2408 (defun speedbar-sort-tag-hierarchy (lst)
2409 "Sort all elements of tag hierarchy LST."
2410 (sort (copy-alist lst)
2411 (lambda (a b) (string< (car a) (car b)))))
2413 (defun speedbar-prefix-group-tag-hierarchy (lst)
2414 "Prefix group names for tag hierarchy LST."
2419 (short-group-list nil)
2420 (short-start-name nil)
2421 (short-end-name nil)
2422 (num-shorts-grouped 0)
2423 (bins (make-vector 256 nil))
2425 ;; Break out sub-lists
2427 (if (and (listp (cdr-safe (car-safe lst)))
2428 ;; This one is for bovine tokens
2429 (not (symbolp (car-safe (cdr-safe (car-safe lst))))))
2430 (setq newlst (cons (car lst) newlst))
2431 (setq sublst (cons (car lst) sublst)))
2432 (setq lst (cdr lst)))
2433 ;; Reverse newlst because it was made backwards.
2434 ;; Sublist doesn't need reversing because the act
2435 ;; of binning things will reverse it for us.
2436 (setq newlst (nreverse newlst))
2437 ;; Now, first find out how long our list is. Never let a
2438 ;; list get-shorter than our minimum.
2439 (if (<= (length sublst) speedbar-tag-split-minimum-length)
2440 (setq work-list (nreverse sublst))
2441 (setq diff-idx (length (try-completion "" sublst)))
2442 ;; Sort the whole list into bins.
2444 (let ((e (car sublst))
2445 (s (car (car sublst))))
2446 (cond ((<= (length s) diff-idx)
2447 ;; 0 storage bin for shorty.
2448 (aset bins 0 (cons e (aref bins 0))))
2450 ;; stuff into a bin based on ascii value at diff
2451 (aset bins (aref s diff-idx)
2452 (cons e (aref bins (aref s diff-idx)))))))
2453 (setq sublst (cdr sublst)))
2454 ;; Go through all our bins Stick singles into our
2455 ;; junk-list, everything else as sublsts in work-list.
2456 ;; If two neighboring lists are both small, make a grouped
2457 ;; group combinding those two sub-lists.
2459 (while (> 256 diff-idx)
2460 (let ((l (nreverse;; Reverse the list since they are stuck in
2462 (aref bins diff-idx))))
2464 (let ((tmp (cons (try-completion "" l) l)))
2465 (if (or (> (length l) speedbar-tag-regroup-maximum-length)
2466 (> (+ (length l) (length short-group-list))
2467 speedbar-tag-split-minimum-length))
2469 ;; We have reached a longer list, so we
2470 ;; must finish off a grouped group.
2472 ((and short-group-list
2473 (= (length short-group-list)
2474 num-shorts-grouped))
2475 ;; All singles? Junk list
2476 (setq junk-list (append short-group-list
2478 ((= num-shorts-grouped 1)
2479 ;; Only one short group? Just stick it in
2480 ;; there by itself. Make a group, and find
2482 (let ((subexpression (try-completion
2483 "" short-group-list)))
2484 (if (< (length subexpression)
2485 speedbar-tag-group-name-minimum-length)
2487 (concat short-start-name
2490 (car (car short-group-list))
2491 (length short-start-name))
2494 (cons (cons subexpression
2498 ;; Multiple groups to be named in a special
2499 ;; way by displaying the range over which we
2500 ;; have grouped them.
2502 (cons (cons (concat short-start-name
2505 (nreverse short-group-list))
2507 ;; Reset short group list information every time.
2508 (setq short-group-list nil
2509 short-start-name nil
2511 num-shorts-grouped 0)))
2512 ;; Ok, now that we cleaned up the short-group-list,
2513 ;; we can deal with this new list, to decide if it
2514 ;; should go on one of these sub-lists or not.
2515 (if (< (length l) speedbar-tag-regroup-maximum-length)
2516 (setq short-group-list (append short-group-list l)
2517 num-shorts-grouped (1+ num-shorts-grouped)
2518 short-end-name (car tmp)
2519 short-start-name (if short-start-name
2522 (setq work-list (cons tmp work-list))))))
2523 (setq diff-idx (1+ diff-idx))))
2524 ;; Did we run out of things? Drop our new list onto the end.
2526 ((and short-group-list (= (length short-group-list) num-shorts-grouped))
2527 ;; All singles? Junk list
2528 (setq junk-list (append short-group-list junk-list)))
2529 ((= num-shorts-grouped 1)
2530 ;; Only one short group? Just stick it in
2533 (cons (cons (try-completion "" short-group-list)
2537 ;; Multiple groups to be named in a special
2538 ;; way by displaying the range over which we
2539 ;; have grouped them.
2541 (cons (cons (concat short-start-name " to " short-end-name)
2544 ;; Reverse the work list nreversed when consing.
2545 (setq work-list (nreverse work-list))
2546 ;; Now, stick our new list onto the end of
2549 (append newlst work-list junk-list)
2550 (append newlst work-list))
2551 (append newlst junk-list))))
2553 (defun speedbar-trim-words-tag-hierarchy (lst)
2554 "Trim all words in a tag hierarchy.
2555 Base trimming information on word separators, and group names.
2556 Argument LST is the list of tags to trim."
2563 (if (listp (cdr-safe (car-safe lst)))
2564 (setq newlst (cons (car lst) newlst))
2565 (setq sublst (cons (car lst) sublst)))
2566 (setq lst (cdr lst)))
2567 ;; Get the prefix to trim by. Make sure that we don't trim
2568 ;; off silly pieces, only complete understandable words.
2569 (setq trim-prefix (try-completion "" sublst))
2570 (if (or (= (length sublst) 1)
2572 (not (string-match "\\(\\w+\\W+\\)+" trim-prefix)))
2573 (append (nreverse newlst) (nreverse sublst))
2574 (setq trim-prefix (substring trim-prefix (match-beginning 0)
2576 (setq trim-chars (length trim-prefix))
2579 (cons (substring (car (car sublst)) trim-chars)
2582 sublst (cdr sublst)))
2583 ;; Put the lists together
2584 (append (nreverse newlst) trimlst))))
2586 (defun speedbar-simple-group-tag-hierarchy (lst)
2587 "Create a simple 'Tags' group with orphaned tags.
2588 Argument LST is the list of tags to sort into groups."
2592 (if (listp (cdr-safe (car-safe lst)))
2593 (setq newlst (cons (car lst) newlst))
2594 (setq sublst (cons (car lst) sublst)))
2595 (setq lst (cdr lst)))
2598 (setq newlst (cons (cons "Tags" (nreverse sublst)) newlst))
2599 (nreverse newlst))))
2601 (defun speedbar-create-tag-hierarchy (lst)
2602 "Adjust the tag hierarchy in LST, and return it.
2603 This uses `speedbar-tag-hierarchy-method' to determine how to adjust
2605 (let* ((f (save-excursion
2607 (speedbar-line-path)))
2608 (methods (if (get-file-buffer f)
2609 (save-excursion (set-buffer (get-file-buffer f))
2610 speedbar-tag-hierarchy-method)
2611 speedbar-tag-hierarchy-method))
2612 (lst (if (fboundp 'copy-tree)
2616 (setq lst (funcall (car methods) lst)
2617 methods (cdr methods)))
2620 (defun speedbar-insert-generic-list (level lst expand-fun find-fun)
2621 "At LEVEL, insert a generic multi-level alist LST.
2622 Associations with lists get {+} tags (to expand into more nodes) and
2623 those with positions just get a > as the indicator. {+} buttons will
2624 have the function EXPAND-FUN and the token is the CDR list. The token
2625 name will have the function FIND-FUN and not token."
2626 ;; Remove imenu rescan button
2627 (if (string= (car (car lst)) "*Rescan*")
2628 (setq lst (cdr lst)))
2630 (setq lst (speedbar-create-tag-hierarchy lst))
2633 (cond ((null (car-safe lst)) nil) ;this would be a separator
2634 ((or (numberp (cdr-safe (car-safe lst)))
2635 (markerp (cdr-safe (car-safe lst))))
2636 (speedbar-make-tag-line nil nil nil nil ;no expand button data
2637 (car (car lst)) ;button name
2639 (cdr (car lst)) ;token is position
2642 ((listp (cdr-safe (car-safe lst)))
2643 (speedbar-make-tag-line 'curly ?+ expand-fun (cdr (car lst))
2644 (car (car lst)) ;button name
2645 nil nil 'speedbar-tag-face
2647 (t (speedbar-message "Ooops!")))
2648 (setq lst (cdr lst))))
2650 (defun speedbar-insert-imenu-list (indent lst)
2651 "At level INDENT, insert the imenu generated LST."
2652 (speedbar-insert-generic-list indent lst
2653 'speedbar-tag-expand
2654 'speedbar-tag-find))
2656 (defun speedbar-insert-etags-list (indent lst)
2657 "At level INDENT, insert the etags generated LST."
2658 (speedbar-insert-generic-list indent lst
2659 'speedbar-tag-expand
2660 'speedbar-tag-find))
2664 (defun speedbar-update-contents ()
2665 "Generically update the contents of the speedbar buffer."
2667 ;; Set the current special buffer
2668 (setq speedbar-desired-buffer nil)
2669 ;; Check for special modes
2670 (speedbar-maybe-add-localized-support (current-buffer))
2671 ;; Choose the correct method of doodling.
2672 (if (and speedbar-mode-specific-contents-flag
2673 (listp speedbar-special-mode-expansion-list)
2674 speedbar-special-mode-expansion-list
2676 'speedbar-special-mode-expansion-list
2678 ;;(eq (get major-mode 'mode-class 'special)))
2679 (speedbar-update-special-contents)
2680 (speedbar-update-directory-contents)))
2682 (defun speedbar-update-directory-contents ()
2683 "Update the contents of the speedbar buffer based on the current directory."
2684 (let ((cbd (expand-file-name default-directory))
2686 (funclst (speedbar-initial-expansion-list))
2687 (cache speedbar-full-text-cache)
2688 ;; disable stealth during update
2689 (speedbar-stealthy-function-list nil)
2692 ;; Because there is a bug I can't find just yet
2695 (set-buffer speedbar-buffer)
2696 ;; If we are updating contents to where we are, then this is
2697 ;; really a request to update existing contents, so we must be
2698 ;; careful with our text cache!
2699 (if (member cbd speedbar-shown-directories)
2702 ;; If the current directory is not the last element in the dir
2703 ;; list, then we ALSO need to zap the list of expanded directories
2704 (if (/= (length (member cbd speedbar-shown-directories)) 1)
2705 (setq speedbar-shown-directories (list cbd))))
2707 ;; Build cbd-parent, and see if THAT is in the current shown
2708 ;; directories. First, go through pains to get the parent directory
2709 (if (and speedbar-smart-directory-expand-flag
2711 (setq cbd-parent cbd)
2712 (if (string-match "[/\\]$" cbd-parent)
2713 (setq cbd-parent (substring cbd-parent 0
2714 (match-beginning 0))))
2715 (setq cbd-parent (file-name-directory cbd-parent)))
2716 (member cbd-parent speedbar-shown-directories))
2717 (setq expand-local t)
2719 ;; If this directory is NOT in the current list of available
2720 ;; paths, then use the cache, and set the cache to our new
2721 ;; value. Make sure to unhighlight the current file, or if we
2722 ;; come back to this directory, it might be a different file
2723 ;; and then we get a mess!
2724 (if (> (point-max) 1)
2726 (speedbar-clear-current-file)
2727 (setq speedbar-full-text-cache
2728 (cons speedbar-shown-directories (buffer-string)))))
2730 ;; Check if our new directory is in the list of directories
2731 ;; shown in the text-cache
2732 (if (member cbd (car cache))
2733 (setq speedbar-shown-directories (car cache)
2735 ;; default the shown directories to this list...
2736 (setq speedbar-shown-directories (list cbd)))
2738 (if (not expand-local) (setq speedbar-last-selected-file nil))
2739 (speedbar-with-writable
2740 (if (and expand-local
2741 ;; Find this directory as a speedbar node.
2742 (speedbar-path-line cbd))
2744 (speedbar-expand-line)
2747 (setq default-directory
2748 (nth (1- (length speedbar-shown-directories))
2749 speedbar-shown-directories))
2750 (insert (cdr cache)))
2753 (setq default-directory cbd)
2754 (funcall (car funclst) cbd 0)
2755 (setq funclst (cdr funclst))))))
2756 (goto-char (point-min)))))
2757 (speedbar-reconfigure-keymaps))
2759 (defun speedbar-update-special-contents ()
2760 "Use the mode-specific variable to fill in the speedbar buffer.
2761 This should only be used by modes classified as special."
2762 (let ((funclst speedbar-special-mode-expansion-list)
2763 (specialbuff (current-buffer)))
2765 (setq speedbar-desired-buffer specialbuff)
2766 (set-buffer speedbar-buffer)
2767 ;; If we are leaving a directory, cache it.
2768 (if (not speedbar-shown-directories)
2771 ;; Clean up directory maintenance stuff
2772 (speedbar-clear-current-file)
2773 (setq speedbar-full-text-cache
2774 (cons speedbar-shown-directories (buffer-string))
2775 speedbar-shown-directories nil))
2776 ;; Now fill in the buffer with our newly found specialized list.
2777 (speedbar-with-writable
2779 ;; We do not erase the buffer because these functions may
2780 ;; decide NOT to update themselves.
2781 (funcall (car funclst) specialbuff)
2782 (setq funclst (cdr funclst))))
2783 (goto-char (point-min))))
2784 (speedbar-reconfigure-keymaps))
2786 (defun speedbar-timer-fn ()
2787 "Run whenever Emacs is idle to update the speedbar item."
2788 (if (not (and (frame-live-p speedbar-frame)
2789 (frame-live-p speedbar-attached-frame)))
2790 (speedbar-set-timer nil)
2791 ;; Save all the match data so that we don't mess up executing fns
2793 ;; Only do stuff if the frame is visible, not an icon, and if
2794 ;; it is currently flagged to do something.
2795 (if (and speedbar-update-flag
2796 (frame-visible-p speedbar-frame)
2797 (not (eq (frame-visible-p speedbar-frame) 'icon)))
2798 (let ((af (selected-frame)))
2799 (save-window-excursion
2800 (select-frame speedbar-attached-frame)
2801 ;; make sure we at least choose a window to
2802 ;; get a good directory from
2803 (if (window-minibuffer-p (selected-window))
2805 ;; Check for special modes
2806 (speedbar-maybe-add-localized-support (current-buffer))
2807 ;; Update for special mode all the time!
2808 (if (and speedbar-mode-specific-contents-flag
2809 (listp speedbar-special-mode-expansion-list)
2810 speedbar-special-mode-expansion-list
2812 'speedbar-special-mode-expansion-list
2814 ;;(eq (get major-mode 'mode-class 'special)))
2816 (if (<= 2 speedbar-verbosity-level)
2818 "Updating speedbar to special mode: %s..."
2820 (speedbar-update-special-contents)
2821 (if (<= 2 speedbar-verbosity-level)
2824 "Updating speedbar to special mode: %s...done"
2826 (speedbar-message nil))))
2827 ;; Update all the contents if directories change!
2828 (if (or (member (expand-file-name default-directory)
2829 speedbar-shown-directories)
2830 (and speedbar-ignored-path-regexp
2832 speedbar-ignored-path-regexp
2833 (expand-file-name default-directory)))
2834 (member major-mode speedbar-ignored-modes)
2835 (eq af speedbar-frame)
2836 (not (buffer-file-name)))
2838 (if (<= 1 speedbar-verbosity-level)
2839 (speedbar-message "Updating speedbar to: %s..."
2841 (speedbar-update-directory-contents)
2842 (if (<= 1 speedbar-verbosity-level)
2844 (speedbar-message "Updating speedbar to: %s...done"
2846 (speedbar-message nil)))))
2848 ;; Now run stealthy updates of time-consuming items
2849 (speedbar-stealthy-updates)))
2850 ;; Now run the mouse tracking system
2851 (speedbar-show-info-under-mouse)))
2852 (run-hooks 'speedbar-timer-hook))
2855 ;;; Stealthy activities
2857 (defvar speedbar-stealthy-update-recurse nil
2858 "Recursion avoidance variable for stealthy update.")
2860 (defun speedbar-stealthy-updates ()
2861 "For a given speedbar, run all items in the stealthy function list.
2862 Each item returns t if it completes successfully, or nil if
2863 interrupted by the user."
2864 (if (not speedbar-stealthy-update-recurse)
2865 (let ((l (speedbar-initial-stealthy-functions))
2866 (speedbar-stealthy-update-recurse t))
2868 (speedbar-with-writable
2869 (while (and l (funcall (car l)))
2872 ;;(speedbar-message "Exit with %S" (car l))
2875 (defun speedbar-reset-scanners ()
2876 "Reset any variables used by functions in the stealthy list as state.
2877 If new functions are added, their state needs to be updated here."
2878 (setq speedbar-vc-to-do-point t
2879 speedbar-obj-to-do-point t)
2880 (run-hooks 'speedbar-scanner-reset-hook)
2883 (defun speedbar-find-selected-file (file)
2884 "Go to the line where FILE is."
2885 (goto-char (point-min))
2887 (while (and (setq m (re-search-forward
2888 (concat " \\(" (regexp-quote (file-name-nondirectory file))
2889 "\\)\\(" speedbar-indicator-regex "\\)?\n")
2895 (goto-char (match-beginning 0))
2898 (looking-at "[0-9]+:")
2899 (string-to-number (match-string 0)))))
2900 (match-string 1))))))
2903 (goto-char (match-beginning 1))
2904 (match-string 1)))))
2906 (defun speedbar-clear-current-file ()
2907 "Locate the file thought to be current, and remove its highlighting."
2909 (set-buffer speedbar-buffer)
2910 (if speedbar-last-selected-file
2911 (speedbar-with-writable
2912 (if (speedbar-find-selected-file speedbar-last-selected-file)
2913 (put-text-property (match-beginning 1)
2916 'speedbar-file-face))))))
2918 (defun speedbar-update-current-file ()
2919 "Find the current file, and update our visuals to indicate its name.
2920 This is specific to file names. If the file name doesn't show up, but
2921 it should be in the list, then the directory cache needs to be
2923 (let* ((lastf (selected-frame))
2924 (newcfd (save-excursion
2925 (select-frame speedbar-attached-frame)
2926 (let ((rf (if (buffer-file-name)
2929 (select-frame lastf)
2931 (newcf (if newcfd newcfd))
2932 (lastb (current-buffer))
2933 (sucf-recursive (boundp 'sucf-recursive))
2934 (case-fold-search read-file-name-completion-ignore-case))
2936 ;; check here, that way we won't refresh to newcf until
2937 ;; its been written, thus saving ourselves some time
2938 (file-exists-p newcf)
2939 (not (string= newcf speedbar-last-selected-file)))
2941 ;; It is important to select the frame, otherwise the window
2942 ;; we want the cursor to move in will not be updated by the
2943 ;; search-forward command.
2944 (select-frame speedbar-frame)
2945 ;; Remove the old file...
2946 (speedbar-clear-current-file)
2947 ;; now highlight the new one.
2948 (set-buffer speedbar-buffer)
2949 (speedbar-with-writable
2950 (if (speedbar-find-selected-file newcf)
2951 ;; put the property on it
2952 (put-text-property (match-beginning 1)
2955 'speedbar-selected-face)
2956 ;; Oops, it's not in the list. Should it be?
2957 (if (and (string-match speedbar-file-regexp newcf)
2958 (string= (file-name-directory newcfd)
2959 (expand-file-name default-directory)))
2960 ;; yes, it is (we will ignore unknowns for now...)
2963 (if (speedbar-find-selected-file newcf)
2964 ;; put the property on it
2965 (put-text-property (match-beginning 1)
2968 'speedbar-selected-face)))
2969 ;; if it's not in there now, whatever...
2971 (setq speedbar-last-selected-file newcf))
2972 (if (not sucf-recursive)
2974 (speedbar-center-buffer-smartly)
2975 (speedbar-position-cursor-on-line)
2978 (select-frame lastf)
2980 ;; return that we are done with this activity.
2983 (defun speedbar-add-indicator (indicator-string &optional replace-this)
2984 "Add INDICATOR-STRING to the end of this speedbar line.
2985 If INDICATOR-STRING is space, and REPLACE-THIS is a character, then
2986 the existing indicator is removed. If there is already an
2987 indicator, then do not add a space."
2989 ;; The nature of the beast: Assume we are in "the right place"
2991 (skip-chars-backward (concat " " speedbar-vc-indicator
2992 (car speedbar-obj-indicator)
2993 (cdr speedbar-obj-indicator)))
2994 (if (and (not (looking-at speedbar-indicator-regex))
2995 (not (string= indicator-string " ")))
2996 (insert speedbar-indicator-separator))
2997 (speedbar-with-writable
2999 (if (and replace-this
3000 (re-search-forward replace-this (save-excursion (end-of-line)
3003 (delete-region (match-beginning 0) (match-end 0))))
3005 (if (not (string= " " indicator-string))
3006 (insert indicator-string))))
3008 ;; Load efs/ange-ftp only if compiling to remove byte-compiler warnings.
3009 ;; Steven L Baur <steve@xemacs.org> said this was important:
3010 (eval-when-compile (or (featurep 'xemacs)
3011 (condition-case () (require 'efs)
3012 (error (require 'ange-ftp)))))
3014 (defun speedbar-check-vc ()
3015 "Scan all files in a directory, and for each see if it's checked out.
3016 See `speedbar-this-file-in-vc' and `speedbar-vc-check-dir-p' for how
3017 to add more types of version control systems."
3018 ;; Check for to-do to be reset. If reset but no RCS is available
3019 ;; then set to nil (do nothing) otherwise, start at the beginning
3021 (set-buffer speedbar-buffer)
3022 (if (and speedbar-vc-do-check (eq speedbar-vc-to-do-point t)
3023 (speedbar-vc-check-dir-p default-directory)
3024 (not (or (and (featurep 'ange-ftp)
3026 (car (if speedbar-xemacsp
3027 ange-ftp-path-format
3028 ange-ftp-name-format))
3029 (expand-file-name default-directory)))
3030 ;; efs support: Bob Weiner
3031 (and (featurep 'efs)
3033 (car efs-path-regexp)
3034 (expand-file-name default-directory))))))
3035 (setq speedbar-vc-to-do-point 0))
3036 (if (numberp speedbar-vc-to-do-point)
3038 (goto-char speedbar-vc-to-do-point)
3039 (while (and (not (input-pending-p))
3040 (re-search-forward "^\\([0-9]+\\):\\s-*\\[[+-]\\] "
3042 (setq speedbar-vc-to-do-point (point))
3043 (if (speedbar-check-vc-this-line (match-string 1))
3044 (speedbar-add-indicator speedbar-vc-indicator
3045 (regexp-quote speedbar-vc-indicator))
3046 (speedbar-add-indicator " "
3047 (regexp-quote speedbar-vc-indicator))))
3048 (if (input-pending-p)
3049 ;; return that we are incomplete
3051 ;; we are done, set to-do to nil
3052 (setq speedbar-vc-to-do-point nil)
3057 (defun speedbar-check-vc-this-line (depth)
3058 "Return t if the file on this line is check of of a version control system.
3059 Parameter DEPTH is a string with the current depth of indentation of
3060 the file being checked."
3061 (let* ((d (string-to-int depth))
3062 (f (speedbar-line-path d))
3063 (fn (buffer-substring-no-properties
3064 ;; Skip-chars: thanks ptype@dra.hmg.gb
3066 (skip-chars-forward "^ "
3067 (save-excursion (end-of-line)
3070 (fulln (concat f fn)))
3071 (if (<= 2 speedbar-verbosity-level)
3072 (speedbar-message "Speedbar vc check...%s" fulln))
3073 (and (file-writable-p fulln)
3074 (speedbar-this-file-in-vc f fn))))
3076 (defun speedbar-vc-check-dir-p (path)
3077 "Return t if we should bother checking PATH for version control files.
3078 This can be overloaded to add new types of version control systems."
3081 (file-exists-p (concat path "RCS/"))
3083 (file-exists-p (concat path "SCCS/"))
3084 ;; Remote SCCS project
3085 (let ((proj-dir (getenv "PROJECTDIR")))
3087 (file-exists-p (concat proj-dir "/SCCS"))
3090 (run-hook-with-args 'speedbar-vc-path-enable-hook path)
3093 (defun speedbar-this-file-in-vc (path name)
3094 "Check to see if the file in PATH with NAME is in a version control system.
3095 You can add new VC systems by overriding this function. You can
3096 optimize this function by overriding it and only doing those checks
3097 that will occur on your system."
3100 (file-exists-p (concat path "RCS/" name ",v"))
3101 (file-exists-p (concat path "RCS/" name))
3102 ;; Local SCCS file name
3103 (file-exists-p (concat path "SCCS/s." name))
3104 ;; Remote SCCS file name
3105 (let ((proj-dir (getenv "PROJECTDIR")))
3107 (file-exists-p (concat proj-dir "/SCCS/s." name))
3110 (run-hook-with-args 'speedbar-vc-in-control-hook path name)
3113 ;; Objet File scanning
3114 (defun speedbar-check-objects ()
3115 "Scan all files in a directory, and for each see if there is an object.
3116 See `speedbar-check-obj-this-line' and `speedbar-obj-alist' for how
3117 to add more object types."
3118 ;; Check for to-do to be reset. If reset but no RCS is available
3119 ;; then set to nil (do nothing) otherwise, start at the beginning
3121 (set-buffer speedbar-buffer)
3122 (if (and speedbar-obj-do-check (eq speedbar-obj-to-do-point t))
3123 (setq speedbar-obj-to-do-point 0))
3124 (if (numberp speedbar-obj-to-do-point)
3126 (goto-char speedbar-obj-to-do-point)
3127 (while (and (not (input-pending-p))
3128 (re-search-forward "^\\([0-9]+\\):\\s-*\\[[+-]\\] "
3130 (setq speedbar-obj-to-do-point (point))
3131 (let ((ind (speedbar-check-obj-this-line (match-string 1))))
3132 (if (not ind) (setq ind " "))
3133 (speedbar-add-indicator ind (concat
3134 (car speedbar-obj-indicator)
3136 (cdr speedbar-obj-indicator)))))
3137 (if (input-pending-p)
3138 ;; return that we are incomplete
3140 ;; we are done, set to-do to nil
3141 (setq speedbar-obj-to-do-point nil)
3146 (defun speedbar-check-obj-this-line (depth)
3147 "Return t if the file on this line has an associated object.
3148 Parameter DEPTH is a string with the current depth of indentation of
3149 the file being checked."
3150 (let* ((d (string-to-int depth))
3151 (f (speedbar-line-path d))
3152 (fn (buffer-substring-no-properties
3153 ;; Skip-chars: thanks ptype@dra.hmg.gb
3155 (skip-chars-forward "^ "
3156 (save-excursion (end-of-line)
3159 (fulln (concat f fn)))
3160 (if (<= 2 speedbar-verbosity-level)
3161 (speedbar-message "Speedbar obj check...%s" fulln))
3162 (let ((oa speedbar-obj-alist))
3163 (while (and oa (not (string-match (car (car oa)) fulln)))
3165 (if (not (and oa (file-exists-p (concat (file-name-sans-extension fulln)
3168 ;; Find out if the object is out of date or not.
3169 (let ((date1 (nth 5 (file-attributes fulln)))
3170 (date2 (nth 5 (file-attributes (concat
3171 (file-name-sans-extension fulln)
3173 (if (or (< (car date1) (car date2))
3174 (and (= (car date1) (car date2))
3175 (< (nth 1 date1) (nth 1 date2))))
3176 (car speedbar-obj-indicator)
3177 (cdr speedbar-obj-indicator)))))))
3179 ;;; Clicking Activity
3181 (defun speedbar-mouse-set-point (e)
3182 "Set POINT based on event E.
3183 Handle clicking on images in XEmacs."
3184 (if (and (fboundp 'event-over-glyph-p) (event-over-glyph-p e))
3185 ;; We are in XEmacs, and clicked on a picture
3186 (let ((ext (event-glyph-extent e)))
3187 ;; This position is back inside the extent where the
3188 ;; junk we pushed into the property list lives.
3189 (if (extent-end-position ext)
3190 (goto-char (1- (extent-end-position ext)))
3191 (mouse-set-point e)))
3192 ;; We are not in XEmacs, OR we didn't click on a picture.
3193 (mouse-set-point e)))
3195 (defun speedbar-quick-mouse (e)
3196 "Since mouse events are strange, this will keep the mouse nicely positioned.
3197 This should be bound to mouse event E."
3199 (speedbar-mouse-set-point e)
3200 (speedbar-position-cursor-on-line)
3203 (defun speedbar-position-cursor-on-line ()
3204 "Position the cursor on a line."
3205 (let ((oldpos (point)))
3207 (if (looking-at "[0-9]+:\\s-*..?.? ")
3208 (goto-char (1- (match-end 0)))
3209 (goto-char oldpos))))
3211 (defun speedbar-power-click (e)
3212 "Activate any speedbar button as a power click.
3213 A power click will dispose of cached data (if available) or bring a buffer
3214 up into a different window.
3215 This should be bound to mouse event E."
3217 (let ((speedbar-power-click t))
3218 (speedbar-click e)))
3220 (defun speedbar-click (e)
3221 "Activate any speedbar buttons where the mouse is clicked.
3222 This must be bound to a mouse event. A button is any location of text
3223 with a mouse face that has a text property called `speedbar-function'.
3224 This should be bound to mouse event E."
3226 (speedbar-mouse-set-point e)
3227 (speedbar-do-function-pointer)
3228 (speedbar-quick-mouse e))
3230 (defun speedbar-double-click (e)
3231 "Activate any speedbar buttons where the mouse is clicked.
3232 This must be bound to a mouse event. A button is any location of text
3233 with a mouse face that has a text property called `speedbar-function'.
3234 This should be bound to mouse event E."
3236 ;; Emacs only. XEmacs handles this via `mouse-track-click-hook'.
3237 (cond ((eq (car e) 'down-mouse-1)
3238 (speedbar-mouse-set-point e))
3239 ((eq (car e) 'mouse-1)
3240 (speedbar-quick-mouse e))
3241 ((or (eq (car e) 'double-down-mouse-1)
3242 (eq (car e) 'triple-down-mouse-1))
3243 (speedbar-mouse-set-point e)
3244 (speedbar-do-function-pointer)
3245 (speedbar-quick-mouse e))))
3247 (defun speedbar-do-function-pointer ()
3248 "Look under the cursor and examine the text properties.
3249 From this extract the file/tag name, token, indentation level and call
3250 a function if appropriate."
3251 (let* ((fn (get-text-property (point) 'speedbar-function))
3252 (tok (get-text-property (point) 'speedbar-token))
3253 ;; The 1-,+ is safe because scaning starts AFTER the point
3254 ;; specified. This lets the search include the character the
3256 (tp (previous-single-property-change
3257 (1+ (point)) 'speedbar-function))
3258 (np (next-single-property-change
3259 (point) 'speedbar-function))
3260 (txt (buffer-substring-no-properties (or tp (point-min))
3261 (or np (point-max))))
3262 (dent (save-excursion (beginning-of-line)
3264 (if (looking-at "[0-9]+")
3265 (buffer-substring-no-properties
3266 (match-beginning 0) (match-end 0))
3268 ;;(speedbar-message "%S:%S:%S:%s" fn tok txt dent)
3269 (and fn (funcall fn txt tok dent)))
3270 (speedbar-position-cursor-on-line))
3272 ;;; Reading info from the speedbar buffer
3274 (defun speedbar-line-text (&optional p)
3275 "Retrieve the text after prefix junk for the current line.
3276 Optional argument P is where to start the search from."
3278 (if p (goto-char p))
3280 (if (looking-at (concat
3281 "\\([0-9]+\\): *[[<{][-+?][]>}] \\([^ \n]+\\)\\("
3282 speedbar-indicator-regex "\\)?"))
3286 (defun speedbar-line-token (&optional p)
3287 "Retrieve the token information after the prefix junk for the current line.
3288 Optional argument P is where to start the search from."
3290 (if p (goto-char p))
3292 (if (looking-at (concat
3293 "\\([0-9]+\\): *[[<{]?[-+?=][]>}@()|] \\([^ \n]+\\)\\("
3294 speedbar-indicator-regex "\\)?"))
3296 (goto-char (match-beginning 2))
3297 (get-text-property (point) 'speedbar-token))
3300 (defun speedbar-line-file (&optional p)
3301 "Retrieve the file or whatever from the line at point P.
3302 The return value is a string representing the file. If it is a
3303 directory, then it is the directory name."
3305 (let ((f (speedbar-line-text p)))
3307 (let* ((depth (string-to-int (match-string 1)))
3308 (path (speedbar-line-path depth)))
3309 (if (file-exists-p (concat path f))
3314 (defun speedbar-goto-this-file (file)
3315 "If FILE is displayed, go to this line and return t.
3316 Otherwise do not move and return nil."
3317 (let ((path (substring (file-name-directory (expand-file-name file))
3318 (length (expand-file-name default-directory))))
3321 (goto-char (point-min))
3322 ;; scan all the directories
3323 (while (and path (not (eq path t)))
3324 (if (string-match "^[/\\]?\\([^/\\]+\\)" path)
3325 (let ((pp (match-string 1 path)))
3326 (if (save-match-data
3327 (re-search-forward (concat "> " (regexp-quote pp) "$")
3329 (setq path (substring path (match-end 1)))
3332 ;; find the file part
3333 (if (or (not path) (string= (file-name-nondirectory file) ""))
3334 ;; only had a dir part
3337 (speedbar-position-cursor-on-line)
3339 (goto-char dest) nil)
3340 ;; find the file part
3341 (let ((nd (file-name-nondirectory file)))
3342 (if (re-search-forward
3343 (concat "] \\(" (regexp-quote nd)
3344 "\\)\\(" speedbar-indicator-regex "\\)$")
3347 (speedbar-position-cursor-on-line)
3352 (defun speedbar-line-path (&optional depth)
3353 "Retrieve the pathname associated with the current line.
3354 This may require traversing backwards from DEPTH and combining the default
3355 directory with these items. This function is replaceable in
3356 `speedbar-mode-functions-list' as `speedbar-line-path'."
3357 (let ((rf (speedbar-fetch-replacement-function 'speedbar-line-path)))
3358 (if rf (funcall rf depth) default-directory)))
3360 (defun speedbar-files-line-path (&optional depth)
3361 "Retrieve the pathname associated with the current line.
3362 This may require traversing backwards from DEPTH and combining the default
3363 directory with these items."
3369 (looking-at "^\\([0-9]+\\):")
3370 (setq depth (string-to-int (match-string 1)))))
3372 (setq depth (1- depth))
3373 (while (/= depth -1)
3374 (if (not (re-search-backward (format "^%d:" depth) nil t))
3375 (error "Error building path of tag")
3376 (cond ((looking-at "[0-9]+:\\s-*<->\\s-+\\([^\n]+\\)$")
3377 (setq path (concat (buffer-substring-no-properties
3378 (match-beginning 1) (match-end 1))
3381 ((looking-at "[0-9]+:\\s-*[-]\\s-+\\([^\n]+\\)$")
3382 ;; This is the start of our path.
3383 (setq path (buffer-substring-no-properties
3384 (match-beginning 1) (match-end 1))))))
3385 (setq depth (1- depth)))
3387 (string-match (concat speedbar-indicator-regex "$")
3389 (setq path (substring path 0 (match-beginning 0))))
3390 (concat default-directory path)))))
3392 (defun speedbar-path-line (path)
3393 "Position the cursor on the line specified by PATH."
3395 (if (string-match "[/\\]$" path)
3396 (setq path (substring path 0 (match-beginning 0))))
3397 (let ((nomatch t) (depth 0)
3398 (fname (file-name-nondirectory path))
3399 (pname (file-name-directory path)))
3400 (if (not (member pname speedbar-shown-directories))
3401 (error "Internal Error: File %s not shown in speedbar" path))
3402 (goto-char (point-min))
3405 (concat "[]>] \\(" (regexp-quote fname)
3406 "\\)\\(" speedbar-indicator-regex "\\)?$")
3409 (looking-at "\\([0-9]+\\):")
3410 (setq depth (string-to-int (match-string 0))
3411 nomatch (not (string= pname (speedbar-line-path depth))))
3416 (defun speedbar-edit-line ()
3417 "Edit whatever tag or file is on the current speedbar line."
3421 ;; If this fails, then it is a non-standard click, and as such,
3422 ;; perfectly allowed.
3423 (if (re-search-forward "[]>?}] [^ ]"
3424 (save-excursion (end-of-line) (point))
3428 (speedbar-do-function-pointer))
3430 (speedbar-do-function-pointer)))
3432 (defun speedbar-expand-line (&optional arg)
3433 "Expand the line under the cursor.
3434 With universal argument ARG, flush cached data."
3437 (let ((speedbar-power-click arg))
3440 (re-search-forward ":\\s-*.\\+. "
3441 (save-excursion (end-of-line) (point)))
3443 (speedbar-do-function-pointer))
3444 (error (speedbar-position-cursor-on-line)))))
3446 (defun speedbar-flush-expand-line ()
3447 "Expand the line under the cursor and flush any cached information."
3449 (speedbar-expand-line 1))
3451 (defun speedbar-contract-line ()
3452 "Contract the line under the cursor."
3457 (re-search-forward ":\\s-*.-. "
3458 (save-excursion (end-of-line) (point)))
3460 (speedbar-do-function-pointer))
3461 (error (speedbar-position-cursor-on-line))))
3463 (if speedbar-xemacsp
3464 (defalias 'speedbar-mouse-event-p 'button-press-event-p)
3465 (defun speedbar-mouse-event-p (event)
3466 "Return t if the event is a mouse related event."
3467 ;; And Emacs does it this way
3468 (if (and (listp event)
3469 (member (event-basic-type event)
3470 '(mouse-1 mouse-2 mouse-3)))
3474 (defun speedbar-maybee-jump-to-attached-frame ()
3475 "Jump to the attached frame ONLY if this was not a mouse event."
3476 (if (or (not (speedbar-mouse-event-p last-input-event))
3477 speedbar-activity-change-focus-flag)
3479 (select-frame speedbar-attached-frame)
3482 (defun speedbar-find-file (text token indent)
3483 "Speedbar click handler for filenames.
3484 TEXT, the file will be displayed in the attached frame.
3485 TOKEN is unused, but required by the click handler. INDENT is the
3486 current indentation level."
3487 (let ((cdd (speedbar-line-path indent)))
3488 (speedbar-find-file-in-frame (concat cdd text))
3489 (speedbar-stealthy-updates)
3490 (run-hooks 'speedbar-visiting-file-hook)
3491 ;; Reset the timer with a new timeout when cliking a file
3492 ;; in case the user was navigating directories, we can cancel
3493 ;; that other timer.
3494 (speedbar-set-timer speedbar-update-speed))
3495 (speedbar-maybee-jump-to-attached-frame))
3497 (defun speedbar-dir-follow (text token indent)
3498 "Speedbar click handler for directory names.
3499 Clicking a directory will cause the speedbar to list files in
3500 the subdirectory TEXT. TOKEN is an unused requirement. The
3501 subdirectory chosen will be at INDENT level."
3502 (setq default-directory
3503 (concat (expand-file-name (concat (speedbar-line-path indent) text))
3505 ;; Because we leave speedbar as the current buffer,
3506 ;; update contents will change directory without
3507 ;; having to touch the attached frame. Turn off smart expand just
3509 (let ((speedbar-smart-directory-expand-flag nil))
3510 (speedbar-update-contents))
3511 (speedbar-set-timer speedbar-navigating-speed)
3512 (setq speedbar-last-selected-file nil)
3513 (speedbar-stealthy-updates))
3515 (defun speedbar-delete-subblock (indent)
3516 "Delete text from point to indentation level INDENT or greater.
3517 Handles end-of-sublist smartly."
3518 (speedbar-with-writable
3520 (end-of-line) (forward-char 1)
3521 (let ((start (point)))
3522 (while (and (looking-at "^\\([0-9]+\\):")
3523 (> (string-to-int (match-string 1)) indent)
3526 (beginning-of-line))
3527 (delete-region start (point))))))
3529 (defun speedbar-dired (text token indent)
3530 "Speedbar click handler for directory expand button.
3531 Clicking this button expands or contracts a directory. TEXT is the
3532 button clicked which has either a + or -. TOKEN is the directory to be
3533 expanded. INDENT is the current indentation level."
3534 (cond ((string-match "+" text) ;we have to expand this dir
3535 (setq speedbar-shown-directories
3536 (cons (expand-file-name
3537 (concat (speedbar-line-path indent) token "/"))
3538 speedbar-shown-directories))
3539 (speedbar-change-expand-button-char ?-)
3540 (speedbar-reset-scanners)
3542 (end-of-line) (forward-char 1)
3543 (speedbar-with-writable
3544 (speedbar-default-directory-list
3545 (concat (speedbar-line-path indent) token "/")
3547 ((string-match "-" text) ;we have to contract this node
3548 (speedbar-reset-scanners)
3549 (let ((oldl speedbar-shown-directories)
3551 (td (expand-file-name
3552 (concat (speedbar-line-path indent) token))))
3554 (if (not (string-match (concat "^" (regexp-quote td)) (car oldl)))
3555 (setq newl (cons (car oldl) newl)))
3556 (setq oldl (cdr oldl)))
3557 (setq speedbar-shown-directories (nreverse newl)))
3558 (speedbar-change-expand-button-char ?+)
3559 (speedbar-delete-subblock indent)
3561 (t (error "Ooops... not sure what to do")))
3562 (speedbar-center-buffer-smartly)
3563 (setq speedbar-last-selected-file nil)
3564 (save-excursion (speedbar-stealthy-updates)))
3566 (defun speedbar-directory-buttons-follow (text token indent)
3567 "Speedbar click handler for default directory buttons.
3568 TEXT is the button clicked on. TOKEN is the directory to follow.
3569 INDENT is the current indentation level and is unused."
3570 (if (string-match "^[A-z]:$" token)
3571 (setq default-directory (concat token "/"))
3572 (setq default-directory token))
3573 ;; Because we leave speedbar as the current buffer,
3574 ;; update contents will change directory without
3575 ;; having to touch the attached frame.
3576 (speedbar-update-contents)
3577 (speedbar-set-timer speedbar-navigating-speed))
3579 (defun speedbar-tag-file (text token indent)
3580 "The cursor is on a selected line. Expand the tags in the specified file.
3581 The parameter TEXT and TOKEN are required, where TEXT is the button
3582 clicked, and TOKEN is the file to expand. INDENT is the current
3584 (cond ((string-match "+" text) ;we have to expand this file
3585 (let* ((fn (expand-file-name (concat (speedbar-line-path indent)
3588 (lst (speedbar-fetch-dynamic-tags fn)))
3589 ;; if no list, then remove expando button
3591 (speedbar-change-expand-button-char ??)
3592 (speedbar-change-expand-button-char ?-)
3593 (speedbar-with-writable
3595 (end-of-line) (forward-char 1)
3596 (funcall (car lst) indent (cdr lst)))))))
3597 ((string-match "-" text) ;we have to contract this node
3598 (speedbar-change-expand-button-char ?+)
3599 (speedbar-delete-subblock indent))
3600 (t (error "Ooops... not sure what to do")))
3601 (speedbar-center-buffer-smartly))
3603 (defun speedbar-tag-find (text token indent)
3604 "For the tag TEXT in a file TOKEN, go to that position.
3605 INDENT is the current indentation level."
3606 (let ((file (speedbar-line-path indent)))
3607 (speedbar-find-file-in-frame file)
3608 (save-excursion (speedbar-stealthy-updates))
3609 ;; Reset the timer with a new timeout when cliking a file
3610 ;; in case the user was navigating directories, we can cancel
3611 ;; that other timer.
3612 (speedbar-set-timer speedbar-update-speed)
3614 (run-hooks 'speedbar-visiting-tag-hook)
3616 (speedbar-maybee-jump-to-attached-frame)
3619 (defun speedbar-tag-expand (text token indent)
3620 "Expand a tag sublist. Imenu will return sub-lists of specialized tag types.
3621 Etags does not support this feature. TEXT will be the button
3622 string. TOKEN will be the list, and INDENT is the current indentation
3624 (cond ((string-match "+" text) ;we have to expand this file
3625 (speedbar-change-expand-button-char ?-)
3626 (speedbar-with-writable
3628 (end-of-line) (forward-char 1)
3629 (speedbar-insert-generic-list indent token 'speedbar-tag-expand
3630 'speedbar-tag-find))))
3631 ((string-match "-" text) ;we have to contract this node
3632 (speedbar-change-expand-button-char ?+)
3633 (speedbar-delete-subblock indent))
3634 (t (error "Ooops... not sure what to do")))
3635 (speedbar-center-buffer-smartly))
3637 ;;; Loading files into the attached frame.
3639 (defun speedbar-find-file-in-frame (file)
3640 "This will load FILE into the speedbar attached frame.
3641 If the file is being displayed in a different frame already, then raise that
3643 (let* ((buff (find-file-noselect file))
3644 (bwin (get-buffer-window buff 0)))
3647 (select-window bwin)
3648 (raise-frame (window-frame bwin)))
3649 (if speedbar-power-click
3650 (let ((pop-up-frames t)) (select-window (display-buffer buff)))
3651 (select-frame speedbar-attached-frame)
3652 (switch-to-buffer buff))))
3655 ;;; Centering Utility
3657 (defun speedbar-center-buffer-smartly ()
3658 "Recenter a speedbar buffer so the current indentation level is all visible.
3659 This assumes that the cursor is on a file, or tag of a file which the user is
3661 (if (<= (count-lines (point-min) (point-max))
3662 (1- (window-height (selected-window))))
3663 ;; whole buffer fits
3665 (goto-char (point-min))
3669 (let (depth start end exp p)
3672 (setq depth (if (looking-at "[0-9]+")
3673 (string-to-int (buffer-substring-no-properties
3674 (match-beginning 0) (match-end 0)))
3676 (setq exp (format "^%d:\\s-*[[{<]\\([?+-]\\)[]>}]" depth)))
3679 (if (re-search-backward exp nil t)
3680 (setq start (point))
3681 (setq start (point-min)))
3682 (save-excursion ;Not sure about this part.
3685 (while (and (not (re-search-forward exp nil t))
3687 (setq depth (1- depth))
3688 (setq exp (format "^%d:\\s-*[[{<]\\([?+-]\\)[]>}]" depth)))
3691 (setq end (point-max)))))
3692 ;; Now work out the details of centering
3693 (let ((nl (count-lines start end))
3695 (if (> nl (window-height (selected-window)))
3696 ;; We can't fit it all, so just center on cursor
3697 (progn (goto-char start)
3699 ;; we can fit everything on the screen, but...
3700 (if (and (pos-visible-in-window-p start (selected-window))
3701 (pos-visible-in-window-p end (selected-window)))
3704 ;; we need to do something...
3706 (let ((newcent (/ (- (window-height (selected-window)) nl) 2))
3707 (lte (count-lines start (point-max))))
3708 (if (and (< (+ newcent lte) (window-height (selected-window)))
3709 (> (- (window-height (selected-window)) lte 1)
3711 (setq newcent (- (window-height (selected-window))
3713 (recenter newcent))))
3717 ;;; Tag Management -- List of expanders:
3719 (defun speedbar-fetch-dynamic-tags (file)
3720 "Return a list of tags generated dynamically from FILE.
3721 This uses the entries in `speedbar-dynamic-tags-function-list'
3722 to find the proper tags. It is up to each of those individual
3723 functions to do caching and flushing if appropriate."
3725 (set-buffer (find-file-noselect file))
3726 ;; If there is a buffer-local value of
3727 ;; speedbar-dynamic-tags-function-list, it will now be available.
3728 (let ((dtf speedbar-dynamic-tags-function-list)
3730 (while (and (eq ret t) dtf)
3732 (if (fboundp (car (car dtf)))
3733 (funcall (car (car dtf)) (buffer-file-name))
3736 (setq dtf (cdr dtf))))
3738 ;; No valid tag list, return nil
3740 ;; We have some tags. Return the list with the insert fn
3742 (cons (cdr (car dtf)) ret)))))
3744 ;;; Tag Management -- Imenu
3746 (if (not speedbar-use-imenu-flag)
3750 (eval-when-compile (if (locate-library "imenu") (require 'imenu)))
3752 (defun speedbar-fetch-dynamic-imenu (file)
3753 "Load FILE into a buffer, and generate tags using Imenu.
3754 Returns the tag list, or t for an error."
3755 ;; Load this AND compile it in
3757 (if speedbar-power-click (setq imenu--index-alist nil))
3759 (let ((index-alist (imenu--make-index-alist t)))
3760 (if speedbar-sort-tags
3761 (sort (copy-alist index-alist)
3762 (lambda (a b) (string< (car a) (car b))))
3767 ;;; Tag Management -- etags (old XEmacs compatibility part)
3769 (defvar speedbar-fetch-etags-parse-list
3770 '(;; Note that java has the same parse-group as c
3771 ("\\.\\([cChH]\\|c\\+\\+\\|cpp\\|cc\\|hh\\|java\\)\\'" .
3772 speedbar-parse-c-or-c++tag)
3773 ("^\\.emacs$\\|.\\(el\\|l\\|lsp\\)\\'" .
3774 "def[^i]+\\s-+\\(\\(\\w\\|[-_]\\)+\\)\\s-*\C-?")
3775 ; ("\\.\\([fF]\\|for\\|FOR\\|77\\|90\\)\\'" .
3776 ; speedbar-parse-fortran77-tag)
3777 ("\\.tex\\'" . speedbar-parse-tex-string)
3779 "\\(\\(FUNCTION\\|function\\|PROCEDURE\\|procedure\\)\\s-+\\([a-zA-Z0-9_.:]+\\)\\)\\s-*(?^?")
3781 "Associations of file extensions and expressions for extracting tags.
3782 To add a new file type, you would want to add a new association to the
3783 list, where the car is the file match, and the cdr is the way to
3784 extract an element from the tags output. If the output is complex,
3785 use a function symbol instead of regexp. The function should expect
3786 to be at the beginning of a line in the etags buffer.
3788 This variable is ignored if `speedbar-use-imenu-flag' is non-nil.")
3790 (defvar speedbar-fetch-etags-command "etags"
3791 "*Command used to create an etags file.
3793 This variable is ignored if `speedbar-use-imenu-flag' is t.")
3795 (defvar speedbar-fetch-etags-arguments '("-D" "-I" "-o" "-")
3796 "*List of arguments to use with `speedbar-fetch-etags-command'.
3797 This creates an etags output buffer. Use `speedbar-toggle-etags' to
3798 modify this list conveniently.
3800 This variable is ignored if `speedbar-use-imenu-flag' is t.")
3802 (defun speedbar-toggle-etags (flag)
3803 "Toggle FLAG in `speedbar-fetch-etags-arguments'.
3804 FLAG then becomes a member of etags command line arguments. If flag
3805 is \"sort\", then toggle the value of `speedbar-sort-tags'. If its
3806 value is \"show\" then toggle the value of
3807 `speedbar-show-unknown-files'.
3809 This function is a convenience function for XEmacs menu created by
3810 Farzin Guilak <farzin@protocol.com>."
3813 ((equal flag "sort")
3814 (setq speedbar-sort-tags (not speedbar-sort-tags)))
3815 ((equal flag "show")
3816 (setq speedbar-show-unknown-files (not speedbar-show-unknown-files)))
3817 ((or (equal flag "-C")
3820 (if (member flag speedbar-fetch-etags-arguments)
3821 (setq speedbar-fetch-etags-arguments
3822 (delete flag speedbar-fetch-etags-arguments))
3823 (add-to-list 'speedbar-fetch-etags-arguments flag)))
3826 (defun speedbar-fetch-dynamic-etags (file)
3827 "For FILE, run etags and create a list of symbols extracted.
3828 Each symbol will be associated with its line position in FILE."
3829 (let ((newlist nil))
3832 (if (get-buffer "*etags tmp*")
3833 (kill-buffer "*etags tmp*")) ;kill to clean it up
3834 (if (<= 1 speedbar-verbosity-level)
3835 (speedbar-message "Fetching etags..."))
3836 (set-buffer (get-buffer-create "*etags tmp*"))
3837 (apply 'call-process speedbar-fetch-etags-command nil
3838 (current-buffer) nil
3839 (append speedbar-fetch-etags-arguments (list file)))
3840 (goto-char (point-min))
3841 (if (<= 1 speedbar-verbosity-level)
3842 (speedbar-message "Fetching etags..."))
3844 (let ((exprlst speedbar-fetch-etags-parse-list)
3846 (while (and (not ans) exprlst)
3847 (if (string-match (car (car exprlst)) file)
3848 (setq ans (car exprlst)))
3849 (setq exprlst (cdr exprlst)))
3853 (set-buffer (get-buffer-create "*etags tmp*"))
3854 (while (not (save-excursion (end-of-line) (eobp)))
3856 (setq tnl (speedbar-extract-one-symbol expr)))
3857 (if tnl (setq newlist (cons tnl newlist)))
3860 "Sorry, no support for a file of that extension"))))
3862 (if speedbar-sort-tags
3863 (sort newlist (lambda (a b) (string< (car a) (car b))))
3864 (reverse newlist))))
3866 ;; This bit donated by Farzin Guilak <farzin@protocol.com> but I'm not
3867 ;; sure it's needed with the different sorting method.
3869 ;(defun speedbar-clean-etags()
3870 ; "Removes spaces before the ^? character, and removes `#define',
3871 ;return types, etc. preceding tags. This ensures that the sort operation
3872 ;works on the tags, not the return types."
3874 ; (goto-char (point-min))
3876 ; (re-search-forward "(?[ \t](?\C-?" nil t)
3877 ; (replace-match "\C-?" nil nil))
3878 ; (goto-char (point-min))
3880 ; (re-search-forward "\\(.*[ \t]+\\)\\([^ \t\n]+.*\C-?\\)" nil t)
3881 ; (delete-region (match-beginning 1) (match-end 1)))))
3883 (defun speedbar-extract-one-symbol (expr)
3884 "At point, return nil, or one alist in the form: (SYMBOL . POSITION)
3885 The line should contain output from etags. Parse the output using the
3886 regular expression EXPR."
3887 (let* ((sym (if (stringp expr)
3889 (re-search-forward expr (save-excursion
3892 (buffer-substring-no-properties (match-beginning 1)
3895 (pos (let ((j (re-search-forward "[\C-?\C-a]\\([0-9]+\\),\\([0-9]+\\)"
3901 (1+ (string-to-int (buffer-substring-no-properties
3909 (defun speedbar-parse-c-or-c++tag ()
3910 "Parse a C or C++ tag, which tends to be a little complex."
3912 (let ((bound (save-excursion (end-of-line) (point))))
3913 (cond ((re-search-forward "\C-?\\([^\C-a]+\\)\C-a" bound t)
3914 (buffer-substring-no-properties (match-beginning 1)
3916 ((re-search-forward "\\<\\([^ \t]+\\)\\s-+new(" bound t)
3917 (buffer-substring-no-properties (match-beginning 1)
3919 ((re-search-forward "\\<\\([^ \t(]+\\)\\s-*(\C-?" bound t)
3920 (buffer-substring-no-properties (match-beginning 1)
3925 (defun speedbar-parse-tex-string ()
3926 "Parse a Tex string. Only find data which is relevant."
3928 (let ((bound (save-excursion (end-of-line) (point))))
3929 (cond ((re-search-forward "\\(\\(sub\\)*section\\|chapter\\|cite\\)\\s-*{[^\C-?}]*}?" bound t)
3930 (buffer-substring-no-properties (match-beginning 0)
3935 ;;; BUFFER DISPLAY mode.
3937 (defvar speedbar-buffers-key-map nil
3938 "Keymap used when in the buffers display mode.")
3940 (if speedbar-buffers-key-map
3942 (setq speedbar-buffers-key-map (speedbar-make-specialized-keymap))
3944 ;; Basic tree features
3945 (define-key speedbar-buffers-key-map "e" 'speedbar-edit-line)
3946 (define-key speedbar-buffers-key-map "\C-m" 'speedbar-edit-line)
3947 (define-key speedbar-buffers-key-map "+" 'speedbar-expand-line)
3948 (define-key speedbar-buffers-key-map "=" 'speedbar-expand-line)
3949 (define-key speedbar-buffers-key-map "-" 'speedbar-contract-line)
3951 ;; Buffer specific keybindings
3952 (define-key speedbar-buffers-key-map "k" 'speedbar-buffer-kill-buffer)
3953 (define-key speedbar-buffers-key-map "r" 'speedbar-buffer-revert-buffer)
3957 (defvar speedbar-buffer-easymenu-definition
3958 '(["Jump to buffer" speedbar-edit-line t]
3959 ["Expand File Tags" speedbar-expand-line
3960 (save-excursion (beginning-of-line)
3961 (looking-at "[0-9]+: *.\\+. "))]
3962 ["Flush Cache & Expand" speedbar-flush-expand-line
3963 (save-excursion (beginning-of-line)
3964 (looking-at "[0-9]+: *.\\+. "))]
3965 ["Contract File Tags" speedbar-contract-line
3966 (save-excursion (beginning-of-line)
3967 (looking-at "[0-9]+: *.-. "))]
3968 ["Kill Buffer" speedbar-buffer-kill-buffer
3969 (save-excursion (beginning-of-line)
3970 (looking-at "[0-9]+: *.-. "))]
3971 ["Revert Buffer" speedbar-buffer-revert-buffer
3972 (save-excursion (beginning-of-line)
3973 (looking-at "[0-9]+: *.-. "))]
3975 "Menu item elements shown when displaying a buffer list.")
3977 (defun speedbar-buffer-buttons (directory zero)
3978 "Create speedbar buttons based on the buffers currently loaded.
3979 DIRECTORY is the path to the currently active buffer, and ZERO is 0."
3980 (speedbar-buffer-buttons-engine nil))
3982 (defun speedbar-buffer-buttons-temp (directory zero)
3983 "Create speedbar buttons based on the buffers currently loaded.
3984 DIRECTORY is the path to the currently active buffer, and ZERO is 0."
3985 (speedbar-buffer-buttons-engine t))
3987 (defun speedbar-buffer-buttons-engine (temp)
3988 "Create speedbar buffer buttons.
3989 If TEMP is non-nil, then clicking on a buffer restores the previous display."
3990 (insert "Active Buffers:\n")
3991 (let ((bl (buffer-list)))
3993 (if (string-match "^[ *]" (buffer-name (car bl)))
3995 (let* ((known (string-match speedbar-file-regexp
3996 (buffer-name (car bl))))
3997 (expchar (if known ?+ ??))
3998 (fn (if known 'speedbar-tag-file nil))
3999 (fname (save-excursion (set-buffer (car bl))
4000 (buffer-file-name))))
4001 (speedbar-make-tag-line 'bracket expchar fn
4002 (if fname (file-name-nondirectory fname))
4003 (buffer-name (car bl))
4004 'speedbar-buffer-click temp
4005 'speedbar-file-face 0)))
4007 (setq bl (buffer-list))
4008 (insert "Scratch Buffers:\n")
4010 (if (not (string-match "^\\*" (buffer-name (car bl))))
4012 (if (eq (car bl) speedbar-buffer)
4014 (speedbar-make-tag-line 'bracket ?? nil nil
4015 (buffer-name (car bl))
4016 'speedbar-buffer-click temp
4017 'speedbar-file-face 0)))
4019 (setq bl (buffer-list))
4020 (insert "Hidden Buffers:\n")
4022 (if (not (string-match "^ " (buffer-name (car bl))))
4024 (if (eq (car bl) speedbar-buffer)
4026 (speedbar-make-tag-line 'bracket ?? nil nil
4027 (buffer-name (car bl))
4028 'speedbar-buffer-click temp
4029 'speedbar-file-face 0)))
4030 (setq bl (cdr bl)))))
4032 (defun speedbar-buffers-item-info ()
4033 "Display information about the current buffer on the current line."
4034 (or (speedbar-item-info-tag-helper)
4035 (let* ((item (speedbar-line-text))
4036 (buffer (if item (get-buffer item) nil)))
4038 (speedbar-message "%s%s %S %d %s"
4039 (if (buffer-modified-p buffer) "* " "")
4041 (save-excursion (set-buffer buffer) major-mode)
4042 (save-excursion (set-buffer buffer)
4044 (or (buffer-file-name buffer) "<No file>"))))))
4046 (defun speedbar-buffers-line-path (&optional depth)
4047 "Fetch the full path to the file (buffer) specified on the current line.
4048 Optional argument DEPTH specifies the current depth of the back search."
4051 (let ((start (point)))
4052 ;; Buffers are always at level 0
4053 (if (not (re-search-backward "^0:" nil t))
4055 (let* ((bn (speedbar-line-text))
4056 (buffer (if bn (get-buffer bn))))
4061 (file-name-directory (buffer-file-name buffer))
4062 (buffer-file-name buffer))))))))
4064 (defun speedbar-buffer-click (text token indent)
4065 "When the users clicks on a buffer-button in speedbar.
4066 TEXT is the buffer's name, TOKEN and INDENT are unused."
4067 (if speedbar-power-click
4068 (let ((pop-up-frames t)) (select-window (display-buffer text)))
4069 (select-frame speedbar-attached-frame)
4070 (switch-to-buffer text)
4071 (if token (speedbar-change-initial-expansion-list
4072 speedbar-previously-used-expansion-list-name))))
4074 (defun speedbar-buffer-kill-buffer ()
4075 "Kill the buffer the cursor is on in the speedbar buffer."
4079 ;; If this fails, then it is a non-standard click, and as such,
4080 ;; perfectly allowed.
4081 (if (re-search-forward "[]>?}] [^ ]"
4082 (save-excursion (end-of-line) (point))
4086 (buffer-substring (point) (save-excursion
4089 (if (and (get-buffer text)
4090 (speedbar-y-or-n-p (format "Kill buffer %s? " text)))
4092 (speedbar-refresh))))))
4094 (defun speedbar-buffer-revert-buffer ()
4095 "Revert the buffer the cursor is on in the speedbar buffer."
4099 ;; If this fails, then it is a non-standard click, and as such,
4100 ;; perfectly allowed
4101 (if (re-search-forward "[]>?}] [^ ]"
4102 (save-excursion (end-of-line) (point))
4106 (buffer-substring (point) (save-excursion
4109 (if (get-buffer text)
4112 (revert-buffer t)))))))
4115 ;;; Useful hook values and such.
4117 (defvar speedbar-highlight-one-tag-line nil
4118 "Overlay used for highlighting the most recently jumped to tag line.")
4120 (defun speedbar-highlight-one-tag-line ()
4121 "Highlight the current line, unhighlighting a previously jumped to line."
4122 (speedbar-unhighlight-one-tag-line)
4123 (setq speedbar-highlight-one-tag-line
4124 (speedbar-make-overlay (save-excursion (beginning-of-line) (point))
4125 (save-excursion (end-of-line)
4128 (speedbar-overlay-put speedbar-highlight-one-tag-line 'face
4129 'speedbar-highlight-face)
4130 (add-hook 'pre-command-hook 'speedbar-unhighlight-one-tag-line)
4133 (defun speedbar-unhighlight-one-tag-line ()
4134 "Unhighlight the currently highlighted line."
4135 (if speedbar-highlight-one-tag-line
4137 (speedbar-delete-overlay speedbar-highlight-one-tag-line)
4138 (setq speedbar-highlight-one-tag-line nil)))
4139 (remove-hook 'pre-command-hook 'speedbar-unhighlight-one-tag-line))
4141 (defun speedbar-recenter-to-top ()
4142 "Recenter the current buffer so POINT is on the top of the window."
4145 (defun speedbar-recenter ()
4146 "Recenter the current buffer so POINT is in the center of the window."
4147 (recenter (/ (window-height (selected-window)) 2)))
4150 ;;; Color loading section.
4152 (defface speedbar-button-face '((((class color) (background light))
4153 (:foreground "green4"))
4154 (((class color) (background dark))
4155 (:foreground "green3")))
4156 "Face used for +/- buttons."
4157 :group 'speedbar-faces)
4159 (defface speedbar-file-face '((((class color) (background light))
4160 (:foreground "cyan4"))
4161 (((class color) (background dark))
4162 (:foreground "cyan"))
4164 "Face used for file names."
4165 :group 'speedbar-faces)
4167 (defface speedbar-directory-face '((((class color) (background light))
4168 (:foreground "blue4"))
4169 (((class color) (background dark))
4170 (:foreground "light blue")))
4171 "Face used for directory names."
4172 :group 'speedbar-faces)
4173 (defface speedbar-tag-face '((((class color) (background light))
4174 (:foreground "brown"))
4175 (((class color) (background dark))
4176 (:foreground "yellow")))
4177 "Face used for displaying tags."
4178 :group 'speedbar-faces)
4180 (defface speedbar-selected-face '((((class color) (background light))
4181 (:foreground "red" :underline t))
4182 (((class color) (background dark))
4183 (:foreground "red" :underline t))
4185 "Face used to underline the file in the active window."
4186 :group 'speedbar-faces)
4188 (defface speedbar-highlight-face '((((class color) (background light))
4189 (:background "green"))
4190 (((class color) (background dark))
4191 (:background "sea green"))
4192 (((class grayscale mono)
4194 (:background "black"))
4195 (((class grayscale mono)
4197 (:background "white")))
4198 "Face used for highlighting buttons with the mouse."
4199 :group 'speedbar-faces)
4202 ;;; Image loading and inlining
4205 ;;; Some images if defimage is available:
4208 (if (fboundp 'defimage)
4209 (defalias 'defimage-speedbar 'defimage)
4211 (if (not (fboundp 'make-glyph))
4213 (defmacro defimage-speedbar (variable imagespec docstring)
4214 "Don't bother loading up an image...
4215 Argument VARIABLE is the variable to define.
4216 Argument IMAGESPEC is the list defining the image to create.
4217 Argument DOCSTRING is the documentation for VARIABLE."
4218 `(defvar ,variable nil ,docstring))
4221 (defun speedbar-find-image-on-load-path (image)
4222 "Find the image file IMAGE on the load path."
4225 (while (and l (not r))
4226 (if (file-exists-p (concat (car l) "/" image))
4227 (setq r (concat (car l) "/" image)))
4231 (defun speedbar-convert-emacs21-imagespec-to-xemacs (spec)
4232 "Convert the Emacs21 image SPEC into an XEmacs image spec."
4233 (let* ((sl (car spec))
4236 (vector itype ':file (speedbar-find-image-on-load-path ifile))))
4238 (defmacro defimage-speedbar (variable imagespec docstring)
4239 "Define VARIABLE as an image if `defimage' is not available.
4240 IMAGESPEC is the image data, and DOCSTRING is documentation for the image."
4242 ;; The Emacs21 version of defimage looks just like the XEmacs image
4243 ;; specifier, except that it needs a :type keyword. If we line
4244 ;; stuff up right, we can use this cheat to support XEmacs specifiers.
4247 (make-image-specifier
4248 (speedbar-convert-emacs21-imagespec-to-xemacs (quote ,imagespec)))
4253 (defimage-speedbar speedbar-directory-plus
4254 ((:type xpm :file "sb-dir-plus.xpm" :ascent center))
4255 "Image used for closed directories with stuff in them.")
4257 (defimage-speedbar speedbar-directory-minus
4258 ((:type xpm :file "sb-dir-minus.xpm" :ascent center))
4259 "Image used for open directories with stuff in them.")
4261 (defimage-speedbar speedbar-directory
4262 ((:type xpm :file "sb-dir.xpm" :ascent center))
4263 "Image used for empty or unreadable directories.")
4265 (defimage-speedbar speedbar-page-plus
4266 ((:type xpm :file "sb-pg-plus.xpm" :ascent center))
4267 "Image used for closed files with stuff in them.")
4269 (defimage-speedbar speedbar-page-minus
4270 ((:type xpm :file "sb-pg-minus.xpm" :ascent center))
4271 "Image used for open files with stuff in them.")
4273 (defimage-speedbar speedbar-page
4274 ((:type xpm :file "sb-pg.xpm" :ascent center))
4275 "Image used for files that can't be opened.")
4277 (defimage-speedbar speedbar-tag
4278 ((:type xpm :file "sb-tag.xpm" :ascent center))
4279 "Image used for tags.")
4281 (defimage-speedbar speedbar-tag-plus
4282 ((:type xpm :file "sb-tag-plus.xpm" :ascent center))
4283 "Image used for closed tag groups.")
4285 (defimage-speedbar speedbar-tag-minus
4286 ((:type xpm :file "sb-tag-minus.xpm" :ascent center))
4287 "Image used for open tag groups.")
4289 (defimage-speedbar speedbar-tag-gt
4290 ((:type xpm :file "sb-tag-gt.xpm" :ascent center))
4291 "Image used for open tag groups.")
4293 (defimage-speedbar speedbar-tag-v
4294 ((:type xpm :file "sb-tag-v.xpm" :ascent center))
4295 "Image used for open tag groups.")
4297 (defimage-speedbar speedbar-tag-type
4298 ((:type xpm :file "sb-tag-type.xpm" :ascent center))
4299 "Image used for open tag groups.")
4301 (defimage-speedbar speedbar-mail
4302 ((:type xpm :file "sb-mail.xpm" :ascent center))
4303 "Image used for open tag groups.")
4305 (defvar speedbar-expand-image-button-alist
4306 '(("<+>" . speedbar-directory-plus)
4307 ("<->" . speedbar-directory-minus)
4308 ("< >" . speedbar-directory)
4309 ("[+]" . speedbar-page-plus)
4310 ("[-]" . speedbar-page-minus)
4311 ("[?]" . speedbar-page)
4312 ("{+}" . speedbar-tag-plus)
4313 ("{-}" . speedbar-tag-minus)
4314 ("<M>" . speedbar-mail)
4315 (" =>" . speedbar-tag)
4316 (" +>" . speedbar-tag-gt)
4317 (" ->" . speedbar-tag-v)
4318 (">" . speedbar-tag)
4319 ("@" . speedbar-tag-type)
4320 (" @" . speedbar-tag-type)
4322 "List of text and image associations.")
4324 (defun speedbar-insert-image-button-maybe (start length)
4325 "Insert an image button based on text starting at START for LENGTH chars.
4326 If buttontext is unknown, just insert that text.
4327 If we have an image associated with it, use that image."
4328 (if speedbar-use-images
4329 (let* ((bt (buffer-substring start (+ length start)))
4330 (a (assoc bt speedbar-expand-image-button-alist)))
4331 ;; Regular images (created with `insert-image' are intangible
4332 ;; which (I suppose) make them more compatible with XEmacs 21.
4333 ;; Unfortunatly, there is a giant pile o code dependent on the
4334 ;; underlying text. This means if we leave it tangible, then I
4335 ;; don't have to change said giant piles o code.
4336 (if (and a (symbol-value (cdr a)))
4337 (if (featurep 'xemacs)
4338 (add-text-properties (+ start (length bt)) start
4339 (list 'end-glyph (symbol-value (cdr a))
4340 'rear-nonsticky (list 'display)
4343 (add-text-properties start (+ start (length bt))
4344 (list 'display (symbol-value (cdr a))
4345 'rear-nonsticky (list 'display))))
4346 ;(message "Bad text [%s]" (buffer-substring start (+ start length)))
4350 ;; some edebug hooks
4351 (add-hook 'edebug-setup-hook
4353 (def-edebug-spec speedbar-with-writable def-body)))
4357 ;; run load-time hooks
4358 (run-hooks 'speedbar-load-hook)
4360 ;;; arch-tag: 4477e6d1-f78c-48b9-a503-387d3c9767d5
4361 ;;; speedbar.el ends here