Add new command gnus-article-sort-by-marks
[emacs.git] / lisp / speedbar.el
blob31134711830efba3b34793b6c7463cf579506dcb
1 ;;; speedbar --- quick access to files and tags in a frame
3 ;; Copyright (C) 1996-2017 Free Software Foundation, Inc.
5 ;; Author: Eric M. Ludlam <zappo@gnu.org>
6 ;; Keywords: file, tags, tools
8 (defvar speedbar-version "1.0"
9 "The current version of speedbar.")
10 (defvar speedbar-incompatible-version "0.14beta4"
11 "This version of speedbar is incompatible with this version.
12 Due to massive API changes (removing the use of the word PATH)
13 this version is not backward compatible to 0.14 or earlier.")
15 ;; This file is part of GNU Emacs.
17 ;; GNU Emacs is free software: you can redistribute it and/or modify
18 ;; it under the terms of the GNU General Public License as published by
19 ;; the Free Software Foundation, either version 3 of the License, or
20 ;; (at your option) any later version.
22 ;; GNU Emacs is distributed in the hope that it will be useful,
23 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
24 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 ;; GNU General Public License for more details.
27 ;; You should have received a copy of the GNU General Public License
28 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
30 ;;; Commentary:
32 ;; The speedbar provides a frame in which files, and locations in
33 ;; files are displayed. These items can be clicked on with mouse-2 in
34 ;; to display that file location.
36 ;;; Customizing and Developing for speedbar
38 ;; Please see the speedbar manual for information.
40 ;;; Notes:
42 ;; AUC-TEX users: The imenu tags for AUC-TEX mode don't work very
43 ;; well. Use the imenu keywords from tex-mode.el for better results.
45 ;;; Developing for speedbar
47 ;; Adding a speedbar specialized display mode:
49 ;; Speedbar can be configured to create a special display for certain
50 ;; modes that do not display traditional file/tag data. Rmail, Info,
51 ;; and the debugger are examples. These modes can, however, benefit
52 ;; from a speedbar style display in their own way.
54 ;; If your `major-mode' is `foo-mode', the only requirement is to
55 ;; create a function called `foo-speedbar-buttons' which takes one
56 ;; argument, BUFFER. BUFFER will be the buffer speedbar wants filled.
57 ;; In `foo-speedbar-buttons' there are several functions that make
58 ;; building a speedbar display easy. See the documentation for
59 ;; `speedbar-with-writable' (needed because the buffer is usually
60 ;; read-only) `speedbar-make-tag-line', `speedbar-insert-button', and
61 ;; `speedbar-insert-generic-list'. If you use
62 ;; `speedbar-insert-generic-list', also read the doc for
63 ;; `speedbar-tag-hierarchy-method' in case you wish to override it.
64 ;; The macro `dframe-with-attached-buffer' brings you back to the
65 ;; buffer speedbar is displaying for.
67 ;; For those functions that make buttons, the "function" should be a
68 ;; symbol that is the function to call when clicked on. The "token"
69 ;; is extra data you can pass along. The "function" must take three
70 ;; parameters. They are (TEXT TOKEN INDENT). TEXT is the text of the
71 ;; button clicked on. TOKEN is the data passed in when you create the
72 ;; button. INDENT is an indentation level, or 0. You can store
73 ;; indentation levels with `speedbar-make-tag-line' which creates a
74 ;; line with an expander (eg. [+]) and a text button.
76 ;; Some useful functions when writing expand functions, and click
77 ;; functions are `speedbar-change-expand-button-char',
78 ;; `speedbar-delete-subblock', and `speedbar-center-buffer-smartly'.
79 ;; The variable `speedbar-power-click' is set to t in your functions
80 ;; when the user shift-clicks. This is an indication of anything from
81 ;; refreshing cached data to making a buffer appear in a new frame.
83 ;; If you wish to add to the default speedbar menu for the case of
84 ;; `foo-mode', create a variable `foo-speedbar-menu-items'. This
85 ;; should be a list compatible with the `easymenu' package. It will
86 ;; be spliced into the main menu. (Available with click-mouse-3). If
87 ;; you wish to have extra key bindings in your special mode, create a
88 ;; variable `foo-speedbar-key-map'. Instead of using `make-keymap',
89 ;; or `make-sparse-keymap', use the function
90 ;; `speedbar-make-specialized-keymap'. This lets you inherit all of
91 ;; speedbar's default bindings with low overhead.
93 ;; Adding a speedbar top-level display mode:
95 ;; Unlike the specialized modes, there are no name requirements,
96 ;; however the methods for writing a button display, menu, and keymap
97 ;; are the same. Once you create these items, you can call the
98 ;; function `speedbar-add-expansion-list'. It takes one parameter
99 ;; which is a list element of the form (NAME MENU KEYMAP &rest
100 ;; BUTTON-FUNCTIONS). NAME is a string that will show up in the
101 ;; Displays menu item. MENU is a symbol containing the menu items to
102 ;; splice in. KEYMAP is a symbol holding the keymap to use, and
103 ;; BUTTON-FUNCTIONS are the function names to call, in order, to create
104 ;; the display.
105 ;; Another tweakable variable is `speedbar-stealthy-function-list'
106 ;; which is of the form (NAME &rest FUNCTION ...). NAME is the string
107 ;; name matching `speedbar-add-expansion-list'. (It does not need to
108 ;; exist.). This provides additional display info which might be
109 ;; time-consuming to calculate.
110 ;; Lastly, `speedbar-mode-functions-list' allows you to set special
111 ;; function overrides.
113 ;;; TODO:
114 ;; - Timeout directories we haven't visited in a while.
116 (require 'easymenu)
117 (require 'dframe)
118 (require 'sb-image)
120 ;; customization stuff
121 (defgroup speedbar nil
122 "File and tag browser frame."
123 :group 'etags
124 :group 'tools
125 :group 'convenience
126 :link '(custom-manual "(speedbar) Top")
127 :link '(info-link "(speedbar) Customizing")
128 ; :version "20.3"
131 (defgroup speedbar-faces nil
132 "Faces used in speedbar."
133 :prefix "speedbar-"
134 :link '(info-link "(speedbar) Frames and Faces")
135 :group 'speedbar
136 :group 'faces)
138 (defgroup speedbar-vc nil
139 "Version control display in speedbar."
140 :link '(info-link "(speedbar) Version Control")
141 :prefix "speedbar-"
142 :group 'speedbar)
144 ;;; Code:
146 ;; Note: `inversion-test' requires parts of the CEDET package that are
147 ;; not included with Emacs.
149 ;; (defun speedbar-require-version (major minor &optional beta)
150 ;; "Non-nil if this version of SPEEDBAR does not satisfy a specific version.
151 ;; Arguments can be:
153 ;; (MAJOR MINOR &optional BETA)
155 ;; Values MAJOR and MINOR must be integers. BETA can be an integer, or
156 ;; excluded if a released version is required.
158 ;; It is assumed that if the current version is newer than that specified,
159 ;; everything passes. Exceptions occur when known incompatibilities are
160 ;; introduced."
161 ;; (inversion-test 'speedbar
162 ;; (concat major "." minor
163 ;; (when beta (concat "beta" beta)))))
165 (defvar speedbar-initial-expansion-mode-alist
166 '(("buffers" speedbar-buffer-easymenu-definition speedbar-buffers-key-map
167 speedbar-buffer-buttons)
168 ("quick buffers" speedbar-buffer-easymenu-definition speedbar-buffers-key-map
169 speedbar-buffer-buttons-temp)
170 ;; Files last, means first in the Displays menu
171 ("files" speedbar-easymenu-definition-special speedbar-file-key-map
172 speedbar-directory-buttons speedbar-default-directory-list)
174 "List of named expansion elements for filling the speedbar frame.
175 These expansion lists are only valid for regular files. Special modes
176 still get to override this list on a mode-by-mode basis. This list of
177 lists is of the form (NAME MENU KEYMAP FN1 FN2 ...). NAME is a string
178 representing the types of things to be displayed. MENU is an easymenu
179 structure used when in this mode. KEYMAP is a local keymap to install
180 over the regular speedbar keymap. FN1 ... are functions that will be
181 called in order. These functions will always get the default
182 directory to use passed in as the first parameter, and a 0 as the
183 second parameter. The 0 indicates the uppermost indentation level.
184 They must assume that the cursor is at the position where they start
185 inserting buttons.")
187 (defvar speedbar-initial-expansion-list-name "files"
188 "A symbol name representing the expansion list to use.
189 The expansion list `speedbar-initial-expansion-mode-alist' contains
190 the names and associated functions to use for buttons in speedbar.")
192 (defvar speedbar-previously-used-expansion-list-name "files"
193 "Save the last expansion list method.
194 This is used for returning to a previous expansion list method when
195 the user is done with the current expansion list.")
197 (defvar speedbar-stealthy-function-list
198 '(("files"
199 speedbar-update-current-file
200 speedbar-check-read-only
201 speedbar-check-vc
202 speedbar-check-objects)
204 "List of functions to periodically call stealthily.
205 This list is of the form:
206 ( (\"NAME\" FUNCTION ...)
207 ...)
208 where NAME is the name of the major display mode these functions are
209 for, and the remaining elements FUNCTION are functions to call in order.
210 Each function must return nil if interrupted, or t if completed.
211 Stealthy functions which have a single operation should always return t.
212 Functions which take a long time should maintain a state (where they
213 are in their speedbar related calculations) and permit interruption.
214 See `speedbar-check-vc' as a good example.")
216 (defvar speedbar-mode-functions-list
217 '(("files" (speedbar-item-info . speedbar-files-item-info)
218 (speedbar-line-directory . speedbar-files-line-directory))
219 ("buffers" (speedbar-item-info . speedbar-buffers-item-info)
220 (speedbar-line-directory . speedbar-buffers-line-directory))
221 ("quick buffers" (speedbar-item-info . speedbar-buffers-item-info)
222 (speedbar-line-directory . speedbar-buffers-line-directory))
224 "List of function tables to use for different major display modes.
225 It is not necessary to define any functions for a specialized mode.
226 This just provides a simple way of adding lots of customizations.
227 Each sublist is of the form:
228 (\"NAME\" (FUNCTIONSYMBOL . REPLACEMENTFUNCTION) ...)
229 Where NAME is the name of the specialized mode. The rest of the list
230 is a set of dotted pairs of the form FUNCTIONSYMBOL, which is the name
231 of a function you would like to replace, and REPLACEMENTFUNCTION,
232 which is a function you can call instead. Not all functions can be
233 replaced this way. Replaceable functions must provide that
234 functionality individually.")
236 (defcustom speedbar-mode-specific-contents-flag t
237 "Non-nil means speedbar will show special mode contents.
238 This permits some modes to create customized contents for the speedbar
239 frame."
240 :group 'speedbar
241 :type 'boolean)
243 (defcustom speedbar-query-confirmation-method 'all
244 "Query control for file operations.
245 The `all' flag means to always query before file operations.
246 The `none-but-delete' flag means to not query before any file
247 operations, except before a file deletion."
248 :group 'speedbar
249 :type '(radio (const :tag "Always Query before some file operations."
250 all)
251 (const :tag "Never Query before file operations, except for deletions."
252 none-but-delete)
253 ;;;; (const :tag "Never Every Query."
254 ;;;; none)
257 (defvar speedbar-special-mode-expansion-list nil
258 "Default function list for creating specialized button lists.
259 This list is set by modes that wish to have special speedbar displays.
260 The list is of function names. Each function is called with one
261 parameter BUFFER, the originating buffer. The current buffer is the
262 speedbar buffer.")
264 (defvar speedbar-special-mode-key-map nil
265 "Default keymap used when identifying a specialized display mode.
266 This keymap is local to each buffer that wants to define special keybindings
267 effective when its display is shown.")
269 (defcustom speedbar-before-visiting-file-hook '(push-mark)
270 "Hooks run before speedbar visits a file in the selected frame.
271 The default buffer is the buffer in the selected window in the attached frame."
272 :group 'speedbar
273 :type 'hook)
275 (defcustom speedbar-visiting-file-hook nil
276 "Hooks run when speedbar visits a file in the selected frame."
277 :group 'speedbar
278 :type 'hook)
280 (defcustom speedbar-before-visiting-tag-hook '(push-mark)
281 "Hooks run before speedbar visits a tag in the selected frame.
282 The default buffer is the buffer in the selected window in the attached frame."
283 :group 'speedbar
284 :type 'hook)
286 (defcustom speedbar-visiting-tag-hook '(speedbar-highlight-one-tag-line)
287 "Hooks run when speedbar visits a tag in the selected frame."
288 :group 'speedbar
289 :type 'hook
290 :options '(speedbar-highlight-one-tag-line
291 speedbar-recenter-to-top
292 speedbar-recenter
295 (defcustom speedbar-load-hook nil
296 "Hooks run when speedbar is loaded."
297 :group 'speedbar
298 :type 'hook)
300 (defcustom speedbar-reconfigure-keymaps-hook nil
301 "Hooks run when the keymaps are regenerated."
302 :group 'speedbar
303 :type 'hook)
305 (defcustom speedbar-show-unknown-files nil
306 "Non-nil show files we can't expand with a ? in the expand button.
307 A nil value means don't show the file in the list."
308 :group 'speedbar
309 :type 'boolean)
311 ;;; EVENTUALLY REMOVE THESE
313 ;; When I moved to a repeating timer, I had the horrible misfortune
314 ;; of losing the ability for adaptive speed choice. This update
315 ;; speed currently causes long delays when it should have been turned off.
316 (defvar speedbar-update-speed dframe-update-speed)
317 (make-obsolete-variable 'speedbar-update-speed
318 'dframe-update-speed
319 "speedbar 1.0pre3 (Emacs 23.1)")
321 (defvar speedbar-navigating-speed dframe-update-speed)
322 (make-obsolete-variable 'speedbar-navigating-speed
323 'dframe-update-speed
324 "speedbar 1.0pre3 (Emacs 23.1)")
325 ;;; END REMOVE THESE
327 (defcustom speedbar-frame-parameters '((minibuffer . nil)
328 (width . 20)
329 (border-width . 0)
330 (menu-bar-lines . 0)
331 (tool-bar-lines . 0)
332 (unsplittable . t)
333 (left-fringe . 0)
335 "Parameters to use when creating the speedbar frame in Emacs.
336 Any parameter supported by a frame may be added. The parameter `height'
337 will be initialized to the height of the frame speedbar is
338 attached to and added to this list before the new frame is initialized."
339 :group 'speedbar
340 :type '(repeat (cons :format "%v"
341 (symbol :tag "Parameter")
342 (sexp :tag "Value"))))
344 ;; These values by Hrvoje Niksic <hniksic@srce.hr>
345 (defcustom speedbar-frame-plist
346 '(minibuffer nil width 20 border-width 0
347 internal-border-width 0 unsplittable t
348 default-toolbar-visible-p nil has-modeline-p nil
349 menubar-visible-p nil
350 default-gutter-visible-p nil
352 "Parameters to use when creating the speedbar frame in XEmacs.
353 Parameters not listed here which will be added automatically are
354 `height' which will be initialized to the height of the frame speedbar
355 is attached to."
356 :group 'speedbar
357 :type '(repeat (group :inline t
358 (symbol :tag "Property")
359 (sexp :tag "Value"))))
361 (defcustom speedbar-use-imenu-flag (fboundp 'imenu)
362 "Non-nil means use imenu for file parsing, nil to use etags.
363 XEmacs prior to 20.4 doesn't support imenu, therefore the default is to
364 use etags instead. Etags support is not as robust as imenu support."
365 :tag "Use Imenu for tags"
366 :group 'speedbar
367 :type 'boolean)
369 (defvar speedbar-dynamic-tags-function-list
370 '((speedbar-fetch-dynamic-imenu . speedbar-insert-imenu-list)
371 (speedbar-fetch-dynamic-etags . speedbar-insert-etags-list))
372 "Set to a list of functions which will return and insert a list of tags.
373 Each element is of the form ( FETCH . INSERT ) where FETCH
374 is a function which takes one parameter (the file to tag) and returns a
375 list of tags. The tag list can be of any form as long as the
376 corresponding insert method can handle it. If it returns t, then an
377 error occurred, and the next fetch routine is tried.
378 INSERT is a function which takes an INDENTation level, and a LIST of
379 tags to insert. It will then create the speedbar buttons.")
381 (defcustom speedbar-use-tool-tips-flag (fboundp 'tooltip-mode)
382 "Non-nil means to use tool tips if they are available.
383 When tooltips are not available, mouse-tracking and minibuffer
384 display is used instead."
385 :group 'speedbar
386 :type 'boolean)
388 (defcustom speedbar-track-mouse-flag (not speedbar-use-tool-tips-flag)
389 "Non-nil means to display info about the line under the mouse."
390 :group 'speedbar
391 :type 'boolean)
393 (defcustom speedbar-default-position 'left-right
394 "Default position of the speedbar frame.
395 Possible values are `left', `right' or `left-right'.
396 If value is `left-right', the most suitable location is
397 determined automatically."
398 :group 'speedbar
399 :type '(radio (const :tag "Automatic" left-right)
400 (const :tag "Left" left)
401 (const :tag "Right" right)))
403 (defcustom speedbar-sort-tags nil
404 "If non-nil, sort tags in the speedbar display. *Obsolete*.
405 Use `semantic-tag-hierarchy-method' instead."
406 :group 'speedbar
407 :type 'boolean)
409 (defcustom speedbar-tag-hierarchy-method
410 '(speedbar-prefix-group-tag-hierarchy
411 speedbar-trim-words-tag-hierarchy)
412 "List of hooks which speedbar will use to organize tags into groups.
413 Groups are defined as expandable meta-tags. Imenu supports
414 such things in some languages, such as separating variables from
415 functions. Each hook takes one argument LST, and may destructively
416 create a new list of the same form. LST is a list of elements of the
417 form:
418 (ELT1 ELT2 ... ELTn)
419 where each ELT is of the form
420 (TAG-NAME-STRING . NUMBER-OR-MARKER)
422 (GROUP-NAME-STRING ELT1 ELT2... ELTn)"
423 :group 'speedbar
424 :type 'hook
425 :options '(speedbar-prefix-group-tag-hierarchy
426 speedbar-trim-words-tag-hierarchy
427 speedbar-simple-group-tag-hierarchy
428 speedbar-sort-tag-hierarchy)
431 (defcustom speedbar-tag-group-name-minimum-length 4
432 "The minimum length of a prefix group name before expanding.
433 Thus, if the `speedbar-tag-hierarchy-method' includes `prefix-group'
434 and one such groups common characters is less than this number of
435 characters, then the group name will be changed to the form of:
436 worda to wordb
437 instead of just
438 word
439 This way we won't get silly looking listings."
440 :group 'speedbar
441 :type 'integer)
443 (defcustom speedbar-tag-split-minimum-length 20
444 "Minimum length before we stop trying to create sub-lists in tags.
445 This is used by all tag-hierarchy methods that break large lists into
446 sub-lists."
447 :group 'speedbar
448 :type 'integer)
450 (defcustom speedbar-tag-regroup-maximum-length 10
451 "Maximum length of submenus that are regrouped.
452 If the regrouping option is used, then if two or more short subgroups
453 are next to each other, then they are combined until this number of
454 items is reached."
455 :group 'speedbar
456 :type 'integer)
458 (defcustom speedbar-directory-button-trim-method 'span
459 "Indicates how the directory button will be displayed.
460 Possible values are:
461 `span' - span large directories over multiple lines.
462 `trim' - trim large directories to only show the last few.
463 nil - no trimming."
464 :group 'speedbar
465 :type '(radio (const :tag "Span large directories over multiple lines."
466 span)
467 (const :tag "Trim large directories to only show the last few."
468 trim)
469 (const :tag "No trimming." nil)))
471 (defcustom speedbar-smart-directory-expand-flag t
472 "Non-nil means speedbar should use smart expansion.
473 Smart expansion only affects when speedbar wants to display a
474 directory for a file in the attached frame. When smart expansion is
475 enabled, new directories which are children of a displayed directory
476 are expanded in the current framework. If nil, then the current
477 hierarchy would be replaced with the new directory."
478 :group 'speedbar
479 :type 'boolean)
481 (defcustom speedbar-indentation-width 1
482 "When sub-nodes are expanded, the number of spaces used for indentation."
483 :group 'speedbar
484 :type 'integer)
486 (defcustom speedbar-hide-button-brackets-flag nil
487 "Non-nil means speedbar will hide the brackets around the + or -."
488 :group 'speedbar
489 :type 'boolean)
491 (defcustom speedbar-before-popup-hook nil
492 "Hooks called before popping up the speedbar frame."
493 :group 'speedbar
494 :type 'hook)
496 (defcustom speedbar-after-create-hook '(speedbar-frame-reposition-smartly)
497 "Hooks called after popping up the speedbar frame."
498 :group 'speedbar
499 :type 'hook)
501 (defcustom speedbar-before-delete-hook nil
502 "Hooks called before deleting the speedbar frame."
503 :group 'speedbar
504 :type 'hook)
506 (defcustom speedbar-mode-hook nil
507 "Hook run after creating a speedbar buffer."
508 :group 'speedbar
509 :type 'hook)
511 (defcustom speedbar-timer-hook nil
512 "Hooks called after running the speedbar timer function."
513 :group 'speedbar
514 :type 'hook)
516 (defcustom speedbar-verbosity-level 1
517 "Verbosity level of the speedbar.
518 0 means say nothing.
519 1 means medium level verbosity.
520 2 and higher are higher levels of verbosity."
521 :group 'speedbar
522 :type 'integer)
524 (defvar speedbar-indicator-separator " "
525 "String separating file text from indicator characters.")
527 (defcustom speedbar-vc-do-check t
528 "Non-nil check all files in speedbar to see if they have been checked out.
529 Any file checked out is marked with `speedbar-vc-indicator'."
530 :group 'speedbar-vc
531 :type 'boolean)
533 (defvar speedbar-vc-indicator "*"
534 "Text used to mark files which are currently checked out.
535 Other version control systems can be added by examining the function
536 `speedbar-vc-directory-enable-hook' and `speedbar-vc-in-control-hook'.")
538 (defcustom speedbar-vc-directory-enable-hook nil
539 "Return non-nil if the current directory should be checked for Version Control.
540 Functions in this hook must accept one parameter which is the directory
541 being checked."
542 :group 'speedbar-vc
543 :type 'hook)
545 (defcustom speedbar-vc-in-control-hook nil
546 "Return non-nil if the specified file is under Version Control.
547 Functions in this hook must accept two parameters. The DIRECTORY of the
548 current file, and the FILENAME of the file being checked."
549 :group 'speedbar-vc
550 :type 'hook)
552 (defvar speedbar-vc-to-do-point nil
553 "Local variable maintaining the current version control check position.")
555 (defcustom speedbar-obj-do-check t
556 "Non-nil check all files in speedbar to see if they have an object file.
557 Any file checked out is marked with `speedbar-obj-indicator', and the
558 marking is based on `speedbar-obj-alist'"
559 :group 'speedbar-vc
560 :type 'boolean)
562 (defvar speedbar-obj-to-do-point nil
563 "Local variable maintaining the current version control check position.")
565 (defvar speedbar-obj-indicator '("#" . "!")
566 "Text used to mark files that have a corresponding hidden object file.
567 The car is for an up-to-date object. The cdr is for an out of date object.
568 The expression `speedbar-obj-alist' defines who gets tagged.")
570 (defvar speedbar-obj-alist
571 '(("\\.\\([cpC]\\|cpp\\|cc\\|cxx\\)$" . ".o")
572 ("\\.el$" . ".elc")
573 ("\\.java$" . ".class")
574 ("\\.f\\(or\\|90\\|77\\)?$" . ".o")
575 ("\\.tex$" . ".dvi")
576 ("\\.texi$" . ".info"))
577 "Alist of file extensions, and their corresponding object file type.")
579 (defvar speedbar-ro-to-do-point nil
580 "Local variable maintaining the current read only check position.")
582 (defvar speedbar-object-read-only-indicator "%"
583 "Indicator to append onto a line if that item is Read Only.")
585 ;; Note: Look for addition place to add indicator lists that
586 ;; use skip-chars instead of a regular expression.
587 (defvar speedbar-indicator-regex
588 (concat (regexp-quote speedbar-indicator-separator)
589 "\\("
590 (regexp-quote speedbar-vc-indicator)
591 "\\|"
592 (regexp-quote (car speedbar-obj-indicator))
593 "\\|"
594 (regexp-quote (cdr speedbar-obj-indicator))
595 "\\|"
596 (regexp-quote speedbar-object-read-only-indicator)
597 "\\)*")
598 "Regular expression used when identifying files.
599 Permits stripping of indicator characters from a line.")
601 (defcustom speedbar-scanner-reset-hook nil
602 "Hook called whenever generic scanners are reset.
603 Set this to implement your own scanning / rescan safe functions with
604 state data."
605 :group 'speedbar
606 :type 'hook)
608 (defcustom speedbar-ignored-modes '(fundamental-mode)
609 "List of major modes which speedbar will not switch directories for."
610 :group 'speedbar
611 :type '(choice (const nil)
612 (repeat :tag "List of modes" (symbol :tag "Major mode"))))
614 (defun speedbar-extension-list-to-regex (extlist)
615 "Takes EXTLIST, a list of extensions and transforms it into regexp.
616 All the preceding `.' are stripped for an optimized expression starting
617 with `.' followed by extensions, followed by full-filenames."
618 (let ((regex1 nil) (regex2 nil))
619 (while extlist
620 (if (= (string-to-char (car extlist)) ?.)
621 (setq regex1 (concat regex1 (if regex1 "\\|" "")
622 (substring (car extlist) 1)))
623 (setq regex2 (concat regex2 (if regex2 "\\|" "") (car extlist))))
624 (setq extlist (cdr extlist)))
625 ;; Concatenate all the subexpressions together, making sure all types
626 ;; of parts exist during concatenation.
627 (concat "\\("
628 (if regex1 (concat "\\(\\.\\(" regex1 "\\)\\)") "")
629 (if (and regex1 regex2) "\\|" "")
630 (if regex2 (concat "\\(" regex2 "\\)") "")
631 "\\)$")))
633 (defvar speedbar-ignored-directory-regexp nil
634 "Regular expression matching directories speedbar will not switch to.
635 Created from `speedbar-ignored-directory-expressions' with the function
636 `speedbar-extension-list-to-regex' (a misnamed function in this case.)
637 Use the function `speedbar-add-ignored-directory-regexp', or customize the
638 variable `speedbar-ignored-directory-expressions' to modify this variable.")
640 (define-obsolete-variable-alias 'speedbar-ignored-path-expressions
641 'speedbar-ignored-directory-expressions "22.1")
643 (defcustom speedbar-ignored-directory-expressions
644 '("[/\\]logs?[/\\]\\'")
645 "List of regular expressions matching directories speedbar will ignore.
646 They should included directories which are notoriously very large
647 and take a long time to load in. Use the function
648 `speedbar-add-ignored-directory-regexp' to add new items to this list after
649 speedbar is loaded. You may place anything you like in this list
650 before speedbar has been loaded."
651 :group 'speedbar
652 :type '(repeat (regexp :tag "Directory Regexp"))
653 :set (lambda (_sym val)
654 (setq speedbar-ignored-directory-expressions val
655 speedbar-ignored-directory-regexp
656 (speedbar-extension-list-to-regex val))))
658 (defcustom speedbar-directory-unshown-regexp "^\\(\\..*\\)\\'"
659 "Regular expression matching directories not to show in speedbar.
660 They should include commonly existing directories which are not
661 useful. It is no longer necessary to include version-control
662 directories here; see `vc-directory-exclusion-list'."
663 :group 'speedbar
664 :type 'string)
666 (defcustom speedbar-file-unshown-regexp
667 (let ((nstr "") (noext completion-ignored-extensions))
668 (while noext
669 (setq nstr (concat nstr (regexp-quote (car noext)) "\\'"
670 (if (cdr noext) "\\|" ""))
671 noext (cdr noext)))
672 ;; backup refdir lockfile
673 (concat nstr "\\|#[^#]+#$\\|\\.\\.?\\'\\|\\.#"))
674 "Regexp matching files we don't want displayed in a speedbar buffer.
675 It is generated from the variable `completion-ignored-extensions'."
676 :group 'speedbar
677 :type 'string)
679 (defvar speedbar-file-regexp nil
680 "Regular expression matching files we know how to expand.
681 Created from `speedbar-supported-extension-expressions' with the
682 function `speedbar-extension-list-to-regex'.")
684 ;; this is dangerous to customize, because the defaults will probably
685 ;; change in the future.
686 (defcustom speedbar-supported-extension-expressions
687 (append '(".[ch]\\(\\+\\+\\|pp\\|c\\|h\\|xx\\)?" ".tex\\(i\\(nfo\\)?\\)?"
688 ".el" ".emacs" ".l" ".lsp" ".p" ".java" ".js" ".f\\(90\\|77\\|or\\)?")
689 (if speedbar-use-imenu-flag
690 '(".ad[abs]" ".p[lm]" ".tcl" ".m" ".scm" ".pm" ".py" ".g"
691 ;; html is not supported by default, but an imenu tags package
692 ;; is available. Also, html files are nice to be able to see.
693 ".s?html"
694 ".ma?k" "[Mm]akefile\\(\\.in\\)?")))
695 "List of regular expressions which will match files supported by tagging.
696 Do not prefix the `.' char with a double \\ to quote it, as the period
697 will be stripped by a simplified optimizer when compiled into a
698 singular expression. This variable will be turned into
699 `speedbar-file-regexp' for use with speedbar. You should use the
700 function `speedbar-add-supported-extension' to add a new extension at
701 runtime, or use the configuration dialog to set it in your init file.
702 If you add an extension to this list, and it does not appear, you may
703 need to also modify `completion-ignored-extension' which will also help
704 file completion."
705 :group 'speedbar
706 :type '(repeat (regexp :tag "Extension Regexp"))
707 :set (lambda (_sym val)
708 (set 'speedbar-supported-extension-expressions val)
709 (set 'speedbar-file-regexp (speedbar-extension-list-to-regex val))))
711 (setq speedbar-file-regexp
712 (speedbar-extension-list-to-regex speedbar-supported-extension-expressions))
714 (defun speedbar-add-supported-extension (extension)
715 "Add EXTENSION as a new supported extension for speedbar tagging.
716 This should start with a `.' if it is not a complete file name, and
717 the dot should NOT be quoted in with \\. Other regular expression
718 matchers are allowed however. EXTENSION may be a single string or a
719 list of strings."
720 (interactive "sExtension: ")
721 (if (not (listp extension)) (setq extension (list extension)))
722 (while extension
723 (if (member (car extension) speedbar-supported-extension-expressions)
725 (setq speedbar-supported-extension-expressions
726 (cons (car extension) speedbar-supported-extension-expressions)))
727 (setq extension (cdr extension)))
728 (setq speedbar-file-regexp (speedbar-extension-list-to-regex
729 speedbar-supported-extension-expressions)))
731 (defun speedbar-add-ignored-directory-regexp (directory-expression)
732 "Add DIRECTORY-EXPRESSION as a new ignored directory for speedbar tracking.
733 This function will modify `speedbar-ignored-directory-regexp' and add
734 DIRECTORY-EXPRESSION to `speedbar-ignored-directory-expressions'."
735 (interactive "sDirectory regex: ")
736 (if (not (listp directory-expression))
737 (setq directory-expression (list directory-expression)))
738 (while directory-expression
739 (if (member (car directory-expression) speedbar-ignored-directory-expressions)
741 (setq speedbar-ignored-directory-expressions
742 (cons (car directory-expression) speedbar-ignored-directory-expressions)))
743 (setq directory-expression (cdr directory-expression)))
744 (setq speedbar-ignored-directory-regexp (speedbar-extension-list-to-regex
745 speedbar-ignored-directory-expressions)))
747 ;; If we don't have custom, then we set it here by hand.
748 (if (not (fboundp 'custom-declare-variable))
749 (setq speedbar-file-regexp (speedbar-extension-list-to-regex
750 speedbar-supported-extension-expressions)
751 speedbar-ignored-directory-regexp (speedbar-extension-list-to-regex
752 speedbar-ignored-directory-expressions)))
754 (defcustom speedbar-update-flag dframe-have-timer-flag
755 "Non-nil means to automatically update the display.
756 When this is nil then speedbar will not follow the attached frame's directory.
757 If you want to change this while speedbar is active, either use
758 \\[customize] or call \\<speedbar-mode-map> `\\[speedbar-toggle-updates]'."
759 :group 'speedbar
760 :initialize 'custom-initialize-default
761 :set (lambda (sym val)
762 (set sym val)
763 (speedbar-toggle-updates))
764 :type 'boolean)
766 (defvar speedbar-update-flag-disable nil
767 "Permanently disable changing of the update flag.")
769 (define-obsolete-variable-alias
770 'speedbar-syntax-table 'speedbar-mode-syntax-table "24.1")
771 (defvar speedbar-mode-syntax-table
772 (let ((st (make-syntax-table)))
773 ;; Turn off paren matching around here.
774 (modify-syntax-entry ?\' " " st)
775 (modify-syntax-entry ?\" " " st)
776 (modify-syntax-entry ?\( " " st)
777 (modify-syntax-entry ?\) " " st)
778 (modify-syntax-entry ?\{ " " st)
779 (modify-syntax-entry ?\} " " st)
780 (modify-syntax-entry ?\[ " " st)
781 (modify-syntax-entry ?\] " " st)
783 "Syntax-table used on the speedbar.")
786 (define-obsolete-variable-alias 'speedbar-key-map 'speedbar-mode-map "24.1")
787 (defvar speedbar-mode-map
788 (let ((map (make-keymap)))
789 (suppress-keymap map t)
791 ;; Control.
792 (define-key map "t" 'speedbar-toggle-updates)
793 (define-key map "g" 'speedbar-refresh)
795 ;; Navigation.
796 (define-key map "n" 'speedbar-next)
797 (define-key map "p" 'speedbar-prev)
798 (define-key map "\M-n" 'speedbar-restricted-next)
799 (define-key map "\M-p" 'speedbar-restricted-prev)
800 (define-key map "\C-\M-n" 'speedbar-forward-list)
801 (define-key map "\C-\M-p" 'speedbar-backward-list)
802 ;; These commands never seemed useful.
803 ;; (define-key map " " 'speedbar-scroll-up)
804 ;; (define-key map [delete] 'speedbar-scroll-down)
806 ;; Short cuts I happen to find useful.
807 (define-key map "r"
808 (lambda () (interactive)
809 (speedbar-change-initial-expansion-list
810 speedbar-previously-used-expansion-list-name)))
811 (define-key map "b"
812 (lambda () (interactive)
813 (speedbar-change-initial-expansion-list "quick buffers")))
814 (define-key map "f"
815 (lambda () (interactive)
816 (speedbar-change-initial-expansion-list "files")))
818 (dframe-update-keymap map)
819 map)
820 "Keymap used in speedbar buffer.")
822 (defun speedbar-make-specialized-keymap ()
823 "Create a keymap for use with a speedbar major or minor display mode.
824 This basically creates a sparse keymap, and makes its parent be
825 `speedbar-mode-map'."
826 (let ((k (make-sparse-keymap)))
827 (set-keymap-parent k speedbar-mode-map)
830 (defvar speedbar-file-key-map
831 (let ((map (speedbar-make-specialized-keymap)))
833 ;; Basic tree features.
834 (define-key map "e" 'speedbar-edit-line)
835 (define-key map "\C-m" 'speedbar-edit-line)
836 (define-key map "+" 'speedbar-expand-line)
837 (define-key map "=" 'speedbar-expand-line)
838 (define-key map "-" 'speedbar-contract-line)
840 (define-key map "[" 'speedbar-expand-line-descendants)
841 (define-key map "]" 'speedbar-contract-line-descendants)
843 (define-key map " " 'speedbar-toggle-line-expansion)
845 ;; File based commands.
846 (define-key map "U" 'speedbar-up-directory)
847 (define-key map "I" 'speedbar-item-info)
848 (define-key map "B" 'speedbar-item-byte-compile)
849 (define-key map "L" 'speedbar-item-load)
850 (define-key map "C" 'speedbar-item-copy)
851 (define-key map "D" 'speedbar-item-delete)
852 (define-key map "O" 'speedbar-item-object-delete)
853 (define-key map "R" 'speedbar-item-rename)
854 (define-key map "M" 'speedbar-create-directory)
855 map)
856 "Keymap used in speedbar buffer while files are displayed.")
858 (defvar speedbar-easymenu-definition-base
859 (append
860 '("Speedbar"
861 ["Update" speedbar-refresh t]
862 ["Auto Update" speedbar-toggle-updates
863 :active (not speedbar-update-flag-disable)
864 :style toggle :selected speedbar-update-flag])
865 (if (and (or (fboundp 'defimage)
866 (fboundp 'make-image-specifier))
867 (if (fboundp 'display-graphic-p)
868 (display-graphic-p)
869 window-system))
870 (list
871 ["Use Images" speedbar-toggle-images
872 :style toggle :selected speedbar-use-images]))
874 "Base part of the speedbar menu.")
876 (defvar speedbar-easymenu-definition-special
877 '(["Edit Item On Line" speedbar-edit-line t]
878 ["Show All Files" speedbar-toggle-show-all-files
879 :style toggle :selected speedbar-show-unknown-files]
880 ["Expand File Tags" speedbar-expand-line
881 (save-excursion (beginning-of-line)
882 (looking-at "[0-9]+: *.\\+. "))]
883 ["Flush Cache & Expand" speedbar-flush-expand-line
884 (save-excursion (beginning-of-line)
885 (looking-at "[0-9]+: *.\\+. "))]
886 ["Expand All Descendants" speedbar-expand-line-descendants
887 (save-excursion (beginning-of-line)
888 (looking-at "[0-9]+: *.\\+. ")) ]
889 ["Contract File Tags" speedbar-contract-line
890 (save-excursion (beginning-of-line)
891 (looking-at "[0-9]+: *.-. "))]
892 ; ["Sort Tags" speedbar-toggle-sorting
893 ; :style toggle :selected speedbar-sort-tags]
894 "----"
895 ["File/Tag Information" speedbar-item-info t]
896 ["Load Lisp File" speedbar-item-load
897 (save-excursion
898 (beginning-of-line)
899 (looking-at "[0-9]+: *\\[[+-]\\] .+\\(\\.el\\)\\( \\|$\\)"))]
900 ["Byte Compile File" speedbar-item-byte-compile
901 (save-excursion
902 (beginning-of-line)
903 (looking-at "[0-9]+: *\\[[+-]\\] .+\\(\\.el\\)\\( \\|$\\)"))]
904 ["Copy File" speedbar-item-copy
905 (save-excursion (beginning-of-line) (looking-at "[0-9]+: *\\["))]
906 ["Rename File" speedbar-item-rename
907 (save-excursion (beginning-of-line) (looking-at "[0-9]+: *[[<]"))]
908 ["Create Directory" speedbar-create-directory
909 (save-excursion (beginning-of-line) (looking-at "[0-9]+: *[[<]"))]
910 ["Delete File" speedbar-item-delete
911 (save-excursion (beginning-of-line) (looking-at "[0-9]+: *[[<]"))]
912 ["Delete Object" speedbar-item-object-delete
913 (save-excursion (beginning-of-line)
914 (looking-at "[0-9]+: *\\[[+-]\\] [^ \n]+ \\*?[!#]$"))]
916 "Additional menu items while in file-mode.")
918 (defvar speedbar-easymenu-definition-trailer
919 (append
920 (if (and (featurep 'custom) (fboundp 'custom-declare-variable))
921 (list ["Customize..." speedbar-customize t]))
922 (list
923 ["Close" dframe-close-frame t]
924 ["Quit" delete-frame t] ))
925 "Menu items appearing at the end of the speedbar menu.")
927 (defvar speedbar-desired-buffer nil
928 "Non-nil when speedbar is showing buttons specific to a special mode.
929 In this case it is the originating buffer.")
930 (defvar speedbar-buffer nil
931 "The buffer displaying the speedbar.")
932 (defvar speedbar-frame nil
933 "The frame displaying speedbar.")
934 (defvar speedbar-cached-frame nil
935 "The frame that was last created, then removed from the display.")
936 (defvar speedbar-full-text-cache nil
937 "The last open directory is saved in its entirety for ultra-fast switching.")
939 (defvar speedbar-last-selected-file nil
940 "The last file which was selected in speedbar buffer.")
942 (defvar speedbar-shown-directories nil
943 "Maintain list of directories simultaneously open in the current speedbar.")
945 (defvar speedbar-directory-contents-alist nil
946 "An association list of directories and their contents.
947 Each sublist was returned by `speedbar-file-lists'. This list is
948 maintained to speed up the refresh rate when switching between
949 directories.")
951 (defvar speedbar-power-click nil
952 "Never set this by hand. Value is t when S-mouse activity occurs.")
955 ;;; Compatibility
957 (defalias 'speedbar-make-overlay
958 (if (featurep 'xemacs) 'make-extent 'make-overlay))
960 (defalias 'speedbar-overlay-put
961 (if (featurep 'xemacs) 'set-extent-property 'overlay-put))
963 (defalias 'speedbar-delete-overlay
964 (if (featurep 'xemacs) 'delete-extent 'delete-overlay))
966 (defalias 'speedbar-mode-line-update
967 (if (featurep 'xemacs) 'redraw-modeline 'force-mode-line-update))
969 ;;; Mode definitions/ user commands
972 ;;;###autoload
973 (defalias 'speedbar 'speedbar-frame-mode)
974 ;;;###autoload
975 (defun speedbar-frame-mode (&optional arg)
976 "Enable or disable speedbar. Positive ARG means turn on, negative turn off.
977 A nil ARG means toggle. Once the speedbar frame is activated, a buffer in
978 `speedbar-mode' will be displayed. Currently, only one speedbar is
979 supported at a time.
980 `speedbar-before-popup-hook' is called before popping up the speedbar frame.
981 `speedbar-before-delete-hook' is called before the frame is deleted."
982 (interactive "P")
983 ;; Get the buffer to play with
984 (if (not (buffer-live-p speedbar-buffer))
985 (save-excursion
986 (setq speedbar-buffer (get-buffer-create " SPEEDBAR"))
987 (set-buffer speedbar-buffer)
988 (speedbar-mode)))
989 ;; Do the frame thing
990 (dframe-frame-mode arg
991 'speedbar-frame
992 'speedbar-cached-frame
993 'speedbar-buffer
994 "Speedbar"
995 #'speedbar-frame-mode
996 (if (featurep 'xemacs)
997 (append speedbar-frame-plist
998 ;; This is a hack to get speedbar to iconify
999 ;; with the selected frame.
1000 (list 'parent (selected-frame)))
1001 speedbar-frame-parameters)
1002 'speedbar-before-delete-hook
1003 'speedbar-before-popup-hook
1004 'speedbar-after-create-hook)
1005 ;; Start up the timer
1006 (if (not speedbar-frame)
1007 (speedbar-set-timer nil)
1008 (speedbar-reconfigure-keymaps)
1009 (speedbar-update-contents)
1010 (speedbar-set-timer dframe-update-speed)
1012 ;; Frame modifications
1013 (set (make-local-variable 'dframe-delete-frame-function)
1014 'speedbar-handle-delete-frame)
1015 ;; hscroll
1016 (set (make-local-variable 'auto-hscroll-mode) nil)
1017 ;; reset the selection variable
1018 (setq speedbar-last-selected-file nil))
1020 (defun speedbar-frame-reposition-smartly ()
1021 "Reposition the speedbar frame to be next to the attached frame."
1022 (cond ((and (featurep 'xemacs)
1023 (or (member 'left speedbar-frame-plist)
1024 (member 'top speedbar-frame-plist)))
1025 (dframe-reposition-frame
1026 speedbar-frame
1027 (dframe-attached-frame speedbar-frame)
1028 (cons (car (cdr (member 'left speedbar-frame-plist)))
1029 (car (cdr (member 'top speedbar-frame-plist)))))
1031 ((and (not (featurep 'xemacs))
1032 (or (assoc 'left speedbar-frame-parameters)
1033 (assoc 'top speedbar-frame-parameters)))
1034 ;; if left/top were specified in the parameters, pass them
1035 ;; down to the reposition function
1036 (dframe-reposition-frame
1037 speedbar-frame
1038 (dframe-attached-frame speedbar-frame)
1039 (cons (cdr (assoc 'left speedbar-frame-parameters))
1040 (cdr (assoc 'top speedbar-frame-parameters))))
1043 (dframe-reposition-frame speedbar-frame
1044 (dframe-attached-frame speedbar-frame)
1045 speedbar-default-position))))
1047 (defsubst speedbar-current-frame ()
1048 "Return the frame to use for speedbar based on current context."
1049 (dframe-current-frame 'speedbar-frame 'speedbar-mode))
1051 (defun speedbar-handle-delete-frame (e)
1052 "Handle a delete frame event E.
1053 If the deleted frame is the frame speedbar is attached to,
1054 we need to delete speedbar also."
1055 (when (and speedbar-frame
1056 (eq (car (car (cdr e))) ;; frame to be deleted
1057 dframe-attached-frame))
1058 (delete-frame speedbar-frame)))
1060 ;;;###autoload
1061 (defun speedbar-get-focus ()
1062 "Change frame focus to or from the speedbar frame.
1063 If the selected frame is not speedbar, then speedbar frame is
1064 selected. If the speedbar frame is active, then select the attached frame."
1065 (interactive)
1066 (speedbar-reset-scanners)
1067 (dframe-get-focus 'speedbar-frame 'speedbar-frame-mode)
1068 (let ((speedbar-update-flag t))
1069 (speedbar-timer-fn)))
1071 (defsubst speedbar-frame-width ()
1072 "Return the width of the speedbar frame in characters.
1073 Return nil if it doesn't exist."
1074 (frame-width speedbar-frame))
1076 (define-derived-mode speedbar-mode fundamental-mode "Speedbar"
1077 "Major mode for managing a display of directories and tags.
1078 \\<speedbar-mode-map>
1079 The first line represents the default directory of the speedbar frame.
1080 Each directory segment is a button which jumps speedbar's default
1081 directory to that directory. Buttons are activated by clicking `\\[speedbar-click]'.
1082 In some situations using `\\[dframe-power-click]' is a `power click' which will
1083 rescan cached items, or pop up new frames.
1085 Each line starting with <+> represents a directory. Click on the <+>
1086 to insert the directory listing into the current tree. Click on the
1087 <-> to retract that list. Click on the directory name to go to that
1088 directory as the default.
1090 Each line starting with [+] is a file. If the variable
1091 `speedbar-show-unknown-files' is t, the lines starting with [?] are
1092 files which don't have imenu support, but are not expressly ignored.
1093 Files are completely ignored if they match `speedbar-file-unshown-regexp'
1094 which is generated from `completion-ignored-extensions'.
1096 Files with a `*' character after their name are files checked out of a
1097 version control system. (Currently only RCS is supported.) New
1098 version control systems can be added by examining the documentation
1099 for `speedbar-this-file-in-vc' and `speedbar-vc-check-dir-p'.
1101 Files with a `#' or `!' character after them are source files that
1102 have an object file associated with them. The `!' indicates that the
1103 files is out of date. You can control what source/object associations
1104 exist through the variable `speedbar-obj-alist'.
1106 Click on the [+] to display a list of tags from that file. Click on
1107 the [-] to retract the list. Click on the file name to edit the file
1108 in the attached frame.
1110 If you open tags, you might find a node starting with {+}, which is a
1111 category of tags. Click the {+} to expand the category. Jump-able
1112 tags start with >. Click the name of the tag to go to that position
1113 in the selected file.
1115 \\{speedbar-mode-map}"
1116 (save-excursion
1117 (setq font-lock-keywords nil) ;; no font-locking please
1118 (setq truncate-lines t)
1119 (make-local-variable 'frame-title-format)
1120 (setq frame-title-format (concat "Speedbar " speedbar-version)
1121 case-fold-search nil
1122 buffer-read-only t)
1123 (speedbar-set-mode-line-format)
1124 ;; Add in our dframe hooks.
1125 (if speedbar-track-mouse-flag
1126 (setq dframe-track-mouse-function #'speedbar-track-mouse))
1127 (setq dframe-help-echo-function #'speedbar-item-info
1128 dframe-mouse-click-function #'speedbar-click
1129 dframe-mouse-position-function #'speedbar-position-cursor-on-line))
1130 speedbar-buffer)
1132 (define-obsolete-function-alias 'speedbar-message 'dframe-message "24.4")
1134 (defsubst speedbar-y-or-n-p (prompt &optional deleting)
1135 "Like `y-or-n-p', but for use in the speedbar frame.
1136 Argument PROMPT is the prompt to use.
1137 Optional argument DELETING means this is a query that will delete something.
1138 The variable `speedbar-query-confirmation-method' can cause this to
1139 return true without a query."
1140 (or (and (not deleting)
1141 (eq speedbar-query-confirmation-method 'none-but-delete))
1142 (dframe-y-or-n-p prompt)))
1144 (defsubst speedbar-select-attached-frame ()
1145 "Select the frame attached to this speedbar."
1146 (dframe-select-attached-frame (speedbar-current-frame)))
1148 ;; Backwards compatibility
1149 (define-obsolete-function-alias 'speedbar-with-attached-buffer
1150 'dframe-with-attached-buffer "24.4") ; macro
1151 (define-obsolete-function-alias 'speedbar-maybee-jump-to-attached-frame
1152 'dframe-maybee-jump-to-attached-frame "24.4")
1154 (defun speedbar-set-mode-line-format ()
1155 "Set the format of the mode line based on the current speedbar environment.
1156 This gives visual indications of what is up. It EXPECTS the speedbar
1157 frame and window to be the currently active frame and window."
1158 (if (and (frame-live-p (speedbar-current-frame))
1159 (or (not (featurep 'xemacs))
1160 (with-no-warnings
1161 (specifier-instance has-modeline-p)))
1162 speedbar-buffer)
1163 (with-current-buffer speedbar-buffer
1164 (let* ((w (or (speedbar-frame-width) 20))
1165 (p1 "<<")
1166 (p5 ">>")
1167 (p3 (if speedbar-update-flag "#" "!"))
1168 (p35 (capitalize speedbar-initial-expansion-list-name))
1169 (blank (- w (length p1) (length p3) (length p5) (length p35)
1170 (if line-number-mode 5 1)))
1171 (p2 (if (> blank 0)
1172 (make-string (/ blank 2) ? )
1173 ""))
1174 (p4 (if (> blank 0)
1175 (make-string (+ (/ blank 2) (% blank 2)) ? )
1176 ""))
1178 (if line-number-mode
1179 (list (concat p1 p2 p3 " " p35) '(line-number-mode " %3l")
1180 (concat p4 p5))
1181 (list (concat p1 p2 p3 p4 p5)))))
1182 (if (not (equal mode-line-format tf))
1183 (progn
1184 (setq mode-line-format tf)
1185 (speedbar-mode-line-update)))))))
1187 (defvar speedbar-previous-menu nil
1188 "The menu before the last `speedbar-reconfigure-keymaps' was called.")
1190 (defun speedbar-reconfigure-keymaps ()
1191 "Reconfigure the menu-bar in a speedbar frame.
1192 Different menu items are displayed depending on the current display mode
1193 and the existence of packages."
1194 (let ((md (append
1195 speedbar-easymenu-definition-base
1196 (if speedbar-shown-directories
1197 ;; file display mode version
1198 (speedbar-initial-menu)
1199 (save-excursion
1200 (dframe-select-attached-frame speedbar-frame)
1201 (eval (nth 1 (assoc speedbar-initial-expansion-list-name
1202 speedbar-initial-expansion-mode-alist)))))
1203 ;; Dynamic menu stuff
1204 '("-")
1205 (list (cons "Displays"
1206 (let ((displays nil)
1207 (alist speedbar-initial-expansion-mode-alist))
1208 (while alist
1209 (setq displays
1210 (cons
1211 (vector
1212 (capitalize (car (car alist)))
1213 (list
1214 'speedbar-change-initial-expansion-list
1215 (car (car alist)))
1216 :style 'radio
1217 :selected
1218 `(string= ,(car (car alist))
1219 speedbar-initial-expansion-list-name)
1221 displays))
1222 (setq alist (cdr alist)))
1223 displays)))
1224 ;; The trailer
1225 speedbar-easymenu-definition-trailer))
1226 (localmap (save-excursion
1227 (let ((cf (selected-frame)))
1228 (prog2
1229 (dframe-select-attached-frame speedbar-frame)
1230 (if (local-variable-p
1231 'speedbar-special-mode-key-map
1232 (current-buffer))
1233 speedbar-special-mode-key-map)
1234 (select-frame cf))))))
1235 (with-current-buffer speedbar-buffer
1236 (use-local-map (or localmap
1237 (speedbar-initial-keymap)
1238 ;; This creates a small keymap we can glom the
1239 ;; menu adjustments into.
1240 (speedbar-make-specialized-keymap)))
1241 ;; Delete the old menu if applicable.
1242 (if speedbar-previous-menu (easy-menu-remove speedbar-previous-menu))
1243 (setq speedbar-previous-menu md)
1244 ;; Now add the new menu
1245 (if (not (featurep 'xemacs))
1246 (easy-menu-define speedbar-menu-map (current-local-map)
1247 "Speedbar menu" md)
1248 (easy-menu-add md (current-local-map))
1249 ;; XEmacs-specific:
1250 (if (fboundp 'set-buffer-menubar)
1251 (set-buffer-menubar (list md)))))
1253 (run-hooks 'speedbar-reconfigure-keymaps-hook)))
1256 ;;; User Input stuff
1258 (defun speedbar-customize ()
1259 "Customize speedbar using the Custom package."
1260 (interactive)
1261 (let ((sf (selected-frame)))
1262 (dframe-select-attached-frame speedbar-frame)
1263 (customize-group 'speedbar)
1264 (select-frame sf))
1265 (dframe-maybee-jump-to-attached-frame))
1267 (defun speedbar-track-mouse (event)
1268 "For motion EVENT, display info about the current line."
1269 (if (not speedbar-track-mouse-flag)
1271 (save-excursion
1272 (save-window-excursion
1273 (condition-case nil
1274 (progn
1275 (mouse-set-point event)
1276 (if (eq major-mode 'speedbar-mode)
1277 ;; XEmacs may let us get in here in other mode buffers.
1278 (speedbar-item-info)))
1279 (error (dframe-message nil)))))))
1281 (defun speedbar-show-info-under-mouse ()
1282 "Call the info function for the line under the mouse."
1283 (let ((pos (mouse-position))) ; we ignore event until I use it later.
1284 (if (equal (car pos) speedbar-frame)
1285 (save-excursion
1286 (save-window-excursion
1287 (apply 'set-mouse-position pos)
1288 (speedbar-item-info))))))
1290 (defun speedbar-next (arg)
1291 "Move to the next ARGth line in a speedbar buffer."
1292 (interactive "p")
1293 (forward-line (or arg 1))
1294 (speedbar-item-info)
1295 (speedbar-position-cursor-on-line))
1297 (defun speedbar-prev (arg)
1298 "Move to the previous ARGth line in a speedbar buffer."
1299 (interactive "p")
1300 (speedbar-next (if arg (- arg) -1)))
1302 (defun speedbar-restricted-move (arg)
1303 "Move to the next ARGth line in a speedbar buffer at the same depth.
1304 This means that movement is restricted to a subnode, and that siblings
1305 of intermediate nodes are skipped."
1306 (if (not (numberp arg)) (signal 'wrong-type-argument (list 'numberp arg)))
1307 ;; First find the extent for which we are allowed to move.
1308 (let ((depth (save-excursion (beginning-of-line)
1309 (if (looking-at "[0-9]+:")
1310 (string-to-number (match-string 0))
1311 0)))
1312 (crement (if (< arg 0) 1 -1)) ; decrement or increment
1313 (lastmatch (point)))
1314 (while (/= arg 0)
1315 (forward-line (- crement))
1316 (let ((subdepth (save-excursion (beginning-of-line)
1317 (if (looking-at "[0-9]+:")
1318 (string-to-number (match-string 0))
1319 0))))
1320 (cond ((or (< subdepth depth)
1321 (progn (end-of-line) (eobp))
1322 (progn (beginning-of-line) (bobp)))
1323 ;; We have reached the end of this block.
1324 (goto-char lastmatch)
1325 (setq arg 0)
1326 (error "End of sub-list"))
1327 ((= subdepth depth)
1328 (setq lastmatch (point)
1329 arg (+ arg crement))))))
1330 (speedbar-position-cursor-on-line)))
1332 (defun speedbar-restricted-next (arg)
1333 "Move to the next ARGth line in a speedbar buffer at the same depth.
1334 This means that movement is restricted to a subnode, and that siblings
1335 of intermediate nodes are skipped."
1336 (interactive "p")
1337 (speedbar-restricted-move (or arg 1))
1338 (speedbar-item-info))
1340 (defun speedbar-restricted-prev (arg)
1341 "Move to the previous ARGth line in a speedbar buffer at the same depth.
1342 This means that movement is restricted to a subnode, and that siblings
1343 of intermediate nodes are skipped."
1344 (interactive "p")
1345 (speedbar-restricted-move (if arg (- arg) -1))
1346 (speedbar-item-info))
1348 (defun speedbar-navigate-list (arg)
1349 "Move across ARG groups of similarly typed items in speedbar.
1350 Stop on the first line of the next type of item, or on the last or first item
1351 if we reach a buffer boundary."
1352 (interactive "p")
1353 (beginning-of-line)
1354 (if (looking-at "[0-9]+: *[[<{][-+?][]>}] ")
1355 (let ((str (regexp-quote (match-string 0))))
1356 (while (looking-at str)
1357 (speedbar-restricted-move arg)
1358 (beginning-of-line))))
1359 (speedbar-position-cursor-on-line))
1361 (defun speedbar-forward-list ()
1362 "Move forward over the current list.
1363 A LIST in speedbar is a group of similarly typed items, such as directories,
1364 files, or the directory button."
1365 (interactive)
1366 (speedbar-navigate-list 1)
1367 (speedbar-item-info))
1369 (defun speedbar-backward-list ()
1370 "Move backward over the current list.
1371 A LIST in speedbar is a group of similarly typed items, such as directories,
1372 files, or the directory button."
1373 (interactive)
1374 (speedbar-navigate-list -1)
1375 (speedbar-item-info))
1377 (defun speedbar-scroll-up (&optional arg)
1378 "Page down one screen-full of the speedbar, or ARG lines."
1379 (interactive "P")
1380 (scroll-up arg)
1381 (speedbar-position-cursor-on-line))
1383 (defun speedbar-scroll-down (&optional arg)
1384 "Page up one screen-full of the speedbar, or ARG lines."
1385 (interactive "P")
1386 (scroll-down arg)
1387 (speedbar-position-cursor-on-line))
1389 (defun speedbar-up-directory ()
1390 "Keyboard accelerator for moving the default directory up one.
1391 Assumes that the current buffer is the speedbar buffer."
1392 (interactive)
1393 (setq default-directory (expand-file-name (concat default-directory "../")))
1394 (speedbar-update-contents))
1396 ;;; Speedbar file activity (aka creeping featurism)
1398 (defun speedbar-refresh (&optional arg)
1399 "Refresh the current speedbar display, disposing of any cached data.
1400 Argument ARG represents to force a refresh past any caches that may exist."
1401 (interactive "P")
1402 (let ((dl speedbar-shown-directories)
1403 (dframe-power-click arg)
1404 deactivate-mark)
1405 ;; We need to hack something so this works in detached frames.
1406 (dolist (d dl)
1407 (setq speedbar-directory-contents-alist
1408 (delq (assoc d speedbar-directory-contents-alist)
1409 speedbar-directory-contents-alist)))
1410 (if (<= 1 speedbar-verbosity-level)
1411 (dframe-message "Refreshing speedbar..."))
1412 (speedbar-update-contents)
1413 (speedbar-stealthy-updates)
1414 ;; Reset the timer in case it got really hosed for some reason...
1415 (speedbar-set-timer dframe-update-speed)
1416 (if (<= 1 speedbar-verbosity-level)
1417 (dframe-message "Refreshing speedbar...done"))))
1419 (defun speedbar-item-load ()
1420 "Load the item under the cursor or mouse if it is a Lisp file."
1421 (interactive)
1422 (let ((f (speedbar-line-file)))
1423 (if (and (file-exists-p f) (string-match "\\.el\\'" f))
1424 (if (and (file-exists-p (concat f "c"))
1425 (speedbar-y-or-n-p (format "Load %sc? " f)))
1426 ;; If the compiled version exists, load that instead...
1427 (load-file (concat f "c"))
1428 (load-file f))
1429 (error "Not a loadable file"))))
1431 (defun speedbar-item-byte-compile ()
1432 "Byte compile the item under the cursor or mouse if it is a Lisp file."
1433 (interactive)
1434 (let ((f (speedbar-line-file))
1435 (sf (selected-frame)))
1436 (if (and (file-exists-p f) (string-match "\\.el\\'" f))
1437 (progn
1438 (dframe-select-attached-frame speedbar-frame)
1439 (byte-compile-file f nil)
1440 (select-frame sf)
1441 (speedbar-reset-scanners)))
1444 (defun speedbar-mouse-item-info (event)
1445 "Provide information about what the user clicked on.
1446 This should be bound to a mouse EVENT."
1447 (interactive "e")
1448 (mouse-set-point event)
1449 (speedbar-item-info))
1451 (defun speedbar-generic-item-info ()
1452 "Attempt to derive, and then display information about this line item.
1453 File style information is displayed with `speedbar-item-info'."
1454 (save-excursion
1455 (beginning-of-line)
1456 ;; Skip invisible number info.
1457 (if (looking-at "\\([0-9]+\\):") (goto-char (match-end 0)))
1458 ;; Skip items in "folder" type text characters.
1459 (if (looking-at "\\s-*[[<({].[]>)}] ") (goto-char (match-end 0)))
1460 ;; Get the text
1461 (dframe-message "Text: %s" (buffer-substring-no-properties
1462 (point) (line-end-position)))))
1464 (defun speedbar-item-info ()
1465 "Display info in the minibuffer about the button the mouse is over.
1466 This function can be replaced in `speedbar-mode-functions-list' as
1467 `speedbar-item-info'."
1468 (interactive)
1469 (let (message-log-max)
1470 (funcall (or (speedbar-fetch-replacement-function 'speedbar-item-info)
1471 'speedbar-generic-item-info))))
1473 (defun speedbar-item-info-file-helper (&optional filename)
1474 "Display info about a file that is on the current line.
1475 Return nil if not applicable. If FILENAME, then use that
1476 instead of reading it from the speedbar buffer."
1477 (let* ((item (or filename (speedbar-line-file)))
1478 (attr (if item (file-attributes item) nil)))
1479 (if (and item attr) (dframe-message "%s %-6d %s" (nth 8 attr)
1480 (nth 7 attr) item)
1481 nil)))
1483 (defun speedbar-item-info-tag-helper ()
1484 "Display info about a tag that is on the current line.
1485 Return nil if not applicable."
1486 (save-excursion
1487 (beginning-of-line)
1488 (if (re-search-forward " [-+=]?> \\([^\n]+\\)" (line-end-position) t)
1489 (let* ((tag (match-string 1))
1490 (attr (speedbar-line-token))
1491 (item nil)
1492 (semantic-tagged (if (fboundp 'semantic-tag-p)
1493 (semantic-tag-p attr))))
1494 (if semantic-tagged
1495 (with-no-warnings
1496 (save-excursion
1497 (when (and (semantic-tag-overlay attr)
1498 (semantic-tag-buffer attr))
1499 (set-buffer (semantic-tag-buffer attr)))
1500 (dframe-message
1501 (funcall semantic-sb-info-format-tag-function attr)
1503 (looking-at "\\([0-9]+\\):")
1504 (setq item (file-name-nondirectory (speedbar-line-directory)))
1505 (dframe-message "Tag: %s in %s" tag item)))
1506 (if (re-search-forward "{[+-]} \\([^\n]+\\)$" (line-end-position) t)
1507 (dframe-message "Group of tags \"%s\"" (match-string 1))
1508 (if (re-search-forward " [+-]?[()|@] \\([^\n]+\\)$" nil t)
1509 (let* ((detailtext (match-string 1))
1510 (detail (or (speedbar-line-token) detailtext))
1511 (parent (save-excursion
1512 (beginning-of-line)
1513 (let ((dep (if (looking-at "[0-9]+:")
1514 (1- (string-to-number (match-string 0)))
1515 0)))
1516 (re-search-backward (concat "^"
1517 (int-to-string dep)
1518 ":")
1519 nil t))
1520 (if (looking-at "[0-9]+: +[-+=>]> \\([^\n]+\\)$")
1521 (speedbar-line-token)
1522 nil))))
1523 (if (featurep 'semantic)
1524 (with-no-warnings
1525 (if (semantic-tag-p detail)
1526 (dframe-message
1527 (funcall semantic-sb-info-format-tag-function detail parent))
1528 (if parent
1529 (dframe-message "Detail: %s of tag %s" detail
1530 (if (semantic-tag-p parent)
1531 (semantic-format-tag-name parent nil t)
1532 parent))
1533 (dframe-message "Detail: %s" detail))))
1534 ;; Not using `semantic':
1535 (if parent
1536 (dframe-message "Detail: %s of tag %s" detail parent)
1537 (dframe-message "Detail: %s" detail))))
1538 nil)))))
1540 (defun speedbar-files-item-info ()
1541 "Display info in the minibuffer about the button the mouse is over."
1542 (if (not speedbar-shown-directories)
1543 (speedbar-generic-item-info)
1544 (or (speedbar-item-info-file-helper)
1545 (speedbar-item-info-tag-helper)
1546 (speedbar-generic-item-info))))
1548 (defun speedbar-item-copy ()
1549 "Copy the item under the cursor.
1550 Files can be copied to new names or places."
1551 (interactive)
1552 (let ((f (speedbar-line-file)))
1553 (if (not f) (error "Not a file"))
1554 (if (file-directory-p f)
1555 (error "Cannot copy directory")
1556 (let* ((rt (read-file-name (format "Copy %s to: "
1557 (file-name-nondirectory f))
1558 (file-name-directory f)))
1559 (refresh (member (expand-file-name (file-name-directory rt))
1560 speedbar-shown-directories)))
1561 ;; Create the right file name part
1562 (if (file-directory-p rt)
1563 (setq rt
1564 (concat (expand-file-name rt)
1565 (if (string-match "[/\\]$" rt) "" "/")
1566 (file-name-nondirectory f))))
1567 (if (or (not (file-exists-p rt))
1568 (speedbar-y-or-n-p (format "Overwrite %s with %s? " rt f)
1570 (progn
1571 (copy-file f rt t t)
1572 ;; refresh display if the new place is currently displayed.
1573 (if refresh
1574 (progn
1575 (speedbar-refresh)
1576 (if (not (speedbar-goto-this-file rt))
1577 (speedbar-goto-this-file f))))
1578 ))))))
1580 (defun speedbar-item-rename ()
1581 "Rename the item under the cursor or mouse.
1582 Files can be renamed to new names or moved to new directories."
1583 (interactive)
1584 (let ((f (speedbar-line-file)))
1585 (if f
1586 (let* ((rt (read-file-name (format "Rename %s to: "
1587 (file-name-nondirectory f))
1588 (file-name-directory f)))
1589 (refresh (member (expand-file-name (file-name-directory rt))
1590 speedbar-shown-directories)))
1591 ;; Create the right file name part
1592 (if (file-directory-p rt)
1593 (setq rt
1594 (concat (expand-file-name rt)
1595 (if (string-match "[/\\]\\'" rt) "" "/")
1596 (file-name-nondirectory f))))
1597 (if (or (not (file-exists-p rt))
1598 (speedbar-y-or-n-p (format "Overwrite %s with %s? " rt f)
1600 (progn
1601 (rename-file f rt t)
1602 ;; refresh display if the new place is currently displayed.
1603 (if refresh
1604 (progn
1605 (speedbar-refresh)
1606 (speedbar-goto-this-file rt)
1607 )))))
1608 (error "Not a file"))))
1610 (defun speedbar-create-directory ()
1611 "Create a directory in speedbar."
1612 (interactive)
1613 (let ((f (speedbar-line-file)))
1614 (if f
1615 (let* ((basedir (file-name-directory f))
1616 (nd (read-directory-name "Create directory: "
1617 basedir)))
1618 ;; Make the directory
1619 (make-directory nd t)
1620 (speedbar-refresh)
1621 (speedbar-goto-this-file nd)
1623 (error "Not a file"))))
1625 (defun speedbar-item-delete ()
1626 "Delete the item under the cursor. Files are removed from disk."
1627 (interactive)
1628 (let ((f (speedbar-line-file)))
1629 (if (not f) (error "Not a file"))
1630 (if (speedbar-y-or-n-p (format "Delete %s? " f) t)
1631 (progn
1632 (if (file-directory-p f)
1633 (delete-directory f t t)
1634 (delete-file f t))
1635 (dframe-message "Okie dokie.")
1636 (let ((p (point)))
1637 (speedbar-refresh)
1638 (goto-char p))
1642 (defun speedbar-item-object-delete ()
1643 "Delete the object associated from the item under the cursor.
1644 The file is removed from disk. The object is determined from the
1645 variable `speedbar-obj-alist'."
1646 (interactive)
1647 (let* ((f (speedbar-line-file))
1648 (obj nil)
1649 (oa speedbar-obj-alist))
1650 (if (not f) (error "Not a file"))
1651 (while (and oa (not (string-match (car (car oa)) f)))
1652 (setq oa (cdr oa)))
1653 (setq obj (concat (file-name-sans-extension f) (cdr (car oa))))
1654 (if (and oa (file-exists-p obj)
1655 (speedbar-y-or-n-p (format "Delete %s? " obj) t))
1656 (progn
1657 (delete-file obj)
1658 (speedbar-reset-scanners)))))
1660 (defun speedbar-enable-update ()
1661 "Enable automatic updating in speedbar via timers."
1662 (interactive)
1663 (setq speedbar-update-flag t)
1664 (speedbar-set-mode-line-format)
1665 (speedbar-set-timer dframe-update-speed))
1667 (defun speedbar-disable-update ()
1668 "Disable automatic updating and stop consuming resources."
1669 (interactive)
1670 (setq speedbar-update-flag nil)
1671 (speedbar-set-mode-line-format)
1672 (speedbar-set-timer nil))
1674 (defun speedbar-toggle-updates ()
1675 "Toggle automatic update for the speedbar frame."
1676 (interactive)
1677 (if speedbar-update-flag
1678 (speedbar-disable-update)
1679 (speedbar-enable-update)))
1681 (defun speedbar-toggle-images ()
1682 "Toggle use of images in the speedbar frame."
1683 (interactive)
1684 (setq speedbar-use-images (not speedbar-use-images))
1685 (speedbar-refresh))
1687 (defun speedbar-toggle-sorting ()
1688 "Toggle tag sorting."
1689 (interactive)
1690 (setq speedbar-sort-tags (not speedbar-sort-tags)))
1692 (defun speedbar-toggle-show-all-files ()
1693 "Toggle display of files speedbar can not tag."
1694 (interactive)
1695 (setq speedbar-show-unknown-files (not speedbar-show-unknown-files))
1696 (speedbar-refresh))
1698 (defmacro speedbar-with-writable (&rest forms)
1699 "Allow the buffer to be writable and evaluate FORMS."
1700 (declare (indent 0))
1701 `(let ((inhibit-read-only t))
1702 ,@forms))
1704 (defun speedbar-insert-button (text face mouse function
1705 &optional token prevline)
1706 "Insert TEXT as the next logical speedbar button.
1707 FACE is the face to put on the button, MOUSE is the highlight face to use.
1708 When the user clicks on TEXT, FUNCTION is called with the TOKEN parameter.
1709 This function assumes that the current buffer is the speedbar buffer.
1710 If PREVLINE, then put this button on the previous line.
1712 This is a convenience function for special modes that create their own
1713 specialized speedbar displays."
1714 (goto-char (point-max))
1715 (let ((start (point)))
1716 (if (/= (current-column) 0) (insert "\n"))
1717 (put-text-property start (point) 'invisible nil))
1718 (if prevline (progn (delete-char -1)
1719 (insert " ") ;back up if desired...
1720 (put-text-property (1- (point)) (point) 'invisible nil)))
1721 (let ((start (point)))
1722 (insert text)
1723 (speedbar-make-button start (point) face mouse function token))
1724 (let ((start (point)))
1725 (insert "\n")
1726 (add-text-properties
1727 start (point) '(face nil invisible nil mouse-face nil))))
1729 (defun speedbar-insert-separator (text)
1730 "Insert a separation label of TEXT.
1731 Separators are not active, have no labels, depth, or actions."
1732 (if speedbar-use-images
1733 (let ((start (point)))
1734 (insert "//")
1735 (speedbar-insert-image-button-maybe start 2)))
1736 (let ((start (point)))
1737 (insert text "\n")
1738 (speedbar-make-button start (point)
1739 'speedbar-separator-face
1740 nil nil nil)))
1742 (defun speedbar-make-button (start end face mouse function &optional token)
1743 "Create a button from START to END, with FACE as the display face.
1744 MOUSE is the mouse face. When this button is clicked on FUNCTION
1745 will be run with the TOKEN parameter (any Lisp object). If FACE
1746 is t use the text properties of the string that is passed as an
1747 argument."
1748 (unless (eq face t)
1749 (put-text-property start end 'face face))
1750 (add-text-properties
1751 start end `(mouse-face ,mouse invisible nil
1752 speedbar-text ,(buffer-substring-no-properties start end)))
1753 (if speedbar-use-tool-tips-flag
1754 (put-text-property start end 'help-echo #'dframe-help-echo))
1755 (if function (put-text-property start end 'speedbar-function function))
1756 (if token (put-text-property start end 'speedbar-token token))
1757 ;; So far the only text we have is less that 3 chars.
1758 (if (<= (- end start) 3)
1759 (speedbar-insert-image-button-maybe start (- end start)))
1762 ;;; Initial Expansion list management
1764 (defun speedbar-initial-expansion-list ()
1765 "Return the current default expansion list.
1766 This is based on `speedbar-initial-expansion-list-name' referencing
1767 `speedbar-initial-expansion-mode-alist'."
1768 ;; cdr1 - name, cdr2 - menu
1769 (cdr (cdr (cdr (assoc speedbar-initial-expansion-list-name
1770 speedbar-initial-expansion-mode-alist)))))
1772 (defun speedbar-initial-menu ()
1773 "Return the current default menu data.
1774 This is based on `speedbar-initial-expansion-list-name' referencing
1775 `speedbar-initial-expansion-mode-alist'."
1776 (symbol-value
1777 (car (cdr (assoc speedbar-initial-expansion-list-name
1778 speedbar-initial-expansion-mode-alist)))))
1780 (defun speedbar-initial-keymap ()
1781 "Return the current default menu data.
1782 This is based on `speedbar-initial-expansion-list-name' referencing
1783 `speedbar-initial-expansion-mode-alist'."
1784 (symbol-value
1785 (car (cdr (cdr (assoc speedbar-initial-expansion-list-name
1786 speedbar-initial-expansion-mode-alist))))))
1788 (defun speedbar-initial-stealthy-functions ()
1789 "Return a list of functions to call stealthily.
1790 This is based on `speedbar-initial-expansion-list-name' referencing
1791 `speedbar-stealthy-function-list'."
1792 (cdr (assoc speedbar-initial-expansion-list-name
1793 speedbar-stealthy-function-list)))
1795 (defun speedbar-add-expansion-list (new-list)
1796 "Add NEW-LIST to the list of expansion lists."
1797 (add-to-list 'speedbar-initial-expansion-mode-alist new-list))
1799 (defun speedbar-change-initial-expansion-list (new-default)
1800 "Change speedbar's default expansion list to NEW-DEFAULT."
1801 (interactive
1802 (list
1803 (completing-read (format "Speedbar Mode (default %s): "
1804 speedbar-previously-used-expansion-list-name)
1805 speedbar-initial-expansion-mode-alist
1806 nil t "" nil
1807 speedbar-previously-used-expansion-list-name)))
1808 (setq speedbar-previously-used-expansion-list-name
1809 speedbar-initial-expansion-list-name
1810 speedbar-initial-expansion-list-name new-default)
1811 (if (and (speedbar-current-frame) (frame-live-p (speedbar-current-frame)))
1812 (progn
1813 (speedbar-refresh)
1814 (speedbar-reconfigure-keymaps))))
1816 (defun speedbar-fetch-replacement-function (function)
1817 "Return a current mode-specific replacement for function, or nil.
1818 Scans `speedbar-mode-functions-list' first for the current mode, then
1819 for FUNCTION."
1820 (cdr (assoc function
1821 (cdr (assoc speedbar-initial-expansion-list-name
1822 speedbar-mode-functions-list)))))
1824 (defun speedbar-add-mode-functions-list (new-list)
1825 "Add NEW-LIST to the list of mode functions.
1826 See `speedbar-mode-functions-list' for details."
1827 (add-to-list 'speedbar-mode-functions-list new-list))
1830 ;;; Special speedbar display management
1832 (defun speedbar-maybe-add-localized-support (buffer)
1833 "Quick check function called on BUFFERs by the speedbar timer function.
1834 Maintains the value of local variables which control speedbar's use
1835 of the special mode functions."
1836 (or speedbar-special-mode-expansion-list
1837 (speedbar-add-localized-speedbar-support buffer)))
1839 (defun speedbar-add-localized-speedbar-support (buffer)
1840 "Add localized speedbar support to BUFFER's mode if it is available."
1841 (interactive "bBuffer: ")
1842 (if (stringp buffer) (setq buffer (get-buffer buffer)))
1843 (if (not (buffer-live-p buffer))
1845 (with-current-buffer buffer
1846 (save-match-data
1847 (let ((ms (symbol-name major-mode)) v)
1848 (if (not (string-match "-mode$" ms))
1849 nil ;; do nothing to broken mode
1850 (setq ms (substring ms 0 (match-beginning 0)))
1851 (setq v (intern-soft (concat ms "-speedbar-buttons")))
1852 (make-local-variable 'speedbar-special-mode-expansion-list)
1853 (if (not v)
1854 (setq speedbar-special-mode-expansion-list t)
1855 ;; If it is autoloaded, we need to load it now so that
1856 ;; we have access to the variable -speedbar-menu-items.
1857 ;; Is this XEmacs safe?
1858 (autoload-do-load (symbol-function v) v)
1859 (setq speedbar-special-mode-expansion-list (list v))
1860 (setq v (intern-soft (concat ms "-speedbar-key-map")))
1861 (if (not v)
1862 nil ;; don't add special keymap
1863 (make-local-variable 'speedbar-special-mode-key-map)
1864 (setq speedbar-special-mode-key-map
1865 (symbol-value v)))
1866 (setq v (intern-soft (concat ms "-speedbar-menu-items")))
1867 (if (not v)
1868 nil ;; don't add special menus
1869 (make-local-variable 'speedbar-easymenu-definition-special)
1870 (setq speedbar-easymenu-definition-special
1871 (symbol-value v)))
1872 )))))))
1874 (defun speedbar-remove-localized-speedbar-support (buffer)
1875 "Remove any traces that BUFFER supports speedbar in a specialized way."
1876 (with-current-buffer buffer
1877 (kill-local-variable 'speedbar-special-mode-expansion-list)
1878 (kill-local-variable 'speedbar-special-mode-key-map)
1879 (kill-local-variable 'speedbar-easymenu-definition-special)))
1881 ;;; File button management
1883 (defun speedbar-file-lists (directory)
1884 "Create file lists for DIRECTORY.
1885 The car is the list of directories, the cdr is list of files not
1886 matching ignored headers. Cache any directory files found in
1887 `speedbar-directory-contents-alist' and use that cache before scanning
1888 the file-system."
1889 (setq directory (expand-file-name directory))
1890 ;; find the directory, either in the cache, or build it.
1891 (or (and (not dframe-power-click) ;; In powerclick mode, always rescan.
1892 (cdr-safe (assoc directory speedbar-directory-contents-alist)))
1893 (let ((default-directory directory)
1894 (dir (directory-files directory nil))
1895 (dirs nil)
1896 (files nil))
1897 (while dir
1898 (if (not
1899 (or (string-match speedbar-file-unshown-regexp (car dir))
1900 (member (car dir) vc-directory-exclusion-list)
1901 (string-match speedbar-directory-unshown-regexp (car dir))))
1902 (if (file-directory-p (car dir))
1903 (setq dirs (cons (car dir) dirs))
1904 (setq files (cons (car dir) files))))
1905 (setq dir (cdr dir)))
1906 (let ((nl (cons (nreverse dirs) (list (nreverse files))))
1907 (ae (assoc directory speedbar-directory-contents-alist)))
1908 (if ae (setcdr ae nl)
1909 (push (cons directory nl)
1910 speedbar-directory-contents-alist))
1911 nl))
1914 (defun speedbar-directory-buttons (directory _index)
1915 "Insert a single button group at point for DIRECTORY.
1916 Each directory part is a different button. If part of the directory
1917 matches the user directory ~, then it is replaced with a ~.
1918 INDEX is not used, but is required by the caller."
1919 (let* ((tilde (expand-file-name "~/"))
1920 (dd (expand-file-name directory))
1921 (junk (string-match (regexp-quote tilde) dd))
1922 (displayme (if junk
1923 (concat "~/" (substring dd (match-end 0)))
1924 dd))
1925 (p (point)))
1926 (if (string-match "^~[/\\]?\\'" displayme) (setq displayme tilde))
1927 (insert displayme)
1928 (save-excursion
1929 (goto-char p)
1930 (while (re-search-forward "\\([^/\\]+\\)[/\\]" nil t)
1931 (speedbar-make-button (match-beginning 1) (match-end 1)
1932 'speedbar-directory-face
1933 'speedbar-highlight-face
1934 'speedbar-directory-buttons-follow
1935 (if (and (= (match-beginning 1) p)
1936 (not (char-equal (char-after (+ p 1)) ?:)))
1937 (expand-file-name "~/") ;the tilde
1938 (buffer-substring-no-properties
1939 p (match-end 0)))))
1940 ;; Nuke the beginning of the directory if it's too long...
1941 (cond ((eq speedbar-directory-button-trim-method 'span)
1942 (beginning-of-line)
1943 (let ((ww (or (speedbar-frame-width) 20)))
1944 (move-to-column ww nil)
1945 (while (>= (current-column) ww)
1946 (re-search-backward "[/\\]" nil t)
1947 (if (<= (current-column) 2)
1948 (progn
1949 (re-search-forward "[/\\]" nil t)
1950 (if (< (current-column) 4)
1951 (re-search-forward "[/\\]" nil t))
1952 (forward-char -1)))
1953 (if (looking-at "[/\\]?$")
1954 (beginning-of-line)
1955 (insert "/...\n ")
1956 (move-to-column ww nil)))))
1957 ((eq speedbar-directory-button-trim-method 'trim)
1958 (end-of-line)
1959 (let ((ww (or (speedbar-frame-width) 20))
1960 (tl (current-column)))
1961 (if (< ww tl)
1962 (progn
1963 (move-to-column (- tl ww))
1964 (if (re-search-backward "[/\\]" nil t)
1965 (progn
1966 (delete-region (point-min) (point))
1967 (insert "$")
1968 )))))))
1970 (if (string-match "\\`[/\\][^/\\]+[/\\]\\'" displayme)
1971 (progn
1972 (insert " ")
1973 (let ((p (point)))
1974 (insert "<root>")
1975 (speedbar-make-button p (point)
1976 'speedbar-directory-face
1977 'speedbar-highlight-face
1978 'speedbar-directory-buttons-follow
1979 "/"))))
1980 (end-of-line)
1981 (insert-char ?\n 1 nil)))
1983 (defun speedbar-make-tag-line (exp-button-type
1984 exp-button-char exp-button-function
1985 exp-button-data
1986 tag-button tag-button-function tag-button-data
1987 tag-button-face depth)
1988 "Create a tag line with EXP-BUTTON-TYPE for the small expansion button.
1989 This is the button that expands or contracts a node (if applicable),
1990 and EXP-BUTTON-CHAR the character in it (+, -, ?, etc). EXP-BUTTON-FUNCTION
1991 is the function to call if it's clicked on. Button types are
1992 `bracket', `angle', `curly', `expandtag', `statictag', t, or nil.
1993 EXP-BUTTON-DATA is extra data attached to the text forming the expansion
1994 button.
1996 Next, TAG-BUTTON is the text of the tag. TAG-BUTTON-FUNCTION is the
1997 function to call if clicked on, and TAG-BUTTON-DATA is the data to
1998 attach to the text field (such a tag positioning, etc).
1999 TAG-BUTTON-FACE is a face used for this type of tag.
2001 Lastly, DEPTH shows the depth of expansion.
2003 This function assumes that the cursor is in the speedbar window at the
2004 position to insert a new item, and that the new item will end with a CR."
2005 (let ((start (point))
2006 (end (progn
2007 (insert (int-to-string depth) ":")
2008 (point)))
2009 (depthspacesize (* depth speedbar-indentation-width)))
2010 (put-text-property start end 'invisible t)
2011 (insert-char ? depthspacesize nil)
2012 (put-text-property (- (point) depthspacesize) (point) 'invisible nil)
2013 (let* ((exp-button (cond ((eq exp-button-type 'bracket) "[%c]")
2014 ((eq exp-button-type 'angle) "<%c>")
2015 ((eq exp-button-type 'curly) "{%c}")
2016 ((eq exp-button-type 'expandtag) " %c>")
2017 ((eq exp-button-type 'statictag) " =>")
2018 (t ">")))
2019 (buttxt (format exp-button exp-button-char))
2020 (start (point))
2021 (end (progn (insert buttxt) (point)))
2022 (bf (if (and exp-button-type (not (eq exp-button-type 'statictag)))
2023 'speedbar-button-face nil))
2024 (mf (if exp-button-function 'speedbar-highlight-face nil))
2026 (speedbar-make-button start end bf mf exp-button-function exp-button-data)
2027 (if speedbar-hide-button-brackets-flag
2028 (progn
2029 (put-text-property start (1+ start) 'invisible t)
2030 (put-text-property end (1- end) 'invisible t)))
2032 (insert-char ? 1 nil)
2033 (put-text-property (1- (point)) (point) 'invisible nil)
2034 (let ((start (point))
2035 (end (progn (insert tag-button) (point))))
2036 (insert-char ?\n 1 nil)
2037 (put-text-property (1- (point)) (point) 'invisible nil)
2038 (speedbar-make-button start end tag-button-face
2039 (if tag-button-function 'speedbar-highlight-face nil)
2040 tag-button-function tag-button-data))
2043 (defun speedbar-change-expand-button-char (char)
2044 "Change the expansion button character to CHAR for the current line."
2045 (save-excursion
2046 (beginning-of-line)
2047 (if (re-search-forward ":\\s-*.\\([-+?]\\)" (line-end-position) t)
2048 (speedbar-with-writable
2049 (goto-char (match-end 1))
2050 (insert-char char 1 t)
2051 (forward-char -1)
2052 (delete-char -1)
2053 ;;(put-text-property (point) (1- (point)) 'invisible nil)
2054 ;; make sure we fix the image on the text here.
2055 (speedbar-insert-image-button-maybe (- (point) 1) 3)))))
2058 ;;; Build button lists
2060 (defun speedbar-insert-files-at-point (files level)
2061 "Insert list of FILES starting at point, and indenting all files to LEVEL.
2062 Tag expandable items with a +, otherwise a ?. Don't highlight ? as we
2063 don't know how to manage them. The input parameter FILES is a cons
2064 cell of the form (DIRLIST . FILELIST)."
2065 ;; Start inserting all the directories
2066 (let ((dirs (car files)))
2067 (while dirs
2068 (speedbar-make-tag-line 'angle ?+ 'speedbar-dired (car dirs)
2069 (car dirs) 'speedbar-dir-follow nil
2070 'speedbar-directory-face level)
2071 (setq dirs (cdr dirs))))
2072 (let ((lst (car (cdr files)))
2073 (case-fold-search t))
2074 (while lst
2075 (let* ((known (string-match speedbar-file-regexp (car lst)))
2076 (expchar (if known ?+ ??))
2077 (fn (if known 'speedbar-tag-file nil)))
2078 (if (or speedbar-show-unknown-files (/= expchar ??))
2079 (speedbar-make-tag-line 'bracket expchar fn (car lst)
2080 (car lst) 'speedbar-find-file nil
2081 'speedbar-file-face level)))
2082 (setq lst (cdr lst)))))
2084 (defun speedbar-default-directory-list (directory index)
2085 "Insert files for DIRECTORY with level INDEX at point."
2086 (speedbar-insert-files-at-point
2087 (speedbar-file-lists directory) index)
2088 (speedbar-reset-scanners)
2089 (if (= index 0)
2090 ;; If the shown files variable has extra directories, then
2091 ;; it is our responsibility to redraw them all
2092 ;; Luckily, the nature of inserting items into this list means
2093 ;; that by reversing it, we can easily go in the right order
2094 (let ((sf (cdr (reverse speedbar-shown-directories))))
2095 (setq speedbar-shown-directories
2096 (list (expand-file-name default-directory)))
2097 ;; Expand them all as we find them.
2098 (while sf
2099 (if (speedbar-goto-this-file (car sf))
2100 (progn
2101 (beginning-of-line)
2102 (if (looking-at "[0-9]+:[ ]*<")
2103 (progn
2104 (goto-char (match-end 0))
2105 (speedbar-do-function-pointer)))))
2106 (setq sf (cdr sf)))
2108 ;;; Generic List support
2110 ;; Generic lists are hierarchies of tags which we may need to permute
2111 ;; in order to make it look nice.
2113 ;; A generic list is of the form:
2114 ;; ( ("name" . marker-or-number) <-- one tag at this level
2115 ;; ("name" marker-or-number goto-fun . args) <-- one tag at this level
2116 ;; ("name" ("name" . mon) ("name" . mon) ) <-- one group of tags
2117 ;; ("name" mon ("name" . mon) ) <-- group w/ a position and tags
2118 (defun speedbar-generic-list-group-p (sublst)
2119 "Non-nil if SUBLST is a group.
2120 Groups may optionally contain a position."
2121 (and (stringp (car-safe sublst))
2122 (or (and (listp (cdr-safe sublst))
2123 (or (speedbar-generic-list-tag-p (car-safe (cdr-safe sublst)))
2124 (speedbar-generic-list-group-p (car-safe (cdr-safe sublst))
2126 (and (number-or-marker-p (car-safe (cdr-safe sublst)))
2127 (listp (cdr-safe (cdr-safe sublst)))
2128 (speedbar-generic-list-tag-p
2129 (car-safe (cdr-safe (cdr-safe sublst)))))
2132 (defun speedbar-generic-list-positioned-group-p (sublst)
2133 "Non-nil if SUBLST is a group with a position."
2134 (and (stringp (car-safe sublst))
2135 (number-or-marker-p (car-safe (cdr-safe sublst)))
2136 (listp (cdr-safe (cdr-safe sublst)))
2137 (let ((rest (car-safe (cdr-safe (cdr-safe sublst)))))
2138 (or (speedbar-generic-list-tag-p rest)
2139 (speedbar-generic-list-group-p rest)
2140 (speedbar-generic-list-positioned-group-p rest)
2141 ))))
2143 (defun speedbar-generic-list-tag-p (sublst)
2144 "Non-nil if SUBLST is a tag."
2145 (and (stringp (car-safe sublst))
2146 (or (and (number-or-marker-p (cdr-safe sublst))
2147 (not (cdr-safe (cdr-safe sublst))))
2148 (ignore-errors (and (number-or-marker-p (nth 1 sublst))
2149 (functionp (nth 2 sublst))))
2150 ;; For semantic/bovine items, this is needed
2151 (symbolp (car-safe (cdr-safe sublst))))
2154 (defun speedbar-sort-tag-hierarchy (lst)
2155 "Sort all elements of tag hierarchy LST."
2156 (sort (copy-alist lst)
2157 (lambda (a b) (string< (car a) (car b)))))
2159 (defun speedbar-try-completion (string alist)
2160 "A wrapper for `try-completion'.
2161 Passes STRING and ALIST to `try-completion' if ALIST
2162 passes some tests."
2163 (if (and (consp alist)
2164 (listp (car alist)) (stringp (car (car alist))))
2165 (try-completion string alist)
2166 nil))
2168 (defun speedbar-prefix-group-tag-hierarchy (lst)
2169 "Prefix group names for tag hierarchy LST."
2170 (let ((newlst nil)
2171 (sublst nil)
2172 (work-list nil)
2173 (junk-list nil)
2174 (short-group-list nil)
2175 (short-start-name nil)
2176 (short-end-name nil)
2177 (num-shorts-grouped 0)
2178 (bins (make-vector 256 nil))
2179 (diff-idx 0))
2180 (if (<= (length lst) speedbar-tag-regroup-maximum-length)
2181 ;; Do nothing. Too short to bother with.
2183 ;; Break out sub-lists
2184 (while lst
2185 (if (speedbar-generic-list-group-p (car-safe lst))
2186 (setq newlst (cons (car lst) newlst))
2187 (setq sublst (cons (car lst) sublst)))
2188 (setq lst (cdr lst)))
2189 ;; Reverse newlst because it was made backwards.
2190 ;; Sublist doesn't need reversing because the act
2191 ;; of binning things will reverse it for us.
2192 (setq newlst (nreverse newlst)
2193 sublst sublst)
2194 ;; Now, first find out how long our list is. Never let a
2195 ;; list get-shorter than our minimum.
2196 (if (<= (length sublst) speedbar-tag-split-minimum-length)
2197 (setq work-list sublst)
2198 (setq diff-idx (length (speedbar-try-completion "" sublst)))
2199 ;; Sort the whole list into bins.
2200 (while sublst
2201 (let ((e (car sublst))
2202 (s (car (car sublst))))
2203 (cond ((<= (length s) diff-idx)
2204 ;; 0 storage bin for shorty.
2205 (aset bins 0 (cons e (aref bins 0))))
2207 ;; stuff into a bin based on ascii value at diff
2208 (aset bins (aref s diff-idx)
2209 (cons e (aref bins (aref s diff-idx)))))))
2210 (setq sublst (cdr sublst)))
2211 ;; Go through all our bins Stick singles into our
2212 ;; junk-list, everything else as sublsts in work-list.
2213 ;; If two neighboring lists are both small, make a grouped
2214 ;; group combining those two sub-lists.
2215 (setq diff-idx 0)
2216 (while (> 256 diff-idx)
2217 ;; The bins contents are currently in forward order.
2218 (let ((l (aref bins diff-idx)))
2219 (if l
2220 (let ((tmp (cons (speedbar-try-completion "" l) l)))
2221 (if (or (> (length l) speedbar-tag-regroup-maximum-length)
2222 (> (+ (length l) (length short-group-list))
2223 speedbar-tag-split-minimum-length))
2224 (progn
2225 ;; We have reached a longer list, so we
2226 ;; must finish off a grouped group.
2227 (cond
2228 ((and short-group-list
2229 (= (length short-group-list)
2230 num-shorts-grouped))
2231 ;; All singles? Junk list
2232 (setq junk-list (append (nreverse short-group-list)
2233 junk-list)))
2234 ((= num-shorts-grouped 1)
2235 ;; Only one short group? Just stick it in
2236 ;; there by itself. Make a group, and find
2237 ;; a subexpression
2238 (let ((subexpression (speedbar-try-completion
2239 "" short-group-list)))
2240 (if (< (length subexpression)
2241 speedbar-tag-group-name-minimum-length)
2242 (setq subexpression
2243 (concat short-start-name
2244 " ("
2245 (substring
2246 (car (car short-group-list))
2247 (length short-start-name))
2248 ")")))
2249 (setq work-list
2250 (cons (cons subexpression
2251 short-group-list)
2252 work-list ))))
2253 (short-group-list
2254 ;; Multiple groups to be named in a special
2255 ;; way by displaying the range over which we
2256 ;; have grouped them.
2257 (setq work-list
2258 (cons (cons (concat short-start-name
2259 " to "
2260 short-end-name)
2261 short-group-list)
2262 work-list))))
2263 ;; Reset short group list information every time.
2264 (setq short-group-list nil
2265 short-start-name nil
2266 short-end-name nil
2267 num-shorts-grouped 0)))
2268 ;; Ok, now that we cleaned up the short-group-list,
2269 ;; we can deal with this new list, to decide if it
2270 ;; should go on one of these sub-lists or not.
2271 (if (< (length l) speedbar-tag-regroup-maximum-length)
2272 (setq short-group-list (append l short-group-list)
2273 num-shorts-grouped (1+ num-shorts-grouped)
2274 short-end-name (car tmp)
2275 short-start-name (if short-start-name
2276 short-start-name
2277 (car tmp)))
2278 (setq work-list (cons tmp work-list))))))
2279 (setq diff-idx (1+ diff-idx))))
2280 ;; Did we run out of things? Drop our new list onto the end.
2281 (cond
2282 ((and short-group-list (= (length short-group-list) num-shorts-grouped))
2283 ;; All singles? Junk list
2284 (setq junk-list (append short-group-list junk-list)))
2285 ((= num-shorts-grouped 1)
2286 ;; Only one short group? Just stick it in
2287 ;; there by itself.
2288 (setq work-list
2289 (cons (cons (speedbar-try-completion "" short-group-list)
2290 short-group-list)
2291 work-list)))
2292 (short-group-list
2293 ;; Multiple groups to be named in a special
2294 ;; way by displaying the range over which we
2295 ;; have grouped them.
2296 (setq work-list
2297 (cons (cons (concat short-start-name " to " short-end-name)
2298 short-group-list)
2299 work-list))))
2300 ;; Reverse the work list nreversed when consing.
2301 (setq work-list (nreverse work-list))
2302 ;; Now, stick our new list onto the end of
2303 (if work-list
2304 (if junk-list
2305 (append newlst work-list junk-list)
2306 (append newlst work-list))
2307 (append newlst junk-list)))))
2309 (defun speedbar-trim-words-tag-hierarchy (lst)
2310 "Trim all words in a tag hierarchy.
2311 Base trimming information on word separators, and group names.
2312 Argument LST is the list of tags to trim."
2313 (let ((newlst nil)
2314 (sublst nil)
2315 (trim-prefix nil)
2316 (trim-chars 0)
2317 (trimlst nil))
2318 (while lst
2319 (if (speedbar-generic-list-group-p (car-safe lst))
2320 (setq newlst (cons (car lst) newlst))
2321 (setq sublst (cons (car lst) sublst)))
2322 (setq lst (cdr lst)))
2323 ;; Get the prefix to trim by. Make sure that we don't trim
2324 ;; off silly pieces, only complete understandable words.
2325 (setq trim-prefix (speedbar-try-completion "" sublst)
2326 newlst (nreverse newlst))
2327 (if (or (= (length sublst) 1)
2328 (not trim-prefix)
2329 (not (string-match "\\(\\w+\\W+\\)+" trim-prefix)))
2330 (append newlst (nreverse sublst))
2331 (setq trim-prefix (substring trim-prefix (match-beginning 0)
2332 (match-end 0)))
2333 (setq trim-chars (length trim-prefix))
2334 (while sublst
2335 (setq trimlst (cons
2336 (cons (substring (car (car sublst)) trim-chars)
2337 (cdr (car sublst)))
2338 trimlst)
2339 sublst (cdr sublst)))
2340 ;; Put the lists together
2341 (append newlst trimlst))))
2343 (defun speedbar-simple-group-tag-hierarchy (lst)
2344 "Create a simple `Tags' group with orphaned tags.
2345 Argument LST is the list of tags to sort into groups."
2346 (let ((newlst nil)
2347 (sublst nil))
2348 (while lst
2349 (if (speedbar-generic-list-group-p (car-safe lst))
2350 (setq newlst (cons (car lst) newlst))
2351 (setq sublst (cons (car lst) sublst)))
2352 (setq lst (cdr lst)))
2353 (if (not newlst)
2354 (nreverse sublst)
2355 (setq newlst (cons (cons "Tags" (nreverse sublst)) newlst))
2356 (nreverse newlst))))
2358 (defun speedbar-create-tag-hierarchy (lst)
2359 "Adjust the tag hierarchy in LST, and return it.
2360 This uses `speedbar-tag-hierarchy-method' to determine how to adjust
2361 the list."
2362 (let* ((f (save-excursion
2363 (forward-line -1)
2364 (or (speedbar-line-file)
2365 (speedbar-line-directory))))
2366 (methods (if (get-file-buffer f)
2367 (with-current-buffer (get-file-buffer f)
2368 speedbar-tag-hierarchy-method)
2369 speedbar-tag-hierarchy-method))
2370 (lst (if (fboundp 'copy-tree)
2371 (copy-tree lst)
2372 lst)))
2373 (while methods
2374 (setq lst (funcall (car methods) lst)
2375 methods (cdr methods)))
2376 lst))
2378 (defvar speedbar-generic-list-group-expand-button-type 'curly
2379 "The type of button created for groups of tags.
2380 Good values for this are `curly' and `expandtag'.
2381 Make buffer local for your mode.")
2383 (defvar speedbar-generic-list-tag-button-type nil
2384 "The type of button created for tags in generic lists.
2385 Good values for this are nil and `statictag'.
2386 Make buffer local for your mode.")
2388 (defun speedbar-insert-generic-list (level lst expand-fun find-fun)
2389 "At LEVEL, insert a generic multi-level alist LST.
2390 Associations with lists get {+} tags (to expand into more nodes) and
2391 those with positions just get a > as the indicator. {+} buttons will
2392 have the function EXPAND-FUN and the token is the cdr list. The token
2393 name will have the function FIND-FUN and not token."
2394 ;; Remove imenu rescan button
2395 (if (string= (car (car lst)) "*Rescan*")
2396 (setq lst (cdr lst)))
2397 ;; Get, and set up variables that define how we treat these tags.
2398 (let ((f (save-excursion (forward-line -1)
2399 (or (speedbar-line-file)
2400 (speedbar-line-directory))))
2401 expand-button tag-button)
2402 (save-excursion
2403 (if (get-file-buffer f)
2404 (set-buffer (get-file-buffer f)))
2405 (setq expand-button speedbar-generic-list-group-expand-button-type
2406 tag-button speedbar-generic-list-tag-button-type))
2407 ;; Adjust the list.
2408 (setq lst (speedbar-create-tag-hierarchy lst))
2409 ;; insert the parts
2410 (while lst
2411 (cond ((null (car-safe lst)) nil) ;this would be a separator
2412 ((speedbar-generic-list-tag-p (car lst))
2413 (speedbar-make-tag-line tag-button
2414 nil nil nil ;no expand button data
2415 (car (car lst)) ;button name
2416 find-fun ;function
2417 (cdr (car lst)) ;token is position
2418 'speedbar-tag-face
2419 (1+ level)))
2420 ((speedbar-generic-list-positioned-group-p (car lst))
2421 (speedbar-make-tag-line expand-button
2422 ?+ expand-fun (cdr (cdr (car lst)))
2423 (car (car lst)) ;button name
2424 find-fun ;function
2425 (car (cdr (car lst))) ;token is posn
2426 'speedbar-tag-face
2427 (1+ level)))
2428 ((speedbar-generic-list-group-p (car lst))
2429 (speedbar-make-tag-line expand-button
2430 ?+ expand-fun (cdr (car lst))
2431 (car (car lst)) ;button name
2432 nil nil 'speedbar-tag-face
2433 (1+ level)))
2434 (t (dframe-message "speedbar-insert-generic-list: malformed list!")
2436 (setq lst (cdr lst)))))
2438 (defun speedbar-insert-imenu-list (indent lst)
2439 "At level INDENT, insert the imenu generated LST."
2440 (speedbar-insert-generic-list indent lst
2441 'speedbar-tag-expand
2442 'speedbar-tag-find))
2444 (defun speedbar-insert-etags-list (indent lst)
2445 "At level INDENT, insert the etags generated LST."
2446 (speedbar-insert-generic-list indent lst
2447 'speedbar-tag-expand
2448 'speedbar-tag-find))
2450 ;;; Timed functions
2452 (defun speedbar-update-contents ()
2453 "Generically update the contents of the speedbar buffer."
2454 (interactive)
2455 ;; Set the current special buffer
2456 (setq speedbar-desired-buffer nil)
2458 ;; Check for special modes
2459 (speedbar-maybe-add-localized-support (current-buffer))
2461 ;; Choose the correct method of doodling.
2462 (if (and speedbar-mode-specific-contents-flag
2463 (consp speedbar-special-mode-expansion-list)
2464 (local-variable-p
2465 'speedbar-special-mode-expansion-list
2466 (current-buffer)))
2467 ;;(eq (get major-mode 'mode-class 'special)))
2468 (speedbar-update-special-contents)
2469 (speedbar-update-directory-contents)))
2471 (defun speedbar-update-localized-contents ()
2472 "Update the contents of the speedbar buffer for the current situation."
2473 ;; Due to the historical growth of speedbar, we need to do something
2474 ;; special for "files" mode. Too bad.
2475 (let ((name speedbar-initial-expansion-list-name)
2476 (funclst (speedbar-initial-expansion-list))
2478 (if (string= name "files")
2479 ;; Do all the files type work. It still goes through the
2480 ;; expansion list stuff. :(
2481 (if (or (member (expand-file-name default-directory)
2482 speedbar-shown-directories)
2483 (and speedbar-ignored-directory-regexp
2484 (string-match
2485 speedbar-ignored-directory-regexp
2486 (expand-file-name default-directory))))
2488 (if (<= 1 speedbar-verbosity-level)
2489 (dframe-message "Updating speedbar to: %s..."
2490 default-directory))
2491 (speedbar-update-directory-contents)
2492 (if (<= 1 speedbar-verbosity-level)
2493 (progn
2494 (dframe-message "Updating speedbar to: %s...done"
2495 default-directory)
2496 (dframe-message nil))))
2497 ;; Else, we can do a short cut. No text cache.
2498 (let ((cbd (expand-file-name default-directory)))
2499 (set-buffer speedbar-buffer)
2500 (speedbar-with-writable
2501 (let* ((window (get-buffer-window speedbar-buffer 0))
2502 (p (window-point window))
2503 (start (window-start window)))
2504 (erase-buffer)
2505 (dolist (func funclst)
2506 (setq default-directory cbd)
2507 (funcall func cbd 0))
2508 (speedbar-reconfigure-keymaps)
2509 (set-window-point window p)
2510 (set-window-start window start)))))))
2512 (defun speedbar-update-directory-contents ()
2513 "Update the contents of the speedbar buffer based on the current directory."
2514 (let ((cbd (expand-file-name default-directory))
2515 cbd-parent
2516 (funclst (speedbar-initial-expansion-list))
2517 (cache speedbar-full-text-cache)
2518 ;; disable stealth during update
2519 (speedbar-stealthy-function-list nil)
2520 (use-cache nil)
2521 (expand-local nil)
2522 ;; Because there is a bug I can't find just yet
2523 (inhibit-quit nil))
2524 (set-buffer speedbar-buffer)
2525 ;; If we are updating contents to where we are, then this is
2526 ;; really a request to update existing contents, so we must be
2527 ;; careful with our text cache!
2528 (if (member cbd speedbar-shown-directories)
2529 (progn
2530 (setq cache nil)
2531 ;; If the current directory is not the last element in the dir
2532 ;; list, then we ALSO need to zap the list of expanded directories
2533 (if (/= (length (member cbd speedbar-shown-directories)) 1)
2534 (setq speedbar-shown-directories (list cbd))))
2536 ;; Build cbd-parent, and see if THAT is in the current shown
2537 ;; directories. First, go through pains to get the parent directory
2538 (if (and speedbar-smart-directory-expand-flag
2539 (save-match-data
2540 (setq cbd-parent cbd)
2541 (if (string-match "[/\\]$" cbd-parent)
2542 (setq cbd-parent (substring cbd-parent 0
2543 (match-beginning 0))))
2544 (setq cbd-parent (file-name-directory cbd-parent)))
2545 (member cbd-parent speedbar-shown-directories))
2546 (setq expand-local t)
2548 ;; If this directory is NOT in the current list of available
2549 ;; directories, then use the cache, and set the cache to our new
2550 ;; value. Make sure to unhighlight the current file, or if we
2551 ;; come back to this directory, it might be a different file
2552 ;; and then we get a mess!
2553 (if (> (point-max) 1)
2554 (progn
2555 (speedbar-clear-current-file)
2556 (setq speedbar-full-text-cache
2557 (cons speedbar-shown-directories (buffer-string)))))
2559 ;; Check if our new directory is in the list of directories
2560 ;; shown in the text-cache
2561 (if (member cbd (car cache))
2562 (setq speedbar-shown-directories (car cache)
2563 use-cache t)
2564 ;; default the shown directories to this list...
2565 (setq speedbar-shown-directories (list cbd)))
2567 (if (not expand-local) (setq speedbar-last-selected-file nil))
2568 (speedbar-with-writable
2569 (if (and expand-local
2570 ;; Find this directory as a speedbar node.
2571 (speedbar-directory-line cbd))
2572 ;; Open it.
2573 (speedbar-expand-line)
2574 (let* ((window (get-buffer-window speedbar-buffer 0))
2575 (p (window-point window))
2576 (start (window-start window)))
2577 (erase-buffer)
2578 (cond (use-cache
2579 (setq default-directory
2580 (nth (1- (length speedbar-shown-directories))
2581 speedbar-shown-directories))
2582 (insert (cdr cache)))
2584 (dolist (func funclst)
2585 (setq default-directory cbd)
2586 (funcall func cbd 0))))
2587 (set-window-point window p)
2588 (set-window-start window start)))))
2589 (speedbar-reconfigure-keymaps))
2591 (defun speedbar-update-special-contents ()
2592 "Use the mode-specific variable to fill in the speedbar buffer.
2593 This should only be used by modes classified as special."
2594 (let ((funclst speedbar-special-mode-expansion-list)
2595 (specialbuff (current-buffer)))
2596 (setq speedbar-desired-buffer specialbuff)
2597 (with-current-buffer speedbar-buffer
2598 ;; If we are leaving a directory, cache it.
2599 (if (not speedbar-shown-directories)
2600 ;; Do nothing
2602 ;; Clean up directory maintenance stuff
2603 (speedbar-clear-current-file)
2604 (setq speedbar-full-text-cache
2605 (cons speedbar-shown-directories (buffer-string))
2606 speedbar-shown-directories nil))
2607 ;; Now fill in the buffer with our newly found specialized list.
2608 (speedbar-with-writable
2609 (dolist (func funclst)
2610 ;; We do not erase the buffer because these functions may
2611 ;; decide NOT to update themselves.
2612 (funcall func specialbuff)))))
2613 (speedbar-reconfigure-keymaps))
2615 (defun speedbar-set-timer (timeout)
2616 "Set up the speedbar timer with TIMEOUT.
2617 Uses `dframe-set-timer'.
2618 Also resets scanner functions."
2619 (dframe-set-timer timeout 'speedbar-timer-fn 'speedbar-update-flag)
2620 ;; Apply a revert hook that will reset the scanners. We attach to revert
2621 ;; because most reverts occur during VC state change, and this lets our
2622 ;; VC scanner fix itself.
2623 (if timeout
2624 (add-hook 'after-revert-hook 'speedbar-reset-scanners)
2625 (remove-hook 'after-revert-hook 'speedbar-reset-scanners))
2626 ;; change this if it changed for some reason
2627 (speedbar-set-mode-line-format))
2629 (defun speedbar-timer-fn ()
2630 "Run whenever Emacs is idle to update the speedbar item."
2631 (if (or (not (speedbar-current-frame))
2632 (not (frame-live-p (speedbar-current-frame))))
2633 (speedbar-set-timer nil)
2634 ;; Save all the match data so that we don't mess up executing fns
2635 (save-match-data
2636 ;; Only do stuff if the frame is visible, not an icon, and if
2637 ;; it is currently flagged to do something.
2638 (if (and speedbar-update-flag
2639 (speedbar-current-frame)
2640 (frame-visible-p (speedbar-current-frame))
2641 (not (eq (frame-visible-p (speedbar-current-frame)) 'icon)))
2642 (let ((af (selected-frame)))
2643 (dframe-select-attached-frame speedbar-frame)
2644 ;; make sure we at least choose a window to
2645 ;; get a good directory from
2646 (if (window-minibuffer-p)
2648 ;; Check for special modes
2649 (speedbar-maybe-add-localized-support (current-buffer))
2650 ;; Update for special mode all the time!
2651 (if (and speedbar-mode-specific-contents-flag
2652 (consp speedbar-special-mode-expansion-list)
2653 (local-variable-p
2654 'speedbar-special-mode-expansion-list
2655 (current-buffer)))
2656 ;;(eq (get major-mode 'mode-class 'special)))
2657 (progn
2658 (if (<= 2 speedbar-verbosity-level)
2659 (dframe-message
2660 "Updating speedbar to special mode: %s..."
2661 major-mode))
2662 (speedbar-update-special-contents)
2663 (if (<= 2 speedbar-verbosity-level)
2664 (progn
2665 (dframe-message
2666 "Updating speedbar to special mode: %s...done"
2667 major-mode)
2668 (dframe-message nil))))
2670 ;; Update all the contents if directories change!
2671 (unless (and (or (member major-mode speedbar-ignored-modes)
2672 (eq af (speedbar-current-frame))
2673 (not (buffer-file-name)))
2674 ;; Always update for GUD.
2675 (not (string-equal "GUD"
2676 speedbar-initial-expansion-list-name)))
2677 (speedbar-update-localized-contents)))
2678 (select-frame af))
2679 ;; Now run stealthy updates of time-consuming items
2680 (speedbar-stealthy-updates)))))
2681 (run-hooks 'speedbar-timer-hook))
2684 ;;; Stealthy activities
2686 (defvar speedbar-stealthy-update-recurse nil
2687 "Recursion avoidance variable for stealthy update.")
2689 (defun speedbar-stealthy-updates ()
2690 "For a given speedbar, run all items in the stealthy function list.
2691 Each item returns t if it completes successfully, or nil if
2692 interrupted by the user."
2693 (if (not speedbar-stealthy-update-recurse)
2694 (let ((l (speedbar-initial-stealthy-functions))
2695 (speedbar-stealthy-update-recurse t))
2696 (unwind-protect
2697 (speedbar-with-writable
2698 (while (and l (funcall (car l)))
2699 ;;(sit-for 0)
2700 (setq l (cdr l))))
2701 ;;(dframe-message "Exit with %S" (car l))
2702 ))))
2704 (defun speedbar-reset-scanners ()
2705 "Reset any variables used by functions in the stealthy list as state.
2706 If new functions are added, their state needs to be updated here."
2707 (setq speedbar-vc-to-do-point t
2708 speedbar-obj-to-do-point t
2709 speedbar-ro-to-do-point t)
2710 (run-hooks 'speedbar-scanner-reset-hook)
2713 (defun speedbar-find-selected-file (file)
2714 "Go to the line where FILE is."
2716 (set-buffer speedbar-buffer)
2718 (goto-char (point-min))
2719 (let ((m nil))
2720 (while (and (setq m (re-search-forward
2721 (concat " \\(" (regexp-quote (file-name-nondirectory file))
2722 "\\)\\(" speedbar-indicator-regex "\\)?\n")
2723 nil t))
2724 (not (string= file
2725 (concat
2726 (speedbar-line-directory
2727 (save-excursion
2728 (goto-char (match-beginning 0))
2729 (beginning-of-line)
2730 (save-match-data
2731 (looking-at "[0-9]+:")
2732 (string-to-number (match-string 0)))))
2733 (match-string 1))))))
2734 (if m
2735 (progn
2736 (goto-char (match-beginning 1))
2737 (match-string 1)))))
2739 (defun speedbar-clear-current-file ()
2740 "Locate the file thought to be current, and remove its highlighting."
2741 (save-excursion
2742 ;;(set-buffer speedbar-buffer)
2743 (if speedbar-last-selected-file
2744 (speedbar-with-writable
2745 (if (speedbar-find-selected-file speedbar-last-selected-file)
2746 (put-text-property (match-beginning 1)
2747 (match-end 1)
2748 'face
2749 'speedbar-file-face))))))
2751 (defun speedbar-update-current-file ()
2752 "Find the current file, and update our visuals to indicate its name.
2753 This is specific to file names. If the file name doesn't show up, but
2754 it should be in the list, then the directory cache needs to be updated."
2755 (let* ((lastf (selected-frame))
2756 (newcfd (save-excursion
2757 (dframe-select-attached-frame speedbar-frame)
2758 (let ((rf (if (buffer-file-name)
2759 (buffer-file-name)
2760 nil)))
2761 (select-frame lastf)
2762 rf)))
2763 (newcf (if newcfd newcfd))
2764 (lastb (current-buffer))
2765 (sucf-recursive (boundp 'sucf-recursive))
2766 (case-fold-search t))
2767 (if (and newcf
2768 ;; check here, that way we won't refresh to newcf until
2769 ;; its been written, thus saving ourselves some time
2770 (file-exists-p newcf)
2771 (not (string= newcf speedbar-last-selected-file)))
2772 (progn
2773 ;; It is important to select the frame, otherwise the window
2774 ;; we want the cursor to move in will not be updated by the
2775 ;; search-forward command.
2776 (select-frame (speedbar-current-frame))
2777 ;; Remove the old file...
2778 (speedbar-clear-current-file)
2779 ;; now highlight the new one.
2780 ;; (set-buffer speedbar-buffer)
2781 (speedbar-with-writable
2782 (if (speedbar-find-selected-file newcf)
2783 ;; put the property on it
2784 (put-text-property (match-beginning 1)
2785 (match-end 1)
2786 'face
2787 'speedbar-selected-face)
2788 ;; Oops, it's not in the list. Should it be?
2789 (if (and (string-match speedbar-file-regexp newcf)
2790 (string= (file-name-directory newcfd)
2791 (expand-file-name default-directory)))
2792 ;; yes, it is (we will ignore unknowns for now...)
2793 (progn
2794 (speedbar-refresh)
2795 (if (speedbar-find-selected-file newcf)
2796 ;; put the property on it
2797 (put-text-property (match-beginning 1)
2798 (match-end 1)
2799 'face
2800 'speedbar-selected-face)))
2801 ;; if it's not in there now, whatever...
2803 (setq speedbar-last-selected-file newcf))
2804 (if (not sucf-recursive)
2805 (progn
2807 ;;Sat Dec 15 2001 12:40 AM (burton@openprivacy.org): this
2808 ;;doesn't need to be in. We don't want to recenter when we are
2809 ;;updating files.
2811 ;;(speedbar-center-buffer-smartly)
2813 (speedbar-position-cursor-on-line)
2815 (set-buffer lastb)
2816 (select-frame lastf)
2818 ;; return that we are done with this activity.
2821 (defun speedbar-add-indicator (indicator-string &optional replace-this)
2822 "Add INDICATOR-STRING to the end of this speedbar line.
2823 If INDICATOR-STRING is space, and REPLACE-THIS is a character,
2824 then the existing indicator is removed. If there is already an
2825 indicator, then do not add a space."
2826 (beginning-of-line)
2827 ;; The nature of the beast: Assume we are in "the right place"
2828 (end-of-line)
2829 (skip-chars-backward (concat " " speedbar-vc-indicator
2830 speedbar-object-read-only-indicator
2831 (car speedbar-obj-indicator)
2832 (cdr speedbar-obj-indicator)))
2833 (if (and (not (looking-at speedbar-indicator-regex))
2834 (not (string= indicator-string " ")))
2835 (insert speedbar-indicator-separator))
2836 (speedbar-with-writable
2837 (save-excursion
2838 (if (and replace-this
2839 (re-search-forward replace-this (line-end-position) t))
2840 (delete-region (match-beginning 0) (match-end 0))))
2841 (end-of-line)
2842 (if (not (string= " " indicator-string))
2843 (let ((start (point)))
2844 (insert indicator-string)
2845 (speedbar-insert-image-button-maybe start (length indicator-string))
2846 ))))
2848 (defun speedbar-check-read-only ()
2849 "Scan all the files in a directory, and for each see if it is read only."
2850 ;; Check for to-do to be reset. If reset but no RCS is available
2851 ;; then set to nil (do nothing) otherwise, start at the beginning
2852 (save-excursion
2853 (if speedbar-buffer (set-buffer speedbar-buffer))
2854 (if (eq speedbar-ro-to-do-point t)
2855 (setq speedbar-ro-to-do-point 0))
2856 (if (numberp speedbar-ro-to-do-point)
2857 (progn
2858 (goto-char speedbar-ro-to-do-point)
2859 (while (and (not (input-pending-p))
2860 (re-search-forward "^\\([0-9]+\\):\\s-*[[<][+-?][]>] "
2861 nil t))
2862 (setq speedbar-ro-to-do-point (point))
2863 (let ((f (speedbar-line-file)))
2864 (if f
2865 (if (not (file-writable-p f))
2866 (speedbar-add-indicator
2867 speedbar-object-read-only-indicator
2868 (regexp-quote speedbar-object-read-only-indicator))
2869 (speedbar-add-indicator
2870 " " (regexp-quote
2871 speedbar-object-read-only-indicator))))))
2872 (if (input-pending-p)
2873 ;; return that we are incomplete
2875 ;; we are done, set to-do to nil
2876 (setq speedbar-ro-to-do-point nil)
2877 ;; and return t
2879 t)))
2881 (defun speedbar-check-vc ()
2882 "Scan all files in a directory, and for each see if it's checked out.
2883 See `speedbar-this-file-in-vc' and `speedbar-vc-check-dir-p' for how
2884 to add more types of version control systems."
2885 ;; Check for to-do to be reset. If reset but no RCS is available
2886 ;; then set to nil (do nothing) otherwise, start at the beginning
2887 (save-excursion
2888 (if speedbar-buffer (set-buffer speedbar-buffer))
2889 (if (and speedbar-vc-do-check (eq speedbar-vc-to-do-point t)
2890 (speedbar-vc-check-dir-p default-directory)
2891 (not (or (and (featurep 'ange-ftp)
2892 (string-match
2893 (car (symbol-value
2894 (if (featurep 'xemacs)
2895 'ange-ftp-directory-format
2896 'ange-ftp-name-format)))
2897 (expand-file-name default-directory)))
2898 ;; efs support: Bob Weiner
2899 (and (featurep 'efs)
2900 (string-match
2901 (let ((reg (symbol-value 'efs-directory-regexp)))
2902 (if (stringp reg)
2904 (car reg)))
2905 (expand-file-name default-directory))))))
2906 (setq speedbar-vc-to-do-point 0))
2907 (if (numberp speedbar-vc-to-do-point)
2908 (progn
2909 (goto-char speedbar-vc-to-do-point)
2910 (while (and (not (input-pending-p))
2911 (re-search-forward "^\\([0-9]+\\):\\s-*\\[[+-?]\\] "
2912 nil t))
2913 (setq speedbar-vc-to-do-point (point))
2914 (if (speedbar-check-vc-this-line (match-string 1))
2915 (speedbar-add-indicator speedbar-vc-indicator
2916 (regexp-quote speedbar-vc-indicator))
2917 (speedbar-add-indicator " "
2918 (regexp-quote speedbar-vc-indicator))))
2919 (if (input-pending-p)
2920 ;; return that we are incomplete
2922 ;; we are done, set to-do to nil
2923 (setq speedbar-vc-to-do-point nil)
2924 ;; and return t
2926 t)))
2928 (defun speedbar-check-vc-this-line (depth)
2929 "Return t if the file on this line is checked out of a version control system.
2930 Parameter DEPTH is a string with the current depth of indentation of
2931 the file being checked."
2932 (let* ((d (string-to-number depth))
2933 (f (speedbar-line-directory d))
2934 (fn (buffer-substring-no-properties
2935 ;; Skip-chars: thanks ptype@dra.hmg.gb
2936 (point) (progn
2937 (skip-chars-forward "^ " (line-end-position))
2938 (point))))
2939 (fulln (concat f fn)))
2940 (if (<= 2 speedbar-verbosity-level)
2941 (dframe-message "Speedbar vc check...%s" fulln))
2942 (and (file-writable-p fulln)
2943 (speedbar-this-file-in-vc f fn))))
2945 (defun speedbar-vc-check-dir-p (directory)
2946 "Return t if we should bother checking DIRECTORY for version control files.
2947 This can be overloaded to add new types of version control systems."
2949 (catch t (dolist (vcd vc-directory-exclusion-list)
2950 (if (file-exists-p (concat directory vcd)) (throw t t))) nil)
2951 ;; User extension
2952 (run-hook-with-args-until-success 'speedbar-vc-directory-enable-hook
2953 directory)
2956 (defun speedbar-this-file-in-vc (directory name)
2957 "Check to see if the file in DIRECTORY with NAME is in a version control system.
2958 Automatically recognizes all VCs supported by VC mode. You can
2959 optimize this function by overriding it and only doing those checks
2960 that will occur on your system."
2962 (vc-backend (concat directory "/" name))
2963 ;; User extension
2964 (run-hook-with-args 'speedbar-vc-in-control-hook directory name)
2967 ;; Object File scanning
2968 (defun speedbar-check-objects ()
2969 "Scan all files in a directory, and for each see if there is an object.
2970 See `speedbar-check-obj-this-line' and `speedbar-obj-alist' for how
2971 to add more object types."
2972 ;; Check for to-do to be reset. If reset but no RCS is available
2973 ;; then set to nil (do nothing) otherwise, start at the beginning
2974 (save-excursion
2975 (if speedbar-buffer (set-buffer speedbar-buffer))
2976 (if (and speedbar-obj-do-check (eq speedbar-obj-to-do-point t))
2977 (setq speedbar-obj-to-do-point 0))
2978 (if (numberp speedbar-obj-to-do-point)
2979 (progn
2980 (goto-char speedbar-obj-to-do-point)
2981 (while (and (not (input-pending-p))
2982 (re-search-forward "^\\([0-9]+\\):\\s-*\\[[+-]\\] "
2983 nil t))
2984 (setq speedbar-obj-to-do-point (point))
2985 (let ((ind (speedbar-check-obj-this-line (match-string 1))))
2986 (if (not ind) (setq ind " "))
2987 (speedbar-add-indicator ind (concat
2988 (car speedbar-obj-indicator)
2989 "\\|"
2990 (cdr speedbar-obj-indicator)))))
2991 (if (input-pending-p)
2992 ;; return that we are incomplete
2994 ;; we are done, set to-do to nil
2995 (setq speedbar-obj-to-do-point nil)
2996 ;; and return t
2998 t)))
3000 (defun speedbar-check-obj-this-line (depth)
3001 "Return t if the file on this line has an associated object.
3002 Parameter DEPTH is a string with the current depth of indentation of
3003 the file being checked."
3004 (let* ((d (string-to-number depth))
3005 (f (speedbar-line-directory d))
3006 (fn (buffer-substring-no-properties
3007 ;; Skip-chars: thanks ptype@dra.hmg.gb
3008 (point) (progn
3009 (skip-chars-forward "^ " (line-end-position))
3010 (point))))
3011 (fulln (concat f fn)))
3012 (if (<= 2 speedbar-verbosity-level)
3013 (dframe-message "Speedbar obj check...%s" fulln))
3014 (let ((oa speedbar-obj-alist))
3015 (while (and oa (not (string-match (car (car oa)) fulln)))
3016 (setq oa (cdr oa)))
3017 (if (not (and oa (file-exists-p (concat (file-name-sans-extension fulln)
3018 (cdr (car oa))))))
3020 ;; Find out if the object is out of date or not.
3021 (let ((date1 (nth 5 (file-attributes fulln)))
3022 (date2 (nth 5 (file-attributes (concat
3023 (file-name-sans-extension fulln)
3024 (cdr (car oa)))))))
3025 (if (or (< (car date1) (car date2))
3026 (and (= (car date1) (car date2))
3027 (< (nth 1 date1) (nth 1 date2))))
3028 (car speedbar-obj-indicator)
3029 (cdr speedbar-obj-indicator)))))))
3031 ;;; Clicking Activity
3033 (defun speedbar-position-cursor-on-line ()
3034 "Position the cursor on a line."
3035 (let ((oldpos (point)))
3036 (beginning-of-line)
3037 (if (looking-at "[0-9]+:\\s-*..?.? ")
3038 (goto-char (1- (match-end 0)))
3039 (goto-char oldpos))))
3041 (defun speedbar-click (e)
3042 "Activate any speedbar buttons where the mouse is clicked.
3043 This must be bound to a mouse event. A button is any location of text
3044 with a mouse face that has a text property called `speedbar-function'.
3045 Argument E is the click event."
3046 ;; Backward compatibility let statement.
3047 (let ((speedbar-power-click dframe-power-click))
3048 (speedbar-do-function-pointer))
3049 (dframe-quick-mouse e))
3051 (defun speedbar-do-function-pointer ()
3052 "Look under the cursor and examine the text properties.
3053 From this extract the file/tag name, token, indentation level and call
3054 a function if appropriate."
3055 (let* ((speedbar-frame (speedbar-current-frame))
3056 (fn (get-text-property (point) 'speedbar-function))
3057 (tok (get-text-property (point) 'speedbar-token))
3058 ;; The 1-,+ is safe because scanning starts AFTER the point
3059 ;; specified. This lets the search include the character the
3060 ;; cursor is on.
3061 (tp (previous-single-property-change
3062 (1+ (point)) 'speedbar-function))
3063 (np (next-single-property-change
3064 (point) 'speedbar-function))
3065 (txt (buffer-substring-no-properties (or tp (point-min))
3066 (or np (point-max))))
3067 (dent (save-excursion (beginning-of-line)
3068 (string-to-number
3069 (if (looking-at "[0-9]+")
3070 (buffer-substring-no-properties
3071 (match-beginning 0) (match-end 0))
3072 "0")))))
3073 ;;(dframe-message "%S:%S:%S:%s" fn tok txt dent)
3074 (and fn (funcall fn txt tok dent)))
3075 (speedbar-position-cursor-on-line))
3077 ;;; Reading info from the speedbar buffer
3079 (defun speedbar-line-text (&optional p)
3080 "Retrieve the text after prefix junk for the current line.
3081 Optional argument P is where to start the search from."
3082 (save-excursion
3083 (if p (goto-char p))
3084 (beginning-of-line)
3085 (if (looking-at (concat
3086 "\\([0-9]+\\): *[[<{]?[-+?= ][]>}@()|] \\([^ \n]+\\)"))
3087 (get-text-property (match-beginning 2) 'speedbar-text)
3088 nil)))
3090 (defun speedbar-line-token (&optional p)
3091 "Retrieve the token information after the prefix junk for the current line.
3092 Optional argument P is where to start the search from."
3093 (save-excursion
3094 (if p (goto-char p))
3095 (beginning-of-line)
3096 (if (looking-at (concat
3097 "\\([0-9]+\\): *[[<{]?[-+?= ][]>}@()|] \\([^ \n]+\\)\\("
3098 speedbar-indicator-regex "\\)?"))
3099 (progn
3100 (goto-char (match-beginning 2))
3101 (get-text-property (point) 'speedbar-token))
3102 nil)))
3104 (defun speedbar-line-file (&optional p)
3105 "Retrieve the file or whatever from the line at point P.
3106 The return value is a string representing the file. If it is a
3107 directory, then it is the directory name."
3108 (save-match-data
3109 (save-restriction
3110 (widen)
3111 (let ((f (speedbar-line-text p)))
3112 (if f
3113 (let* ((depth (string-to-number (match-string 1)))
3114 (directory (speedbar-line-directory depth)))
3115 (if (file-exists-p (concat directory f))
3116 (concat directory f)
3117 nil))
3118 nil)))))
3120 (defun speedbar-goto-this-file (file)
3121 "If FILE is displayed, go to this line and return t.
3122 Otherwise do not move and return nil."
3123 (let ((directory (substring (file-name-directory (expand-file-name file))
3124 (length (expand-file-name default-directory))))
3125 (dest (point)))
3126 (save-match-data
3127 (goto-char (point-min))
3128 ;; scan all the directories
3129 (while (and directory (not (eq directory t)))
3130 (if (string-match "^[/\\]?\\([^/\\]+\\)" directory)
3131 (let ((pp (match-string 1 directory)))
3132 (if (save-match-data
3133 (re-search-forward (concat "> " (regexp-quote pp) "$")
3134 nil t))
3135 (setq directory (substring directory (match-end 1)))
3136 (setq directory nil)))
3137 (setq directory t)))
3138 ;; find the file part
3139 (if (or (not directory) (string= (file-name-nondirectory file) ""))
3140 ;; only had a dir part
3141 (if directory
3142 (progn
3143 (speedbar-position-cursor-on-line)
3145 (goto-char dest) nil)
3146 ;; find the file part
3147 (let ((nd (file-name-nondirectory file)))
3148 (if (re-search-forward
3149 (concat "] \\(" (regexp-quote nd)
3150 "\\)\\(" speedbar-indicator-regex "\\)$")
3151 nil t)
3152 (progn
3153 (speedbar-position-cursor-on-line)
3155 (goto-char dest)
3156 nil))))))
3158 (defun speedbar-line-directory (&optional depth)
3159 "Retrieve the directory name associated with the current line.
3160 This may require traversing backwards from DEPTH and combining the default
3161 directory with these items. This function is replaceable in
3162 `speedbar-mode-functions-list' as `speedbar-line-directory'."
3163 (save-restriction
3164 (widen)
3165 (let ((rf (speedbar-fetch-replacement-function 'speedbar-line-directory)))
3166 (if rf (funcall rf depth) default-directory))))
3168 (defun speedbar-files-line-directory (&optional depth)
3169 "Retrieve the directory associated with the current line.
3170 This may require traversing backwards from DEPTH and combining the default
3171 directory with these items."
3172 (save-excursion
3173 (save-match-data
3174 (if (not depth)
3175 (progn
3176 (beginning-of-line)
3177 (looking-at "^\\([0-9]+\\):")
3178 (setq depth (string-to-number (match-string 1)))))
3179 (let ((directory nil))
3180 (setq depth (1- depth))
3181 (while (/= depth -1)
3182 (if (not (re-search-backward (format "^%d:" depth) nil t))
3183 (error "Error building filename of tag")
3184 (cond ((looking-at "[0-9]+:\\s-*<->\\s-+\\([^\n]+\\)")
3185 (setq directory (concat (speedbar-line-text)
3187 directory)))
3188 ((looking-at "[0-9]+:\\s-*[-]\\s-+\\([^\n]+\\)")
3189 ;; This is the start of our directory.
3190 (setq directory (speedbar-line-text)))))
3191 (setq depth (1- depth)))
3192 (if (and directory
3193 (string-match (concat speedbar-indicator-regex "$")
3194 directory))
3195 (setq directory (substring directory 0 (match-beginning 0))))
3196 (concat default-directory directory)))))
3198 (defun speedbar-directory-line (directory)
3199 "Position the cursor on the line specified by DIRECTORY."
3200 (save-match-data
3201 (if (string-match "[/\\]$" directory)
3202 (setq directory (substring directory 0 (match-beginning 0))))
3203 (let ((nomatch t) (depth 0)
3204 (fname (file-name-nondirectory directory))
3205 (pname (file-name-directory directory)))
3206 (if (not (member pname speedbar-shown-directories))
3207 (error "Internal Error: File %s not shown in speedbar" directory))
3208 (goto-char (point-min))
3209 (while (and nomatch
3210 (re-search-forward
3211 (concat "[]>] \\(" (regexp-quote fname)
3212 "\\)\\(" speedbar-indicator-regex "\\)?$")
3213 nil t))
3214 (beginning-of-line)
3215 (looking-at "\\([0-9]+\\):")
3216 (setq depth (string-to-number (match-string 0))
3217 nomatch (not (string= pname (speedbar-line-directory depth))))
3218 (end-of-line))
3219 (beginning-of-line)
3220 (not nomatch))))
3222 (defun speedbar-edit-line ()
3223 "Edit whatever tag or file is on the current speedbar line."
3224 (interactive)
3225 (or (save-excursion
3226 (beginning-of-line)
3227 ;; If this fails, then it is a non-standard click, and as such,
3228 ;; perfectly allowed.
3229 (if (re-search-forward "[]>?}] [^ ]"
3230 (line-end-position)
3232 (progn
3233 (forward-char -1)
3234 (speedbar-do-function-pointer))
3235 nil))
3236 (speedbar-do-function-pointer)))
3238 (defun speedbar-expand-line (&optional arg)
3239 "Expand the line under the cursor.
3240 With universal argument ARG, flush cached data."
3241 (interactive "P")
3242 (beginning-of-line)
3243 (let* ((dframe-power-click arg)
3244 (speedbar-power-click arg))
3245 (condition-case nil
3246 (progn
3247 (re-search-forward ":\\s-*.\\+. "
3248 (line-end-position))
3249 (forward-char -2)
3250 (speedbar-do-function-pointer))
3251 (error (speedbar-position-cursor-on-line)))))
3253 (defun speedbar-flush-expand-line ()
3254 "Expand the line under the cursor and flush any cached information."
3255 (interactive)
3256 (speedbar-expand-line 1))
3258 (defun speedbar-contract-line ()
3259 "Contract the line under the cursor."
3260 (interactive)
3261 (beginning-of-line)
3262 (condition-case nil
3263 (progn
3264 (re-search-forward ":\\s-*.-. "
3265 (line-end-position))
3266 (forward-char -2)
3267 (speedbar-do-function-pointer))
3268 (error (speedbar-position-cursor-on-line))))
3270 (defun speedbar-toggle-line-expansion ()
3271 "Contract or expand the line under the cursor."
3272 (interactive)
3273 (beginning-of-line)
3274 (condition-case nil
3275 (progn
3276 (re-search-forward ":\\s-*.[-+]. "
3277 (line-end-position))
3278 (forward-char -2)
3279 (speedbar-do-function-pointer))
3280 (error (speedbar-position-cursor-on-line))))
3282 (defun speedbar-expand-line-descendants (&optional arg)
3283 "Expand the line under the cursor and all descendants.
3284 Optional argument ARG indicates that any cache should be flushed."
3285 (interactive "P")
3286 (speedbar-expand-line arg)
3287 ;; Now, inside the area expanded here, expand all subnodes of
3288 ;; the same descendant type.
3289 (save-excursion
3290 (speedbar-next 1) ;; Move into the list.
3291 (let ((err nil))
3292 (while (not err)
3293 (condition-case nil
3294 (progn
3295 (speedbar-expand-line-descendants arg)
3296 (speedbar-restricted-next 1))
3297 (error (setq err t))))))
3300 (defun speedbar-contract-line-descendants ()
3301 "Expand the line under the cursor and all descendants."
3302 (interactive)
3303 (speedbar-contract-line)
3304 ;; Don't need to do anything else since all descendants are
3305 ;; hidden by default anyway. Yay! It's easy.
3308 (defun speedbar-find-file (text _token indent)
3309 "Speedbar click handler for filenames.
3310 TEXT, the file will be displayed in the attached frame.
3311 TOKEN is unused, but required by the click handler. INDENT is the
3312 current indentation level."
3313 (let ((cdd (speedbar-line-directory indent)))
3314 ;; Run before visiting file hook here.
3315 (let ((f (selected-frame)))
3316 (dframe-select-attached-frame speedbar-frame)
3317 (run-hooks 'speedbar-before-visiting-file-hook)
3318 (select-frame f))
3319 (speedbar-find-file-in-frame (concat cdd text))
3320 (speedbar-stealthy-updates)
3321 (run-hooks 'speedbar-visiting-file-hook)
3322 ;; Reset the timer with a new timeout when clicking a file
3323 ;; in case the user was navigating directories, we can cancel
3324 ;; that other timer.
3325 (speedbar-set-timer dframe-update-speed))
3326 (dframe-maybee-jump-to-attached-frame))
3328 (defun speedbar-dir-follow (text _token indent)
3329 "Speedbar click handler for directory names.
3330 Clicking a directory will cause the speedbar to list files in
3331 the subdirectory TEXT. TOKEN is an unused requirement. The
3332 subdirectory chosen will be at INDENT level."
3333 (setq default-directory
3334 (concat (expand-file-name (concat (speedbar-line-directory indent) text))
3335 "/"))
3336 ;; Because we leave speedbar as the current buffer,
3337 ;; update contents will change directory without
3338 ;; having to touch the attached frame. Turn off smart expand just
3339 ;; in case.
3340 (let ((speedbar-smart-directory-expand-flag nil))
3341 (speedbar-update-contents))
3342 (speedbar-set-timer speedbar-navigating-speed)
3343 (setq speedbar-last-selected-file nil)
3344 (speedbar-stealthy-updates))
3346 (defun speedbar-delete-subblock (indent)
3347 "Delete text from point to indentation level INDENT or greater.
3348 Handles end-of-sublist smartly."
3349 (speedbar-with-writable
3350 (save-excursion
3351 (end-of-line) (forward-char 1)
3352 (let ((start (point)))
3353 (while (and (looking-at "^\\([0-9]+\\):")
3354 (> (string-to-number (match-string 1)) indent)
3355 (not (eobp)))
3356 (forward-line 1)
3357 (beginning-of-line))
3358 (delete-region start (point))))))
3360 (defun speedbar-dired (text token indent)
3361 "Speedbar click handler for directory expand button.
3362 Clicking this button expands or contracts a directory. TEXT is the
3363 button clicked which has either a + or -. TOKEN is the directory to be
3364 expanded. INDENT is the current indentation level."
3365 (cond ((string-match "+" text) ;we have to expand this dir
3366 (setq speedbar-shown-directories
3367 (cons (expand-file-name
3368 (concat (speedbar-line-directory indent) token "/"))
3369 speedbar-shown-directories))
3370 (speedbar-change-expand-button-char ?-)
3371 (speedbar-reset-scanners)
3372 (save-excursion
3373 (end-of-line) (forward-char 1)
3374 (speedbar-with-writable
3375 (speedbar-default-directory-list
3376 (concat (speedbar-line-directory indent) token "/")
3377 (1+ indent)))))
3378 ((string-match "-" text) ;we have to contract this node
3379 (speedbar-reset-scanners)
3380 (let ((oldl speedbar-shown-directories)
3381 (newl nil)
3382 (td (expand-file-name
3383 (concat (speedbar-line-directory indent) token))))
3384 (while oldl
3385 (if (not (string-match (concat "^" (regexp-quote td)) (car oldl)))
3386 (setq newl (cons (car oldl) newl)))
3387 (setq oldl (cdr oldl)))
3388 (setq speedbar-shown-directories (nreverse newl)))
3389 (speedbar-change-expand-button-char ?+)
3390 (speedbar-delete-subblock indent)
3392 (t (error "Ooops... not sure what to do")))
3393 (speedbar-center-buffer-smartly)
3394 (save-excursion (speedbar-stealthy-updates)))
3396 (defun speedbar-directory-buttons-follow (_text token _indent)
3397 "Speedbar click handler for default directory buttons.
3398 TEXT is the button clicked on. TOKEN is the directory to follow.
3399 INDENT is the current indentation level and is unused."
3400 (if (string-match "^[A-z]:$" token)
3401 (setq default-directory (concat token "/"))
3402 (setq default-directory token))
3403 ;; Because we leave speedbar as the current buffer,
3404 ;; update contents will change directory without
3405 ;; having to touch the attached frame.
3406 (speedbar-update-contents)
3407 (speedbar-set-timer speedbar-navigating-speed))
3409 (defun speedbar-tag-file (text token indent)
3410 "The cursor is on a selected line. Expand the tags in the specified file.
3411 The parameter TEXT and TOKEN are required, where TEXT is the button
3412 clicked, and TOKEN is the file to expand. INDENT is the current
3413 indentation level."
3414 (cond ((string-match "+" text) ;we have to expand this file
3415 (let* ((fn (expand-file-name (concat (speedbar-line-directory indent)
3416 token)))
3417 (lst (speedbar-fetch-dynamic-tags fn)))
3418 ;; if no list, then remove expando button
3419 (if (not lst)
3420 (speedbar-change-expand-button-char ??)
3421 (speedbar-change-expand-button-char ?-)
3422 (speedbar-with-writable
3423 (save-excursion
3424 (end-of-line) (forward-char 1)
3425 (funcall (car lst) indent (cdr lst)))))))
3426 ((string-match "-" text) ;we have to contract this node
3427 (speedbar-change-expand-button-char ?+)
3428 (speedbar-delete-subblock indent))
3429 (t (error "Ooops... not sure what to do")))
3430 (speedbar-center-buffer-smartly))
3432 (defun speedbar-tag-find (_text token indent)
3433 "For the tag TEXT in a file TOKEN, go to that position.
3434 INDENT is the current indentation level."
3435 (let ((file (speedbar-line-directory indent)))
3436 (let ((f (selected-frame)))
3437 (dframe-select-attached-frame speedbar-frame)
3438 (run-hooks 'speedbar-before-visiting-tag-hook)
3439 (select-frame f))
3440 (speedbar-find-file-in-frame file)
3441 (save-excursion (speedbar-stealthy-updates))
3442 ;; Reset the timer with a new timeout when clicking a file
3443 ;; in case the user was navigating directories, we can cancel
3444 ;; that other timer.
3445 (speedbar-set-timer dframe-update-speed)
3446 (goto-char token)
3447 (run-hooks 'speedbar-visiting-tag-hook)
3448 (dframe-maybee-jump-to-attached-frame)
3451 (defun speedbar-tag-expand (text token indent)
3452 "Expand a tag sublist. Imenu will return sub-lists of specialized tag types.
3453 Etags does not support this feature. TEXT will be the button string.
3454 TOKEN will be the list, and INDENT is the current indentation level."
3455 (cond ((string-match "+" text) ;we have to expand this file
3456 (speedbar-change-expand-button-char ?-)
3457 (speedbar-with-writable
3458 (save-excursion
3459 (end-of-line) (forward-char 1)
3460 (speedbar-insert-generic-list indent token 'speedbar-tag-expand
3461 'speedbar-tag-find))))
3462 ((string-match "-" text) ;we have to contract this node
3463 (speedbar-change-expand-button-char ?+)
3464 (speedbar-delete-subblock indent))
3465 (t (error "Ooops... not sure what to do")))
3466 (speedbar-center-buffer-smartly))
3468 ;;; Loading files into the attached frame.
3470 (defcustom speedbar-select-frame-method 'attached
3471 "Specify how to select a frame for displaying a file.
3472 A number such as 1 or -1 means to pass that number to `other-frame'
3473 while selecting a frame from speedbar. Any other value means to use
3474 the attached frame (the frame that speedbar was started from)."
3475 :group 'speedbar
3476 :type '(choice integer (other :tag "attached" attached)))
3478 (defun speedbar-find-file-in-frame (file)
3479 "This will load FILE into the speedbar attached frame.
3480 If the file is being displayed in a different frame already, then raise that
3481 frame instead."
3482 (let* ((buff (find-file-noselect file))
3483 (bwin (get-buffer-window buff 0)))
3484 (if bwin
3485 (progn
3486 (select-window bwin)
3487 (raise-frame (window-frame bwin)))
3488 (if dframe-power-click
3489 (let ((pop-up-frames t)) (select-window (display-buffer buff)))
3490 (if (numberp speedbar-select-frame-method)
3491 (other-frame speedbar-select-frame-method)
3492 (dframe-select-attached-frame speedbar-frame))
3493 (switch-to-buffer buff))))
3496 ;;; Centering Utility
3498 (defun speedbar-center-buffer-smartly ()
3499 "Recenter a speedbar buffer so the current indentation level is all visible.
3500 This assumes that the cursor is on a file, or tag of a file which the user is
3501 interested in."
3503 (save-selected-window
3505 (select-window (get-buffer-window speedbar-buffer t))
3507 (set-buffer speedbar-buffer)
3509 (if (<= (count-lines (point-min) (point-max))
3510 (1- (window-height)))
3511 ;; whole buffer fits
3512 (let ((cp (point)))
3514 (goto-char (point-min))
3515 (recenter 0)
3516 (goto-char cp))
3517 ;; too big
3518 (let (depth start end exp p)
3519 (save-excursion
3520 (beginning-of-line)
3521 (setq depth (if (looking-at "[0-9]+")
3522 (string-to-number (buffer-substring-no-properties
3523 (match-beginning 0) (match-end 0)))
3525 (setq exp (format "^%d:" depth)))
3526 (save-excursion
3527 (end-of-line)
3528 (if (re-search-backward exp nil t)
3529 (setq start (point))
3530 (setq start (point-min)))
3531 (save-excursion ;Not sure about this part.
3532 (end-of-line)
3533 (setq p (point))
3534 (while (and (not (re-search-forward exp nil t))
3535 (>= depth 0))
3536 (setq depth (1- depth))
3537 (setq exp (format "^%d:" depth)))
3538 (if (/= (point) p)
3539 (setq end (point))
3540 (setq end (point-max)))))
3541 ;; Now work out the details of centering
3542 (let ((nl (count-lines start end))
3543 (wl (1- (window-height)))
3544 (cp (point)))
3545 (if (> nl wl)
3546 ;; We can't fit it all, so just center on cursor
3547 (progn (goto-char start)
3548 (recenter 1))
3549 ;; we can fit everything on the screen, but...
3550 (if (and (pos-visible-in-window-p start (selected-window))
3551 (pos-visible-in-window-p end (selected-window)))
3552 ;; we are all set!
3554 ;; we need to do something...
3555 (goto-char start)
3556 (let ((newcent (/ (- (window-height) nl) 2))
3557 (lte (count-lines start (point-max))))
3558 (if (and (< (+ newcent lte) (window-height))
3559 (> (- (window-height) lte 1)
3560 newcent))
3561 (setq newcent (- (window-height)
3562 lte 1)))
3563 (recenter newcent))))
3564 (goto-char cp))))))
3566 ;;; Tag Management -- List of expanders:
3568 (defun speedbar-fetch-dynamic-tags (file)
3569 "Return a list of tags generated dynamically from FILE.
3570 This uses the entries in `speedbar-dynamic-tags-function-list'
3571 to find the proper tags. It is up to each of those individual
3572 functions to do caching and flushing if appropriate."
3573 (save-excursion
3574 ;; If a file is in memory, switch to that buffer. This allows
3575 ;; us to use the local variable. If the file is on disk, we
3576 ;; can try a few of the defaults that can get tags without
3577 ;; opening the file.
3578 (if (get-file-buffer file)
3579 (set-buffer (get-file-buffer file)))
3580 ;; If there is a buffer-local value of
3581 ;; speedbar-dynamic-tags-function-list, it will now be available.
3582 (let ((dtf speedbar-dynamic-tags-function-list)
3583 (ret t))
3584 (while (and (eq ret t) dtf)
3585 (setq ret
3586 (if (fboundp (car (car dtf)))
3587 (funcall (car (car dtf)) file)
3589 (if (eq ret t)
3590 (setq dtf (cdr dtf))))
3591 (if (eq ret t)
3592 ;; No valid tag list, return nil
3594 ;; We have some tags. Return the list with the insert fn
3595 ;; prepended
3596 (cons (cdr (car dtf)) ret)))))
3598 ;;; Tag Management -- Imenu
3600 (if (not speedbar-use-imenu-flag)
3604 (eval-when-compile (condition-case nil (require 'imenu) (error nil)))
3605 (declare-function imenu--make-index-alist "imenu" (&optional no-error))
3607 (defun speedbar-fetch-dynamic-imenu (file)
3608 "Load FILE into a buffer, and generate tags using Imenu.
3609 Returns the tag list, or t for an error."
3610 ;; Load this AND compile it in
3611 (require 'imenu)
3612 (set-buffer (find-file-noselect file))
3613 (if dframe-power-click (setq imenu--index-alist nil))
3614 (condition-case nil
3615 (let ((index-alist (imenu--make-index-alist t)))
3616 (if speedbar-sort-tags
3617 (sort (copy-alist index-alist)
3618 (lambda (a b) (string< (car a) (car b))))
3619 index-alist))
3620 (error t)))
3623 ;;; Tag Management -- etags (old XEmacs compatibility part)
3625 (defvar speedbar-fetch-etags-parse-list
3626 '(;; Note that java has the same parse-group as c
3627 ("\\.\\([cChH]\\|c\\+\\+\\|cpp\\|cc\\|hh\\|java\\|cxx\\|hxx\\)\\'" .
3628 speedbar-parse-c-or-c++tag)
3629 ("^\\.emacs$\\|.\\(el\\|l\\|lsp\\)\\'" .
3630 "def[^i]+\\s-+\\(\\(\\w\\|[-_]\\)+\\)\\s-*\C-?")
3631 ; ("\\.\\([fF]\\|for\\|FOR\\|77\\|90\\)\\'" .
3632 ; speedbar-parse-fortran77-tag)
3633 ("\\.tex\\'" . speedbar-parse-tex-string)
3634 ("\\.p\\'" .
3635 "\\(\\(FUNCTION\\|function\\|PROCEDURE\\|procedure\\)\\s-+\\([a-zA-Z0-9_.:]+\\)\\)\\s-*(?^?")
3637 "Associations of file extensions and expressions for extracting tags.
3638 To add a new file type, you would want to add a new association to the
3639 list, where the car is the file match, and the cdr is the way to
3640 extract an element from the tags output. If the output is complex,
3641 use a function symbol instead of regexp. The function should expect
3642 to be at the beginning of a line in the etags buffer.
3644 This variable is ignored if `speedbar-use-imenu-flag' is non-nil.")
3646 (defcustom speedbar-fetch-etags-command "etags"
3647 "Command used to create an etags file.
3648 This variable is ignored if `speedbar-use-imenu-flag' is t."
3649 :group 'speedbar
3650 :type 'string)
3652 (defcustom speedbar-fetch-etags-arguments '("-D" "-I" "-o" "-")
3653 "List of arguments to use with `speedbar-fetch-etags-command'.
3654 This creates an etags output buffer. Use `speedbar-toggle-etags' to
3655 modify this list conveniently.
3656 This variable is ignored if `speedbar-use-imenu-flag' is t."
3657 :group 'speedbar
3658 :type '(choice (const nil)
3659 (repeat :tag "List of arguments" string)))
3661 (defun speedbar-toggle-etags (flag)
3662 "Toggle FLAG in `speedbar-fetch-etags-arguments'.
3663 FLAG then becomes a member of etags command line arguments. If flag
3664 is \"sort\", then toggle the value of `speedbar-sort-tags'. If its
3665 value is \"show\" then toggle the value of
3666 `speedbar-show-unknown-files'.
3668 This function is a convenience function for XEmacs menu created by
3669 Farzin Guilak <farzin@protocol.com>."
3670 (interactive)
3671 (cond
3672 ((equal flag "sort")
3673 (setq speedbar-sort-tags (not speedbar-sort-tags)))
3674 ((equal flag "show")
3675 (setq speedbar-show-unknown-files (not speedbar-show-unknown-files)))
3676 ((or (equal flag "-C")
3677 (equal flag "-S")
3678 (equal flag "-D"))
3679 (if (member flag speedbar-fetch-etags-arguments)
3680 (setq speedbar-fetch-etags-arguments
3681 (delete flag speedbar-fetch-etags-arguments))
3682 (add-to-list 'speedbar-fetch-etags-arguments flag)))
3683 (t nil)))
3685 (defun speedbar-fetch-dynamic-etags (file)
3686 "For FILE, run etags and create a list of symbols extracted.
3687 Each symbol will be associated with its line position in FILE."
3688 (let ((newlist nil))
3689 (unwind-protect
3690 (save-excursion
3691 (if (get-buffer "*etags tmp*")
3692 (kill-buffer "*etags tmp*")) ;kill to clean it up
3693 (if (<= 1 speedbar-verbosity-level)
3694 (dframe-message "Fetching etags..."))
3695 (set-buffer (get-buffer-create "*etags tmp*"))
3696 (apply 'call-process speedbar-fetch-etags-command nil
3697 (current-buffer) nil
3698 (append speedbar-fetch-etags-arguments (list file)))
3699 (goto-char (point-min))
3700 (if (<= 1 speedbar-verbosity-level)
3701 (dframe-message "Fetching etags..."))
3702 (let ((expr
3703 (let ((exprlst speedbar-fetch-etags-parse-list)
3704 (ans nil))
3705 (while (and (not ans) exprlst)
3706 (if (string-match (car (car exprlst)) file)
3707 (setq ans (car exprlst)))
3708 (setq exprlst (cdr exprlst)))
3709 (cdr ans))))
3710 (if expr
3711 (let (tnl)
3712 (set-buffer (get-buffer-create "*etags tmp*"))
3713 (while (not (save-excursion (end-of-line) (eobp)))
3714 (save-excursion
3715 (setq tnl (speedbar-extract-one-symbol expr)))
3716 (if tnl (setq newlist (cons tnl newlist)))
3717 (forward-line 1)))
3718 (dframe-message
3719 "Sorry, no support for a file of that extension"))))
3721 (if speedbar-sort-tags
3722 (sort newlist (lambda (a b) (string< (car a) (car b))))
3723 (reverse newlist))))
3725 ;; This bit donated by Farzin Guilak <farzin@protocol.com> but I'm not
3726 ;; sure it's needed with the different sorting method.
3728 ;(defun speedbar-clean-etags()
3729 ; "Removes spaces before the ^? character, and removes `#define',
3730 ;return types, etc. preceding tags. This ensures that the sort operation
3731 ;works on the tags, not the return types."
3732 ; (save-excursion
3733 ; (goto-char (point-min))
3734 ; (while
3735 ; (re-search-forward "(?[ \t](?\C-?" nil t)
3736 ; (replace-match "\C-?" nil nil))
3737 ; (goto-char (point-min))
3738 ; (while
3739 ; (re-search-forward "\\(.*[ \t]+\\)\\([^ \t\n]+.*\C-?\\)" nil t)
3740 ; (delete-region (match-beginning 1) (match-end 1)))))
3742 (defun speedbar-extract-one-symbol (expr)
3743 "At point, return nil, or one alist in the form (SYMBOL . POSITION).
3744 The line should contain output from etags. Parse the output using the
3745 regular expression EXPR."
3746 (let* ((sym (if (stringp expr)
3747 (if (save-excursion
3748 (re-search-forward expr (line-end-position) t))
3749 (buffer-substring-no-properties (match-beginning 1)
3750 (match-end 1)))
3751 (funcall expr)))
3752 (pos (let ((j (re-search-forward "[\C-?\C-a]\\([0-9]+\\),\\([0-9]+\\)"
3753 (line-end-position) t)))
3754 (if (and j sym)
3755 (1+ (string-to-number (buffer-substring-no-properties
3756 (match-beginning 2)
3757 (match-end 2))))
3758 0))))
3759 (if (/= pos 0)
3760 (cons sym pos)
3761 nil)))
3763 (defun speedbar-parse-c-or-c++tag ()
3764 "Parse a C or C++ tag, which tends to be a little complex."
3765 (save-excursion
3766 (let ((bound (line-end-position)))
3767 (cond ((re-search-forward "\C-?\\([^\C-a]+\\)\C-a" bound t)
3768 (buffer-substring-no-properties (match-beginning 1)
3769 (match-end 1)))
3770 ((re-search-forward "\\<\\([^ \t]+\\)\\s-+new(" bound t)
3771 (buffer-substring-no-properties (match-beginning 1)
3772 (match-end 1)))
3773 ((re-search-forward "\\<\\([^ \t(]+\\)\\s-*(\C-?" bound t)
3774 (buffer-substring-no-properties (match-beginning 1)
3775 (match-end 1)))
3776 (t nil))
3779 (defun speedbar-parse-tex-string ()
3780 "Parse a Tex string. Only find data which is relevant."
3781 (save-excursion
3782 (let ((bound (line-end-position)))
3783 (cond ((re-search-forward "\\(\\(sub\\)*section\\|chapter\\|cite\\)\\s-*{[^\C-?}]*}?" bound t)
3784 (buffer-substring-no-properties (match-beginning 0)
3785 (match-end 0)))
3786 (t nil)))))
3789 ;;; BUFFER DISPLAY mode.
3791 (defvar speedbar-buffers-key-map nil
3792 "Keymap used when in the buffers display mode.")
3794 (if speedbar-buffers-key-map
3796 (setq speedbar-buffers-key-map (speedbar-make-specialized-keymap))
3798 ;; Basic tree features
3799 (define-key speedbar-buffers-key-map "e" 'speedbar-edit-line)
3800 (define-key speedbar-buffers-key-map "\C-m" 'speedbar-edit-line)
3801 (define-key speedbar-buffers-key-map "+" 'speedbar-expand-line)
3802 (define-key speedbar-buffers-key-map "=" 'speedbar-expand-line)
3803 (define-key speedbar-buffers-key-map "-" 'speedbar-contract-line)
3804 (define-key speedbar-buffers-key-map " " 'speedbar-toggle-line-expansion)
3806 ;; Buffer specific keybindings
3807 (define-key speedbar-buffers-key-map "k" 'speedbar-buffer-kill-buffer)
3808 (define-key speedbar-buffers-key-map "r" 'speedbar-buffer-revert-buffer)
3812 (defvar speedbar-buffer-easymenu-definition
3813 '(["Jump to buffer" speedbar-edit-line t]
3814 ["Expand File Tags" speedbar-expand-line
3815 (save-excursion (beginning-of-line)
3816 (looking-at "[0-9]+: *.\\+. "))]
3817 ["Flush Cache & Expand" speedbar-flush-expand-line
3818 (save-excursion (beginning-of-line)
3819 (looking-at "[0-9]+: *.\\+. "))]
3820 ["Contract File Tags" speedbar-contract-line
3821 (save-excursion (beginning-of-line)
3822 (looking-at "[0-9]+: *.-. "))]
3823 "----"
3824 ["Kill Buffer" speedbar-buffer-kill-buffer
3825 (save-excursion (beginning-of-line)
3826 (looking-at "[0-9]+: *.[-+?]. "))]
3827 ["Revert Buffer" speedbar-buffer-revert-buffer
3828 (save-excursion (beginning-of-line)
3829 (looking-at "[0-9]+: *.[-+?]. "))]
3831 "Menu item elements shown when displaying a buffer list.")
3833 (defun speedbar-buffer-buttons (_directory _zero)
3834 "Create speedbar buttons based on the buffers currently loaded.
3835 DIRECTORY is the directory of the currently active buffer, and ZERO is 0."
3836 (speedbar-buffer-buttons-engine nil))
3838 (defun speedbar-buffer-buttons-temp (_directory _zero)
3839 "Create speedbar buttons based on the buffers currently loaded.
3840 DIRECTORY is the directory of the currently active buffer, and ZERO is 0."
3841 (speedbar-buffer-buttons-engine t))
3843 (defun speedbar-buffer-buttons-engine (temp)
3844 "Create speedbar buffer buttons.
3845 If TEMP is non-nil, then clicking on a buffer restores the previous display."
3846 (speedbar-insert-separator "Active Buffers:")
3847 (let ((bl (buffer-list))
3848 (case-fold-search t))
3849 (while bl
3850 (if (string-match "^[ *]" (buffer-name (car bl)))
3852 (let* ((known (string-match speedbar-file-regexp
3853 (buffer-name (car bl))))
3854 (expchar (if known ?+ ??))
3855 (fn (if known 'speedbar-tag-file nil))
3856 (fname (with-current-buffer (car bl)
3857 (buffer-file-name))))
3858 (speedbar-make-tag-line 'bracket expchar fn
3859 (if fname (file-name-nondirectory fname))
3860 (buffer-name (car bl))
3861 'speedbar-buffer-click temp
3862 'speedbar-file-face 0)
3863 (speedbar-buffers-tail-notes (car bl))))
3864 (setq bl (cdr bl)))
3865 (setq bl (buffer-list))
3866 (speedbar-insert-separator "Scratch Buffers:")
3867 (while bl
3868 (if (not (string-match "^\\*" (buffer-name (car bl))))
3870 (if (eq (car bl) speedbar-buffer)
3872 (speedbar-make-tag-line 'bracket ?? nil nil
3873 (buffer-name (car bl))
3874 'speedbar-buffer-click temp
3875 'speedbar-file-face 0)
3876 (speedbar-buffers-tail-notes (car bl))))
3877 (setq bl (cdr bl)))
3878 (setq bl (buffer-list))
3879 ;;(speedbar-insert-separator "Hidden Buffers:")
3880 ;;(while bl
3881 ;; (if (not (string-match "^ " (buffer-name (car bl))))
3882 ;; nil
3883 ;; (if (eq (car bl) speedbar-buffer)
3884 ;; nil
3885 ;; (speedbar-make-tag-line 'bracket ?? nil nil
3886 ;; (buffer-name (car bl))
3887 ;; 'speedbar-buffer-click temp
3888 ;; 'speedbar-file-face 0)
3889 ;; (speedbar-buffers-tail-notes (car bl))))
3890 ;; (setq bl (cdr bl)))
3893 (defun speedbar-buffers-tail-notes (buffer)
3894 "Add a note to the end of the last tag line.
3895 Argument BUFFER is the buffer being tested."
3896 (when (with-current-buffer buffer buffer-read-only)
3897 (speedbar-insert-button "%" nil nil nil nil t)))
3899 (defun speedbar-buffers-item-info ()
3900 "Display information about the current buffer on the current line."
3901 (or (speedbar-item-info-tag-helper)
3902 (let* ((item (speedbar-line-text))
3903 (buffer (if item (get-buffer item) nil)))
3904 (and buffer
3905 (dframe-message "%s%s %S %d %s"
3906 (if (buffer-modified-p buffer) "* " "")
3907 item
3908 (with-current-buffer buffer major-mode)
3909 (with-current-buffer buffer (buffer-size))
3910 (or (buffer-file-name buffer) "<No file>"))))))
3912 (defun speedbar-buffers-line-directory (&optional _depth)
3913 "Fetch the directory of the file (buffer) specified on the current line.
3914 Optional argument DEPTH specifies the current depth of the back search."
3915 (save-excursion
3916 (end-of-line)
3917 (let ((start (point)))
3918 ;; Buffers are always at level 0
3919 (if (not (re-search-backward "^0:" nil t))
3921 (let* ((bn (speedbar-line-text))
3922 (buffer (if bn (get-buffer bn))))
3923 (if buffer
3924 (if (eq start (line-end-position))
3925 (or (with-current-buffer buffer default-directory)
3927 (buffer-file-name buffer))))))))
3929 (defun speedbar-buffer-click (text token _indent)
3930 "When the users clicks on a buffer-button in speedbar.
3931 TEXT is the buffer's name, TOKEN and INDENT are unused."
3932 (if dframe-power-click
3933 (let ((pop-up-frames t)) (select-window (display-buffer text)))
3934 (dframe-select-attached-frame speedbar-frame)
3935 (switch-to-buffer text)
3936 (if token (speedbar-change-initial-expansion-list
3937 speedbar-previously-used-expansion-list-name))))
3939 (defun speedbar-buffer-kill-buffer ()
3940 "Kill the buffer the cursor is on in the speedbar buffer."
3941 (interactive)
3942 (or (save-excursion
3943 (let ((text (speedbar-line-text)))
3944 (if (and (get-buffer text)
3945 (speedbar-y-or-n-p (format "Kill buffer %s? " text)))
3946 (kill-buffer text))
3947 (speedbar-refresh)))))
3949 (defun speedbar-buffer-revert-buffer ()
3950 "Revert the buffer the cursor is on in the speedbar buffer."
3951 (interactive)
3952 (save-excursion
3953 (beginning-of-line)
3954 ;; If this fails, then it is a non-standard click, and as such,
3955 ;; perfectly allowed
3956 (if (re-search-forward "[]>?}] [^ ]" (line-end-position) t)
3957 (let ((text (progn
3958 (forward-char -1)
3959 (buffer-substring (point) (line-end-position)))))
3960 (if (get-buffer text)
3961 (progn
3962 (set-buffer text)
3963 (revert-buffer t)))))))
3966 ;;; Useful hook values and such.
3968 (defvar speedbar-highlight-one-tag-line nil
3969 "Overlay used for highlighting the most recently jumped to tag line.")
3971 (defun speedbar-highlight-one-tag-line ()
3972 "Highlight the current line, unhighlighting a previously jumped to line."
3973 (speedbar-unhighlight-one-tag-line)
3974 (setq speedbar-highlight-one-tag-line
3975 (speedbar-make-overlay (line-beginning-position)
3976 (1+ (line-end-position))))
3977 (speedbar-overlay-put speedbar-highlight-one-tag-line 'face
3978 'speedbar-highlight-face)
3979 (add-hook 'pre-command-hook 'speedbar-unhighlight-one-tag-line))
3981 (defun speedbar-unhighlight-one-tag-line ()
3982 "Unhighlight the currently highlighted line."
3983 (when (and speedbar-highlight-one-tag-line
3984 (not (eq this-command 'handle-switch-frame)))
3985 (speedbar-delete-overlay speedbar-highlight-one-tag-line)
3986 (setq speedbar-highlight-one-tag-line nil)
3987 (remove-hook 'pre-command-hook 'speedbar-unhighlight-one-tag-line)))
3989 (defun speedbar-recenter-to-top ()
3990 "Recenter the current buffer so point is on the top of the window."
3991 (recenter 1))
3993 (defun speedbar-recenter ()
3994 "Recenter the current buffer so point is in the center of the window."
3995 (recenter (/ (window-height) 2)))
3998 ;;; Color loading section.
4000 (defface speedbar-button-face '((((class color) (background light))
4001 :foreground "green4")
4002 (((class color) (background dark))
4003 :foreground "green3"))
4004 "Speedbar face for +/- buttons."
4005 :group 'speedbar-faces)
4007 (defface speedbar-file-face '((((class color) (background light))
4008 :foreground "cyan4")
4009 (((class color) (background dark))
4010 :foreground "cyan")
4011 (t :weight bold))
4012 "Speedbar face for file names."
4013 :group 'speedbar-faces)
4015 (defface speedbar-directory-face '((((class color) (background light))
4016 :foreground "blue4")
4017 (((class color) (background dark))
4018 :foreground "light blue"))
4019 "Speedbar face for directory names."
4020 :group 'speedbar-faces)
4022 (defface speedbar-tag-face '((((class color) (background light))
4023 :foreground "brown")
4024 (((class color) (background dark))
4025 :foreground "yellow"))
4026 "Speedbar face for tags."
4027 :group 'speedbar-faces)
4029 (defface speedbar-selected-face '((((class color) (background light))
4030 :foreground "red" :underline t)
4031 (((class color) (background dark))
4032 :foreground "red" :underline t)
4033 (t :underline t))
4034 "Speedbar face for the file in the active window."
4035 :group 'speedbar-faces)
4037 (defface speedbar-highlight-face '((((class color) (background light))
4038 :background "green")
4039 (((class color) (background dark))
4040 :background "sea green"))
4041 "Speedbar face for highlighting buttons with the mouse."
4042 :group 'speedbar-faces)
4044 (defface speedbar-separator-face '((((class color) (background light))
4045 :background "blue"
4046 :foreground "white"
4047 :overline "gray")
4048 (((class color) (background dark))
4049 :background "blue"
4050 :foreground "white"
4051 :overline "gray")
4052 (((class grayscale monochrome)
4053 (background light))
4054 :background "black"
4055 :foreground "white"
4056 :overline "white")
4057 (((class grayscale monochrome)
4058 (background dark))
4059 :background "white"
4060 :foreground "black"
4061 :overline "black"))
4062 "Speedbar face for separator labels in a display."
4063 :group 'speedbar-faces)
4065 ;; some edebug hooks
4066 (add-hook 'edebug-setup-hook
4067 (lambda ()
4068 (def-edebug-spec speedbar-with-writable def-body)))
4070 ;; Fix a font lock problem for some versions of Emacs
4071 (and (boundp 'font-lock-global-modes)
4072 font-lock-global-modes
4073 (if (eq font-lock-global-modes t)
4074 (setq font-lock-global-modes '(not speedbar-mode))
4075 (if (eq (car font-lock-global-modes) 'not)
4076 (add-to-list 'font-lock-global-modes 'speedbar-mode t)
4077 (setq font-lock-global-modes (delq 'speedbar-mode
4078 font-lock-global-modes)))))
4080 ;;; Obsolete variables and functions
4082 (define-obsolete-variable-alias
4083 'speedbar-ignored-path-regexp 'speedbar-ignored-directory-regexp "22.1")
4085 (define-obsolete-function-alias 'speedbar-add-ignored-path-regexp
4086 'speedbar-add-ignored-directory-regexp "22.1")
4088 (define-obsolete-function-alias 'speedbar-line-path
4089 'speedbar-line-directory "22.1")
4091 (define-obsolete-function-alias 'speedbar-buffers-line-path
4092 'speedbar-buffers-line-directory "22.1")
4094 (define-obsolete-function-alias 'speedbar-path-line
4095 'speedbar-directory-line "22.1")
4097 (define-obsolete-function-alias 'speedbar-buffers-line-path
4098 'speedbar-buffers-line-directory "22.1")
4100 (provide 'speedbar)
4102 ;; run load-time hooks
4103 (run-hooks 'speedbar-load-hook)
4105 ;;; speedbar ends here