*** empty log message ***
[emacs.git] / lisp / speedbar.el
blobc182dffdba7062e23129cb7a8cacc67274884fda
1 ;;; speedbar.el --- quick access to files and tags in a frame
3 ;;; Copyright (C) 1996, 97, 98, 99, 2000, 01 Free Software Foundation
5 ;; Author: Eric M. Ludlam <zappo@gnu.org>
6 ;; Version: 0.11a
7 ;; Keywords: file, tags, tools
9 ;; This file is part of GNU Emacs.
11 ;; GNU Emacs is free software; you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation; either version 2, or (at your option)
14 ;; any later version.
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs; see the file COPYING. If not, write to the
23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 ;; Boston, MA 02111-1307, USA.
26 ;;; Commentary:
28 ;; The speedbar provides a frame in which files, and locations in
29 ;; files are displayed. These items can be clicked on with mouse-2
30 ;; in order to make the last active frame display that file location.
32 ;; Starting Speedbar:
34 ;; Simply type `M-x speedbar', and it will be autoloaded for you.
36 ;; If you want to choose it from a menu, such as "Tools", you can do this:
38 ;; (define-key-after (lookup-key global-map [menu-bar tools])
39 ;; [speedbar] '("Speedbar" . speedbar-frame-mode) [calendar])
41 ;; If you want to access speedbar using only the keyboard, do this:
43 ;; (global-set-key [f4] 'speedbar-get-focus)
45 ;; This will let you hit f4 (or whatever key you choose) to jump
46 ;; focus to the speedbar frame. Pressing it again will bring you back
47 ;; to the attached frame. Pressing RET or e to jump to a file
48 ;; or tag will move you back to the attached frame. The command
49 ;; `speedbar-get-focus' will also create a speedbar frame if it does
50 ;; not exist.
52 ;; Customizing Speedbar:
54 ;; Once a speedbar frame is active, it takes advantage of idle time
55 ;; to keep its contents updated. The contents is usually a list of
56 ;; files in the directory of the currently active buffer. When
57 ;; applicable, tags in the active file can be expanded.
59 ;; To add new supported files types into speedbar, use the function
60 ;; `speedbar-add-supported-extension'. If speedbar complains that the
61 ;; file type is not supported, that means there is no built in
62 ;; support from imenu, and the etags part wasn't set up correctly. You
63 ;; may add elements to `speedbar-supported-extension-expressions' as long
64 ;; as it is done before speedbar is loaded.
66 ;; To prevent speedbar from following you into certain directories
67 ;; use the function `speedbar-add-ignored-path-regexp' to add a new
68 ;; regular expression matching a type of path. You may add list
69 ;; elements to `speedbar-ignored-path-expressions' as long as it is
70 ;; done before speedbar is loaded.
72 ;; To add new file types to imenu, see the documentation in the
73 ;; file imenu.el that comes with Emacs. To add new file types which
74 ;; etags supports, you need to modify the variable
75 ;; `speedbar-fetch-etags-parse-list'.
77 ;; If the updates are going too slow for you, modify the variable
78 ;; `speedbar-update-speed' to a longer idle time before updates.
80 ;; If you navigate directories, you will probably notice that you
81 ;; will navigate to a directory which is eventually replaced after
82 ;; you go back to editing a file (unless you pull up a new file.)
83 ;; The delay time before this happens is in
84 ;; `speedbar-navigating-speed', and defaults to 10 seconds.
86 ;; To enable mouse tracking with information in the minibuffer of
87 ;; the attached frame, use the variable `speedbar-track-mouse-flag'.
89 ;; Tag layout can be modified through `speedbar-tag-hierarchy-method',
90 ;; which controls how tags are layed out. It is actually a list of
91 ;; functions that filter the data. The default groups large tag lists
92 ;; into sub-lists. A long flat list can be used instead if needed.
93 ;; Other filters can be easily added.
95 ;; AUCTEX users: The imenu tags for AUCTEX mode doesn't work very
96 ;; well. Use the imenu keywords from tex-mode.el for better results.
98 ;; This file requires the library package assoc (association lists)
100 ;;; Developing for speedbar
102 ;; Adding a speedbar specialized display mode:
104 ;; Speedbar can be configured to create a special display for certain
105 ;; modes that do not display traditional file/tag data. Rmail, Info,
106 ;; and the debugger are examples. These modes can, however, benefit
107 ;; from a speedbar style display in their own way.
109 ;; If your `major-mode' is `foo-mode', the only requirement is to
110 ;; create a function called `foo-speedbar-buttons' which takes one
111 ;; argument, BUFFER. BUFFER will be the buffer speedbar wants filled.
112 ;; In `foo-speedbar-buttons' there are several functions that make
113 ;; building a speedbar display easy. See the documentation for
114 ;; `speedbar-with-writable' (needed because the buffer is usually
115 ;; read-only) `speedbar-make-tag-line', `speedbar-insert-button', and
116 ;; `speedbar-insert-generic-list'. If you use
117 ;; `speedbar-insert-generic-list', also read the doc for
118 ;; `speedbar-tag-hierarchy-method' in case you wish to override it.
119 ;; The macro `speedbar-with-attached-buffer' brings you back to the
120 ;; buffer speedbar is displaying for.
122 ;; For those functions that make buttons, the "function" should be a
123 ;; symbol that is the function to call when clicked on. The "token"
124 ;; is extra data you can pass along. The "function" must take three
125 ;; parameters. They are (TEXT TOKEN INDENT). TEXT is the text of the
126 ;; button clicked on. TOKEN is the data passed in when you create the
127 ;; button. INDENT is an indentation level, or 0. You can store
128 ;; indentation levels with `speedbar-make-tag-line' which creates a
129 ;; line with an expander (eg. [+]) and a text button.
131 ;; Some useful functions when writing expand functions, and click
132 ;; functions are `speedbar-change-expand-button-char',
133 ;; `speedbar-delete-subblock', and `speedbar-center-buffer-smartly'.
134 ;; The variable `speedbar-power-click' is set to t in your functions
135 ;; when the user shift-clicks. This is an indication of anything from
136 ;; refreshing cached data to making a buffer appear in a new frame.
138 ;; If you wish to add to the default speedbar menu for the case of
139 ;; `foo-mode', create a variable `foo-speedbar-menu-items'. This
140 ;; should be a list compatible with the `easymenu' package. It will
141 ;; be spliced into the main menu. (Available with click-mouse-3). If
142 ;; you wish to have extra key bindings in your special mode, create a
143 ;; variable `foo-speedbar-key-map'. Instead of using `make-keymap',
144 ;; or `make-sparse-keymap', use the function
145 ;; `speedbar-make-specialized-keymap'. This lets you inherit all of
146 ;; speedbar's default bindings with low overhead.
148 ;; Adding a speedbar top-level display mode:
150 ;; Unlike the specialized modes, there are no name requirements,
151 ;; however the methods for writing a button display, menu, and keymap
152 ;; are the same. Once you create these items, you can call the
153 ;; function `speedbar-add-expansion-list'. It takes one parameter
154 ;; which is a list element of the form (NAME MENU KEYMAP &rest
155 ;; BUTTON-FUNCTIONS). NAME is a string that will show up in the
156 ;; Displays menu item. MENU is a symbol containing the menu items to
157 ;; splice in. KEYMAP is a symbol holding the keymap to use, and
158 ;; BUTTON-FUNCTIONS are the function names to call, in order, to create
159 ;; the display.
160 ;; Another tweakable variable is `speedbar-stealthy-function-list'
161 ;; which is of the form (NAME &rest FUNCTION ...). NAME is the string
162 ;; name matching `speedbar-add-expansion-list'. (It does not need to
163 ;; exist.). This provides additional display info which might be
164 ;; time-consuming to calculate.
165 ;; Lastly, `speedbar-mode-functions-list' allows you to set special
166 ;; function overrides. At the moment very few functions may be
167 ;; overridden, but more will be added as the need is discovered.
169 ;;; TODO:
170 ;; - More functions to create buttons and options
171 ;; - Timeout directories we haven't visited in a while.
173 (require 'assoc)
174 (require 'easymenu)
176 (condition-case nil
177 (require 'image)
178 (error nil))
180 (defvar speedbar-xemacsp (string-match "XEmacs" emacs-version)
181 "Non-nil if we are running in the XEmacs environment.")
182 (defvar speedbar-xemacs20p (and speedbar-xemacsp
183 (>= emacs-major-version 20)))
185 ;; customization stuff
186 (defgroup speedbar nil
187 "File and tag browser frame."
188 :group 'etags
189 :group 'tools
190 :group 'convenience
191 :version "20.3")
193 (defgroup speedbar-faces nil
194 "Faces used in speedbar."
195 :prefix "speedbar-"
196 :group 'speedbar
197 :group 'faces)
199 (defgroup speedbar-vc nil
200 "Version control display in speedbar."
201 :prefix "speedbar-"
202 :group 'speedbar)
204 ;;; Code:
205 (defvar speedbar-initial-expansion-mode-alist
206 '(("buffers" speedbar-buffer-easymenu-definition speedbar-buffers-key-map
207 speedbar-buffer-buttons)
208 ("quick buffers" speedbar-buffer-easymenu-definition speedbar-buffers-key-map
209 speedbar-buffer-buttons-temp)
210 ;; Files last, means first in the Displays menu
211 ("files" speedbar-easymenu-definition-special speedbar-file-key-map
212 speedbar-directory-buttons speedbar-default-directory-list)
214 "List of named expansion elements for filling the speedbar frame.
215 These expansion lists are only valid for regular files. Special modes
216 still get to override this list on a mode-by-mode basis. This list of
217 lists is of the form (NAME MENU KEYMAP FN1 FN2 ...). NAME is a string
218 representing the types of things to be displayed. MENU is an easymenu
219 structure used when in this mode. KEYMAP is a local keymap to install
220 over the regular speedbar keymap. FN1 ... are functions that will be
221 called in order. These functions will always get the default
222 directory to use passed in as the first parameter, and a 0 as the
223 second parameter. The 0 indicates the uppermost indentation level.
224 They must assume that the cursor is at the position where they start
225 inserting buttons.")
227 (defvar speedbar-initial-expansion-list-name "files"
228 "A symbol name representing the expansion list to use.
229 The expansion list `speedbar-initial-expansion-mode-alist' contains
230 the names and associated functions to use for buttons in speedbar.")
232 (defvar speedbar-previously-used-expansion-list-name "files"
233 "Save the last expansion list method.
234 This is used for returning to a previous expansion list method when
235 the user is done with the current expansion list.")
237 (defvar speedbar-stealthy-function-list
238 '(("files"
239 speedbar-update-current-file speedbar-check-vc speedbar-check-objects)
241 "List of functions to periodically call stealthily.
242 This list is of the form:
243 '( (\"NAME\" FUNCTION ...)
244 ...)
245 where NAME is the name of the major display mode these functions are
246 for, and the remaining elements FUNCTION are functions to call in order.
247 Each function must return nil if interrupted, or t if completed.
248 Stealthy functions which have a single operation should always return
249 t. Functions which take a long time should maintain a state (where
250 they are in their speedbar related calculations) and permit
251 interruption. See `speedbar-check-vc' as a good example.")
253 (defvar speedbar-mode-functions-list
254 '(("files" (speedbar-item-info . speedbar-files-item-info)
255 (speedbar-line-path . speedbar-files-line-path))
256 ("buffers" (speedbar-item-info . speedbar-buffers-item-info)
257 (speedbar-line-path . speedbar-buffers-line-path))
258 ("quick buffers" (speedbar-item-info . speedbar-buffers-item-info)
259 (speedbar-line-path . speedbar-buffers-line-path))
261 "List of function tables to use for different major display modes.
262 It is not necessary to define any functions for a specialized mode.
263 This just provides a simple way of adding lots of customizations.
264 Each sublist is of the form:
265 (\"NAME\" (FUNCTIONSYMBOL . REPLACEMENTFUNCTION) ...)
266 Where NAME is the name of the specialized mode. The rest of the list
267 is a set of dotted pairs of the form FUNCTIONSYMBOL, which is the name
268 of a function you would like to replace, and REPLACEMENTFUNCTION,
269 which is a function you can call instead. Not all functions can be
270 replaced this way. Replaceable functions must provide that
271 functionality individually.")
273 (defcustom speedbar-mode-specific-contents-flag t
274 "*Non-nil means speedbar will show special mode contents.
275 This permits some modes to create customized contents for the speedbar
276 frame."
277 :group 'speedbar
278 :type 'boolean)
280 (defvar speedbar-special-mode-expansion-list nil
281 "Default function list for creating specialized button lists.
282 This list is set by modes that wish to have special speedbar displays.
283 The list is of function names. Each function is called with one
284 parameter BUFFER, the originating buffer. The current buffer is the
285 speedbar buffer.")
287 (defvar speedbar-special-mode-key-map nil
288 "Default keymap used when identifying a specialized display mode.
289 This keymap is local to each buffer that wants to define special keybindings
290 effective when its display is shown.")
292 (defcustom speedbar-visiting-file-hook nil
293 "Hooks run when speedbar visits a file in the selected frame."
294 :group 'speedbar
295 :type 'hook)
297 (defcustom speedbar-visiting-tag-hook '(speedbar-highlight-one-tag-line)
298 "Hooks run when speedbar visits a tag in the selected frame."
299 :group 'speedbar
300 :type 'hook
301 :version "21.1"
302 :options '(speedbar-highlight-one-tag-line
303 speedbar-recenter-to-top
304 speedbar-recenter
307 (defcustom speedbar-load-hook nil
308 "Hooks run when speedbar is loaded."
309 :group 'speedbar
310 :type 'hook)
312 (defcustom speedbar-reconfigure-keymaps-hook nil
313 "Hooks run when the keymaps are regenerated."
314 :group 'speedbar
315 :version "21.1"
316 :type 'hook)
318 (defcustom speedbar-show-unknown-files nil
319 "*Non-nil show files we can't expand with a ? in the expand button.
320 nil means don't show the file in the list."
321 :group 'speedbar
322 :type 'boolean)
324 (defcustom speedbar-update-speed
325 (if speedbar-xemacsp
326 (if speedbar-xemacs20p
327 2 ; 1 is too obrusive in XEmacs
328 5) ; when no idleness, need long delay
330 "*Idle time in seconds needed before speedbar will update itself.
331 Updates occur to allow speedbar to display directory information
332 relevant to the buffer you are currently editing."
333 :group 'speedbar
334 :type 'integer)
336 ;; When I moved to a repeating timer, I had the horrible missfortune
337 ;; of loosing the ability for adaptive speed choice. This update
338 ;; speed currently causes long delays when it should have been turned off.
339 (defcustom speedbar-navigating-speed speedbar-update-speed
340 "*Idle time to wait after navigation commands in speedbar are executed.
341 Navigation commands included expanding/contracting nodes, and moving
342 between different directories."
343 :group 'speedbar
344 :type 'integer)
346 (defcustom speedbar-frame-parameters '((minibuffer . nil)
347 (width . 20)
348 (border-width . 0)
349 (menu-bar-lines . 0)
350 (tool-bar-lines . 0)
351 (unsplittable . t))
352 "*Parameters to use when creating the speedbar frame in Emacs.
353 Any parameter supported by a frame may be added. The parameter `height'
354 will be initialized to the height of the frame speedbar is
355 attached to and added to this list before the new frame is initialized."
356 :group 'speedbar
357 :type '(repeat (cons :format "%v"
358 (symbol :tag "Parameter")
359 (sexp :tag "Value"))))
361 ;; These values by Hrvoje Niksic <hniksic@srce.hr>
362 (defcustom speedbar-frame-plist
363 '(minibuffer nil width 20 border-width 0
364 internal-border-width 0 unsplittable t
365 default-toolbar-visible-p nil has-modeline-p nil
366 menubar-visible-p nil)
367 "*Parameters to use when creating the speedbar frame in XEmacs.
368 Parameters not listed here which will be added automatically are
369 `height' which will be initialized to the height of the frame speedbar
370 is attached to."
371 :group 'speedbar
372 :type '(repeat (group :inline t
373 (symbol :tag "Property")
374 (sexp :tag "Value"))))
376 (defcustom speedbar-use-imenu-flag (stringp (locate-library "imenu"))
377 "*Non-nil means use imenu for file parsing. nil to use etags.
378 XEmacs prior to 20.4 doesn't support imenu, therefore the default is to
379 use etags instead. Etags support is not as robust as imenu support."
380 :tag "Use Imenu for tags"
381 :group 'speedbar
382 :type 'boolean)
384 (defvar speedbar-dynamic-tags-function-list
385 '((speedbar-fetch-dynamic-imenu . speedbar-insert-imenu-list)
386 (speedbar-fetch-dynamic-etags . speedbar-insert-etags-list))
387 "Set to a list of functions which will return and insert a list of tags.
388 Each element is of the form ( FETCH . INSERT ) where FETCH
389 is a function which takes one parameter (the file to tag) and returns a
390 list of tags. The tag list can be of any form as long as the
391 corresponding insert method can handle it. If it returns t, then an
392 error occurred, and the next fetch routine is tried.
393 INSERT is a function which takes an INDENTation level, and a LIST of
394 tags to insert. It will then create the speedbar buttons.")
396 (defcustom speedbar-track-mouse-flag t
397 "*Non-nil means to display info about the line under the mouse."
398 :group 'speedbar
399 :type 'boolean)
401 (defcustom speedbar-sort-tags nil
402 "*If non-nil, sort tags in the speedbar display. *Obsolete*."
403 :group 'speedbar
404 :type 'boolean)
406 (defcustom speedbar-tag-hierarchy-method
407 '(speedbar-prefix-group-tag-hierarchy
408 speedbar-trim-words-tag-hierarchy)
409 "*List of hooks which speedbar will use to organize tags into groups.
410 Groups are defined as expandable meta-tags. Imenu supports
411 such things in some languages, such as separating variables from
412 functions. Each hook takes one argument LST, and may destructively
413 create a new list of the same form. LST is a list of elements of the
414 form:
415 (ELT1 ELT2 ... ELTn)
416 where each ELT is of the form
417 (TAG-NAME-STRING . NUMBER-OR-MARKER)
419 (GROUP-NAME-STRING ELT1 ELT2... ELTn)"
420 :group 'speedbar
421 :type 'hook
422 :options '(speedbar-sort-tag-hierarchy
423 speedbar-trim-words-tag-hierarchy
424 speedbar-prefix-group-tag-hierarchy
425 speedbar-simple-group-tag-hierarchy)
428 (defcustom speedbar-tag-group-name-minimum-length 4
429 "*The minimum length of a prefix group name before expanding.
430 Thus, if the `speedbar-tag-hierarchy-method' includes `prefix-group'
431 and one such groups common characters is less than this number of
432 characters, then the group name will be changed to the form of:
433 worda to wordb
434 instead of just
435 word
436 This way we won't get silly looking listings."
437 :group 'speedbar
438 :type 'integer)
440 (defcustom speedbar-tag-split-minimum-length 20
441 "*Minimum length before we stop trying to create sub-lists in tags.
442 This is used by all tag-hierarchy methods that break large lists into
443 sub-lists."
444 :group 'speedbar
445 :type 'integer)
447 (defcustom speedbar-tag-regroup-maximum-length 10
448 "*Maximum length of submenus that are regrouped.
449 If the regrouping option is used, then if two or more short subgroups
450 are next to each other, then they are combined until this number of
451 items is reached."
452 :group 'speedbar
453 :type 'integer)
455 (defcustom speedbar-activity-change-focus-flag nil
456 "*Non-nil means the selected frame will change based on activity.
457 Thus, if a file is selected for edit, the buffer will appear in the
458 selected frame and the focus will change to that frame."
459 :group 'speedbar
460 :type 'boolean)
462 (defcustom speedbar-directory-button-trim-method 'span
463 "*Indicates how the directory button will be displayed.
464 Possible values are:
465 'span - span large directories over multiple lines.
466 'trim - trim large directories to only show the last few.
467 nil - no trimming."
468 :group 'speedbar
469 :type '(radio (const :tag "Span large directories over mutiple lines."
470 span)
471 (const :tag "Trim large directories to only show the last few."
472 trim)
473 (const :tag "No trimming." nil)))
475 (defcustom speedbar-smart-directory-expand-flag t
476 "*Non-nil means speedbar should use smart expansion.
477 Smart expansion only affects when speedbar wants to display a
478 directory for a file in the attached frame. When smart expansion is
479 enabled, new directories which are children of a displayed directory
480 are expanded in the current framework. If nil, then the current
481 hierarchy would be replaced with the new directory."
482 :group 'speedbar
483 :type 'boolean)
485 (defcustom speedbar-indentation-width 1
486 "*When sub-nodes are expanded, the number of spaces used for indentation."
487 :group 'speedbar
488 :version "21.1"
489 :type 'integer)
491 (defcustom speedbar-hide-button-brackets-flag nil
492 "*Non-nil means speedbar will hide the brackets around the + or -."
493 :group 'speedbar
494 :version "21.1"
495 :type 'boolean)
497 (defcustom speedbar-use-images (and (or (fboundp 'defimage)
498 (fboundp 'make-image-specifier))
499 (if (fboundp 'display-graphic-p)
500 (display-graphic-p)
501 window-system))
502 "*Non-nil if speedbar should display icons."
503 :group 'speedbar
504 :version "21.1"
505 :type 'boolean)
507 (defcustom speedbar-before-popup-hook nil
508 "*Hooks called before popping up the speedbar frame."
509 :group 'speedbar
510 :type 'hook)
512 (defcustom speedbar-before-delete-hook nil
513 "*Hooks called before deleting the speedbar frame."
514 :group 'speedbar
515 :type 'hook)
517 (defcustom speedbar-mode-hook nil
518 "*Hooks called after creating a speedbar buffer."
519 :group 'speedbar
520 :type 'hook)
522 (defcustom speedbar-timer-hook nil
523 "*Hooks called after running the speedbar timer function."
524 :group 'speedbar
525 :type 'hook)
527 (defcustom speedbar-verbosity-level 1
528 "*Verbosity level of the speedbar. 0 means say nothing.
529 1 means medium level verbosity. 2 and higher are higher levels of
530 verbosity."
531 :group 'speedbar
532 :type 'integer)
534 (defvar speedbar-indicator-separator " "
535 "String separating file text from indicator characters.")
537 (defcustom speedbar-vc-do-check t
538 "*Non-nil check all files in speedbar to see if they have been checked out.
539 Any file checked out is marked with `speedbar-vc-indicator'."
540 :group 'speedbar-vc
541 :type 'boolean)
543 (defvar speedbar-vc-indicator "*"
544 "Text used to mark files which are currently checked out.
545 Other version control systems can be added by examining the function
546 `speedbar-vc-path-enable-hook' and `speedbar-vc-in-control-hook'.")
548 (defcustom speedbar-vc-path-enable-hook nil
549 "*Return non-nil if the current path should be checked for Version Control.
550 Functions in this hook must accept one parameter which is the path
551 being checked."
552 :group 'speedbar-vc
553 :type 'hook)
555 (defcustom speedbar-vc-in-control-hook nil
556 "*Return non-nil if the specified file is under Version Control.
557 Functions in this hook must accept two parameters. The PATH of the
558 current file, and the FILENAME of the file being checked."
559 :group 'speedbar-vc
560 :type 'hook)
562 (defvar speedbar-vc-to-do-point nil
563 "Local variable maintaining the current version control check position.")
565 (defcustom speedbar-obj-do-check t
566 "*Non-nil check all files in speedbar to see if they have an object file.
567 Any file checked out is marked with `speedbar-obj-indicator', and the
568 marking is based on `speedbar-obj-alist'."
569 :group 'speedbar-vc
570 :type 'boolean)
572 (defvar speedbar-obj-to-do-point nil
573 "Local variable maintaining the current version control check position.")
575 (defvar speedbar-obj-indicator '("#" . "!")
576 "Text used to mark files that have a corresponding hidden object file.
577 The car is for an up-to-date object. The cdr is for an out of date object.
578 The expression `speedbar-obj-alist' defines who gets tagged.")
580 (defvar speedbar-obj-alist
581 '(("\\.\\([cpC]\\|cpp\\|cc\\)$" . ".o")
582 ("\\.el$" . ".elc")
583 ("\\.java$" . ".class")
584 ("\\.f\\(or\\|90\\|77\\)?$" . ".o")
585 ("\\.tex$" . ".dvi")
586 ("\\.texi$" . ".info"))
587 "Alist of file extensions, and their corresponding object file type.")
589 (defvar speedbar-indicator-regex
590 (concat (regexp-quote speedbar-indicator-separator)
591 "\\("
592 (regexp-quote speedbar-vc-indicator)
593 "\\|"
594 (regexp-quote (car speedbar-obj-indicator))
595 "\\|"
596 (regexp-quote (cdr speedbar-obj-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 (defvar speedbar-ignored-modes nil
609 "*List of major modes which speedbar will not switch directories for.")
611 (defun speedbar-extension-list-to-regex (extlist)
612 "Takes EXTLIST, a list of extensions and transforms it into regexp.
613 All the preceding `.' are stripped for an optimized expression starting
614 with `.' followed by extensions, followed by full-filenames."
615 (let ((regex1 nil) (regex2 nil))
616 (while extlist
617 (if (= (string-to-char (car extlist)) ?.)
618 (setq regex1 (concat regex1 (if regex1 "\\|" "")
619 (substring (car extlist) 1)))
620 (setq regex2 (concat regex2 (if regex2 "\\|" "") (car extlist))))
621 (setq extlist (cdr extlist)))
622 ;; concat all the sub-exressions together, making sure all types
623 ;; of parts exist during concatination.
624 (concat "\\("
625 (if regex1 (concat "\\(\\.\\(" regex1 "\\)\\)") "")
626 (if (and regex1 regex2) "\\|" "")
627 (if regex2 (concat "\\(" regex2 "\\)") "")
628 "\\)$")))
630 (defvar speedbar-ignored-path-regexp nil
631 "Regular expression matching paths speedbar will not switch to.
632 Created from `speedbar-ignored-path-expressions' with the function
633 `speedbar-extension-list-to-regex' (A misnamed function in this case.)
634 Use the function `speedbar-add-ignored-path-regexp', or customize the
635 variable `speedbar-ignored-path-expressions' to modify this variable.")
637 (defcustom speedbar-ignored-path-expressions
638 '("[/\\]logs?[/\\]\\'")
639 "*List of regular expressions matching directories speedbar will ignore.
640 They should included paths to directories which are notoriously very
641 large and take a long time to load in. Use the function
642 `speedbar-add-ignored-path-regexp' to add new items to this list after
643 speedbar is loaded. You may place anything you like in this list
644 before speedbar has been loaded."
645 :group 'speedbar
646 :type '(repeat (regexp :tag "Path Regexp"))
647 :set (lambda (sym val)
648 (setq speedbar-ignored-path-expressions val
649 speedbar-ignored-path-regexp
650 (speedbar-extension-list-to-regex val))))
652 (defcustom speedbar-directory-unshown-regexp "^\\(CVS\\|RCS\\|SCCS\\)\\'"
653 "*Regular expression matching directories not to show in speedbar.
654 They should include commonly existing directories which are not
655 useful, such as version control."
656 :group 'speedbar
657 :type 'string)
659 (defvar speedbar-file-unshown-regexp
660 (let ((nstr "") (noext completion-ignored-extensions))
661 (while noext
662 (setq nstr (concat nstr (regexp-quote (car noext)) "\\'"
663 (if (cdr noext) "\\|" ""))
664 noext (cdr noext)))
665 ;; backup refdir lockfile
666 (concat nstr "\\|#[^#]+#$\\|\\.\\.?\\'\\|\\.#"))
667 "*Regexp matching files we don't want displayed in a speedbar buffer.
668 It is generated from the variable `completion-ignored-extensions'")
670 ;; Compiler silencing trick. The real defvar comes later in this file.
671 (defvar speedbar-file-regexp)
673 ;; this is dangerous to customize, because the defaults will probably
674 ;; change in the future.
675 (defcustom speedbar-supported-extension-expressions
676 (append '(".[ch]\\(\\+\\+\\|pp\\|c\\|h\\|xx\\)?" ".tex\\(i\\(nfo\\)?\\)?"
677 ".el" ".emacs" ".l" ".lsp" ".p" ".java" ".f\\(90\\|77\\|or\\)?")
678 (if speedbar-use-imenu-flag
679 '(".ada" ".p[lm]" ".tcl" ".m" ".scm" ".pm" ".py" ".g"
680 ;; html is not supported by default, but an imenu tags package
681 ;; is available. Also, html files are nice to be able to see.
682 ".s?html"
683 "[Mm]akefile\\(\\.in\\)?")))
684 "*List of regular expressions which will match files supported by tagging.
685 Do not prefix the `.' char with a double \\ to quote it, as the period
686 will be stripped by a simplified optimizer when compiled into a
687 singular expression. This variable will be turned into
688 `speedbar-file-regexp' for use with speedbar. You should use the
689 function `speedbar-add-supported-extension' to add a new extension at
690 runtime, or use the configuration dialog to set it in your .emacs
691 file."
692 :group 'speedbar
693 :version "21.1"
694 :type '(repeat (regexp :tag "Extension Regexp"))
695 :set (lambda (sym val)
696 (setq speedbar-supported-extension-expressions val
697 speedbar-file-regexp (speedbar-extension-list-to-regex val))))
699 (defvar speedbar-file-regexp
700 (speedbar-extension-list-to-regex speedbar-supported-extension-expressions)
701 "Regular expression matching files we know how to expand.
702 Created from `speedbar-supported-extension-expression' with the
703 function `speedbar-extension-list-to-regex'")
705 (defcustom speedbar-scan-subdirs nil
706 "*Non-nil means speedbar will check if subdirs are empty.
707 That way you don't have to click on them to find out. But this
708 incurs extra I/O, hence it slows down directory display
709 proportionally to the number of subdirs."
710 :group 'speedbar
711 :type 'boolean
712 :version 21.4)
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-path-regexp (path-expression)
732 "Add PATH-EXPRESSION as a new ignored path for speedbar tracking.
733 This function will modify `speedbar-ignored-path-regexp' and add
734 PATH-EXPRESSION to `speedbar-ignored-path-expressions'."
735 (interactive "sPath regex: ")
736 (if (not (listp path-expression))
737 (setq path-expression (list path-expression)))
738 (while path-expression
739 (if (member (car path-expression) speedbar-ignored-path-expressions)
741 (setq speedbar-ignored-path-expressions
742 (cons (car path-expression) speedbar-ignored-path-expressions)))
743 (setq path-expression (cdr path-expression)))
744 (setq speedbar-ignored-path-regexp (speedbar-extension-list-to-regex
745 speedbar-ignored-path-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-path-regexp (speedbar-extension-list-to-regex
752 speedbar-ignored-path-expressions)))
754 (defvar speedbar-update-flag (and
755 (or (fboundp 'run-with-idle-timer)
756 (fboundp 'start-itimer)
757 (boundp 'post-command-idle-hook))
758 (if (fboundp 'display-graphic-p)
759 (display-graphic-p)
760 window-system))
761 "*Non-nil means to automatically update the display.
762 When this is nil then speedbar will not follow the attached frame's path.
763 When speedbar is active, use:
765 \\<speedbar-key-map> `\\[speedbar-toggle-updates]'
767 to toggle this value.")
769 (defvar speedbar-syntax-table nil
770 "Syntax-table used on the speedbar.")
772 (if speedbar-syntax-table
774 (setq speedbar-syntax-table (make-syntax-table))
775 ;; turn off paren matching around here.
776 (modify-syntax-entry ?\' " " speedbar-syntax-table)
777 (modify-syntax-entry ?\" " " speedbar-syntax-table)
778 (modify-syntax-entry ?( " " speedbar-syntax-table)
779 (modify-syntax-entry ?) " " speedbar-syntax-table)
780 (modify-syntax-entry ?{ " " speedbar-syntax-table)
781 (modify-syntax-entry ?} " " speedbar-syntax-table)
782 (modify-syntax-entry ?[ " " speedbar-syntax-table)
783 (modify-syntax-entry ?] " " speedbar-syntax-table))
785 (defvar speedbar-key-map nil
786 "Keymap used in speedbar buffer.")
788 (if speedbar-key-map
790 (setq speedbar-key-map (make-keymap))
791 (suppress-keymap speedbar-key-map t)
793 ;; control
794 (define-key speedbar-key-map "g" 'speedbar-refresh)
795 (define-key speedbar-key-map "t" 'speedbar-toggle-updates)
796 (define-key speedbar-key-map "q" 'speedbar-close-frame)
797 (define-key speedbar-key-map "Q" 'delete-frame)
799 ;; navigation
800 (define-key speedbar-key-map "n" 'speedbar-next)
801 (define-key speedbar-key-map "p" 'speedbar-prev)
802 (define-key speedbar-key-map "\M-n" 'speedbar-restricted-next)
803 (define-key speedbar-key-map "\M-p" 'speedbar-restricted-prev)
804 (define-key speedbar-key-map "\C-\M-n" 'speedbar-forward-list)
805 (define-key speedbar-key-map "\C-\M-p" 'speedbar-backward-list)
806 (define-key speedbar-key-map " " 'speedbar-scroll-up)
807 (define-key speedbar-key-map [delete] 'speedbar-scroll-down)
809 ;; Short cuts I happen to find useful
810 (define-key speedbar-key-map "r"
811 (lambda () (interactive)
812 (speedbar-change-initial-expansion-list
813 speedbar-previously-used-expansion-list-name)))
814 (define-key speedbar-key-map "b"
815 (lambda () (interactive)
816 (speedbar-change-initial-expansion-list "quick buffers")))
817 (define-key speedbar-key-map "f"
818 (lambda () (interactive)
819 (speedbar-change-initial-expansion-list "files")))
821 ;; Overrides
822 (substitute-key-definition 'switch-to-buffer
823 'speedbar-switch-buffer-attached-frame
824 speedbar-key-map global-map)
826 (if speedbar-xemacsp
827 (progn
828 ;; mouse bindings so we can manipulate the items on each line
829 (define-key speedbar-key-map 'button2 'speedbar-click)
830 (define-key speedbar-key-map '(shift button2) 'speedbar-power-click)
831 ;; Info doc fix from Bob Weiner
832 (if (featurep 'infodoc)
834 (define-key speedbar-key-map 'button3 'speedbar-xemacs-popup-kludge))
835 (define-key speedbar-key-map '(meta button3) 'speedbar-mouse-item-info)
838 ;; mouse bindings so we can manipulate the items on each line
839 (define-key speedbar-key-map [down-mouse-1] 'speedbar-double-click)
840 (define-key speedbar-key-map [mouse-2] 'speedbar-click)
841 ;; This is the power click for new frames, or refreshing a cache
842 (define-key speedbar-key-map [S-mouse-2] 'speedbar-power-click)
843 ;; This adds a small unecessary visual effect
844 ;;(define-key speedbar-key-map [down-mouse-2] 'speedbar-quick-mouse)
845 (define-key speedbar-key-map [M-mouse-2] 'speedbar-mouse-item-info)
847 (define-key speedbar-key-map [down-mouse-3] 'speedbar-emacs-popup-kludge)
849 ;; This lets the user scroll as if we had a scrollbar... well maybe not
850 (define-key speedbar-key-map [mode-line mouse-2] 'speedbar-mouse-hscroll)
851 ;; another handy place users might click to get our menu.
852 (define-key speedbar-key-map [mode-line down-mouse-1]
853 'speedbar-emacs-popup-kludge)
855 ;; We can't switch buffers with the buffer mouse menu. Lets hack it.
856 (define-key speedbar-key-map [C-down-mouse-1] 'speedbar-hack-buffer-menu)
858 ;; Lastly, we want to track the mouse. Play here
859 (define-key speedbar-key-map [mouse-movement] 'speedbar-track-mouse)
862 (defun speedbar-make-specialized-keymap ()
863 "Create a keymap for use with a speedbar major or minor display mode.
864 This basically creates a sparse keymap, and makes it's parent be
865 `speedbar-key-map'."
866 (let ((k (make-sparse-keymap)))
867 (set-keymap-parent k speedbar-key-map)
870 (defvar speedbar-file-key-map nil
871 "Keymap used in speedbar buffer while files are displayed.")
873 (if speedbar-file-key-map
875 (setq speedbar-file-key-map (speedbar-make-specialized-keymap))
877 ;; Basic tree features
878 (define-key speedbar-file-key-map "e" 'speedbar-edit-line)
879 (define-key speedbar-file-key-map "\C-m" 'speedbar-edit-line)
880 (define-key speedbar-file-key-map "+" 'speedbar-expand-line)
881 (define-key speedbar-file-key-map "=" 'speedbar-expand-line)
882 (define-key speedbar-file-key-map "-" 'speedbar-contract-line)
884 ;; file based commands
885 (define-key speedbar-file-key-map "U" 'speedbar-up-directory)
886 (define-key speedbar-file-key-map "I" 'speedbar-item-info)
887 (define-key speedbar-file-key-map "B" 'speedbar-item-byte-compile)
888 (define-key speedbar-file-key-map "L" 'speedbar-item-load)
889 (define-key speedbar-file-key-map "C" 'speedbar-item-copy)
890 (define-key speedbar-file-key-map "D" 'speedbar-item-delete)
891 (define-key speedbar-file-key-map "O" 'speedbar-item-object-delete)
892 (define-key speedbar-file-key-map "R" 'speedbar-item-rename)
895 (defvar speedbar-easymenu-definition-base
896 (append
897 '("Speedbar"
898 ["Update" speedbar-refresh t]
899 ["Auto Update" speedbar-toggle-updates
900 :style toggle :selected speedbar-update-flag])
901 (if (and (or (fboundp 'defimage)
902 (fboundp 'make-image-specifier))
903 (if (fboundp 'display-graphic-p)
904 (display-graphic-p)
905 window-system))
906 (list
907 ["Use Images" speedbar-toggle-images
908 :style toggle :selected speedbar-use-images]))
910 "Base part of the speedbar menu.")
912 (defvar speedbar-easymenu-definition-special
913 '(["Edit Item On Line" speedbar-edit-line t]
914 ["Show All Files" speedbar-toggle-show-all-files
915 :style toggle :selected speedbar-show-unknown-files]
916 ["Expand File Tags" speedbar-expand-line
917 (save-excursion (beginning-of-line)
918 (looking-at "[0-9]+: *.\\+. "))]
919 ["Flush Cache & Expand" speedbar-flush-expand-line
920 (save-excursion (beginning-of-line)
921 (looking-at "[0-9]+: *.\\+. "))]
922 ["Contract File Tags" speedbar-contract-line
923 (save-excursion (beginning-of-line)
924 (looking-at "[0-9]+: *.-. "))]
925 ; ["Sort Tags" speedbar-toggle-sorting
926 ; :style toggle :selected speedbar-sort-tags]
927 "----"
928 ["File/Tag Information" speedbar-item-info t]
929 ["Load Lisp File" speedbar-item-load
930 (save-excursion
931 (beginning-of-line)
932 (looking-at "[0-9]+: *\\[[+-]\\] .+\\(\\.el\\)\\( \\|$\\)"))]
933 ["Byte Compile File" speedbar-item-byte-compile
934 (save-excursion
935 (beginning-of-line)
936 (looking-at "[0-9]+: *\\[[+-]\\] .+\\(\\.el\\)\\( \\|$\\)"))]
937 ["Copy File" speedbar-item-copy
938 (save-excursion (beginning-of-line) (looking-at "[0-9]+: *\\["))]
939 ["Rename File" speedbar-item-rename
940 (save-excursion (beginning-of-line) (looking-at "[0-9]+: *[[<]"))]
941 ["Delete File" speedbar-item-delete
942 (save-excursion (beginning-of-line) (looking-at "[0-9]+: *[[<]"))]
943 ["Delete Object" speedbar-item-object-delete
944 (save-excursion (beginning-of-line)
945 (looking-at "[0-9]+: *\\[[+-]\\] [^ \n]+ \\*?[!#]$"))]
947 "Additional menu items while in file-mode.")
949 (defvar speedbar-easymenu-definition-trailer
950 (append
951 (if (and (featurep 'custom) (fboundp 'custom-declare-variable))
952 (list ["Customize..." speedbar-customize t]))
953 (list
954 ["Close" speedbar-close-frame t]
955 ["Quit" delete-frame t] ))
956 "Menu items appearing at the end of the speedbar menu.")
958 (defvar speedbar-desired-buffer nil
959 "Non-nil when speedbar is showing buttons specific to a special mode.
960 In this case it is the originating buffer.")
961 (defvar speedbar-buffer nil
962 "The buffer displaying the speedbar.")
963 (defvar speedbar-frame nil
964 "The frame displaying speedbar.")
965 (defvar speedbar-cached-frame nil
966 "The frame that was last created, then removed from the display.")
967 (defvar speedbar-full-text-cache nil
968 "The last open directory is saved in its entirety for ultra-fast switching.")
969 (defvar speedbar-timer nil
970 "The speedbar timer used for updating the buffer.")
971 (defvar speedbar-attached-frame nil
972 "The frame which started speedbar mode.
973 This is the frame from which all data displayed in the speedbar is
974 gathered, and in which files and such are displayed.")
976 (defvar speedbar-last-selected-file nil
977 "The last file which was selected in speedbar buffer.")
979 (defvar speedbar-shown-directories nil
980 "Maintain list of directories simultaneously open in the current speedbar.")
982 (defvar speedbar-directory-contents-alist nil
983 "An association list of directories and their contents.
984 Each sublist was returned by `speedbar-file-lists'. This list is
985 maintained to speed up the refresh rate when switching between
986 directories.")
988 (defvar speedbar-power-click nil
989 "Never set this by hand. Value is t when S-mouse activity occurs.")
992 ;;; Compatibility
994 (if (fboundp 'frame-parameter)
996 (defalias 'speedbar-frame-parameter 'frame-parameter)
998 (defun speedbar-frame-parameter (frame parameter)
999 "Return FRAME's PARAMETER value."
1000 (cdr (assoc parameter (frame-parameters frame)))))
1002 (if (fboundp 'make-overlay)
1003 (progn
1004 (defalias 'speedbar-make-overlay 'make-overlay)
1005 (defalias 'speedbar-overlay-put 'overlay-put)
1006 (defalias 'speedbar-delete-overlay 'delete-overlay)
1007 (defalias 'speedbar-overlay-start 'overlay-start)
1008 (defalias 'speedbar-overlay-end 'overlay-end)
1009 (defalias 'speedbar-mode-line-update 'force-mode-line-update))
1010 (defalias 'speedbar-make-overlay 'make-extent)
1011 (defalias 'speedbar-overlay-put 'set-extent-property)
1012 (defalias 'speedbar-delete-overlay 'delete-extent)
1013 (defalias 'speedbar-overlay-start 'extent-start)
1014 (defalias 'speedbar-overlay-end 'extent-end)
1015 (defalias 'speedbar-mode-line-update 'redraw-modeline))
1017 ;;; Mode definitions/ user commands
1020 ;;;###autoload
1021 (defalias 'speedbar 'speedbar-frame-mode)
1022 ;;;###autoload
1023 (defun speedbar-frame-mode (&optional arg)
1024 "Enable or disable speedbar. Positive ARG means turn on, negative turn off.
1025 nil means toggle. Once the speedbar frame is activated, a buffer in
1026 `speedbar-mode' will be displayed. Currently, only one speedbar is
1027 supported at a time.
1028 `speedbar-before-popup-hook' is called before popping up the speedbar frame.
1029 `speedbar-before-delete-hook' is called before the frame is deleted."
1030 (interactive "P")
1031 ;; toggle frame on and off.
1032 (if (not arg) (if (and (frame-live-p speedbar-frame)
1033 (frame-visible-p speedbar-frame))
1034 (setq arg -1) (setq arg 1)))
1035 ;; turn the frame off on neg number
1036 (if (and (numberp arg) (< arg 0))
1037 (progn
1038 (run-hooks 'speedbar-before-delete-hook)
1039 (if (and speedbar-frame (frame-live-p speedbar-frame))
1040 (progn
1041 (setq speedbar-cached-frame speedbar-frame)
1042 (make-frame-invisible speedbar-frame)))
1043 (setq speedbar-frame nil)
1044 (speedbar-set-timer nil)
1045 ;; Used to delete the buffer. This has the annoying affect of
1046 ;; preventing whatever took its place from ever appearing
1047 ;; as the default after a C-x b was typed
1048 ;;(if (bufferp speedbar-buffer)
1049 ;; (kill-buffer speedbar-buffer))
1051 ;; Set this as our currently attached frame
1052 (setq speedbar-attached-frame (selected-frame))
1053 (run-hooks 'speedbar-before-popup-hook)
1054 ;; Get the frame to work in
1055 (if (frame-live-p speedbar-cached-frame)
1056 (progn
1057 (setq speedbar-frame speedbar-cached-frame)
1058 (make-frame-visible speedbar-frame)
1059 ;; Get the buffer to play with
1060 (speedbar-mode)
1061 (select-frame speedbar-frame)
1062 (if (not (eq (current-buffer) speedbar-buffer))
1063 (switch-to-buffer speedbar-buffer))
1064 (set-window-dedicated-p (selected-window) t)
1065 (raise-frame speedbar-frame)
1066 (speedbar-set-timer speedbar-update-speed)
1068 (if (frame-live-p speedbar-frame)
1069 (raise-frame speedbar-frame)
1070 (setq speedbar-frame
1071 (if speedbar-xemacsp
1072 ;; Only guess height if it is not specified.
1073 (if (member 'height speedbar-frame-plist)
1074 (make-frame speedbar-frame-plist)
1075 (make-frame (nconc (list 'height
1076 (speedbar-needed-height))
1077 speedbar-frame-plist)))
1078 (let* ((mh (speedbar-frame-parameter nil 'menu-bar-lines))
1079 (cfx (speedbar-frame-parameter nil 'left))
1080 (cfy (speedbar-frame-parameter nil 'top))
1081 (cfw (frame-pixel-width))
1082 (params
1083 ;; Only add a guessed height if one is not specified
1084 ;; in the input parameters.
1085 (if (assoc 'height speedbar-frame-parameters)
1086 speedbar-frame-parameters
1087 (append
1088 speedbar-frame-parameters
1089 (list (cons 'height (+ mh (frame-height)))))))
1090 (frame
1091 (if (or (< emacs-major-version 20)
1092 (not (eq window-system 'x)))
1093 (make-frame params)
1094 (let ((x-pointer-shape x-pointer-top-left-arrow)
1095 (x-sensitive-text-pointer-shape
1096 x-pointer-hand2))
1097 (make-frame params)))))
1098 ;; Position speedbar frame.
1099 (if (or (not window-system) (eq window-system 'pc)
1100 (assoc 'left speedbar-frame-parameters)
1101 (assoc 'top speedbar-frame-parameters))
1102 ;; Do no positioning if not on a windowing system,
1103 ;; or if left/top were specified in the parameters.
1104 frame
1105 (let ((cfx
1106 (if (not (consp cfx))
1108 ;; If cfx is a list, that means we grow
1109 ;; from a specific edge of the display.
1110 ;; Convert that to the distance from the
1111 ;; left side of the display.
1112 (if (eq (car cfx) '-)
1113 ;; A - means distance from the right edge
1114 ;; of the display, or DW - cfx - framewidth
1115 (- (x-display-pixel-width) (car (cdr cfx))
1116 (frame-pixel-width))
1117 (car (cdr cfx))))))
1118 (modify-frame-parameters
1119 frame
1120 (list
1121 (cons
1122 'left
1123 ;; Decide which side to put it
1124 ;; on. 200 is just a buffer
1125 ;; for the left edge of the
1126 ;; screen. The extra 10 is just
1127 ;; dressings for window decorations.
1128 (let ((sfw (frame-pixel-width frame)))
1129 (let ((left-guess (- cfx 10 sfw))
1130 (right-guess (+ cfx cfw 5)))
1131 (let ((left-margin left-guess)
1132 (right-margin
1133 (- (x-display-pixel-width)
1134 right-guess 5 sfw)))
1135 (cond ((>= left-margin 0) left-guess)
1136 ((>= right-margin 0) right-guess)
1137 ;; otherwise choose side we overlap less
1138 ((> left-margin right-margin) 0)
1139 (t (- (x-display-pixel-width) sfw 5)))))))
1140 (cons 'top cfy)))
1141 frame)))))
1142 ;; reset the selection variable
1143 (setq speedbar-last-selected-file nil)
1144 ;; Put the buffer into the frame
1145 (save-window-excursion
1146 ;; Get the buffer to play with
1147 (speedbar-mode)
1148 (select-frame speedbar-frame)
1149 (switch-to-buffer speedbar-buffer)
1150 (set-window-dedicated-p (selected-window) t))
1151 (if (and (or (null window-system) (eq window-system 'pc))
1152 (fboundp 'set-frame-name))
1153 (progn
1154 (select-frame speedbar-frame)
1155 (set-frame-name "Speedbar")))
1156 (speedbar-set-timer speedbar-update-speed)))))
1158 ;;;###autoload
1159 (defun speedbar-get-focus ()
1160 "Change frame focus to or from the speedbar frame.
1161 If the selected frame is not speedbar, then speedbar frame is
1162 selected. If the speedbar frame is active, then select the attached frame."
1163 (interactive)
1164 (if (eq (selected-frame) speedbar-frame)
1165 (if (frame-live-p speedbar-attached-frame)
1166 (select-frame speedbar-attached-frame))
1167 ;; If updates are off, then refresh the frame (they want it now...)
1168 (if (not speedbar-update-flag)
1169 (let ((speedbar-update-flag t))
1170 (speedbar-timer-fn)))
1171 ;; make sure we have a frame
1172 (if (not (frame-live-p speedbar-frame)) (speedbar-frame-mode 1))
1173 ;; go there
1174 (select-frame speedbar-frame)
1176 (other-frame 0))
1178 (defun speedbar-close-frame ()
1179 "Turn off a currently active speedbar."
1180 (interactive)
1181 (speedbar-frame-mode -1)
1182 (select-frame speedbar-attached-frame)
1183 (other-frame 0))
1185 (defun speedbar-switch-buffer-attached-frame (&optional buffer)
1186 "Switch to BUFFER in speedbar's attached frame, and raise that frame.
1187 This overrides the default behavior of `switch-to-buffer' which is
1188 broken because of the dedicated speedbar frame."
1189 (interactive)
1190 ;; Assume we are in the speedbar frame.
1191 (speedbar-get-focus)
1192 ;; Now switch buffers
1193 (if buffer
1194 (switch-to-buffer buffer)
1195 (call-interactively 'switch-to-buffer nil nil)))
1197 (defmacro speedbar-frame-width ()
1198 "Return the width of the speedbar frame in characters.
1199 nil if it doesn't exist."
1200 '(frame-width speedbar-frame))
1202 ;; XEmacs function only.
1203 (defun speedbar-needed-height (&optional frame)
1204 "The needed height for the tool bar FRAME (in characters)."
1205 (or frame (setq frame (selected-frame)))
1206 ;; The 1 is the missing modeline/minibuffer
1207 (+ 1 (/ (frame-pixel-height frame)
1208 (face-height 'default frame))))
1210 (defun speedbar-mode ()
1211 "Major mode for managing a display of directories and tags.
1212 \\<speedbar-key-map>
1213 The first line represents the default path of the speedbar frame.
1214 Each directory segment is a button which jumps speedbar's default
1215 directory to that path. Buttons are activated by clicking `\\[speedbar-click]'.
1216 In some situations using `\\[speedbar-power-click]' is a `power click' which will
1217 rescan cached items, or pop up new frames.
1219 Each line starting with <+> represents a directory. Click on the <+>
1220 to insert the directory listing into the current tree. Click on the
1221 <-> to retract that list. Click on the directory name to go to that
1222 directory as the default.
1224 Each line starting with [+] is a file. If the variable
1225 `speedbar-show-unknown-files' is t, the lines starting with [?] are
1226 files which don't have imenu support, but are not expressly ignored.
1227 Files are completely ignored if they match `speedbar-file-unshown-regexp'
1228 which is generated from `completion-ignored-extensions'.
1230 Files with a `*' character after their name are files checked out of a
1231 version control system. (Currently only RCS is supported.) New
1232 version control systems can be added by examining the documentation
1233 for `speedbar-this-file-in-vc' and `speedbar-vc-check-dir-p'.
1235 Files with a `#' or `!' character after them are source files that
1236 have an object file associated with them. The `!' indicates that the
1237 files is out of date. You can control what source/object associations
1238 exist through the variable `speedbar-obj-alist'.
1240 Click on the [+] to display a list of tags from that file. Click on
1241 the [-] to retract the list. Click on the file name to edit the file
1242 in the attached frame.
1244 If you open tags, you might find a node starting with {+}, which is a
1245 category of tags. Click the {+} to expand the category. Jump-able
1246 tags start with >. Click the name of the tag to go to that position
1247 in the selected file.
1249 \\{speedbar-key-map}"
1250 ;; NOT interactive
1251 (save-excursion
1252 (setq speedbar-buffer (set-buffer (get-buffer-create " SPEEDBAR")))
1253 (kill-all-local-variables)
1254 (setq major-mode 'speedbar-mode)
1255 (setq mode-name "Speedbar")
1256 (set-syntax-table speedbar-syntax-table)
1257 (setq font-lock-keywords nil) ;; no font-locking please
1258 (setq truncate-lines t)
1259 (make-local-variable 'frame-title-format)
1260 (setq frame-title-format "Speedbar")
1261 ;; Set this up special just for the speedbar buffer
1262 ;; Terminal minibuffer stuff does not require this.
1263 (if (and window-system (not (eq window-system 'pc))
1264 (null default-minibuffer-frame))
1265 (progn
1266 (make-local-variable 'default-minibuffer-frame)
1267 (setq default-minibuffer-frame speedbar-attached-frame)))
1268 ;; Correct use of `temp-buffer-show-function': Bob Weiner
1269 (if (and (boundp 'temp-buffer-show-hook)
1270 (boundp 'temp-buffer-show-function))
1271 (progn (make-local-variable 'temp-buffer-show-hook)
1272 (setq temp-buffer-show-hook temp-buffer-show-function)))
1273 (make-local-variable 'temp-buffer-show-function)
1274 (setq temp-buffer-show-function 'speedbar-temp-buffer-show-function)
1275 (if speedbar-xemacsp
1276 (progn
1277 ;; Argh! mouse-track-click-hook doesn't understand the
1278 ;; make-local-hook conventions.
1279 (make-local-variable 'mouse-track-click-hook)
1280 (add-hook 'mouse-track-click-hook
1281 (lambda (event count)
1282 (if (/= (event-button event) 1)
1283 nil ; Do normal operations.
1284 (cond ((eq count 1)
1285 (speedbar-quick-mouse event))
1286 ((or (eq count 2)
1287 (eq count 3))
1288 (speedbar-mouse-set-point event)
1289 (speedbar-do-function-pointer)
1290 (speedbar-quick-mouse event)))
1291 ;; Don't do normal operations.
1292 t)))))
1293 (add-hook 'kill-buffer-hook (lambda () (let ((skilling (boundp 'skilling)))
1294 (if skilling
1296 (if (eq (current-buffer)
1297 speedbar-buffer)
1298 (speedbar-frame-mode -1)))))
1299 t t)
1300 (toggle-read-only 1)
1301 (speedbar-set-mode-line-format)
1302 (if speedbar-xemacsp
1303 (with-no-warnings
1304 (set (make-local-variable 'mouse-motion-handler)
1305 'speedbar-track-mouse-xemacs))
1306 (if speedbar-track-mouse-flag
1307 (set (make-local-variable 'track-mouse) t)) ;this could be messy.
1308 (setq auto-show-mode nil)) ;no auto-show for Emacs
1309 (run-hooks 'speedbar-mode-hook))
1310 (speedbar-update-contents)
1311 speedbar-buffer)
1313 (defmacro speedbar-with-attached-buffer (&rest forms)
1314 "Execute FORMS in the attached frame's special buffer.
1315 Optionally select that frame if necessary."
1316 `(save-selected-window
1317 (speedbar-set-timer speedbar-update-speed)
1318 (select-frame speedbar-attached-frame)
1319 ,@forms
1320 (speedbar-maybee-jump-to-attached-frame)))
1322 (defun speedbar-message (fmt &rest args)
1323 "Like message, but for use in the speedbar frame.
1324 Argument FMT is the format string, and ARGS are the arguments for message."
1325 (save-selected-window
1326 (select-frame speedbar-attached-frame)
1327 (apply 'message fmt args)))
1329 (defun speedbar-y-or-n-p (prompt)
1330 "Like `y-or-n-p', but for use in the speedbar frame.
1331 Argument PROMPT is the prompt to use."
1332 (save-selected-window
1333 (if (and default-minibuffer-frame (not (eq default-minibuffer-frame
1334 speedbar-attached-frame)))
1335 (select-frame speedbar-attached-frame))
1336 (y-or-n-p prompt)))
1338 (defun speedbar-show-info-under-mouse (&optional event)
1339 "Call the info function for the line under the mouse.
1340 Optional EVENT is currently not used."
1341 (let ((pos (mouse-position))) ; we ignore event until I use it later.
1342 (if (equal (car pos) speedbar-frame)
1343 (save-excursion
1344 (save-window-excursion
1345 (apply 'set-mouse-position pos)
1346 (speedbar-item-info))))))
1348 (defun speedbar-set-mode-line-format ()
1349 "Set the format of the mode line based on the current speedbar environment.
1350 This gives visual indications of what is up. It EXPECTS the speedbar
1351 frame and window to be the currently active frame and window."
1352 (if (and (frame-live-p speedbar-frame)
1353 (or (not speedbar-xemacsp)
1354 (with-no-warnings
1355 (specifier-instance has-modeline-p))))
1356 (save-excursion
1357 (set-buffer speedbar-buffer)
1358 (let* ((w (or (speedbar-frame-width) 20))
1359 (p1 "<<")
1360 (p5 ">>")
1361 (p3 (if speedbar-update-flag "SPEEDBAR" "SLOWBAR"))
1362 (blank (- w (length p1) (length p3) (length p5)
1363 (if line-number-mode 4 0)))
1364 (p2 (if (> blank 0)
1365 (make-string (/ blank 2) ? )
1366 ""))
1367 (p4 (if (> blank 0)
1368 (make-string (+ (/ blank 2) (% blank 2)) ? )
1369 ""))
1371 (if line-number-mode
1372 (list (concat p1 p2 p3) '(line-number-mode " %3l")
1373 (concat p4 p5))
1374 (list (concat p1 p2 p3 p4 p5)))))
1375 (if (not (equal mode-line-format tf))
1376 (progn
1377 (setq mode-line-format tf)
1378 (speedbar-mode-line-update)))))))
1380 (defun speedbar-temp-buffer-show-function (buffer)
1381 "Placed in the variable `temp-buffer-show-function' in `speedbar-mode'.
1382 If a user requests help using \\[help-command] <Key> the temp BUFFER will be
1383 redirected into a window on the attached frame."
1384 (if speedbar-attached-frame (select-frame speedbar-attached-frame))
1385 (pop-to-buffer buffer nil)
1386 (other-window -1)
1387 ;; Fix for using this hook on some platforms: Bob Weiner
1388 (cond ((not speedbar-xemacsp)
1389 (run-hooks 'temp-buffer-show-hook))
1390 ((fboundp 'run-hook-with-args)
1391 (run-hook-with-args 'temp-buffer-show-hook buffer))
1392 ((and (boundp 'temp-buffer-show-hook)
1393 (listp temp-buffer-show-hook))
1394 (mapcar (function (lambda (hook) (funcall hook buffer)))
1395 temp-buffer-show-hook))))
1397 (defvar speedbar-previous-menu nil
1398 "The menu before the last `speedbar-reconfigure-keymaps' was called.")
1400 (defun speedbar-reconfigure-keymaps ()
1401 "Reconfigure the menu-bar in a speedbar frame.
1402 Different menu items are displayed depending on the current display mode
1403 and the existence of packages."
1404 (let ((md (append
1405 speedbar-easymenu-definition-base
1406 (if speedbar-shown-directories
1407 ;; file display mode version
1408 (speedbar-initial-menu)
1409 (save-excursion
1410 (select-frame speedbar-attached-frame)
1411 (if (local-variable-p
1412 'speedbar-easymenu-definition-special
1413 (current-buffer))
1414 ;; If bound locally, we can use it
1415 speedbar-easymenu-definition-special)))
1416 ;; Dynamic menu stuff
1417 '("-")
1418 (list (cons "Displays"
1419 (let ((displays nil)
1420 (alist speedbar-initial-expansion-mode-alist))
1421 (while alist
1422 (setq displays
1423 (cons
1424 (vector
1425 (capitalize (car (car alist)))
1426 (list
1427 'speedbar-change-initial-expansion-list
1428 (car (car alist)))
1430 displays))
1431 (setq alist (cdr alist)))
1432 displays)))
1433 ;; The trailer
1434 speedbar-easymenu-definition-trailer))
1435 (localmap (save-excursion
1436 (let ((cf (selected-frame)))
1437 (prog2
1438 (select-frame speedbar-attached-frame)
1439 (if (local-variable-p
1440 'speedbar-special-mode-key-map
1441 (current-buffer))
1442 speedbar-special-mode-key-map)
1443 (select-frame cf))))))
1444 (save-excursion
1445 (set-buffer speedbar-buffer)
1446 (use-local-map (or localmap
1447 (speedbar-initial-keymap)
1448 ;; This creates a small keymap we can glom the
1449 ;; menu adjustments into.
1450 (speedbar-make-specialized-keymap)))
1451 ;; Delete the old menu if applicable.
1452 (if speedbar-previous-menu (easy-menu-remove speedbar-previous-menu))
1453 (setq speedbar-previous-menu md)
1454 ;; Now add the new menu
1455 (if (not speedbar-xemacsp)
1456 (easy-menu-define speedbar-menu-map (current-local-map)
1457 "Speedbar menu" md)
1458 (easy-menu-add md (current-local-map))
1459 (set-buffer-menubar (list md))))
1460 (run-hooks 'speedbar-reconfigure-keymaps-hook)))
1463 ;;; User Input stuff
1466 ;; XEmacs: this can be implemented using modeline keymaps, but there
1467 ;; is no use, as we have horizontal scrollbar (as the docstring
1468 ;; hints.)
1469 (defun speedbar-mouse-hscroll (e)
1470 "Read a mouse event E from the mode line, and horizontally scroll.
1471 If the mouse is being clicked on the far left, or far right of the
1472 mode-line. This is only useful for non-XEmacs."
1473 (interactive "e")
1474 (let* ((xp (car (nth 2 (car (cdr e)))))
1475 (cpw (/ (frame-pixel-width)
1476 (frame-width)))
1477 (oc (1+ (/ xp cpw)))
1479 (cond ((< oc 3)
1480 (scroll-left 2))
1481 ((> oc (- (window-width) 3))
1482 (scroll-right 2))
1483 (t (speedbar-message
1484 "Click on the edge of the modeline to scroll left/right")))
1485 ;;(speedbar-message "X: Pixel %d Char Pixels %d On char %d" xp cpw oc)
1488 (defun speedbar-customize ()
1489 "Customize speedbar using the Custom package."
1490 (interactive)
1491 (let ((sf (selected-frame)))
1492 (select-frame speedbar-attached-frame)
1493 (customize-group 'speedbar)
1494 (select-frame sf))
1495 (speedbar-maybee-jump-to-attached-frame))
1497 (defun speedbar-track-mouse (event)
1498 "For motion EVENT, display info about the current line."
1499 (interactive "e")
1500 (if (not speedbar-track-mouse-flag)
1502 (save-excursion
1503 (let ((char (nth 1 (car (cdr event)))))
1504 (if (not (numberp char))
1505 (speedbar-message nil)
1506 (goto-char char)
1507 ;; (speedbar-message "%S" event)
1508 (speedbar-item-info)
1509 )))))
1511 (defun speedbar-track-mouse-xemacs (event)
1512 "For motion EVENT, display info about the current line."
1513 (if (functionp (default-value 'mouse-motion-handler))
1514 (funcall (default-value 'mouse-motion-handler) event))
1515 (if speedbar-track-mouse-flag
1516 (save-excursion
1517 (save-window-excursion
1518 (condition-case ()
1519 (progn (mouse-set-point event)
1520 ;; Prevent focus-related bugs.
1521 (if (eq major-mode 'speedbar-mode)
1522 (speedbar-item-info)))
1523 (error nil))))))
1525 ;; In XEmacs, we make popup menus work on the item over mouse (as
1526 ;; opposed to where the point happens to be.) We attain this by
1527 ;; temporarily moving the point to that place.
1528 ;; Hrvoje Niksic <hniksic@srce.hr>
1529 (defun speedbar-xemacs-popup-kludge (event)
1530 "Pop up a menu related to the clicked on item.
1531 Must be bound to EVENT."
1532 (interactive "e")
1533 (select-frame speedbar-frame)
1534 (save-excursion
1535 (goto-char (event-closest-point event))
1536 (beginning-of-line)
1537 (forward-char (min 5 (- (save-excursion (end-of-line) (point))
1538 (save-excursion (beginning-of-line) (point)))))
1539 (popup-mode-menu)
1540 ;; Wait for menu to bail out. `popup-mode-menu' (and other popup
1541 ;; menu functions) return immediately.
1542 (let (new)
1543 (while (not (misc-user-event-p (setq new (next-event))))
1544 (dispatch-event new))
1545 (dispatch-event new))))
1547 (defun speedbar-emacs-popup-kludge (e)
1548 "Pop up a menu related to the clicked on item.
1549 Must be bound to event E."
1550 (interactive "e")
1551 (save-excursion
1552 (mouse-set-point e)
1553 ;; This gets the cursor where the user can see it.
1554 (if (not (bolp)) (forward-char -1))
1555 (sit-for 0)
1556 (mouse-major-mode-menu e nil)))
1558 (defun speedbar-hack-buffer-menu (e)
1559 "Control mouse 1 is buffer menu.
1560 This hack overrides it so that the right thing happens in the main
1561 Emacs frame, not in the speedbar frame.
1562 Argument E is the event causing this activity."
1563 (interactive "e")
1564 (let ((fn (lookup-key global-map (if speedbar-xemacsp
1565 '(control button1)
1566 [C-down-mouse-1])))
1567 (newbuff nil))
1568 (unwind-protect
1569 (save-excursion
1570 (set-window-dedicated-p (selected-window) nil)
1571 (call-interactively fn)
1572 (setq newbuff (current-buffer)))
1573 (switch-to-buffer speedbar-buffer)
1574 (set-window-dedicated-p (selected-window) t))
1575 (if (not (eq newbuff speedbar-buffer))
1576 (speedbar-with-attached-buffer
1577 (switch-to-buffer newbuff)))))
1579 (defun speedbar-next (arg)
1580 "Move to the next ARGth line in a speedbar buffer."
1581 (interactive "p")
1582 (forward-line (or arg 1))
1583 (speedbar-item-info)
1584 (speedbar-position-cursor-on-line))
1586 (defun speedbar-prev (arg)
1587 "Move to the previous ARGth line in a speedbar buffer."
1588 (interactive "p")
1589 (speedbar-next (if arg (- arg) -1)))
1591 (defun speedbar-restricted-move (arg)
1592 "Move to the next ARGth line in a speedbar buffer at the same depth.
1593 This means that movement is restricted to a subnode, and that siblings
1594 of intermediate nodes are skipped."
1595 (if (not (numberp arg)) (signal 'wrong-type-argument (list arg 'numberp)))
1596 ;; First find the extent for which we are allowed to move.
1597 (let ((depth (save-excursion (beginning-of-line)
1598 (if (looking-at "[0-9]+:")
1599 (string-to-int (match-string 0))
1600 0)))
1601 (crement (if (< arg 0) 1 -1)) ; decrement or increment
1602 (lastmatch (point)))
1603 (while (/= arg 0)
1604 (forward-line (- crement))
1605 (let ((subdepth (save-excursion (beginning-of-line)
1606 (if (looking-at "[0-9]+:")
1607 (string-to-int (match-string 0))
1608 0))))
1609 (cond ((or (< subdepth depth)
1610 (progn (end-of-line) (eobp))
1611 (progn (beginning-of-line) (bobp)))
1612 ;; We have reached the end of this block.
1613 (goto-char lastmatch)
1614 (setq arg 0)
1615 (error "End of sub-list"))
1616 ((= subdepth depth)
1617 (setq lastmatch (point)
1618 arg (+ arg crement))))))
1619 (speedbar-position-cursor-on-line)))
1621 (defun speedbar-restricted-next (arg)
1622 "Move to the next ARGth line in a speedbar buffer at the same depth.
1623 This means that movement is restricted to a subnode, and that siblings
1624 of intermediate nodes are skipped."
1625 (interactive "p")
1626 (speedbar-restricted-move (or arg 1))
1627 (speedbar-item-info))
1630 (defun speedbar-restricted-prev (arg)
1631 "Move to the previous ARGth line in a speedbar buffer at the same depth.
1632 This means that movement is restricted to a subnode, and that siblings
1633 of intermediate nodes are skipped."
1634 (interactive "p")
1635 (speedbar-restricted-move (if arg (- arg) -1))
1636 (speedbar-item-info))
1638 (defun speedbar-navigate-list (arg)
1639 "Move across ARG groups of similarly typed items in speedbar.
1640 Stop on the first line of the next type of item, or on the last or first item
1641 if we reach a buffer boundary."
1642 (interactive "p")
1643 (beginning-of-line)
1644 (if (looking-at "[0-9]+: *[[<{][-+?][]>}] ")
1645 (let ((str (regexp-quote (match-string 0))))
1646 (while (looking-at str)
1647 (speedbar-restricted-move arg)
1648 (beginning-of-line))))
1649 (speedbar-position-cursor-on-line))
1651 (defun speedbar-forward-list ()
1652 "Move forward over the current list.
1653 A LIST in speedbar is a group of similarly typed items, such as directories,
1654 files, or the directory button."
1655 (interactive)
1656 (speedbar-navigate-list 1)
1657 (speedbar-item-info))
1659 (defun speedbar-backward-list ()
1660 "Move backward over the current list.
1661 A LIST in speedbar is a group of similarly typed items, such as directories,
1662 files, or the directory button."
1663 (interactive)
1664 (speedbar-navigate-list -1)
1665 (speedbar-item-info))
1667 (defun speedbar-scroll-up (&optional arg)
1668 "Page down one screen-full of the speedbar, or ARG lines."
1669 (interactive "P")
1670 (scroll-up arg)
1671 (speedbar-position-cursor-on-line))
1673 (defun speedbar-scroll-down (&optional arg)
1674 "Page up one screen-full of the speedbar, or ARG lines."
1675 (interactive "P")
1676 (scroll-down arg)
1677 (speedbar-position-cursor-on-line))
1679 (defun speedbar-up-directory ()
1680 "Keyboard accelerator for moving the default directory up one.
1681 Assumes that the current buffer is the speedbar buffer."
1682 (interactive)
1683 (setq default-directory (expand-file-name (concat default-directory "../")))
1684 (speedbar-update-contents))
1686 ;;; Speedbar file activity (aka creeping featurism)
1688 (defun speedbar-refresh ()
1689 "Refresh the current speedbar display, disposing of any cached data."
1690 (interactive)
1691 (let ((dl speedbar-shown-directories)
1692 deactivate-mark)
1693 (while dl
1694 (adelete 'speedbar-directory-contents-alist (car dl))
1695 (setq dl (cdr dl)))
1696 (if (<= 1 speedbar-verbosity-level)
1697 (speedbar-message "Refreshing speedbar..."))
1698 (speedbar-update-contents)
1699 (speedbar-stealthy-updates)
1700 ;; Reset the timer in case it got really hosed for some reason...
1701 (speedbar-set-timer speedbar-update-speed)
1702 (if (<= 1 speedbar-verbosity-level)
1703 (speedbar-message "Refreshing speedbar...done"))))
1705 (defun speedbar-item-load ()
1706 "Load the item under the cursor or mouse if it is a Lisp file."
1707 (interactive)
1708 (let ((f (speedbar-line-file)))
1709 (if (and (file-exists-p f) (string-match "\\.el\\'" f))
1710 (if (and (file-exists-p (concat f "c"))
1711 (speedbar-y-or-n-p (format "Load %sc? " f)))
1712 ;; If the compiled version exists, load that instead...
1713 (load-file (concat f "c"))
1714 (load-file f))
1715 (error "Not a loadable file"))))
1717 (defun speedbar-item-byte-compile ()
1718 "Byte compile the item under the cursor or mouse if it is a Lisp file."
1719 (interactive)
1720 (let ((f (speedbar-line-file))
1721 (sf (selected-frame)))
1722 (if (and (file-exists-p f) (string-match "\\.el\\'" f))
1723 (progn
1724 (select-frame speedbar-attached-frame)
1725 (byte-compile-file f nil)
1726 (select-frame sf)
1727 (speedbar-reset-scanners)))
1730 (defun speedbar-mouse-item-info (event)
1731 "Provide information about what the user clicked on.
1732 This should be bound to a mouse EVENT."
1733 (interactive "e")
1734 (mouse-set-point event)
1735 (speedbar-item-info))
1737 (defun speedbar-generic-item-info ()
1738 "Attempt to derive, and then display information about this line item.
1739 File style information is displayed with `speedbar-item-info'."
1740 (save-excursion
1741 (beginning-of-line)
1742 ;; Skip invisible number info.
1743 (if (looking-at "\\([0-9]+\\):") (goto-char (match-end 0)))
1744 ;; Skip items in "folder" type text characters.
1745 (if (looking-at "\\s-*[[<({].[]>)}] ") (goto-char (match-end 0)))
1746 ;; Get the text
1747 (speedbar-message "Text: %s" (buffer-substring-no-properties
1748 (point) (progn (end-of-line) (point))))))
1750 (defun speedbar-item-info ()
1751 "Display info in the mini-buffer about the button the mouse is over.
1752 This function can be replaced in `speedbar-mode-functions-list' as
1753 `speedbar-item-info'."
1754 (interactive)
1755 (let (message-log-max)
1756 (funcall (or (speedbar-fetch-replacement-function 'speedbar-item-info)
1757 'speedbar-generic-item-info))))
1759 (defun speedbar-item-info-file-helper (&optional filename)
1760 "Display info about a file that is on the current line.
1761 nil if not applicable. If FILENAME, then use that instead of reading
1762 it from the speedbar buffer."
1763 (let* ((item (or filename (speedbar-line-file)))
1764 (attr (if item (file-attributes item) nil)))
1765 (if (and item attr) (speedbar-message "%s %-6d %s" (nth 8 attr)
1766 (nth 7 attr) item)
1767 nil)))
1769 (defun speedbar-item-info-tag-helper ()
1770 "Display info about a tag that is on the current line.
1771 nil if not applicable."
1772 (save-excursion
1773 (beginning-of-line)
1774 (if (re-search-forward " [-+=]?> \\([^\n]+\\)"
1775 (save-excursion(end-of-line)(point)) t)
1776 (let ((tag (match-string 1))
1777 (attr (speedbar-line-token))
1778 (item nil))
1779 (if (and (featurep 'semantic) (semantic-token-p attr))
1780 (speedbar-message (semantic-summerize-nonterminal attr))
1781 (looking-at "\\([0-9]+\\):")
1782 (setq item (file-name-nondirectory (speedbar-line-path)))
1783 (speedbar-message "Tag: %s in %s" tag item)))
1784 (if (re-search-forward "{[+-]} \\([^\n]+\\)$"
1785 (save-excursion(end-of-line)(point)) t)
1786 (speedbar-message "Group of tags \"%s\"" (match-string 1))
1787 (if (re-search-forward " [+-]?[()|@] \\([^\n]+\\)$" nil t)
1788 (let* ((detailtext (match-string 1))
1789 (detail (or (speedbar-line-token) detailtext))
1790 (parent (save-excursion
1791 (beginning-of-line)
1792 (let ((dep (if (looking-at "[0-9]+:")
1793 (1- (string-to-int (match-string 0)))
1794 0)))
1795 (re-search-backward (concat "^"
1796 (int-to-string dep)
1797 ":")
1798 nil t))
1799 (if (looking-at "[0-9]+: +[-+=>]> \\([^\n]+\\)$")
1800 (speedbar-line-token)
1801 nil))))
1802 (if (and (featurep 'semantic) (semantic-token-p detail))
1803 (speedbar-message
1804 (semantic-summerize-nonterminal detail parent))
1805 (if parent
1806 (speedbar-message "Detail: %s of tag %s" detail
1807 (if (and (featurep 'semantic)
1808 (semantic-token-p parent))
1809 (semantic-token-name parent)
1810 parent))
1811 (speedbar-message "Detail: %s" detail))))
1812 nil)))))
1814 (defun speedbar-files-item-info ()
1815 "Display info in the mini-buffer about the button the mouse is over."
1816 (if (not speedbar-shown-directories)
1817 (speedbar-generic-item-info)
1818 (or (speedbar-item-info-file-helper)
1819 (speedbar-item-info-tag-helper)
1820 (speedbar-generic-item-info))))
1822 (defun speedbar-item-copy ()
1823 "Copy the item under the cursor.
1824 Files can be copied to new names or places."
1825 (interactive)
1826 (let ((f (speedbar-line-file)))
1827 (if (not f) (error "Not a file"))
1828 (if (file-directory-p f)
1829 (error "Cannot copy directory")
1830 (let* ((rt (read-file-name (format "Copy %s to: "
1831 (file-name-nondirectory f))
1832 (file-name-directory f)))
1833 (refresh (member (expand-file-name (file-name-directory rt))
1834 speedbar-shown-directories)))
1835 ;; Create the right file name part
1836 (if (file-directory-p rt)
1837 (setq rt
1838 (concat (expand-file-name rt)
1839 (if (string-match "[/\\]$" rt) "" "/")
1840 (file-name-nondirectory f))))
1841 (if (or (not (file-exists-p rt))
1842 (speedbar-y-or-n-p (format "Overwrite %s with %s? " rt f)))
1843 (progn
1844 (copy-file f rt t t)
1845 ;; refresh display if the new place is currently displayed.
1846 (if refresh
1847 (progn
1848 (speedbar-refresh)
1849 (if (not (speedbar-goto-this-file rt))
1850 (speedbar-goto-this-file f))))
1851 ))))))
1853 (defun speedbar-item-rename ()
1854 "Rename the item under the cursor or mouse.
1855 Files can be renamed to new names or moved to new directories."
1856 (interactive)
1857 (let ((f (speedbar-line-file)))
1858 (if f
1859 (let* ((rt (read-file-name (format "Rename %s to: "
1860 (file-name-nondirectory f))
1861 (file-name-directory f)))
1862 (refresh (member (expand-file-name (file-name-directory rt))
1863 speedbar-shown-directories)))
1864 ;; Create the right file name part
1865 (if (file-directory-p rt)
1866 (setq rt
1867 (concat (expand-file-name rt)
1868 (if (string-match "[/\\]\\'" rt) "" "/")
1869 (file-name-nondirectory f))))
1870 (if (or (not (file-exists-p rt))
1871 (speedbar-y-or-n-p (format "Overwrite %s with %s? " rt f)))
1872 (progn
1873 (rename-file f rt t)
1874 ;; refresh display if the new place is currently displayed.
1875 (if refresh
1876 (progn
1877 (speedbar-refresh)
1878 (speedbar-goto-this-file rt)
1879 )))))
1880 (error "Not a file"))))
1882 (defun speedbar-item-delete ()
1883 "Delete the item under the cursor. Files are removed from disk."
1884 (interactive)
1885 (let ((f (speedbar-line-file)))
1886 (if (not f) (error "Not a file"))
1887 (if (speedbar-y-or-n-p (format "Delete %s? " f))
1888 (progn
1889 (if (file-directory-p f)
1890 (delete-directory f)
1891 (delete-file f))
1892 (speedbar-message "Okie dokie..")
1893 (let ((p (point)))
1894 (speedbar-refresh)
1895 (goto-char p))
1899 (defun speedbar-item-object-delete ()
1900 "Delete the object associated from the item under the cursor.
1901 The file is removed from disk. The object is determined from the
1902 variable `speedbar-obj-alist'."
1903 (interactive)
1904 (let* ((f (speedbar-line-file))
1905 (obj nil)
1906 (oa speedbar-obj-alist))
1907 (if (not f) (error "Not a file"))
1908 (while (and oa (not (string-match (car (car oa)) f)))
1909 (setq oa (cdr oa)))
1910 (setq obj (concat (file-name-sans-extension f) (cdr (car oa))))
1911 (if (and oa (file-exists-p obj)
1912 (speedbar-y-or-n-p (format "Delete %s? " obj)))
1913 (progn
1914 (delete-file obj)
1915 (speedbar-reset-scanners)))))
1917 (defun speedbar-enable-update ()
1918 "Enable automatic updating in speedbar via timers."
1919 (interactive)
1920 (setq speedbar-update-flag t)
1921 (speedbar-set-mode-line-format)
1922 (speedbar-set-timer speedbar-update-speed))
1924 (defun speedbar-disable-update ()
1925 "Disable automatic updating and stop consuming resources."
1926 (interactive)
1927 (setq speedbar-update-flag nil)
1928 (speedbar-set-mode-line-format)
1929 (speedbar-set-timer nil))
1931 (defun speedbar-toggle-updates ()
1932 "Toggle automatic update for the speedbar frame."
1933 (interactive)
1934 (if speedbar-update-flag
1935 (speedbar-disable-update)
1936 (speedbar-enable-update)))
1938 (defun speedbar-toggle-images ()
1939 "Toggle images for the speedbar frame."
1940 (interactive)
1941 (setq speedbar-use-images (not speedbar-use-images))
1942 (speedbar-refresh))
1944 (defun speedbar-toggle-sorting ()
1945 "Toggle sorting for the speedbar frame."
1946 (interactive)
1947 (setq speedbar-sort-tags (not speedbar-sort-tags)))
1949 (defun speedbar-toggle-show-all-files ()
1950 "Toggle display of files speedbar can not tag."
1951 (interactive)
1952 (setq speedbar-show-unknown-files (not speedbar-show-unknown-files))
1953 (speedbar-refresh))
1955 ;;; Utility functions
1957 (defun speedbar-set-timer (timeout)
1958 "Apply a timer with TIMEOUT, or remove a timer if TIMEOUT is nil.
1959 TIMEOUT is the number of seconds until the speedbar timer is called
1960 again. When TIMEOUT is nil, turn off all timeouts.
1961 This function will also enable or disable the `vc-checkin-hook' used
1962 to track file check ins, and will change the mode line to match
1963 `speedbar-update-flag'."
1964 (cond
1965 ;; XEmacs
1966 (speedbar-xemacsp
1967 (if speedbar-timer
1968 (progn (delete-itimer speedbar-timer)
1969 (setq speedbar-timer nil)))
1970 (if timeout
1971 (if (and speedbar-xemacsp
1972 (or (>= emacs-major-version 20)
1973 (>= emacs-minor-version 15)))
1974 (setq speedbar-timer (start-itimer "speedbar"
1975 'speedbar-timer-fn
1976 timeout
1977 timeout
1979 (setq speedbar-timer (start-itimer "speedbar"
1980 'speedbar-timer-fn
1981 timeout
1982 nil)))))
1983 ;; Post 19.31 Emacs
1984 ((fboundp 'run-with-idle-timer)
1985 (if speedbar-timer
1986 (progn (cancel-timer speedbar-timer)
1987 (setq speedbar-timer nil)))
1988 (if timeout
1989 (setq speedbar-timer
1990 (run-with-idle-timer timeout t 'speedbar-timer-fn))))
1991 ;; Emacs 19.30 (Thanks twice: ptype@dra.hmg.gb)
1992 ((fboundp 'post-command-idle-hook)
1993 (if timeout
1994 (add-hook 'post-command-idle-hook 'speedbar-timer-fn)
1995 (remove-hook 'post-command-idle-hook 'speedbar-timer-fn)))
1996 ;; Older or other Emacsen with no timers. Set up so that its
1997 ;; obvious this emacs can't handle the updates
1999 (setq speedbar-update-flag nil)))
2000 ;; Apply a revert hook that will reset the scanners. We attach to revert
2001 ;; because most reverts occur during VC state change, and this lets our
2002 ;; VC scanner fix itself.
2003 (if timeout
2004 (add-hook 'after-revert-hook 'speedbar-reset-scanners)
2005 (remove-hook 'after-revert-hook 'speedbar-reset-scanners)
2007 ;; change this if it changed for some reason
2008 (speedbar-set-mode-line-format))
2010 (defmacro speedbar-with-writable (&rest forms)
2011 "Allow the buffer to be writable and evaluate FORMS."
2012 (list 'let '((inhibit-read-only t))
2013 (cons 'progn forms)))
2014 (put 'speedbar-with-writable 'lisp-indent-function 0)
2016 (defun speedbar-select-window (buffer)
2017 "Select a window in which BUFFER is shown.
2018 If it is not shown, force it to appear in the default window."
2019 (let ((win (get-buffer-window buffer speedbar-attached-frame)))
2020 (if win
2021 (select-window win)
2022 (set-window-buffer (selected-window) buffer))))
2024 (defun speedbar-insert-button (text face mouse function
2025 &optional token prevline)
2026 "Insert TEXT as the next logical speedbar button.
2027 FACE is the face to put on the button, MOUSE is the highlight face to use.
2028 When the user clicks on TEXT, FUNCTION is called with the TOKEN parameter.
2029 This function assumes that the current buffer is the speedbar buffer.
2030 If PREVLINE, then put this button on the previous line.
2032 This is a convenience function for special modes that create their own
2033 specialized speedbar displays."
2034 (goto-char (point-max))
2035 (let ((start (point)))
2036 (if (/= (current-column) 0) (insert "\n"))
2037 (put-text-property start (point) 'invisible nil))
2038 (if prevline (progn (delete-char -1)
2039 (insert " ") ;back up if desired...
2040 (put-text-property (1- (point)) (point) 'invisible nil)))
2041 (let ((start (point)))
2042 (insert text)
2043 (speedbar-make-button start (point) face mouse function token))
2044 (let ((start (point)))
2045 (insert "\n")
2046 (put-text-property start (point) 'face nil)
2047 (put-text-property start (point) 'invisible nil)
2048 (put-text-property start (point) 'mouse-face nil)))
2050 (defun speedbar-make-button (start end face mouse function &optional token)
2051 "Create a button from START to END, with FACE as the display face.
2052 MOUSE is the mouse face. When this button is clicked on FUNCTION
2053 will be run with the TOKEN parameter (any Lisp object)."
2054 (put-text-property start end 'face face)
2055 (put-text-property start end 'mouse-face mouse)
2056 (put-text-property start end 'invisible nil)
2057 (if function (put-text-property start end 'speedbar-function function))
2058 (if token (put-text-property start end 'speedbar-token token))
2059 ;; So far the only text we have is less that 3 chars.
2060 (if (<= (- end start) 3)
2061 (speedbar-insert-image-button-maybe start (- end start)))
2064 ;;; Initial Expansion list management
2066 (defun speedbar-initial-expansion-list ()
2067 "Return the current default expansion list.
2068 This is based on `speedbar-initial-expansion-list-name' referencing
2069 `speedbar-initial-expansion-mode-alist'."
2070 ;; cdr1 - name, cdr2 - menu
2071 (cdr (cdr (cdr (assoc speedbar-initial-expansion-list-name
2072 speedbar-initial-expansion-mode-alist)))))
2074 (defun speedbar-initial-menu ()
2075 "Return the current default menu data.
2076 This is based on `speedbar-initial-expansion-list-name' referencing
2077 `speedbar-initial-expansion-mode-alist'."
2078 (symbol-value
2079 (car (cdr (assoc speedbar-initial-expansion-list-name
2080 speedbar-initial-expansion-mode-alist)))))
2082 (defun speedbar-initial-keymap ()
2083 "Return the current default menu data.
2084 This is based on `speedbar-initial-expansion-list-name' referencing
2085 `speedbar-initial-expansion-mode-alist'."
2086 (symbol-value
2087 (car (cdr (cdr (assoc speedbar-initial-expansion-list-name
2088 speedbar-initial-expansion-mode-alist))))))
2090 (defun speedbar-initial-stealthy-functions ()
2091 "Return a list of functions to call stealthily.
2092 This is based on `speedbar-initial-expansion-list-name' referencing
2093 `speedbar-stealthy-function-list'."
2094 (cdr (assoc speedbar-initial-expansion-list-name
2095 speedbar-stealthy-function-list)))
2097 (defun speedbar-add-expansion-list (new-list)
2098 "Add NEW-LIST to the list of expansion lists."
2099 (add-to-list 'speedbar-initial-expansion-mode-alist new-list))
2101 (defun speedbar-change-initial-expansion-list (new-default)
2102 "Change speedbar's default expansion list to NEW-DEFAULT."
2103 (interactive
2104 (list
2105 (completing-read (format "Speedbar Mode (default %s): "
2106 speedbar-previously-used-expansion-list-name)
2107 speedbar-initial-expansion-mode-alist
2108 nil t "" nil
2109 speedbar-previously-used-expansion-list-name)))
2110 (setq speedbar-previously-used-expansion-list-name
2111 speedbar-initial-expansion-list-name
2112 speedbar-initial-expansion-list-name new-default)
2113 (speedbar-refresh)
2114 (speedbar-reconfigure-keymaps))
2116 (defun speedbar-fetch-replacement-function (function)
2117 "Return a current mode specific replacement for function, or nil.
2118 Scans `speedbar-mode-functions-list' first for the current mode, then
2119 for FUNCTION."
2120 (cdr (assoc function
2121 (cdr (assoc speedbar-initial-expansion-list-name
2122 speedbar-mode-functions-list)))))
2124 (defun speedbar-add-mode-functions-list (new-list)
2125 "Add NEW-LIST to the list of mode functions.
2126 See `speedbar-mode-functions-list' for details."
2127 (add-to-list 'speedbar-mode-functions-list new-list))
2130 ;;; Special speedbar display management
2132 (defun speedbar-maybe-add-localized-support (buffer)
2133 "Quick check function called on BUFFERs by the speedbar timer function.
2134 Maintains the value of local variables which control speedbars use
2135 of the special mode functions."
2136 (or speedbar-special-mode-expansion-list
2137 (speedbar-add-localized-speedbar-support buffer)))
2139 (defun speedbar-add-localized-speedbar-support (buffer)
2140 "Add localized speedbar support to BUFFER's mode if it is available."
2141 (interactive "bBuffer: ")
2142 (if (stringp buffer) (setq buffer (get-buffer buffer)))
2143 (if (not (buffer-live-p buffer))
2145 (save-excursion
2146 (set-buffer buffer)
2147 (save-match-data
2148 (let ((ms (symbol-name major-mode)) v)
2149 (if (not (string-match "-mode$" ms))
2150 nil ;; do nothing to broken mode
2151 (setq ms (substring ms 0 (match-beginning 0)))
2152 (setq v (intern-soft (concat ms "-speedbar-buttons")))
2153 (make-local-variable 'speedbar-special-mode-expansion-list)
2154 (if (not v)
2155 (setq speedbar-special-mode-expansion-list t)
2156 ;; If it is autoloaded, we need to load it now so that
2157 ;; we have access to the varialbe -speedbar-menu-items.
2158 ;; Is this XEmacs safe?
2159 (let ((sf (symbol-function v)))
2160 (if (and (listp sf) (eq (car sf) 'autoload))
2161 (load-library (car (cdr sf)))))
2162 (setq speedbar-special-mode-expansion-list (list v))
2163 (setq v (intern-soft (concat ms "-speedbar-key-map")))
2164 (if (not v)
2165 nil ;; don't add special keymap
2166 (make-local-variable 'speedbar-special-mode-key-map)
2167 (setq speedbar-special-mode-key-map
2168 (symbol-value v)))
2169 (setq v (intern-soft (concat ms "-speedbar-menu-items")))
2170 (if (not v)
2171 nil ;; don't add special menus
2172 (make-local-variable 'speedbar-easymenu-definition-special)
2173 (setq speedbar-easymenu-definition-special
2174 (symbol-value v)))
2175 )))))))
2177 (defun speedbar-remove-localized-speedbar-support (buffer)
2178 "Remove any traces that BUFFER supports speedbar in a specialized way."
2179 (save-excursion
2180 (set-buffer buffer)
2181 (kill-local-variable 'speedbar-special-mode-expansion-list)
2182 (kill-local-variable 'speedbar-special-mode-key-map)
2183 (kill-local-variable 'speedbar-easymenu-definition-special)))
2185 ;;; File button management
2187 (defun speedbar-file-lists (directory)
2188 "Create file lists for DIRECTORY.
2189 The car is the list of directories, the cdr is list of files not
2190 matching ignored headers. Cache any directory files found in
2191 `speedbar-directory-contents-alist' and use that cache before scanning
2192 the file-system."
2193 (setq directory (expand-file-name directory))
2194 ;; If in powerclick mode, then the directory we are getting
2195 ;; should be rescanned.
2196 (if speedbar-power-click
2197 (adelete 'speedbar-directory-contents-alist directory))
2198 ;; find the directory, either in the cache, or build it.
2199 (or (cdr-safe (assoc directory speedbar-directory-contents-alist))
2200 (let ((default-directory directory)
2201 (case-fold-search read-file-name-completion-ignore-case)
2202 dirs files)
2203 (dolist (file (directory-files directory nil))
2204 (or (string-match speedbar-file-unshown-regexp file)
2205 (string-match speedbar-directory-unshown-regexp file)
2206 (if (file-directory-p file)
2207 (setq dirs (cons file dirs))
2208 (setq files (cons file files)))))
2209 (let ((nl `(,(nreverse dirs) ,(nreverse files))))
2210 (aput 'speedbar-directory-contents-alist directory nl)
2211 nl))))
2213 (defun speedbar-directory-buttons (directory index)
2214 "Insert a single button group at point for DIRECTORY.
2215 Each directory path part is a different button. If part of the path
2216 matches the user directory ~, then it is replaced with a ~.
2217 INDEX is not used, but is required by the caller."
2218 (let* ((tilde (expand-file-name "~/"))
2219 (dd (expand-file-name directory))
2220 (junk (string-match (regexp-quote tilde) dd))
2221 (displayme (if junk
2222 (concat "~/" (substring dd (match-end 0)))
2223 dd))
2224 (p (point)))
2225 (if (string-match "^~[/\\]?\\'" displayme) (setq displayme tilde))
2226 (insert displayme)
2227 (save-excursion
2228 (goto-char p)
2229 (while (re-search-forward "\\([^/\\]+\\)[/\\]" nil t)
2230 (speedbar-make-button (match-beginning 1) (match-end 1)
2231 'speedbar-directory-face
2232 'speedbar-highlight-face
2233 'speedbar-directory-buttons-follow
2234 (if (and (= (match-beginning 1) p)
2235 (not (char-equal (char-after (+ p 1)) ?:)))
2236 (expand-file-name "~/") ;the tilde
2237 (buffer-substring-no-properties
2238 p (match-end 0)))))
2239 ;; Nuke the beginning of the directory if it's too long...
2240 (cond ((eq speedbar-directory-button-trim-method 'span)
2241 (beginning-of-line)
2242 (let ((ww (or (speedbar-frame-width) 20)))
2243 (move-to-column ww nil)
2244 (while (>= (current-column) ww)
2245 (re-search-backward "[/\\]" nil t)
2246 (if (<= (current-column) 2)
2247 (progn
2248 (re-search-forward "[/\\]" nil t)
2249 (if (< (current-column) 4)
2250 (re-search-forward "[/\\]" nil t))
2251 (forward-char -1)))
2252 (if (looking-at "[/\\]?$")
2253 (beginning-of-line)
2254 (insert "/...\n ")
2255 (move-to-column ww nil)))))
2256 ((eq speedbar-directory-button-trim-method 'trim)
2257 (end-of-line)
2258 (let ((ww (or (speedbar-frame-width) 20))
2259 (tl (current-column)))
2260 (if (< ww tl)
2261 (progn
2262 (move-to-column (- tl ww))
2263 (if (re-search-backward "[/\\]" nil t)
2264 (progn
2265 (delete-region (point-min) (point))
2266 (insert "$")
2267 )))))))
2269 (if (string-match "\\`[/\\][^/\\]+[/\\]\\'" displayme)
2270 (progn
2271 (insert " ")
2272 (let ((p (point)))
2273 (insert "<root>")
2274 (speedbar-make-button p (point)
2275 'speedbar-directory-face
2276 'speedbar-highlight-face
2277 'speedbar-directory-buttons-follow
2278 "/"))))
2279 (end-of-line)
2280 (insert-char ?\n 1 nil)))
2282 (defun speedbar-make-tag-line (exp-button-type
2283 exp-button-char exp-button-function
2284 exp-button-data
2285 tag-button tag-button-function tag-button-data
2286 tag-button-face depth)
2287 "Create a tag line with EXP-BUTTON-TYPE for the small expansion button.
2288 This is the button that expands or contracts a node (if applicable),
2289 and EXP-BUTTON-CHAR the character in it (+, -, ?, etc). EXP-BUTTON-FUNCTION
2290 is the function to call if it's clicked on. Button types are
2291 'bracket, 'angle, 'curly, or nil. EXP-BUTTON-DATA is extra data
2292 attached to the text forming the expansion button.
2294 Next, TAG-BUTTON is the text of the tag. TAG-BUTTON-FUNCTION is the
2295 function to call if clicked on, and TAG-BUTTON-DATA is the data to
2296 attach to the text field (such a tag positioning, etc).
2297 TAG-BUTTON-FACE is a face used for this type of tag.
2299 Lastly, DEPTH shows the depth of expansion.
2301 This function assumes that the cursor is in the speedbar window at the
2302 position to insert a new item, and that the new item will end with a CR."
2303 (let ((start (point))
2304 (end (progn
2305 (insert (int-to-string depth) ":")
2306 (point)))
2307 (depthspacesize (* depth speedbar-indentation-width)))
2308 (put-text-property start end 'invisible t)
2309 (insert-char ? depthspacesize nil)
2310 (put-text-property (- (point) depthspacesize) (point) 'invisible nil)
2311 (let* ((exp-button (cond ((eq exp-button-type 'bracket) "[%c]")
2312 ((eq exp-button-type 'angle) "<%c>")
2313 ((eq exp-button-type 'curly) "{%c}")
2314 (t ">")))
2315 (buttxt (format exp-button exp-button-char))
2316 (start (point))
2317 (end (progn (insert buttxt) (point)))
2318 (bf (if exp-button-type 'speedbar-button-face nil))
2319 (mf (if exp-button-function 'speedbar-highlight-face nil))
2321 (speedbar-make-button start end bf mf exp-button-function exp-button-data)
2322 (if speedbar-hide-button-brackets-flag
2323 (progn
2324 (put-text-property start (1+ start) 'invisible t)
2325 (put-text-property end (1- end) 'invisible t)))
2327 (insert-char ? 1 nil)
2328 (put-text-property (1- (point)) (point) 'invisible nil)
2329 (let ((start (point))
2330 (end (progn (insert tag-button) (point))))
2331 (insert-char ?\n 1 nil)
2332 (put-text-property (1- (point)) (point) 'invisible nil)
2333 (speedbar-make-button start end tag-button-face
2334 (if tag-button-function 'speedbar-highlight-face nil)
2335 tag-button-function tag-button-data))
2338 (defun speedbar-change-expand-button-char (char)
2339 "Change the expansion button character to CHAR for the current line."
2340 (save-excursion
2341 (beginning-of-line)
2342 (if (re-search-forward ":\\s-*.\\([-+?]\\)" (save-excursion (end-of-line)
2343 (point)) t)
2344 (speedbar-with-writable
2345 (goto-char (match-beginning 1))
2346 (delete-char 1)
2347 (insert-char char 1 t)
2348 (put-text-property (point) (1- (point)) 'invisible nil)
2349 ;; make sure we fix the image on the text here.
2350 (speedbar-insert-image-button-maybe (- (point) 2) 3)))))
2353 ;;; Build button lists
2355 (defun speedbar-insert-files-at-point (files level directory)
2356 "Insert list of FILES starting at point, and indenting all files to LEVEL.
2357 Tag expandable items with a +, otherwise a ?. Don't highlight ? as we
2358 don't know how to manage them. The input parameter FILES is a cons
2359 cell of the form ( 'DIRLIST . 'FILELIST )."
2360 ;; Start inserting all the directories
2361 (dolist (dir (car files))
2362 (if (if speedbar-scan-subdirs
2363 (condition-case nil
2364 (let ((l (speedbar-file-lists (concat directory dir))))
2365 (or (car l) (cadr l)))
2366 (file-error))
2367 (file-readable-p (concat directory dir)))
2368 (speedbar-make-tag-line 'angle ?+ 'speedbar-dired dir
2369 dir 'speedbar-dir-follow nil
2370 'speedbar-directory-face level)
2371 (speedbar-make-tag-line 'angle ? nil dir
2372 dir 'speedbar-dir-follow nil
2373 'speedbar-directory-face level)))
2374 (let ((case-fold-search read-file-name-completion-ignore-case))
2375 (dolist (file (cadr files))
2376 (let* ((known (and (file-readable-p (concat directory file))
2377 (string-match speedbar-file-regexp file)))
2378 (expchar (if known ?+ ??))
2379 (fn (if known 'speedbar-tag-file nil)))
2380 (if (or speedbar-show-unknown-files (/= expchar ??))
2381 (speedbar-make-tag-line 'bracket expchar fn file
2382 file 'speedbar-find-file nil
2383 'speedbar-file-face level))))))
2385 (defun speedbar-default-directory-list (directory index)
2386 "Insert files for DIRECTORY with level INDEX at point."
2387 (speedbar-insert-files-at-point
2388 (speedbar-file-lists directory) index directory)
2389 (speedbar-reset-scanners)
2390 (if (= index 0)
2391 ;; If the shown files variable has extra directories, then
2392 ;; it is our responsibility to redraw them all
2393 ;; Luckilly, the nature of inserting items into this list means
2394 ;; that by reversing it, we can easilly go in the right order
2395 (let ((sf (cdr (reverse speedbar-shown-directories))))
2396 (setq speedbar-shown-directories
2397 (list (expand-file-name default-directory)))
2398 ;; exand them all as we find them
2399 (while sf
2400 (if (speedbar-goto-this-file (car sf))
2401 (progn
2402 (beginning-of-line)
2403 (if (looking-at "[0-9]+:[ ]*<")
2404 (progn
2405 (goto-char (match-end 0))
2406 (speedbar-do-function-pointer)))))
2407 (setq sf (cdr sf)))
2410 (defun speedbar-sort-tag-hierarchy (lst)
2411 "Sort all elements of tag hierarchy LST."
2412 (sort (copy-alist lst)
2413 (lambda (a b) (string< (car a) (car b)))))
2415 (defun speedbar-prefix-group-tag-hierarchy (lst)
2416 "Prefix group names for tag hierarchy LST."
2417 (let ((newlst nil)
2418 (sublst nil)
2419 (work-list nil)
2420 (junk-list nil)
2421 (short-group-list nil)
2422 (short-start-name nil)
2423 (short-end-name nil)
2424 (num-shorts-grouped 0)
2425 (bins (make-vector 256 nil))
2426 (diff-idx 0))
2427 ;; Break out sub-lists
2428 (while lst
2429 (if (and (listp (cdr-safe (car-safe lst)))
2430 ;; This one is for bovine tokens
2431 (not (symbolp (car-safe (cdr-safe (car-safe lst))))))
2432 (setq newlst (cons (car lst) newlst))
2433 (setq sublst (cons (car lst) sublst)))
2434 (setq lst (cdr lst)))
2435 ;; Reverse newlst because it was made backwards.
2436 ;; Sublist doesn't need reversing because the act
2437 ;; of binning things will reverse it for us.
2438 (setq newlst (nreverse newlst))
2439 ;; Now, first find out how long our list is. Never let a
2440 ;; list get-shorter than our minimum.
2441 (if (<= (length sublst) speedbar-tag-split-minimum-length)
2442 (setq work-list (nreverse sublst))
2443 (setq diff-idx (length (try-completion "" sublst)))
2444 ;; Sort the whole list into bins.
2445 (while sublst
2446 (let ((e (car sublst))
2447 (s (car (car sublst))))
2448 (cond ((<= (length s) diff-idx)
2449 ;; 0 storage bin for shorty.
2450 (aset bins 0 (cons e (aref bins 0))))
2452 ;; stuff into a bin based on ascii value at diff
2453 (aset bins (aref s diff-idx)
2454 (cons e (aref bins (aref s diff-idx)))))))
2455 (setq sublst (cdr sublst)))
2456 ;; Go through all our bins Stick singles into our
2457 ;; junk-list, everything else as sublsts in work-list.
2458 ;; If two neighboring lists are both small, make a grouped
2459 ;; group combinding those two sub-lists.
2460 (setq diff-idx 0)
2461 (while (> 256 diff-idx)
2462 (let ((l (nreverse;; Reverse the list since they are stuck in
2463 ;; backwards.
2464 (aref bins diff-idx))))
2465 (if l
2466 (let ((tmp (cons (try-completion "" l) l)))
2467 (if (or (> (length l) speedbar-tag-regroup-maximum-length)
2468 (> (+ (length l) (length short-group-list))
2469 speedbar-tag-split-minimum-length))
2470 (progn
2471 ;; We have reached a longer list, so we
2472 ;; must finish off a grouped group.
2473 (cond
2474 ((and short-group-list
2475 (= (length short-group-list)
2476 num-shorts-grouped))
2477 ;; All singles? Junk list
2478 (setq junk-list (append short-group-list
2479 junk-list)))
2480 ((= num-shorts-grouped 1)
2481 ;; Only one short group? Just stick it in
2482 ;; there by itself. Make a group, and find
2483 ;; a subexpression
2484 (let ((subexpression (try-completion
2485 "" short-group-list)))
2486 (if (< (length subexpression)
2487 speedbar-tag-group-name-minimum-length)
2488 (setq subexpression
2489 (concat short-start-name
2490 " ("
2491 (substring
2492 (car (car short-group-list))
2493 (length short-start-name))
2494 ")")))
2495 (setq work-list
2496 (cons (cons subexpression
2497 short-group-list)
2498 work-list))))
2499 (short-group-list
2500 ;; Multiple groups to be named in a special
2501 ;; way by displaying the range over which we
2502 ;; have grouped them.
2503 (setq work-list
2504 (cons (cons (concat short-start-name
2505 " to "
2506 short-end-name)
2507 (nreverse short-group-list))
2508 work-list))))
2509 ;; Reset short group list information every time.
2510 (setq short-group-list nil
2511 short-start-name nil
2512 short-end-name nil
2513 num-shorts-grouped 0)))
2514 ;; Ok, now that we cleaned up the short-group-list,
2515 ;; we can deal with this new list, to decide if it
2516 ;; should go on one of these sub-lists or not.
2517 (if (< (length l) speedbar-tag-regroup-maximum-length)
2518 (setq short-group-list (append short-group-list l)
2519 num-shorts-grouped (1+ num-shorts-grouped)
2520 short-end-name (car tmp)
2521 short-start-name (if short-start-name
2522 short-start-name
2523 (car tmp)))
2524 (setq work-list (cons tmp work-list))))))
2525 (setq diff-idx (1+ diff-idx))))
2526 ;; Did we run out of things? Drop our new list onto the end.
2527 (cond
2528 ((and short-group-list (= (length short-group-list) num-shorts-grouped))
2529 ;; All singles? Junk list
2530 (setq junk-list (append short-group-list junk-list)))
2531 ((= num-shorts-grouped 1)
2532 ;; Only one short group? Just stick it in
2533 ;; there by itself.
2534 (setq work-list
2535 (cons (cons (try-completion "" short-group-list)
2536 short-group-list)
2537 work-list)))
2538 (short-group-list
2539 ;; Multiple groups to be named in a special
2540 ;; way by displaying the range over which we
2541 ;; have grouped them.
2542 (setq work-list
2543 (cons (cons (concat short-start-name " to " short-end-name)
2544 short-group-list)
2545 work-list))))
2546 ;; Reverse the work list nreversed when consing.
2547 (setq work-list (nreverse work-list))
2548 ;; Now, stick our new list onto the end of
2549 (if work-list
2550 (if junk-list
2551 (append newlst work-list junk-list)
2552 (append newlst work-list))
2553 (append newlst junk-list))))
2555 (defun speedbar-trim-words-tag-hierarchy (lst)
2556 "Trim all words in a tag hierarchy.
2557 Base trimming information on word separators, and group names.
2558 Argument LST is the list of tags to trim."
2559 (let ((newlst nil)
2560 (sublst nil)
2561 (trim-prefix nil)
2562 (trim-chars 0)
2563 (trimlst nil))
2564 (while lst
2565 (if (listp (cdr-safe (car-safe lst)))
2566 (setq newlst (cons (car lst) newlst))
2567 (setq sublst (cons (car lst) sublst)))
2568 (setq lst (cdr lst)))
2569 ;; Get the prefix to trim by. Make sure that we don't trim
2570 ;; off silly pieces, only complete understandable words.
2571 (setq trim-prefix (try-completion "" sublst))
2572 (if (or (= (length sublst) 1)
2573 (not trim-prefix)
2574 (not (string-match "\\(\\w+\\W+\\)+" trim-prefix)))
2575 (append (nreverse newlst) (nreverse sublst))
2576 (setq trim-prefix (substring trim-prefix (match-beginning 0)
2577 (match-end 0)))
2578 (setq trim-chars (length trim-prefix))
2579 (while sublst
2580 (setq trimlst (cons
2581 (cons (substring (car (car sublst)) trim-chars)
2582 (cdr (car sublst)))
2583 trimlst)
2584 sublst (cdr sublst)))
2585 ;; Put the lists together
2586 (append (nreverse newlst) trimlst))))
2588 (defun speedbar-simple-group-tag-hierarchy (lst)
2589 "Create a simple 'Tags' group with orphaned tags.
2590 Argument LST is the list of tags to sort into groups."
2591 (let ((newlst nil)
2592 (sublst nil))
2593 (while lst
2594 (if (listp (cdr-safe (car-safe lst)))
2595 (setq newlst (cons (car lst) newlst))
2596 (setq sublst (cons (car lst) sublst)))
2597 (setq lst (cdr lst)))
2598 (if (not newlst)
2599 (nreverse sublst)
2600 (setq newlst (cons (cons "Tags" (nreverse sublst)) newlst))
2601 (nreverse newlst))))
2603 (defun speedbar-create-tag-hierarchy (lst)
2604 "Adjust the tag hierarchy in LST, and return it.
2605 This uses `speedbar-tag-hierarchy-method' to determine how to adjust
2606 the list."
2607 (let* ((f (save-excursion
2608 (forward-line -1)
2609 (speedbar-line-path)))
2610 (methods (if (get-file-buffer f)
2611 (save-excursion (set-buffer (get-file-buffer f))
2612 speedbar-tag-hierarchy-method)
2613 speedbar-tag-hierarchy-method))
2614 (lst (if (fboundp 'copy-tree)
2615 (copy-tree lst)
2616 lst)))
2617 (while methods
2618 (setq lst (funcall (car methods) lst)
2619 methods (cdr methods)))
2620 lst))
2622 (defun speedbar-insert-generic-list (level lst expand-fun find-fun)
2623 "At LEVEL, insert a generic multi-level alist LST.
2624 Associations with lists get {+} tags (to expand into more nodes) and
2625 those with positions just get a > as the indicator. {+} buttons will
2626 have the function EXPAND-FUN and the token is the CDR list. The token
2627 name will have the function FIND-FUN and not token."
2628 ;; Remove imenu rescan button
2629 (if (string= (car (car lst)) "*Rescan*")
2630 (setq lst (cdr lst)))
2631 ;; Adjust the list.
2632 (setq lst (speedbar-create-tag-hierarchy lst))
2633 ;; insert the parts
2634 (while lst
2635 (cond ((null (car-safe lst)) nil) ;this would be a separator
2636 ((or (numberp (cdr-safe (car-safe lst)))
2637 (markerp (cdr-safe (car-safe lst))))
2638 (speedbar-make-tag-line nil nil nil nil ;no expand button data
2639 (car (car lst)) ;button name
2640 find-fun ;function
2641 (cdr (car lst)) ;token is position
2642 'speedbar-tag-face
2643 (1+ level)))
2644 ((listp (cdr-safe (car-safe lst)))
2645 (speedbar-make-tag-line 'curly ?+ expand-fun (cdr (car lst))
2646 (car (car lst)) ;button name
2647 nil nil 'speedbar-tag-face
2648 (1+ level)))
2649 (t (speedbar-message "Ooops!")))
2650 (setq lst (cdr lst))))
2652 (defun speedbar-insert-imenu-list (indent lst)
2653 "At level INDENT, insert the imenu generated LST."
2654 (speedbar-insert-generic-list indent lst
2655 'speedbar-tag-expand
2656 'speedbar-tag-find))
2658 (defun speedbar-insert-etags-list (indent lst)
2659 "At level INDENT, insert the etags generated LST."
2660 (speedbar-insert-generic-list indent lst
2661 'speedbar-tag-expand
2662 'speedbar-tag-find))
2664 ;;; Timed functions
2666 (defun speedbar-update-contents ()
2667 "Generically update the contents of the speedbar buffer."
2668 (interactive)
2669 ;; Set the current special buffer
2670 (setq speedbar-desired-buffer nil)
2671 ;; Check for special modes
2672 (speedbar-maybe-add-localized-support (current-buffer))
2673 ;; Choose the correct method of doodling.
2674 (if (and speedbar-mode-specific-contents-flag
2675 (listp speedbar-special-mode-expansion-list)
2676 speedbar-special-mode-expansion-list
2677 (local-variable-p
2678 'speedbar-special-mode-expansion-list
2679 (current-buffer)))
2680 ;;(eq (get major-mode 'mode-class 'special)))
2681 (speedbar-update-special-contents)
2682 (speedbar-update-directory-contents)))
2684 (defun speedbar-update-directory-contents ()
2685 "Update the contents of the speedbar buffer based on the current directory."
2686 (let ((cbd (expand-file-name default-directory))
2687 cbd-parent
2688 (funclst (speedbar-initial-expansion-list))
2689 (cache speedbar-full-text-cache)
2690 ;; disable stealth during update
2691 (speedbar-stealthy-function-list nil)
2692 (use-cache nil)
2693 (expand-local nil)
2694 ;; Because there is a bug I can't find just yet
2695 (inhibit-quit nil))
2696 (save-excursion
2697 (set-buffer speedbar-buffer)
2698 ;; If we are updating contents to where we are, then this is
2699 ;; really a request to update existing contents, so we must be
2700 ;; careful with our text cache!
2701 (if (member cbd speedbar-shown-directories)
2702 (progn
2703 (setq cache nil)
2704 ;; If the current directory is not the last element in the dir
2705 ;; list, then we ALSO need to zap the list of expanded directories
2706 (if (/= (length (member cbd speedbar-shown-directories)) 1)
2707 (setq speedbar-shown-directories (list cbd))))
2709 ;; Build cbd-parent, and see if THAT is in the current shown
2710 ;; directories. First, go through pains to get the parent directory
2711 (if (and speedbar-smart-directory-expand-flag
2712 (save-match-data
2713 (setq cbd-parent cbd)
2714 (if (string-match "[/\\]$" cbd-parent)
2715 (setq cbd-parent (substring cbd-parent 0
2716 (match-beginning 0))))
2717 (setq cbd-parent (file-name-directory cbd-parent)))
2718 (member cbd-parent speedbar-shown-directories))
2719 (setq expand-local t)
2721 ;; If this directory is NOT in the current list of available
2722 ;; paths, then use the cache, and set the cache to our new
2723 ;; value. Make sure to unhighlight the current file, or if we
2724 ;; come back to this directory, it might be a different file
2725 ;; and then we get a mess!
2726 (if (> (point-max) 1)
2727 (progn
2728 (speedbar-clear-current-file)
2729 (setq speedbar-full-text-cache
2730 (cons speedbar-shown-directories (buffer-string)))))
2732 ;; Check if our new directory is in the list of directories
2733 ;; shown in the text-cache
2734 (if (member cbd (car cache))
2735 (setq speedbar-shown-directories (car cache)
2736 use-cache t)
2737 ;; default the shown directories to this list...
2738 (setq speedbar-shown-directories (list cbd)))
2740 (if (not expand-local) (setq speedbar-last-selected-file nil))
2741 (speedbar-with-writable
2742 (if (and expand-local
2743 ;; Find this directory as a speedbar node.
2744 (speedbar-path-line cbd))
2745 ;; Open it.
2746 (speedbar-expand-line)
2747 (erase-buffer)
2748 (cond (use-cache
2749 (setq default-directory
2750 (nth (1- (length speedbar-shown-directories))
2751 speedbar-shown-directories))
2752 (insert (cdr cache)))
2754 (while funclst
2755 (setq default-directory cbd)
2756 (funcall (car funclst) cbd 0)
2757 (setq funclst (cdr funclst))))))
2758 (goto-char (point-min)))))
2759 (speedbar-reconfigure-keymaps))
2761 (defun speedbar-update-special-contents ()
2762 "Use the mode-specific variable to fill in the speedbar buffer.
2763 This should only be used by modes classified as special."
2764 (let ((funclst speedbar-special-mode-expansion-list)
2765 (specialbuff (current-buffer)))
2766 (save-excursion
2767 (setq speedbar-desired-buffer specialbuff)
2768 (set-buffer speedbar-buffer)
2769 ;; If we are leaving a directory, cache it.
2770 (if (not speedbar-shown-directories)
2771 ;; Do nothing
2773 ;; Clean up directory maintenance stuff
2774 (speedbar-clear-current-file)
2775 (setq speedbar-full-text-cache
2776 (cons speedbar-shown-directories (buffer-string))
2777 speedbar-shown-directories nil))
2778 ;; Now fill in the buffer with our newly found specialized list.
2779 (speedbar-with-writable
2780 (while funclst
2781 ;; We do not erase the buffer because these functions may
2782 ;; decide NOT to update themselves.
2783 (funcall (car funclst) specialbuff)
2784 (setq funclst (cdr funclst))))
2785 (goto-char (point-min))))
2786 (speedbar-reconfigure-keymaps))
2788 (defun speedbar-timer-fn ()
2789 "Run whenever Emacs is idle to update the speedbar item."
2790 (if (not (and (frame-live-p speedbar-frame)
2791 (frame-live-p speedbar-attached-frame)))
2792 (speedbar-set-timer nil)
2793 ;; Save all the match data so that we don't mess up executing fns
2794 (save-match-data
2795 ;; Only do stuff if the frame is visible, not an icon, and if
2796 ;; it is currently flagged to do something.
2797 (if (and speedbar-update-flag
2798 (frame-visible-p speedbar-frame)
2799 (not (eq (frame-visible-p speedbar-frame) 'icon)))
2800 (let ((af (selected-frame)))
2801 (save-window-excursion
2802 (select-frame speedbar-attached-frame)
2803 ;; make sure we at least choose a window to
2804 ;; get a good directory from
2805 (if (window-minibuffer-p (selected-window))
2807 ;; Check for special modes
2808 (speedbar-maybe-add-localized-support (current-buffer))
2809 ;; Update for special mode all the time!
2810 (if (and speedbar-mode-specific-contents-flag
2811 (listp speedbar-special-mode-expansion-list)
2812 speedbar-special-mode-expansion-list
2813 (local-variable-p
2814 'speedbar-special-mode-expansion-list
2815 (current-buffer)))
2816 ;;(eq (get major-mode 'mode-class 'special)))
2817 (progn
2818 (if (<= 2 speedbar-verbosity-level)
2819 (speedbar-message
2820 "Updating speedbar to special mode: %s..."
2821 major-mode))
2822 (speedbar-update-special-contents)
2823 (if (<= 2 speedbar-verbosity-level)
2824 (progn
2825 (speedbar-message
2826 "Updating speedbar to special mode: %s...done"
2827 major-mode)
2828 (speedbar-message nil))))
2829 ;; Update all the contents if directories change!
2830 (if (or (member (expand-file-name default-directory)
2831 speedbar-shown-directories)
2832 (and speedbar-ignored-path-regexp
2833 (string-match
2834 speedbar-ignored-path-regexp
2835 (expand-file-name default-directory)))
2836 (member major-mode speedbar-ignored-modes)
2837 (eq af speedbar-frame)
2838 (not (buffer-file-name)))
2840 (if (<= 1 speedbar-verbosity-level)
2841 (speedbar-message "Updating speedbar to: %s..."
2842 default-directory))
2843 (speedbar-update-directory-contents)
2844 (if (<= 1 speedbar-verbosity-level)
2845 (progn
2846 (speedbar-message "Updating speedbar to: %s...done"
2847 default-directory)
2848 (speedbar-message nil)))))
2849 (select-frame af)))
2850 ;; Now run stealthy updates of time-consuming items
2851 (speedbar-stealthy-updates)))
2852 ;; Now run the mouse tracking system
2853 (speedbar-show-info-under-mouse)))
2854 (run-hooks 'speedbar-timer-hook))
2857 ;;; Stealthy activities
2859 (defvar speedbar-stealthy-update-recurse nil
2860 "Recursion avoidance variable for stealthy update.")
2862 (defun speedbar-stealthy-updates ()
2863 "For a given speedbar, run all items in the stealthy function list.
2864 Each item returns t if it completes successfully, or nil if
2865 interrupted by the user."
2866 (if (not speedbar-stealthy-update-recurse)
2867 (let ((l (speedbar-initial-stealthy-functions))
2868 (speedbar-stealthy-update-recurse t))
2869 (unwind-protect
2870 (speedbar-with-writable
2871 (while (and l (funcall (car l)))
2872 ;;(sit-for 0)
2873 (setq l (cdr l))))
2874 ;;(speedbar-message "Exit with %S" (car l))
2875 ))))
2877 (defun speedbar-reset-scanners ()
2878 "Reset any variables used by functions in the stealthy list as state.
2879 If new functions are added, their state needs to be updated here."
2880 (setq speedbar-vc-to-do-point t
2881 speedbar-obj-to-do-point t)
2882 (run-hooks 'speedbar-scanner-reset-hook)
2885 (defun speedbar-find-selected-file (file)
2886 "Go to the line where FILE is."
2887 (goto-char (point-min))
2888 (let ((m nil))
2889 (while (and (setq m (re-search-forward
2890 (concat " \\(" (regexp-quote (file-name-nondirectory file))
2891 "\\)\\(" speedbar-indicator-regex "\\)?\n")
2892 nil t))
2893 (not (string= file
2894 (concat
2895 (speedbar-line-path
2896 (save-excursion
2897 (goto-char (match-beginning 0))
2898 (beginning-of-line)
2899 (save-match-data
2900 (looking-at "[0-9]+:")
2901 (string-to-number (match-string 0)))))
2902 (match-string 1))))))
2903 (if m
2904 (progn
2905 (goto-char (match-beginning 1))
2906 (match-string 1)))))
2908 (defun speedbar-clear-current-file ()
2909 "Locate the file thought to be current, and remove its highlighting."
2910 (save-excursion
2911 (set-buffer speedbar-buffer)
2912 (if speedbar-last-selected-file
2913 (speedbar-with-writable
2914 (if (speedbar-find-selected-file speedbar-last-selected-file)
2915 (put-text-property (match-beginning 1)
2916 (match-end 1)
2917 'face
2918 'speedbar-file-face))))))
2920 (defun speedbar-update-current-file ()
2921 "Find the current file, and update our visuals to indicate its name.
2922 This is specific to file names. If the file name doesn't show up, but
2923 it should be in the list, then the directory cache needs to be
2924 updated."
2925 (let* ((lastf (selected-frame))
2926 (newcfd (save-excursion
2927 (select-frame speedbar-attached-frame)
2928 (let ((rf (if (buffer-file-name)
2929 (buffer-file-name)
2930 nil)))
2931 (select-frame lastf)
2932 rf)))
2933 (newcf (if newcfd newcfd))
2934 (lastb (current-buffer))
2935 (sucf-recursive (boundp 'sucf-recursive))
2936 (case-fold-search read-file-name-completion-ignore-case))
2937 (if (and newcf
2938 ;; check here, that way we won't refresh to newcf until
2939 ;; its been written, thus saving ourselves some time
2940 (file-exists-p newcf)
2941 (not (string= newcf speedbar-last-selected-file)))
2942 (progn
2943 ;; It is important to select the frame, otherwise the window
2944 ;; we want the cursor to move in will not be updated by the
2945 ;; search-forward command.
2946 (select-frame speedbar-frame)
2947 ;; Remove the old file...
2948 (speedbar-clear-current-file)
2949 ;; now highlight the new one.
2950 (set-buffer speedbar-buffer)
2951 (speedbar-with-writable
2952 (if (speedbar-find-selected-file newcf)
2953 ;; put the property on it
2954 (put-text-property (match-beginning 1)
2955 (match-end 1)
2956 'face
2957 'speedbar-selected-face)
2958 ;; Oops, it's not in the list. Should it be?
2959 (if (and (string-match speedbar-file-regexp newcf)
2960 (string= (file-name-directory newcfd)
2961 (expand-file-name default-directory)))
2962 ;; yes, it is (we will ignore unknowns for now...)
2963 (progn
2964 (speedbar-refresh)
2965 (if (speedbar-find-selected-file newcf)
2966 ;; put the property on it
2967 (put-text-property (match-beginning 1)
2968 (match-end 1)
2969 'face
2970 'speedbar-selected-face)))
2971 ;; if it's not in there now, whatever...
2973 (setq speedbar-last-selected-file newcf))
2974 (if (not sucf-recursive)
2975 (progn
2976 (speedbar-center-buffer-smartly)
2977 (speedbar-position-cursor-on-line)
2979 (set-buffer lastb)
2980 (select-frame lastf)
2982 ;; return that we are done with this activity.
2985 (defun speedbar-add-indicator (indicator-string &optional replace-this)
2986 "Add INDICATOR-STRING to the end of this speedbar line.
2987 If INDICATOR-STRING is space, and REPLACE-THIS is a character, then
2988 the existing indicator is removed. If there is already an
2989 indicator, then do not add a space."
2990 (beginning-of-line)
2991 ;; The nature of the beast: Assume we are in "the right place"
2992 (end-of-line)
2993 (skip-chars-backward (concat " " speedbar-vc-indicator
2994 (car speedbar-obj-indicator)
2995 (cdr speedbar-obj-indicator)))
2996 (if (and (not (looking-at speedbar-indicator-regex))
2997 (not (string= indicator-string " ")))
2998 (insert speedbar-indicator-separator))
2999 (speedbar-with-writable
3000 (save-excursion
3001 (if (and replace-this
3002 (re-search-forward replace-this (save-excursion (end-of-line)
3003 (point))
3005 (delete-region (match-beginning 0) (match-end 0))))
3006 (end-of-line)
3007 (if (not (string= " " indicator-string))
3008 (insert indicator-string))))
3010 ;; Load efs/ange-ftp only if compiling to remove byte-compiler warnings.
3011 ;; Steven L Baur <steve@xemacs.org> said this was important:
3012 (eval-when-compile (or (featurep 'xemacs)
3013 (condition-case () (require 'efs)
3014 (error (require 'ange-ftp)))))
3016 (defun speedbar-check-vc ()
3017 "Scan all files in a directory, and for each see if it's checked out.
3018 See `speedbar-this-file-in-vc' and `speedbar-vc-check-dir-p' for how
3019 to add more types of version control systems."
3020 ;; Check for to-do to be reset. If reset but no RCS is available
3021 ;; then set to nil (do nothing) otherwise, start at the beginning
3022 (save-excursion
3023 (set-buffer speedbar-buffer)
3024 (if (and speedbar-vc-do-check (eq speedbar-vc-to-do-point t)
3025 (speedbar-vc-check-dir-p default-directory)
3026 (not (or (and (featurep 'ange-ftp)
3027 (string-match
3028 (car (if speedbar-xemacsp
3029 ange-ftp-path-format
3030 ange-ftp-name-format))
3031 (expand-file-name default-directory)))
3032 ;; efs support: Bob Weiner
3033 (and (featurep 'efs)
3034 (string-match
3035 (car efs-path-regexp)
3036 (expand-file-name default-directory))))))
3037 (setq speedbar-vc-to-do-point 0))
3038 (if (numberp speedbar-vc-to-do-point)
3039 (progn
3040 (goto-char speedbar-vc-to-do-point)
3041 (while (and (not (input-pending-p))
3042 (re-search-forward "^\\([0-9]+\\):\\s-*\\[[+-]\\] "
3043 nil t))
3044 (setq speedbar-vc-to-do-point (point))
3045 (if (speedbar-check-vc-this-line (match-string 1))
3046 (speedbar-add-indicator speedbar-vc-indicator
3047 (regexp-quote speedbar-vc-indicator))
3048 (speedbar-add-indicator " "
3049 (regexp-quote speedbar-vc-indicator))))
3050 (if (input-pending-p)
3051 ;; return that we are incomplete
3053 ;; we are done, set to-do to nil
3054 (setq speedbar-vc-to-do-point nil)
3055 ;; and return t
3057 t)))
3059 (defun speedbar-check-vc-this-line (depth)
3060 "Return t if the file on this line is check of of a version control system.
3061 Parameter DEPTH is a string with the current depth of indentation of
3062 the file being checked."
3063 (let* ((d (string-to-int depth))
3064 (f (speedbar-line-path d))
3065 (fn (buffer-substring-no-properties
3066 ;; Skip-chars: thanks ptype@dra.hmg.gb
3067 (point) (progn
3068 (skip-chars-forward "^ "
3069 (save-excursion (end-of-line)
3070 (point)))
3071 (point))))
3072 (fulln (concat f fn)))
3073 (if (<= 2 speedbar-verbosity-level)
3074 (speedbar-message "Speedbar vc check...%s" fulln))
3075 (and (file-writable-p fulln)
3076 (speedbar-this-file-in-vc f fn))))
3078 (defun speedbar-vc-check-dir-p (path)
3079 "Return t if we should bother checking PATH for version control files.
3080 This can be overloaded to add new types of version control systems."
3082 ;; Local RCS
3083 (file-exists-p (concat path "RCS/"))
3084 ;; Local SCCS
3085 (file-exists-p (concat path "SCCS/"))
3086 ;; Remote SCCS project
3087 (let ((proj-dir (getenv "PROJECTDIR")))
3088 (if proj-dir
3089 (file-exists-p (concat proj-dir "/SCCS"))
3090 nil))
3091 ;; User extension
3092 (run-hook-with-args 'speedbar-vc-path-enable-hook path)
3095 (defun speedbar-this-file-in-vc (path name)
3096 "Check to see if the file in PATH with NAME is in a version control system.
3097 You can add new VC systems by overriding this function. You can
3098 optimize this function by overriding it and only doing those checks
3099 that will occur on your system."
3101 ;; RCS file name
3102 (file-exists-p (concat path "RCS/" name ",v"))
3103 (file-exists-p (concat path "RCS/" name))
3104 ;; Local SCCS file name
3105 (file-exists-p (concat path "SCCS/s." name))
3106 ;; Remote SCCS file name
3107 (let ((proj-dir (getenv "PROJECTDIR")))
3108 (if proj-dir
3109 (file-exists-p (concat proj-dir "/SCCS/s." name))
3110 nil))
3111 ;; User extension
3112 (run-hook-with-args 'speedbar-vc-in-control-hook path name)
3115 ;; Objet File scanning
3116 (defun speedbar-check-objects ()
3117 "Scan all files in a directory, and for each see if there is an object.
3118 See `speedbar-check-obj-this-line' and `speedbar-obj-alist' for how
3119 to add more object types."
3120 ;; Check for to-do to be reset. If reset but no RCS is available
3121 ;; then set to nil (do nothing) otherwise, start at the beginning
3122 (save-excursion
3123 (set-buffer speedbar-buffer)
3124 (if (and speedbar-obj-do-check (eq speedbar-obj-to-do-point t))
3125 (setq speedbar-obj-to-do-point 0))
3126 (if (numberp speedbar-obj-to-do-point)
3127 (progn
3128 (goto-char speedbar-obj-to-do-point)
3129 (while (and (not (input-pending-p))
3130 (re-search-forward "^\\([0-9]+\\):\\s-*\\[[+-]\\] "
3131 nil t))
3132 (setq speedbar-obj-to-do-point (point))
3133 (let ((ind (speedbar-check-obj-this-line (match-string 1))))
3134 (if (not ind) (setq ind " "))
3135 (speedbar-add-indicator ind (concat
3136 (car speedbar-obj-indicator)
3137 "\\|"
3138 (cdr speedbar-obj-indicator)))))
3139 (if (input-pending-p)
3140 ;; return that we are incomplete
3142 ;; we are done, set to-do to nil
3143 (setq speedbar-obj-to-do-point nil)
3144 ;; and return t
3146 t)))
3148 (defun speedbar-check-obj-this-line (depth)
3149 "Return t if the file on this line has an associated object.
3150 Parameter DEPTH is a string with the current depth of indentation of
3151 the file being checked."
3152 (let* ((d (string-to-int depth))
3153 (f (speedbar-line-path d))
3154 (fn (buffer-substring-no-properties
3155 ;; Skip-chars: thanks ptype@dra.hmg.gb
3156 (point) (progn
3157 (skip-chars-forward "^ "
3158 (save-excursion (end-of-line)
3159 (point)))
3160 (point))))
3161 (fulln (concat f fn)))
3162 (if (<= 2 speedbar-verbosity-level)
3163 (speedbar-message "Speedbar obj check...%s" fulln))
3164 (let ((oa speedbar-obj-alist))
3165 (while (and oa (not (string-match (car (car oa)) fulln)))
3166 (setq oa (cdr oa)))
3167 (if (not (and oa (file-exists-p (concat (file-name-sans-extension fulln)
3168 (cdr (car oa))))))
3170 ;; Find out if the object is out of date or not.
3171 (let ((date1 (nth 5 (file-attributes fulln)))
3172 (date2 (nth 5 (file-attributes (concat
3173 (file-name-sans-extension fulln)
3174 (cdr (car oa)))))))
3175 (if (or (< (car date1) (car date2))
3176 (and (= (car date1) (car date2))
3177 (< (nth 1 date1) (nth 1 date2))))
3178 (car speedbar-obj-indicator)
3179 (cdr speedbar-obj-indicator)))))))
3181 ;;; Clicking Activity
3183 (defun speedbar-mouse-set-point (e)
3184 "Set POINT based on event E.
3185 Handle clicking on images in XEmacs."
3186 (if (and (fboundp 'event-over-glyph-p) (event-over-glyph-p e))
3187 ;; We are in XEmacs, and clicked on a picture
3188 (let ((ext (event-glyph-extent e)))
3189 ;; This position is back inside the extent where the
3190 ;; junk we pushed into the property list lives.
3191 (if (extent-end-position ext)
3192 (goto-char (1- (extent-end-position ext)))
3193 (mouse-set-point e)))
3194 ;; We are not in XEmacs, OR we didn't click on a picture.
3195 (mouse-set-point e)))
3197 (defun speedbar-quick-mouse (e)
3198 "Since mouse events are strange, this will keep the mouse nicely positioned.
3199 This should be bound to mouse event E."
3200 (interactive "e")
3201 (speedbar-mouse-set-point e)
3202 (speedbar-position-cursor-on-line)
3205 (defun speedbar-position-cursor-on-line ()
3206 "Position the cursor on a line."
3207 (let ((oldpos (point)))
3208 (beginning-of-line)
3209 (if (looking-at "[0-9]+:\\s-*..?.? ")
3210 (goto-char (1- (match-end 0)))
3211 (goto-char oldpos))))
3213 (defun speedbar-power-click (e)
3214 "Activate any speedbar button as a power click.
3215 A power click will dispose of cached data (if available) or bring a buffer
3216 up into a different window.
3217 This should be bound to mouse event E."
3218 (interactive "e")
3219 (let ((speedbar-power-click t))
3220 (speedbar-click e)))
3222 (defun speedbar-click (e)
3223 "Activate any speedbar buttons where the mouse is clicked.
3224 This must be bound to a mouse event. A button is any location of text
3225 with a mouse face that has a text property called `speedbar-function'.
3226 This should be bound to mouse event E."
3227 (interactive "e")
3228 (speedbar-mouse-set-point e)
3229 (speedbar-do-function-pointer)
3230 (speedbar-quick-mouse e))
3232 (defun speedbar-double-click (e)
3233 "Activate any speedbar buttons where the mouse is clicked.
3234 This must be bound to a mouse event. A button is any location of text
3235 with a mouse face that has a text property called `speedbar-function'.
3236 This should be bound to mouse event E."
3237 (interactive "e")
3238 ;; Emacs only. XEmacs handles this via `mouse-track-click-hook'.
3239 (cond ((eq (car e) 'down-mouse-1)
3240 (speedbar-mouse-set-point e))
3241 ((eq (car e) 'mouse-1)
3242 (speedbar-quick-mouse e))
3243 ((or (eq (car e) 'double-down-mouse-1)
3244 (eq (car e) 'triple-down-mouse-1))
3245 (speedbar-mouse-set-point e)
3246 (speedbar-do-function-pointer)
3247 (speedbar-quick-mouse e))))
3249 (defun speedbar-do-function-pointer ()
3250 "Look under the cursor and examine the text properties.
3251 From this extract the file/tag name, token, indentation level and call
3252 a function if appropriate."
3253 (let* ((fn (get-text-property (point) 'speedbar-function))
3254 (tok (get-text-property (point) 'speedbar-token))
3255 ;; The 1-,+ is safe because scaning starts AFTER the point
3256 ;; specified. This lets the search include the character the
3257 ;; cursor is on.
3258 (tp (previous-single-property-change
3259 (1+ (point)) 'speedbar-function))
3260 (np (next-single-property-change
3261 (point) 'speedbar-function))
3262 (txt (buffer-substring-no-properties (or tp (point-min))
3263 (or np (point-max))))
3264 (dent (save-excursion (beginning-of-line)
3265 (string-to-number
3266 (if (looking-at "[0-9]+")
3267 (buffer-substring-no-properties
3268 (match-beginning 0) (match-end 0))
3269 "0")))))
3270 ;;(speedbar-message "%S:%S:%S:%s" fn tok txt dent)
3271 (and fn (funcall fn txt tok dent)))
3272 (speedbar-position-cursor-on-line))
3274 ;;; Reading info from the speedbar buffer
3276 (defun speedbar-line-text (&optional p)
3277 "Retrieve the text after prefix junk for the current line.
3278 Optional argument P is where to start the search from."
3279 (save-excursion
3280 (if p (goto-char p))
3281 (beginning-of-line)
3282 (if (looking-at (concat
3283 "\\([0-9]+\\): *[[<{][-+?][]>}] \\([^ \n]+\\)\\("
3284 speedbar-indicator-regex "\\)?"))
3285 (match-string 2)
3286 nil)))
3288 (defun speedbar-line-token (&optional p)
3289 "Retrieve the token information after the prefix junk for the current line.
3290 Optional argument P is where to start the search from."
3291 (save-excursion
3292 (if p (goto-char p))
3293 (beginning-of-line)
3294 (if (looking-at (concat
3295 "\\([0-9]+\\): *[[<{]?[-+?=][]>}@()|] \\([^ \n]+\\)\\("
3296 speedbar-indicator-regex "\\)?"))
3297 (progn
3298 (goto-char (match-beginning 2))
3299 (get-text-property (point) 'speedbar-token))
3300 nil)))
3302 (defun speedbar-line-file (&optional p)
3303 "Retrieve the file or whatever from the line at point P.
3304 The return value is a string representing the file. If it is a
3305 directory, then it is the directory name."
3306 (save-match-data
3307 (let ((f (speedbar-line-text p)))
3308 (if f
3309 (let* ((depth (string-to-int (match-string 1)))
3310 (path (speedbar-line-path depth)))
3311 (if (file-exists-p (concat path f))
3312 (concat path f)
3313 nil))
3314 nil))))
3316 (defun speedbar-goto-this-file (file)
3317 "If FILE is displayed, go to this line and return t.
3318 Otherwise do not move and return nil."
3319 (let ((path (substring (file-name-directory (expand-file-name file))
3320 (length (expand-file-name default-directory))))
3321 (dest (point)))
3322 (save-match-data
3323 (goto-char (point-min))
3324 ;; scan all the directories
3325 (while (and path (not (eq path t)))
3326 (if (string-match "^[/\\]?\\([^/\\]+\\)" path)
3327 (let ((pp (match-string 1 path)))
3328 (if (save-match-data
3329 (re-search-forward (concat "> " (regexp-quote pp) "$")
3330 nil t))
3331 (setq path (substring path (match-end 1)))
3332 (setq path nil)))
3333 (setq path t)))
3334 ;; find the file part
3335 (if (or (not path) (string= (file-name-nondirectory file) ""))
3336 ;; only had a dir part
3337 (if path
3338 (progn
3339 (speedbar-position-cursor-on-line)
3341 (goto-char dest) nil)
3342 ;; find the file part
3343 (let ((nd (file-name-nondirectory file)))
3344 (if (re-search-forward
3345 (concat "] \\(" (regexp-quote nd)
3346 "\\)\\(" speedbar-indicator-regex "\\)$")
3347 nil t)
3348 (progn
3349 (speedbar-position-cursor-on-line)
3351 (goto-char dest)
3352 nil))))))
3354 (defun speedbar-line-path (&optional depth)
3355 "Retrieve the pathname associated with the current line.
3356 This may require traversing backwards from DEPTH and combining the default
3357 directory with these items. This function is replaceable in
3358 `speedbar-mode-functions-list' as `speedbar-line-path'."
3359 (let ((rf (speedbar-fetch-replacement-function 'speedbar-line-path)))
3360 (if rf (funcall rf depth) default-directory)))
3362 (defun speedbar-files-line-path (&optional depth)
3363 "Retrieve the pathname associated with the current line.
3364 This may require traversing backwards from DEPTH and combining the default
3365 directory with these items."
3366 (save-excursion
3367 (save-match-data
3368 (if (not depth)
3369 (progn
3370 (beginning-of-line)
3371 (looking-at "^\\([0-9]+\\):")
3372 (setq depth (string-to-int (match-string 1)))))
3373 (let ((path nil))
3374 (setq depth (1- depth))
3375 (while (/= depth -1)
3376 (if (not (re-search-backward (format "^%d:" depth) nil t))
3377 (error "Error building path of tag")
3378 (cond ((looking-at "[0-9]+:\\s-*<->\\s-+\\([^\n]+\\)$")
3379 (setq path (concat (buffer-substring-no-properties
3380 (match-beginning 1) (match-end 1))
3382 path)))
3383 ((looking-at "[0-9]+:\\s-*[-]\\s-+\\([^\n]+\\)$")
3384 ;; This is the start of our path.
3385 (setq path (buffer-substring-no-properties
3386 (match-beginning 1) (match-end 1))))))
3387 (setq depth (1- depth)))
3388 (if (and path
3389 (string-match (concat speedbar-indicator-regex "$")
3390 path))
3391 (setq path (substring path 0 (match-beginning 0))))
3392 (concat default-directory path)))))
3394 (defun speedbar-path-line (path)
3395 "Position the cursor on the line specified by PATH."
3396 (save-match-data
3397 (if (string-match "[/\\]$" path)
3398 (setq path (substring path 0 (match-beginning 0))))
3399 (let ((nomatch t) (depth 0)
3400 (fname (file-name-nondirectory path))
3401 (pname (file-name-directory path)))
3402 (if (not (member pname speedbar-shown-directories))
3403 (error "Internal Error: File %s not shown in speedbar" path))
3404 (goto-char (point-min))
3405 (while (and nomatch
3406 (re-search-forward
3407 (concat "[]>] \\(" (regexp-quote fname)
3408 "\\)\\(" speedbar-indicator-regex "\\)?$")
3409 nil t))
3410 (beginning-of-line)
3411 (looking-at "\\([0-9]+\\):")
3412 (setq depth (string-to-int (match-string 0))
3413 nomatch (not (string= pname (speedbar-line-path depth))))
3414 (end-of-line))
3415 (beginning-of-line)
3416 (not nomatch))))
3418 (defun speedbar-edit-line ()
3419 "Edit whatever tag or file is on the current speedbar line."
3420 (interactive)
3421 (or (save-excursion
3422 (beginning-of-line)
3423 ;; If this fails, then it is a non-standard click, and as such,
3424 ;; perfectly allowed.
3425 (if (re-search-forward "[]>?}] [^ ]"
3426 (save-excursion (end-of-line) (point))
3428 (progn
3429 (forward-char -1)
3430 (speedbar-do-function-pointer))
3431 nil))
3432 (speedbar-do-function-pointer)))
3434 (defun speedbar-expand-line (&optional arg)
3435 "Expand the line under the cursor.
3436 With universal argument ARG, flush cached data."
3437 (interactive "P")
3438 (beginning-of-line)
3439 (let ((speedbar-power-click arg))
3440 (condition-case nil
3441 (progn
3442 (re-search-forward ":\\s-*.\\+. "
3443 (save-excursion (end-of-line) (point)))
3444 (forward-char -2)
3445 (speedbar-do-function-pointer))
3446 (error (speedbar-position-cursor-on-line)))))
3448 (defun speedbar-flush-expand-line ()
3449 "Expand the line under the cursor and flush any cached information."
3450 (interactive)
3451 (speedbar-expand-line 1))
3453 (defun speedbar-contract-line ()
3454 "Contract the line under the cursor."
3455 (interactive)
3456 (beginning-of-line)
3457 (condition-case nil
3458 (progn
3459 (re-search-forward ":\\s-*.-. "
3460 (save-excursion (end-of-line) (point)))
3461 (forward-char -2)
3462 (speedbar-do-function-pointer))
3463 (error (speedbar-position-cursor-on-line))))
3465 (if speedbar-xemacsp
3466 (defalias 'speedbar-mouse-event-p 'button-press-event-p)
3467 (defun speedbar-mouse-event-p (event)
3468 "Return t if the event is a mouse related event."
3469 ;; And Emacs does it this way
3470 (if (and (listp event)
3471 (member (event-basic-type event)
3472 '(mouse-1 mouse-2 mouse-3)))
3474 nil)))
3476 (defun speedbar-maybee-jump-to-attached-frame ()
3477 "Jump to the attached frame ONLY if this was not a mouse event."
3478 (if (or (not (speedbar-mouse-event-p last-input-event))
3479 speedbar-activity-change-focus-flag)
3480 (progn
3481 (select-frame speedbar-attached-frame)
3482 (other-frame 0))))
3484 (defun speedbar-find-file (text token indent)
3485 "Speedbar click handler for filenames.
3486 TEXT, the file will be displayed in the attached frame.
3487 TOKEN is unused, but required by the click handler. INDENT is the
3488 current indentation level."
3489 (let ((cdd (speedbar-line-path indent)))
3490 (speedbar-find-file-in-frame (concat cdd text))
3491 (speedbar-stealthy-updates)
3492 (run-hooks 'speedbar-visiting-file-hook)
3493 ;; Reset the timer with a new timeout when cliking a file
3494 ;; in case the user was navigating directories, we can cancel
3495 ;; that other timer.
3496 (speedbar-set-timer speedbar-update-speed))
3497 (speedbar-maybee-jump-to-attached-frame))
3499 (defun speedbar-dir-follow (text token indent)
3500 "Speedbar click handler for directory names.
3501 Clicking a directory will cause the speedbar to list files in
3502 the subdirectory TEXT. TOKEN is an unused requirement. The
3503 subdirectory chosen will be at INDENT level."
3504 (setq default-directory
3505 (concat (expand-file-name (concat (speedbar-line-path indent) text))
3506 "/"))
3507 ;; Because we leave speedbar as the current buffer,
3508 ;; update contents will change directory without
3509 ;; having to touch the attached frame. Turn off smart expand just
3510 ;; in case.
3511 (let ((speedbar-smart-directory-expand-flag nil))
3512 (speedbar-update-contents))
3513 (speedbar-set-timer speedbar-navigating-speed)
3514 (setq speedbar-last-selected-file nil)
3515 (speedbar-stealthy-updates))
3517 (defun speedbar-delete-subblock (indent)
3518 "Delete text from point to indentation level INDENT or greater.
3519 Handles end-of-sublist smartly."
3520 (speedbar-with-writable
3521 (save-excursion
3522 (end-of-line) (forward-char 1)
3523 (let ((start (point)))
3524 (while (and (looking-at "^\\([0-9]+\\):")
3525 (> (string-to-int (match-string 1)) indent)
3526 (not (eobp)))
3527 (forward-line 1)
3528 (beginning-of-line))
3529 (delete-region start (point))))))
3531 (defun speedbar-dired (text token indent)
3532 "Speedbar click handler for directory expand button.
3533 Clicking this button expands or contracts a directory. TEXT is the
3534 button clicked which has either a + or -. TOKEN is the directory to be
3535 expanded. INDENT is the current indentation level."
3536 (cond ((string-match "+" text) ;we have to expand this dir
3537 (setq speedbar-shown-directories
3538 (cons (expand-file-name
3539 (concat (speedbar-line-path indent) token "/"))
3540 speedbar-shown-directories))
3541 (speedbar-change-expand-button-char ?-)
3542 (speedbar-reset-scanners)
3543 (save-excursion
3544 (end-of-line) (forward-char 1)
3545 (speedbar-with-writable
3546 (speedbar-default-directory-list
3547 (concat (speedbar-line-path indent) token "/")
3548 (1+ indent)))))
3549 ((string-match "-" text) ;we have to contract this node
3550 (speedbar-reset-scanners)
3551 (let ((oldl speedbar-shown-directories)
3552 (newl nil)
3553 (td (expand-file-name
3554 (concat (speedbar-line-path indent) token))))
3555 (while oldl
3556 (if (not (string-match (concat "^" (regexp-quote td)) (car oldl)))
3557 (setq newl (cons (car oldl) newl)))
3558 (setq oldl (cdr oldl)))
3559 (setq speedbar-shown-directories (nreverse newl)))
3560 (speedbar-change-expand-button-char ?+)
3561 (speedbar-delete-subblock indent)
3563 (t (error "Ooops... not sure what to do")))
3564 (speedbar-center-buffer-smartly)
3565 (setq speedbar-last-selected-file nil)
3566 (save-excursion (speedbar-stealthy-updates)))
3568 (defun speedbar-directory-buttons-follow (text token indent)
3569 "Speedbar click handler for default directory buttons.
3570 TEXT is the button clicked on. TOKEN is the directory to follow.
3571 INDENT is the current indentation level and is unused."
3572 (if (string-match "^[A-z]:$" token)
3573 (setq default-directory (concat token "/"))
3574 (setq default-directory token))
3575 ;; Because we leave speedbar as the current buffer,
3576 ;; update contents will change directory without
3577 ;; having to touch the attached frame.
3578 (speedbar-update-contents)
3579 (speedbar-set-timer speedbar-navigating-speed))
3581 (defun speedbar-tag-file (text token indent)
3582 "The cursor is on a selected line. Expand the tags in the specified file.
3583 The parameter TEXT and TOKEN are required, where TEXT is the button
3584 clicked, and TOKEN is the file to expand. INDENT is the current
3585 indentation level."
3586 (cond ((string-match "+" text) ;we have to expand this file
3587 (let* ((fn (expand-file-name (concat (speedbar-line-path indent)
3588 token)))
3589 (mode nil)
3590 (lst (speedbar-fetch-dynamic-tags fn)))
3591 ;; if no list, then remove expando button
3592 (if (not lst)
3593 (speedbar-change-expand-button-char ??)
3594 (speedbar-change-expand-button-char ?-)
3595 (speedbar-with-writable
3596 (save-excursion
3597 (end-of-line) (forward-char 1)
3598 (funcall (car lst) indent (cdr lst)))))))
3599 ((string-match "-" text) ;we have to contract this node
3600 (speedbar-change-expand-button-char ?+)
3601 (speedbar-delete-subblock indent))
3602 (t (error "Ooops... not sure what to do")))
3603 (speedbar-center-buffer-smartly))
3605 (defun speedbar-tag-find (text token indent)
3606 "For the tag TEXT in a file TOKEN, go to that position.
3607 INDENT is the current indentation level."
3608 (let ((file (speedbar-line-path indent)))
3609 (speedbar-find-file-in-frame file)
3610 (save-excursion (speedbar-stealthy-updates))
3611 ;; Reset the timer with a new timeout when cliking a file
3612 ;; in case the user was navigating directories, we can cancel
3613 ;; that other timer.
3614 (speedbar-set-timer speedbar-update-speed)
3615 (goto-char token)
3616 (run-hooks 'speedbar-visiting-tag-hook)
3617 ;;(recenter)
3618 (speedbar-maybee-jump-to-attached-frame)
3621 (defun speedbar-tag-expand (text token indent)
3622 "Expand a tag sublist. Imenu will return sub-lists of specialized tag types.
3623 Etags does not support this feature. TEXT will be the button
3624 string. TOKEN will be the list, and INDENT is the current indentation
3625 level."
3626 (cond ((string-match "+" text) ;we have to expand this file
3627 (speedbar-change-expand-button-char ?-)
3628 (speedbar-with-writable
3629 (save-excursion
3630 (end-of-line) (forward-char 1)
3631 (speedbar-insert-generic-list indent token 'speedbar-tag-expand
3632 'speedbar-tag-find))))
3633 ((string-match "-" text) ;we have to contract this node
3634 (speedbar-change-expand-button-char ?+)
3635 (speedbar-delete-subblock indent))
3636 (t (error "Ooops... not sure what to do")))
3637 (speedbar-center-buffer-smartly))
3639 ;;; Loading files into the attached frame.
3641 (defun speedbar-find-file-in-frame (file)
3642 "This will load FILE into the speedbar attached frame.
3643 If the file is being displayed in a different frame already, then raise that
3644 frame instead."
3645 (let* ((buff (find-file-noselect file))
3646 (bwin (get-buffer-window buff 0)))
3647 (if bwin
3648 (progn
3649 (select-window bwin)
3650 (raise-frame (window-frame bwin)))
3651 (if speedbar-power-click
3652 (let ((pop-up-frames t)) (select-window (display-buffer buff)))
3653 (select-frame speedbar-attached-frame)
3654 (switch-to-buffer buff))))
3657 ;;; Centering Utility
3659 (defun speedbar-center-buffer-smartly ()
3660 "Recenter a speedbar buffer so the current indentation level is all visible.
3661 This assumes that the cursor is on a file, or tag of a file which the user is
3662 interested in."
3663 (if (<= (count-lines (point-min) (point-max))
3664 (1- (window-height (selected-window))))
3665 ;; whole buffer fits
3666 (let ((cp (point)))
3667 (goto-char (point-min))
3668 (recenter 0)
3669 (goto-char cp))
3670 ;; too big
3671 (let (depth start end exp p)
3672 (save-excursion
3673 (beginning-of-line)
3674 (setq depth (if (looking-at "[0-9]+")
3675 (string-to-int (buffer-substring-no-properties
3676 (match-beginning 0) (match-end 0)))
3678 (setq exp (format "^%d:\\s-*[[{<]\\([?+-]\\)[]>}]" depth)))
3679 (save-excursion
3680 (end-of-line)
3681 (if (re-search-backward exp nil t)
3682 (setq start (point))
3683 (setq start (point-min)))
3684 (save-excursion ;Not sure about this part.
3685 (end-of-line)
3686 (setq p (point))
3687 (while (and (not (re-search-forward exp nil t))
3688 (>= depth 0))
3689 (setq depth (1- depth))
3690 (setq exp (format "^%d:\\s-*[[{<]\\([?+-]\\)[]>}]" depth)))
3691 (if (/= (point) p)
3692 (setq end (point))
3693 (setq end (point-max)))))
3694 ;; Now work out the details of centering
3695 (let ((nl (count-lines start end))
3696 (cp (point)))
3697 (if (> nl (window-height (selected-window)))
3698 ;; We can't fit it all, so just center on cursor
3699 (progn (goto-char start)
3700 (recenter 1))
3701 ;; we can fit everything on the screen, but...
3702 (if (and (pos-visible-in-window-p start (selected-window))
3703 (pos-visible-in-window-p end (selected-window)))
3704 ;; we are all set!
3706 ;; we need to do something...
3707 (goto-char start)
3708 (let ((newcent (/ (- (window-height (selected-window)) nl) 2))
3709 (lte (count-lines start (point-max))))
3710 (if (and (< (+ newcent lte) (window-height (selected-window)))
3711 (> (- (window-height (selected-window)) lte 1)
3712 newcent))
3713 (setq newcent (- (window-height (selected-window))
3714 lte 1)))
3715 (recenter newcent))))
3716 (goto-char cp)))))
3719 ;;; Tag Management -- List of expanders:
3721 (defun speedbar-fetch-dynamic-tags (file)
3722 "Return a list of tags generated dynamically from FILE.
3723 This uses the entries in `speedbar-dynamic-tags-function-list'
3724 to find the proper tags. It is up to each of those individual
3725 functions to do caching and flushing if appropriate."
3726 (save-excursion
3727 (set-buffer (find-file-noselect file))
3728 ;; If there is a buffer-local value of
3729 ;; speedbar-dynamic-tags-function-list, it will now be available.
3730 (let ((dtf speedbar-dynamic-tags-function-list)
3731 (ret t))
3732 (while (and (eq ret t) dtf)
3733 (setq ret
3734 (if (fboundp (car (car dtf)))
3735 (funcall (car (car dtf)) (buffer-file-name))
3737 (if (eq ret t)
3738 (setq dtf (cdr dtf))))
3739 (if (eq ret t)
3740 ;; No valid tag list, return nil
3742 ;; We have some tags. Return the list with the insert fn
3743 ;; prepended
3744 (cons (cdr (car dtf)) ret)))))
3746 ;;; Tag Management -- Imenu
3748 (if (not speedbar-use-imenu-flag)
3752 (eval-when-compile (if (locate-library "imenu") (require 'imenu)))
3754 (defun speedbar-fetch-dynamic-imenu (file)
3755 "Load FILE into a buffer, and generate tags using Imenu.
3756 Returns the tag list, or t for an error."
3757 ;; Load this AND compile it in
3758 (require 'imenu)
3759 (if speedbar-power-click (setq imenu--index-alist nil))
3760 (condition-case nil
3761 (let ((index-alist (imenu--make-index-alist t)))
3762 (if speedbar-sort-tags
3763 (sort (copy-alist index-alist)
3764 (lambda (a b) (string< (car a) (car b))))
3765 index-alist))
3766 (error t)))
3769 ;;; Tag Management -- etags (old XEmacs compatibility part)
3771 (defvar speedbar-fetch-etags-parse-list
3772 '(;; Note that java has the same parse-group as c
3773 ("\\.\\([cChH]\\|c\\+\\+\\|cpp\\|cc\\|hh\\|java\\)\\'" .
3774 speedbar-parse-c-or-c++tag)
3775 ("^\\.emacs$\\|.\\(el\\|l\\|lsp\\)\\'" .
3776 "def[^i]+\\s-+\\(\\(\\w\\|[-_]\\)+\\)\\s-*\C-?")
3777 ; ("\\.\\([fF]\\|for\\|FOR\\|77\\|90\\)\\'" .
3778 ; speedbar-parse-fortran77-tag)
3779 ("\\.tex\\'" . speedbar-parse-tex-string)
3780 ("\\.p\\'" .
3781 "\\(\\(FUNCTION\\|function\\|PROCEDURE\\|procedure\\)\\s-+\\([a-zA-Z0-9_.:]+\\)\\)\\s-*(?^?")
3783 "Associations of file extensions and expressions for extracting tags.
3784 To add a new file type, you would want to add a new association to the
3785 list, where the car is the file match, and the cdr is the way to
3786 extract an element from the tags output. If the output is complex,
3787 use a function symbol instead of regexp. The function should expect
3788 to be at the beginning of a line in the etags buffer.
3790 This variable is ignored if `speedbar-use-imenu-flag' is non-nil.")
3792 (defvar speedbar-fetch-etags-command "etags"
3793 "*Command used to create an etags file.
3795 This variable is ignored if `speedbar-use-imenu-flag' is t.")
3797 (defvar speedbar-fetch-etags-arguments '("-D" "-I" "-o" "-")
3798 "*List of arguments to use with `speedbar-fetch-etags-command'.
3799 This creates an etags output buffer. Use `speedbar-toggle-etags' to
3800 modify this list conveniently.
3802 This variable is ignored if `speedbar-use-imenu-flag' is t.")
3804 (defun speedbar-toggle-etags (flag)
3805 "Toggle FLAG in `speedbar-fetch-etags-arguments'.
3806 FLAG then becomes a member of etags command line arguments. If flag
3807 is \"sort\", then toggle the value of `speedbar-sort-tags'. If its
3808 value is \"show\" then toggle the value of
3809 `speedbar-show-unknown-files'.
3811 This function is a convenience function for XEmacs menu created by
3812 Farzin Guilak <farzin@protocol.com>."
3813 (interactive)
3814 (cond
3815 ((equal flag "sort")
3816 (setq speedbar-sort-tags (not speedbar-sort-tags)))
3817 ((equal flag "show")
3818 (setq speedbar-show-unknown-files (not speedbar-show-unknown-files)))
3819 ((or (equal flag "-C")
3820 (equal flag "-S")
3821 (equal flag "-D"))
3822 (if (member flag speedbar-fetch-etags-arguments)
3823 (setq speedbar-fetch-etags-arguments
3824 (delete flag speedbar-fetch-etags-arguments))
3825 (add-to-list 'speedbar-fetch-etags-arguments flag)))
3826 (t nil)))
3828 (defun speedbar-fetch-dynamic-etags (file)
3829 "For FILE, run etags and create a list of symbols extracted.
3830 Each symbol will be associated with its line position in FILE."
3831 (let ((newlist nil))
3832 (unwind-protect
3833 (save-excursion
3834 (if (get-buffer "*etags tmp*")
3835 (kill-buffer "*etags tmp*")) ;kill to clean it up
3836 (if (<= 1 speedbar-verbosity-level)
3837 (speedbar-message "Fetching etags..."))
3838 (set-buffer (get-buffer-create "*etags tmp*"))
3839 (apply 'call-process speedbar-fetch-etags-command nil
3840 (current-buffer) nil
3841 (append speedbar-fetch-etags-arguments (list file)))
3842 (goto-char (point-min))
3843 (if (<= 1 speedbar-verbosity-level)
3844 (speedbar-message "Fetching etags..."))
3845 (let ((expr
3846 (let ((exprlst speedbar-fetch-etags-parse-list)
3847 (ans nil))
3848 (while (and (not ans) exprlst)
3849 (if (string-match (car (car exprlst)) file)
3850 (setq ans (car exprlst)))
3851 (setq exprlst (cdr exprlst)))
3852 (cdr ans))))
3853 (if expr
3854 (let (tnl)
3855 (set-buffer (get-buffer-create "*etags tmp*"))
3856 (while (not (save-excursion (end-of-line) (eobp)))
3857 (save-excursion
3858 (setq tnl (speedbar-extract-one-symbol expr)))
3859 (if tnl (setq newlist (cons tnl newlist)))
3860 (forward-line 1)))
3861 (speedbar-message
3862 "Sorry, no support for a file of that extension"))))
3864 (if speedbar-sort-tags
3865 (sort newlist (lambda (a b) (string< (car a) (car b))))
3866 (reverse newlist))))
3868 ;; This bit donated by Farzin Guilak <farzin@protocol.com> but I'm not
3869 ;; sure it's needed with the different sorting method.
3871 ;(defun speedbar-clean-etags()
3872 ; "Removes spaces before the ^? character, and removes `#define',
3873 ;return types, etc. preceding tags. This ensures that the sort operation
3874 ;works on the tags, not the return types."
3875 ; (save-excursion
3876 ; (goto-char (point-min))
3877 ; (while
3878 ; (re-search-forward "(?[ \t](?\C-?" nil t)
3879 ; (replace-match "\C-?" nil nil))
3880 ; (goto-char (point-min))
3881 ; (while
3882 ; (re-search-forward "\\(.*[ \t]+\\)\\([^ \t\n]+.*\C-?\\)" nil t)
3883 ; (delete-region (match-beginning 1) (match-end 1)))))
3885 (defun speedbar-extract-one-symbol (expr)
3886 "At point, return nil, or one alist in the form: (SYMBOL . POSITION)
3887 The line should contain output from etags. Parse the output using the
3888 regular expression EXPR."
3889 (let* ((sym (if (stringp expr)
3890 (if (save-excursion
3891 (re-search-forward expr (save-excursion
3892 (end-of-line)
3893 (point)) t))
3894 (buffer-substring-no-properties (match-beginning 1)
3895 (match-end 1)))
3896 (funcall expr)))
3897 (pos (let ((j (re-search-forward "[\C-?\C-a]\\([0-9]+\\),\\([0-9]+\\)"
3898 (save-excursion
3899 (end-of-line)
3900 (point))
3901 t)))
3902 (if (and j sym)
3903 (1+ (string-to-int (buffer-substring-no-properties
3904 (match-beginning 2)
3905 (match-end 2))))
3906 0))))
3907 (if (/= pos 0)
3908 (cons sym pos)
3909 nil)))
3911 (defun speedbar-parse-c-or-c++tag ()
3912 "Parse a C or C++ tag, which tends to be a little complex."
3913 (save-excursion
3914 (let ((bound (save-excursion (end-of-line) (point))))
3915 (cond ((re-search-forward "\C-?\\([^\C-a]+\\)\C-a" bound t)
3916 (buffer-substring-no-properties (match-beginning 1)
3917 (match-end 1)))
3918 ((re-search-forward "\\<\\([^ \t]+\\)\\s-+new(" bound t)
3919 (buffer-substring-no-properties (match-beginning 1)
3920 (match-end 1)))
3921 ((re-search-forward "\\<\\([^ \t(]+\\)\\s-*(\C-?" bound t)
3922 (buffer-substring-no-properties (match-beginning 1)
3923 (match-end 1)))
3924 (t nil))
3927 (defun speedbar-parse-tex-string ()
3928 "Parse a Tex string. Only find data which is relevant."
3929 (save-excursion
3930 (let ((bound (save-excursion (end-of-line) (point))))
3931 (cond ((re-search-forward "\\(\\(sub\\)*section\\|chapter\\|cite\\)\\s-*{[^\C-?}]*}?" bound t)
3932 (buffer-substring-no-properties (match-beginning 0)
3933 (match-end 0)))
3934 (t nil)))))
3937 ;;; BUFFER DISPLAY mode.
3939 (defvar speedbar-buffers-key-map nil
3940 "Keymap used when in the buffers display mode.")
3942 (if speedbar-buffers-key-map
3944 (setq speedbar-buffers-key-map (speedbar-make-specialized-keymap))
3946 ;; Basic tree features
3947 (define-key speedbar-buffers-key-map "e" 'speedbar-edit-line)
3948 (define-key speedbar-buffers-key-map "\C-m" 'speedbar-edit-line)
3949 (define-key speedbar-buffers-key-map "+" 'speedbar-expand-line)
3950 (define-key speedbar-buffers-key-map "=" 'speedbar-expand-line)
3951 (define-key speedbar-buffers-key-map "-" 'speedbar-contract-line)
3953 ;; Buffer specific keybindings
3954 (define-key speedbar-buffers-key-map "k" 'speedbar-buffer-kill-buffer)
3955 (define-key speedbar-buffers-key-map "r" 'speedbar-buffer-revert-buffer)
3959 (defvar speedbar-buffer-easymenu-definition
3960 '(["Jump to buffer" speedbar-edit-line t]
3961 ["Expand File Tags" speedbar-expand-line
3962 (save-excursion (beginning-of-line)
3963 (looking-at "[0-9]+: *.\\+. "))]
3964 ["Flush Cache & Expand" speedbar-flush-expand-line
3965 (save-excursion (beginning-of-line)
3966 (looking-at "[0-9]+: *.\\+. "))]
3967 ["Contract File Tags" speedbar-contract-line
3968 (save-excursion (beginning-of-line)
3969 (looking-at "[0-9]+: *.-. "))]
3970 ["Kill Buffer" speedbar-buffer-kill-buffer
3971 (save-excursion (beginning-of-line)
3972 (looking-at "[0-9]+: *.-. "))]
3973 ["Revert Buffer" speedbar-buffer-revert-buffer
3974 (save-excursion (beginning-of-line)
3975 (looking-at "[0-9]+: *.-. "))]
3977 "Menu item elements shown when displaying a buffer list.")
3979 (defun speedbar-buffer-buttons (directory zero)
3980 "Create speedbar buttons based on the buffers currently loaded.
3981 DIRECTORY is the path to the currently active buffer, and ZERO is 0."
3982 (speedbar-buffer-buttons-engine nil))
3984 (defun speedbar-buffer-buttons-temp (directory zero)
3985 "Create speedbar buttons based on the buffers currently loaded.
3986 DIRECTORY is the path to the currently active buffer, and ZERO is 0."
3987 (speedbar-buffer-buttons-engine t))
3989 (defun speedbar-buffer-buttons-engine (temp)
3990 "Create speedbar buffer buttons.
3991 If TEMP is non-nil, then clicking on a buffer restores the previous display."
3992 (insert "Active Buffers:\n")
3993 (let ((bl (buffer-list)))
3994 (while bl
3995 (if (string-match "^[ *]" (buffer-name (car bl)))
3997 (let* ((known (string-match speedbar-file-regexp
3998 (buffer-name (car bl))))
3999 (expchar (if known ?+ ??))
4000 (fn (if known 'speedbar-tag-file nil))
4001 (fname (save-excursion (set-buffer (car bl))
4002 (buffer-file-name))))
4003 (speedbar-make-tag-line 'bracket expchar fn
4004 (if fname (file-name-nondirectory fname))
4005 (buffer-name (car bl))
4006 'speedbar-buffer-click temp
4007 'speedbar-file-face 0)))
4008 (setq bl (cdr bl)))
4009 (setq bl (buffer-list))
4010 (insert "Scratch Buffers:\n")
4011 (while bl
4012 (if (not (string-match "^\\*" (buffer-name (car bl))))
4014 (if (eq (car bl) speedbar-buffer)
4016 (speedbar-make-tag-line 'bracket ?? nil nil
4017 (buffer-name (car bl))
4018 'speedbar-buffer-click temp
4019 'speedbar-file-face 0)))
4020 (setq bl (cdr bl)))
4021 (setq bl (buffer-list))
4022 (insert "Hidden Buffers:\n")
4023 (while bl
4024 (if (not (string-match "^ " (buffer-name (car bl))))
4026 (if (eq (car bl) speedbar-buffer)
4028 (speedbar-make-tag-line 'bracket ?? nil nil
4029 (buffer-name (car bl))
4030 'speedbar-buffer-click temp
4031 'speedbar-file-face 0)))
4032 (setq bl (cdr bl)))))
4034 (defun speedbar-buffers-item-info ()
4035 "Display information about the current buffer on the current line."
4036 (or (speedbar-item-info-tag-helper)
4037 (let* ((item (speedbar-line-text))
4038 (buffer (if item (get-buffer item) nil)))
4039 (and buffer
4040 (speedbar-message "%s%s %S %d %s"
4041 (if (buffer-modified-p buffer) "* " "")
4042 item
4043 (save-excursion (set-buffer buffer) major-mode)
4044 (save-excursion (set-buffer buffer)
4045 (buffer-size))
4046 (or (buffer-file-name buffer) "<No file>"))))))
4048 (defun speedbar-buffers-line-path (&optional depth)
4049 "Fetch the full path to the file (buffer) specified on the current line.
4050 Optional argument DEPTH specifies the current depth of the back search."
4051 (save-excursion
4052 (end-of-line)
4053 (let ((start (point)))
4054 ;; Buffers are always at level 0
4055 (if (not (re-search-backward "^0:" nil t))
4057 (let* ((bn (speedbar-line-text))
4058 (buffer (if bn (get-buffer bn))))
4059 (if buffer
4060 (if (save-excursion
4061 (end-of-line)
4062 (eq start (point)))
4063 (file-name-directory (buffer-file-name buffer))
4064 (buffer-file-name buffer))))))))
4066 (defun speedbar-buffer-click (text token indent)
4067 "When the users clicks on a buffer-button in speedbar.
4068 TEXT is the buffer's name, TOKEN and INDENT are unused."
4069 (if speedbar-power-click
4070 (let ((pop-up-frames t)) (select-window (display-buffer text)))
4071 (select-frame speedbar-attached-frame)
4072 (switch-to-buffer text)
4073 (if token (speedbar-change-initial-expansion-list
4074 speedbar-previously-used-expansion-list-name))))
4076 (defun speedbar-buffer-kill-buffer ()
4077 "Kill the buffer the cursor is on in the speedbar buffer."
4078 (interactive)
4079 (or (save-excursion
4080 (beginning-of-line)
4081 ;; If this fails, then it is a non-standard click, and as such,
4082 ;; perfectly allowed.
4083 (if (re-search-forward "[]>?}] [^ ]"
4084 (save-excursion (end-of-line) (point))
4086 (let ((text (progn
4087 (forward-char -1)
4088 (buffer-substring (point) (save-excursion
4089 (end-of-line)
4090 (point))))))
4091 (if (and (get-buffer text)
4092 (speedbar-y-or-n-p (format "Kill buffer %s? " text)))
4093 (kill-buffer text))
4094 (speedbar-refresh))))))
4096 (defun speedbar-buffer-revert-buffer ()
4097 "Revert the buffer the cursor is on in the speedbar buffer."
4098 (interactive)
4099 (save-excursion
4100 (beginning-of-line)
4101 ;; If this fails, then it is a non-standard click, and as such,
4102 ;; perfectly allowed
4103 (if (re-search-forward "[]>?}] [^ ]"
4104 (save-excursion (end-of-line) (point))
4106 (let ((text (progn
4107 (forward-char -1)
4108 (buffer-substring (point) (save-excursion
4109 (end-of-line)
4110 (point))))))
4111 (if (get-buffer text)
4112 (progn
4113 (set-buffer text)
4114 (revert-buffer t)))))))
4117 ;;; Useful hook values and such.
4119 (defvar speedbar-highlight-one-tag-line nil
4120 "Overlay used for highlighting the most recently jumped to tag line.")
4122 (defun speedbar-highlight-one-tag-line ()
4123 "Highlight the current line, unhighlighting a previously jumped to line."
4124 (speedbar-unhighlight-one-tag-line)
4125 (setq speedbar-highlight-one-tag-line
4126 (speedbar-make-overlay (save-excursion (beginning-of-line) (point))
4127 (save-excursion (end-of-line)
4128 (forward-char 1)
4129 (point))))
4130 (speedbar-overlay-put speedbar-highlight-one-tag-line 'face
4131 'speedbar-highlight-face)
4132 (add-hook 'pre-command-hook 'speedbar-unhighlight-one-tag-line)
4135 (defun speedbar-unhighlight-one-tag-line ()
4136 "Unhighlight the currently highlighted line."
4137 (if speedbar-highlight-one-tag-line
4138 (progn
4139 (speedbar-delete-overlay speedbar-highlight-one-tag-line)
4140 (setq speedbar-highlight-one-tag-line nil)))
4141 (remove-hook 'pre-command-hook 'speedbar-unhighlight-one-tag-line))
4143 (defun speedbar-recenter-to-top ()
4144 "Recenter the current buffer so POINT is on the top of the window."
4145 (recenter 1))
4147 (defun speedbar-recenter ()
4148 "Recenter the current buffer so POINT is in the center of the window."
4149 (recenter (/ (window-height (selected-window)) 2)))
4152 ;;; Color loading section.
4154 (defface speedbar-button-face '((((class color) (background light))
4155 (:foreground "green4"))
4156 (((class color) (background dark))
4157 (:foreground "green3")))
4158 "Face used for +/- buttons."
4159 :group 'speedbar-faces)
4161 (defface speedbar-file-face '((((class color) (background light))
4162 (:foreground "cyan4"))
4163 (((class color) (background dark))
4164 (:foreground "cyan"))
4165 (t (:weight bold)))
4166 "Face used for file names."
4167 :group 'speedbar-faces)
4169 (defface speedbar-directory-face '((((class color) (background light))
4170 (:foreground "blue4"))
4171 (((class color) (background dark))
4172 (:foreground "light blue")))
4173 "Face used for directory names."
4174 :group 'speedbar-faces)
4175 (defface speedbar-tag-face '((((class color) (background light))
4176 (:foreground "brown"))
4177 (((class color) (background dark))
4178 (:foreground "yellow")))
4179 "Face used for displaying tags."
4180 :group 'speedbar-faces)
4182 (defface speedbar-selected-face '((((class color) (background light))
4183 (:foreground "red" :underline t))
4184 (((class color) (background dark))
4185 (:foreground "red" :underline t))
4186 (t (:underline t)))
4187 "Face used to underline the file in the active window."
4188 :group 'speedbar-faces)
4190 (defface speedbar-highlight-face '((((class color) (background light))
4191 (:background "green"))
4192 (((class color) (background dark))
4193 (:background "sea green"))
4194 (((class grayscale mono)
4195 (background light))
4196 (:background "black"))
4197 (((class grayscale mono)
4198 (background dark))
4199 (:background "white")))
4200 "Face used for highlighting buttons with the mouse."
4201 :group 'speedbar-faces)
4204 ;;; Image loading and inlining
4207 ;;; Some images if defimage is available:
4208 (eval-when-compile
4210 (if (fboundp 'defimage)
4211 (defalias 'defimage-speedbar 'defimage)
4213 (if (not (fboundp 'make-glyph))
4215 (defmacro defimage-speedbar (variable imagespec docstring)
4216 "Don't bother loading up an image...
4217 Argument VARIABLE is the variable to define.
4218 Argument IMAGESPEC is the list defining the image to create.
4219 Argument DOCSTRING is the documentation for VARIABLE."
4220 `(defvar ,variable nil ,docstring))
4222 ;; ELSE
4223 (defun speedbar-find-image-on-load-path (image)
4224 "Find the image file IMAGE on the load path."
4225 (let ((l load-path)
4226 (r nil))
4227 (while (and l (not r))
4228 (if (file-exists-p (concat (car l) "/" image))
4229 (setq r (concat (car l) "/" image)))
4230 (setq l (cdr l)))
4233 (defun speedbar-convert-emacs21-imagespec-to-xemacs (spec)
4234 "Convert the Emacs21 image SPEC into an XEmacs image spec."
4235 (let* ((sl (car spec))
4236 (itype (nth 1 sl))
4237 (ifile (nth 3 sl)))
4238 (vector itype ':file (speedbar-find-image-on-load-path ifile))))
4240 (defmacro defimage-speedbar (variable imagespec docstring)
4241 "Define VARIABLE as an image if `defimage' is not available.
4242 IMAGESPEC is the image data, and DOCSTRING is documentation for the image."
4243 `(defvar ,variable
4244 ;; The Emacs21 version of defimage looks just like the XEmacs image
4245 ;; specifier, except that it needs a :type keyword. If we line
4246 ;; stuff up right, we can use this cheat to support XEmacs specifiers.
4247 (condition-case nil
4248 (make-glyph
4249 (make-image-specifier
4250 (speedbar-convert-emacs21-imagespec-to-xemacs (quote ,imagespec)))
4251 'buffer)
4252 (error nil))
4253 ,docstring)))))
4255 (defimage-speedbar speedbar-directory-plus
4256 ((:type xpm :file "sb-dir-plus.xpm" :ascent center))
4257 "Image used for closed directories with stuff in them.")
4259 (defimage-speedbar speedbar-directory-minus
4260 ((:type xpm :file "sb-dir-minus.xpm" :ascent center))
4261 "Image used for open directories with stuff in them.")
4263 (defimage-speedbar speedbar-directory
4264 ((:type xpm :file "sb-dir.xpm" :ascent center))
4265 "Image used for empty or unreadable directories.")
4267 (defimage-speedbar speedbar-page-plus
4268 ((:type xpm :file "sb-pg-plus.xpm" :ascent center))
4269 "Image used for closed files with stuff in them.")
4271 (defimage-speedbar speedbar-page-minus
4272 ((:type xpm :file "sb-pg-minus.xpm" :ascent center))
4273 "Image used for open files with stuff in them.")
4275 (defimage-speedbar speedbar-page
4276 ((:type xpm :file "sb-pg.xpm" :ascent center))
4277 "Image used for files that can't be opened.")
4279 (defimage-speedbar speedbar-tag
4280 ((:type xpm :file "sb-tag.xpm" :ascent center))
4281 "Image used for tags.")
4283 (defimage-speedbar speedbar-tag-plus
4284 ((:type xpm :file "sb-tag-plus.xpm" :ascent center))
4285 "Image used for closed tag groups.")
4287 (defimage-speedbar speedbar-tag-minus
4288 ((:type xpm :file "sb-tag-minus.xpm" :ascent center))
4289 "Image used for open tag groups.")
4291 (defimage-speedbar speedbar-tag-gt
4292 ((:type xpm :file "sb-tag-gt.xpm" :ascent center))
4293 "Image used for open tag groups.")
4295 (defimage-speedbar speedbar-tag-v
4296 ((:type xpm :file "sb-tag-v.xpm" :ascent center))
4297 "Image used for open tag groups.")
4299 (defimage-speedbar speedbar-tag-type
4300 ((:type xpm :file "sb-tag-type.xpm" :ascent center))
4301 "Image used for open tag groups.")
4303 (defimage-speedbar speedbar-mail
4304 ((:type xpm :file "sb-mail.xpm" :ascent center))
4305 "Image used for open tag groups.")
4307 (defvar speedbar-expand-image-button-alist
4308 '(("<+>" . speedbar-directory-plus)
4309 ("<->" . speedbar-directory-minus)
4310 ("< >" . speedbar-directory)
4311 ("[+]" . speedbar-page-plus)
4312 ("[-]" . speedbar-page-minus)
4313 ("[?]" . speedbar-page)
4314 ("{+}" . speedbar-tag-plus)
4315 ("{-}" . speedbar-tag-minus)
4316 ("<M>" . speedbar-mail)
4317 (" =>" . speedbar-tag)
4318 (" +>" . speedbar-tag-gt)
4319 (" ->" . speedbar-tag-v)
4320 (">" . speedbar-tag)
4321 ("@" . speedbar-tag-type)
4322 (" @" . speedbar-tag-type)
4324 "List of text and image associations.")
4326 (defun speedbar-insert-image-button-maybe (start length)
4327 "Insert an image button based on text starting at START for LENGTH chars.
4328 If buttontext is unknown, just insert that text.
4329 If we have an image associated with it, use that image."
4330 (if speedbar-use-images
4331 (let* ((bt (buffer-substring start (+ length start)))
4332 (a (assoc bt speedbar-expand-image-button-alist)))
4333 ;; Regular images (created with `insert-image' are intangible
4334 ;; which (I suppose) make them more compatible with XEmacs 21.
4335 ;; Unfortunatly, there is a giant pile o code dependent on the
4336 ;; underlying text. This means if we leave it tangible, then I
4337 ;; don't have to change said giant piles o code.
4338 (if (and a (symbol-value (cdr a)))
4339 (if (featurep 'xemacs)
4340 (add-text-properties (+ start (length bt)) start
4341 (list 'end-glyph (symbol-value (cdr a))
4342 'rear-nonsticky (list 'display)
4343 'invisible t
4344 'detachable t))
4345 (add-text-properties start (+ start (length bt))
4346 (list 'display (symbol-value (cdr a))
4347 'rear-nonsticky (list 'display))))
4348 ;(message "Bad text [%s]" (buffer-substring start (+ start length)))
4349 ))))
4352 ;; some edebug hooks
4353 (add-hook 'edebug-setup-hook
4354 (lambda ()
4355 (def-edebug-spec speedbar-with-writable def-body)))
4357 (provide 'speedbar)
4359 ;; run load-time hooks
4360 (run-hooks 'speedbar-load-hook)
4362 ;;; arch-tag: 4477e6d1-f78c-48b9-a503-387d3c9767d5
4363 ;;; speedbar.el ends here