This is ecb.info, produced by makeinfo version 4.3 from ecb.texi.

INFO-DIR-SECTION GNU Emacs Lisp
START-INFO-DIR-ENTRY
* ECB: (ecb).           Emacs Code Browser
END-INFO-DIR-ENTRY


File: ecb.info,  Node: Most important options,  Next: Customizable options,  Prev: Customizing,  Up: Customizing

The most important options of ECB
=================================

Here are the most important options (it is recommended to check at
least the following options before working with ECB):

`ecb-source-path'
   Where ECB can find your sources. You must set this option!

`ecb-show-help-format'
   Should the online help of ECB be displayed in the standard Info
   format or in HTML format in a web-browser.

`ecb-auto-activate'
`ecb-major-modes-activate'
`ecb-major-modes-deactivate'
   Auto. (de)activation of ECB

`ecb-key-map'
   All ECB-keybindings incl. a common prefixkey (*note Using the
   keyboard::).

`ecb-new-ecb-frame'
   Should ECB create a new frame at activation time.

`ecb-primary-secondary-mouse-buttons'
`ecb-primary-mouse-jump-destination'
   Define how to use the mouse (*note Using the mouse::).

`ecb-tree-expand-symbol-before'
`ecb-tree-indent'
   The look&feel of the trees in the tree-buffers. Maybe you like a
   value of 4 for the latter one if you display the expand-symbol before
   (*note Changing the ECB-layout::).

`ecb-source-file-regexps'
   Which files will (not) be shown in ECB.

`ecb-show-node-info-in-minibuffer'
   When and which node-info should be displayed in the minibuffer?

`ecb-layout-nr'
   The ECB layout, means which windows you want to be displayed in the
   ECB-frame and also the location of these windows (*note Changing the
   ECB-layout::).

`ecb-token-display-function'
`ecb-type-token-display'
`ecb-show-tokens'
   How to display the entries in the ECB-method window (*note
   Customizing the display::).

But to make ECB working best for you it is also recommened to have a
look at *Note Customizable options::!


File: ecb.info,  Node: Customizable options,  Prev: Most important options,  Up: Customizing

All customizable options of ECB
===============================

All customization of ECB is divided into the following "customize
groups". You can highly customize all the ECB behavior/layout so just
go to these groups and you will see all well documented ECB-options.

* Menu:

* ecb-general::                 General customizing ECB
* ecb-directories::             Customizing the ECB-directories
* ecb-sources::                 Customizing the ECB-sources
* ecb-methods::                 Customizing the ECB-methods
* ecb-history::                 Customizing the ECB-history
* ecb-layout::                  Customizing the ECB-layout
* ecb-face-options::            Customizing options for faces
* ecb-faces::                   Customizing the faces
* ecb-download::                Customizing how to download ECB
* ecb-help::                    Customizing the online help of ECB


File: ecb.info,  Node: ecb-general,  Next: ecb-directories,  Prev: Customizable options,  Up: Customizable options

Group ecb-general
-----------------

This group contains the following options:

 - User Option: ecb-activate-before-layout-draw-hook
   Normal hook run at the end of activating the ecb-package by running
   `ecb-activate'. This hooks are run after all the internal setup
   process but directly before(!) drawing the layout specified in
   `ecb-layout' (means before dividing the frame into several windows).

   A senseful using of this hook can be maximizing the Emacs-frame for
   example, because this should be done before the layout is drawn
   because ECB computes the size of the ECB-windows with the current
   frame size! If you need a hook-option for the real end of the
   activating process (i.e. after the layout-drawing) look at
   `ecb-activate-hook'.

 - User Option: ecb-activate-hook
   Normal hook run at the end of activating the ecb-package by running
   `ecb-activate'. This hooks are run at the real end of the activating
   process, means after the layout has been drawn!. If you need hooks
   which are run direct before the layout-drawing look at
   `ecb-activate-before-layout-draw-hook'.

 - User Option: ecb-auto-activate
   Automatically startup ECB when Emacs starts up. This should only be
   true if you always want to run `ecb-activate'.

 - User Option: ecb-auto-compatibility-check
   Check at ECB-startup if all ECB-options have correct values. If not
   nil then all ECB-options are checked if their current value have the
   correct type. It the type is incorrect the option is either auto.
   upgraded to the new type or reset to the default-value of current ECB
   if no upgrade is possible. This feature can also upgrade options
   which are renamed in current ECB and try to transform the old-value
   to the new named option. After startup all upgraded or reset options
   are displayed with their old (before upgrade/reset) and new values.
   See also the commands `ecb-upgrade-options' and
   `ecb-display-upgraded-options'. If this option is off then the user
   can perform the check and reset manually with `ecb-upgrade-options'.
   *Note Auto. option-upgrading::.

 - User Option: ecb-current-buffer-sync-hook
   Normal hook run at the end of `ecb-current-buffer-sync'.

 - User Option: ecb-deactivate-hook
   Normal hook run at the end of deactivating (but before the ecb-layout
   is cleared!) ECB by running `ecb-deactivate'.

 - User Option: ecb-debug-mode
   If not nil ECB displays debug-information in the Messages-buffer.
   This is done for some critical situations concerning semantic-tokens
   and their overlays (or extends for XEmacs). Normally you should not
   need this switched on! But if you get errors like "destroyed extend"
   for XEmacs or "wrong-argument-type" concerning overlays for GNU
   Emacs then you should switch on this option and submitting a
   bug-report to the ecb-mailing-list (`ecb-submit-problem-report')
   after getting the error again!

 - User Option: ecb-key-map
   Specifies all keybindings for the ECB minor-mode keymap. The value is
   a cons-cell where the car is a common-prefix key for all the
   keybindings. The cdr is a list of keybindings each of them a list
   again. A keybinding has the following form:

      '(<common-prefix-flag> <keysequence> <function>) where

  `<common-prefix-flag>'
      If t then the common-prefixkey defined as car of the value (see
      above) is used.

  `<keysequence>'
      If the common prefixkey is used then the final keybinding is the
      concatenation of the common-prefixkey (see above) and this
      keysequence.

  `<function>:'
      The function to bind to the key. This can also be a
      lambda-expression .

   It is highly recommended to use one of the standard keys C-c or C-x
   as first key of your common-prefixkey!

   You MUST change this option via customize to take effect!

   All keysequences must be inserted as a string and must follow the
   syntax needed by `read-kbd-macro' or `kbd'. This means you can
   insert the key in the same manner `C-h k' displays keysequences.
   Here is the summary of the syntax:

   Text is divided into "words" separated by whitespace. Except for the
   words described below, the characters of each word go directly as
   characters of the keysequence. The whitespace that separates words
   is ignored. Whitespace in the macro must be written explicitly, as
   in `C-c SPC'.

    * The special words RET, SPC, TAB, DEL, LFD, ESC, and NUL represent
      special control characters. The words must be written in
      uppercase.

    * A word in angle brackets, e.g., <return>, <down>, <left> or <f1>,
      represents a function key. (Note that in the standard
      configuration, the function key <return> and the control key RET
      are synonymous.).  You can use angle brackets on the words RET,
      SPC, etc., but they are not required there.

    * Keys can be written by their ASCII code, using a backslash
      followed by up to six octal digits. This is the only way to
      represent keys with codes above ÿ.

    * One or more prefixes M- (meta), C- (control), S- (shift), A-
      (alt), H- (hyper), and s- (super) may precede a character or key
      notation. For function keys, the prefixes may go inside or
      outside of the brackets: C-<down> = <C-down>. The prefixes may be
      written in any order: M-C-x = C-M-x. Prefixes are not allowed on
      multi-key words, e.g., C-abc, except that the Meta prefix is
      allowed on a sequence of digits and optional minus sign: M-123 =
      M- M-1 M-2 M-3.

    * The `^' notation for control characters also works: ^M = C-m.


 - User Option: ecb-major-modes-activate
   List of major-modes for which ECB shoulb be activated or shown. Do
   not mistake this option with `ecb-auto-activate'. The latter one is
   for activating ECB after Emacs-startup (even without opening a
   buffer) and this one is for defining for which major-modes ECB
   should be activated if the mode goes active!

   The behaviour is like follows: If a mode is contained in this option
   ECB is activated after activating this mode (if ECB was deactivated
   before) or the ECB-windows are shown if ECB was already active but
   its windows were hidden. In every case ECB is activated with visible
   ECB-windows afterwards!

   For every major mode there can be specified an `ecb-layout-nr':

    - `default': The value customized with `ecb-layout-nr' is choosen.

    - an integer: ECB is activated with this layout-nr. This changes
      the value of `ecb-layout-nr' but only for current emacs-session!
      But the layout is only changed if ECB was activated, if just the
      ECB-windows were shown, the current layout is used!

   There are two additional options:

    - `none': No major-modes should activate ECB automatically.

    - a regexp: This means all major-modes which are not listed in
      `ecb-major-modes-deactivate' activate ECB except the symbol-name
      of `major-mode' matches this regexp. If this option is set then
      the default regexp excludes all Info- and customize-buffers
      because this buffers should not change anything in the
      ECB-activation state.

   Any auto. activation is only done if the current-frame is unsplitted
   to avoid changing unnecessarily or unintentionally the frame-layout
   if the user just jumps between different windows.

 - User Option: ecb-major-modes-deactivate
   List of major-modes for which ECB should be deactivated or hidden.
   Specify if ECB should be deactivated or at least hidden if a
   major-mode is active. For each major-mode there must be added an
   action what should be done:

    - `hide': ECB just hides all the ECB windows like with
      `ecb-hide-ecb-windows'.

    - `deactivate': ECB is completely deactivated after activating the
      major-mode.

   There are two additional options:

    * `none': No major-modes should deactivate/hide ECB automatically.

    * A cons for the meaning "All except the activated modes of
      `ecb-major-modes-activate'". The car of this cons can be:

       - `hide-all-except-activated': All major-modes which are not
         listed in `ecb-major-modes-activate' hide the ECB-windows.

       - `deactivate-all-except-activated': All major-modes which are
         not listed in `ecb-major-modes-activate' deactivate ECB.

      The cdr of this cons is a regexp: This means all major-modes
      which are not listed in `ecb-major-modes-activate'
      deactivate/hide ECB except the symbol-name of `major-mode'
      matches this regexp. If this option is set then the default
      regexp excludes all Info- and customize-buffers because this
      buffers should not change anything in the ECB-activation state.

   If a major-mode is listed in `ecb-major-modes-activate' as well as
   in `ecb-major-modes-deactivate' then ECB is activated!

   Any auto. deactivation/hiding is only done if the edit-window of ECB
   is unsplitted and point is in the edit-window to avoid changing
   unnecessarily or unintentionally the frame-layout if the user just
   jumps between different edit-windows, the tree-windows and the
   compile-window of ECB.

 - User Option: ecb-minor-mode-text
   String to display in the mode line when ECB minor mode is active.
   (When the string is not empty, make sure that it has a leading
   space.)

 - User Option: ecb-mode-line-prefixes
   Prefixes shown in the modelines of the ECB buffers. The displayed
   prefix then looks like: "[ <PREFIX>[: ]]", means if a prefix is
   defined for an ECB buffer then a single space is prepended and if
   there is additional text to display (e.g. the current directory in
   the sources buffer) then also the string ": " is appended.

 - User Option: ecb-primary-mouse-jump-destination
   Jump-destination of a primary mouse-button click (see
   `ecb-primary-secondary-mouse-buttons') in an ECB-window, if you
   click onto a source or method or variable. Defines in which
   edit-window (if splitted) ECB does the "right" action (opening the
   source, jumping to a method/variable). There are two possible
   choices:

    - `left-top': Does the "right" action always in the left/topmost
      edit-window.

    - `last-point': Does the "right" action always in that edit-window
      which had the point before.

   If the edit-window is not splitted this setting doesn't matter.

   Note: A click with the secondary mouse-button (see again
   `ecb-primary-secondary-mouse-buttons' does the "right" action always
   in the "other" window related to the setting in this option.

 - User Option: ecb-primary-secondary-mouse-buttons
   Primary- and secondary mouse button for using the ECB-buffers. A
   click with the primary button causes the main effect in each
   ECB-buffer:

    * ECB Directories: Expanding/collapsing nodes and displaying files
      in the ECB Sources buffer.

    * ECB sources/history: Opening the file in that edit-window
      specified by the option `ecb-primary-mouse-jump-destination'.

    * ECB Methods: Jumping to the method in that edit-window specified
      by the option `ecb-primary-mouse-jump-destination'.

   A click with the primary mouse-button while the SHIFT-key is pressed
   only displays the complete clicked node in the minibuffer. This is
   useful if the node is longer as the window-width of the ECB-window
   and `ecb-truncate-lines' is not nil.

   The secondary mouse-button is for opening (jumping to) the file in
   the other window (see the documentation
   `ecb-primary-mouse-jump-destination').

   The following combinations are possible:

    - primary: mouse-2, secondary: C-mouse-2 (means mouse-2 while
      CTRL-key is pressed). This is the default setting.

    - primary: mouse-1, secondary: C-mouse-1

    - primary: mouse-1, secondary: mouse-2

   If you change this during ECB is activated you must deactivate and
   activate ECB again to take effect

 - User Option: ecb-show-help-format
   The format `ecb-show-help' shows its online help. Allowed values are
   'info (for the Info format) and 'html (for HTML format). If the
   value is 'html then `browse-url-browser-function' says which browser
   is used.

 - User Option: ecb-show-node-info-in-minibuffer
   Define which node info should displayed in a tree-buffer after mouse
   moving over the node or after a shift click onto the node.

   For every tree-buffer you can define "when" node info should be
   displayed:

    - `always': Node info is displayed by moving with the mouse over a
      node.

    - `if-too-long': Node info is only displayed by moving with the
      mouse over a node does not fit into the window-width of the
      tree-buffer window. In the ECB directories buffer this means also
      if a node is shortend or if the node has an alias (see
      `ecb-source-path').

    - `shift-click': Node info is only displayed after a shift click
      with the primary mouse button onto the node.

    - `never': Node info is never displayed.

   For every tree-buffer you can define what info should be displayed:

    * Directory-buffer:
       - `name': Only the full node-name is displayed.

       - `path': The full-path of the node is displayed.

    * Sources-buffer:
       - `name': Only the full node-name is displayed.

       - `file-info': File infos for this file are displayed.

       - `file-info-full': Fill infos incl. full path for this file are
         displayed.

    * History-buffer: see Directories-buffer.

    * Methods-buffer:
       - `name': Only the full node name is displayed.

       - `name+type': The full name + the type of the node (function,
         class, variable) is displayed.

   Do NOT set this option directly via setq but use always customize!

 - User Option: ecb-temp-dir
   Specify a directory where ECB can store temporary files.

 - User Option: ecb-tree-RET-selects-edit-window
   In which tree-buffers RET should finally select an edit-window. If a
   name of an ECB tree-buffer is contained in this list then hitting RET
   in this tree-buffer selects as last action the right edit-window
   otherwise only the right action is performed (opening a new source,
   selecting a method etc.) but point stays in the tree-buffer.

   A special remark for the `ecb-directories-buffer-name': Of course
   here the edit-window is only selected if
   `ecb-show-sources-in-directories-buffer' is not nil (otherwise this
   would not make any sense)!

   The setting in this option is only the default for each tree-buffer.
   With `ecb-toggle-RET-selects-edit-window' the behavior of RET can be
   changed fast and easy in a tree-buffer without customizing this
   option, but of course not for future Emacs sessions!

 - User Option: ecb-tree-expand-symbol-before
   Show the expand symbol before the items in a tree.

 - User Option: ecb-tree-incremental-search
   Enable incremental search in the ECB-tree-buffers. For a detailed
   explanation see *Note Using the keyboard::. If you change this
   during ECB is activated you must deactivate and activate ECB again to
   take effect.

 - User Option: ecb-tree-indent
   Indent size for tree buffer. If you change this during ECB is
   activated you must deactivate and activate ECB again to take effect.

 - User Option: ecb-tree-navigation-by-arrow
   Enable smart navigation in the tree-windows by horiz. arrow-keys. If
   not nil then the left- and right-arrow keys work in the ECB
   tree-window in the following smart way if onto an expandable node:

    * Left-arrow: If node is expanded then it will be collapsed
      otherwise point jumps to the next "higher" node in the
      hierarchical tree (higher means the next higher tree-level or -
      if no higher level available - the next higher node on the same
      level).

    * Right-arrow: If node is not expanded then it will be expanded.
      Onto a not expandable node the horizontal arrow-keys go one
      character in the senseful correct direction.

   If this option is changed the new value takes first effect after
   deactivating ECB and then activating it again!

 - User Option: ecb-truncate-lines
   Truncate lines in ECB buffers. If you change this during ECB is
   activated you must deactivate and activate ECB again to take effect.

 - User Option: ecb-truncate-long-names
   Truncate long names that don't fit in the width of the ECB windows.
   If you change this during ECB is activated you must deactivate and
   activate ECB again to take effect.

 - User Option: ecb-use-recursive-edit
   Tell ECB to use a recursive edit so that it can easily be deactivated
   by (keyboard-escape-quit).

 - User Option: ecb-version-check
   If not `nil' ECB checks at start-time if the required versions of
   semantic and eieio are installed and loaded into Emacs. It is
   strongly recommended to set this option to not `nil'!

 - User Option: ecb-window-sync
   Synchronize the ECB-windows automatically with current edit window.
   If `always' then the synchronization takes place always a buffer
   changes in the edit window, if `nil' then never. If a list of
   major-modes then only if the `major-mode' of the new buffer belongs
   NOT to this list.

   But in every case the synchronization takes only place if the
   current-buffer in the edit-window has a relation to files or
   directories. Examples for the former one are all
   programming-language-modes, `Info-mode' too, an example for the
   latter one is `dired-mode'. For all major-modes related to
   non-file/directory-buffers like `help-mode', `customize-mode' and
   others never a synchronization will be done!

   It's recommended to exclude at least `Info-mode' because it makes no
   sense to synchronize the ECB-windows after calling the Info help.
   Per default also `dired-mode' is excluded but it can also making
   sense to synchronize the ECB-directories/sources windows with the
   current directory in the dired-buffer.

 - User Option: ecb-window-sync-delay
   Time Emacs must be idle before the ECB-windows are synchronized with
   current edit window. If nil then there is no delay, means
   synchronization takes place immediately. A small value of about 0.25
   seconds saves CPU resources and you get even though almost the same
   effect as if you set no delay.


File: ecb.info,  Node: ecb-directories,  Next: ecb-sources,  Prev: ecb-general,  Up: Customizable options

Group ecb-directories
---------------------

This group contains the following options:

 - User Option: ecb-add-path-for-not-matching-files
   Add path of a file to `ecb-source-path' if not already contained.
   This is done during the auto. windows synchronization which happens
   if a file is opened not via the file/directory-browser of ECB. In
   such a situation ECB adds the path of the new file auto. to
   `ecb-source-path' at least temporally for the current Emacs session.
   This option defines two things:

   1. Should only the root-part (which means for unix-like systems
      always '/' and for windows-like systems the drive) of the new
      file be added as source-path to `ecb-source-path' or the whole
      directory-part?

   2. Should this path be added for future sessions too?

   The value of this option is a cons-cell where the car is a boolean
   for 1. and the cdr is a boolean for 2.

   A value of not nil for the car (1.) is reasonably if a user often
   opens files not via the ECB-browser which are not located in any of
   the paths of `ecb-source-path' because then only one path for each
   drive (windows) or the root-path (unix) is added to the directory
   buffer of ECB.

 - User Option: ecb-auto-expand-directory-tree
   Automatically expand the directory tree to the current source file.
   There are three options:

    - `best': Expand the best-matching source-path

    - `first': Expand the first matching source-path

    - `nil': Do not automatically expand the directory tree.

 - User Option: ecb-cache-directory-contents
   Cache contents of directories.

   This can be useful if `ecb-source-path' contains directories with
   many files and subdirs, especially if these directories are mounted
   net-drives ("many" means here something > 1000, dependend of the
   speed of the net-connection and the machine). For these directories
   actualizing the sources- and/or directories- buffer of ECB (if
   displayed in current layout!) can slow down dramatically so a caching
   increases speed a lot.

   The value of this option is a list where each element looks like:

        (<dir-regexp> <filenumber threshold> <cache clearing> with

  `<dir-regexp>:'
      Regular expression a directory must match to be cached.

  `<filenumber threshold>:'
      Number of directory contents must exceed this number.

  `<cache clearing>:'
      When the cache should be cleared:

       - `demand': Cache will only be cleared on user demand. See
         `ecb-clear-directory-cache'.

       - `auto': Cache will be cleared if the contents of the directory
         have been changed. ECB can detect this automatically. This
         works for Unix- but probably not for Windows-systems, because
         Windows offers no way to detect when the contents of a
         directory have been changed.

       - `<number>': First selection of directories matching the regexp
         after <number> seconds after last caching time will rescan the
         directory.

   A directory will we only be cached if and only if the directory-name
   matches one rexexp of this option and it's content-number exceeds the
   related threshold.

   Example: A value of `("~/bigdir*" 1000 3600)' means the contents of
   every subdirectory of the home-directory with name beginning with
   "bigdir" will be cached if the directory contains more than 1000
   entries. One hour after the last caching time of such a directory
   the next selection (clicking onto it in the directories-window,
   changing buffers so the directory becomes current in the
   directories-window, etc...) will rescan the directory and update the
   cache.

   *Attention*: Currently the <cache clearing> part is ignored.
   Currently the cache can only be cleared on demand and only the whole
   cache can be cleared, see `ecb-clear-directory-cache'. This will
   change in a future version.

 - User Option: ecb-directories-buffer-name
   Name of the ECB directory buffer. Because it is not a normal buffer
   for editing you should enclose the name with stars, e.g. " *ECB
   Directories*".

   If it is necessary for you you can get emacs-lisp access to the
   buffer-object of the ECB-directory-buffer by this name, e.g. by a
   call of `set-buffer'.

   Changes for this option at runtime will take affect only after
   deactivating and then activating ECB again!

 - User Option: ecb-excluded-directories-regexp
   Specifies directories that should not be included in the directories
   list. The value of this variable should be a regular expression.

 - User Option: ecb-show-sources-in-directories-buffer
   Show source files in directories buffer.

 - User Option: ecb-source-path
   Paths where to find code sources. Each path can have an optional
   alias that is used as it's display name. If no alias is set, the
   path is used as display name.


File: ecb.info,  Node: ecb-sources,  Next: ecb-methods,  Prev: ecb-directories,  Up: Customizable options

Group ecb-sources
-----------------

This group contains the following options:

 - User Option: ecb-show-source-file-extension
   Show the file extension of source files.

 - User Option: ecb-source-file-regexps
   Specifies which files are shown as source files. Consists of one
   exclude regexp and one include regexp. A file is displayed in the
   source-buffer of ECB iff: The file does not match the exclude regexp
   OR the file matches the include regexp. There are three predefined
   and useful combinations of an exclude and include regexp:

    * All files

    * All, but no backup, object, lib or ini-files (except .emacs and
      .gnus). This means all files except those starting with ".", "#"
      or ending with "~", ".elc", ".obj", ".o", ".lib", ".dll", ".a",
      ".so". (but including .emacs and .gnus)

    * Common source file types (.c, .java etc.)

   In addition to these predefined values a custom exclude and include
   combination can be defined.

 - User Option: ecb-sources-buffer-name
   Name of the ECB sources buffer. Because it is not a normal buffer for
   editing you should enclose the name with stars, e.g. "*ECB Sources*".

   If it is necessary for you you can get emacs-lisp access to the
   buffer-object of the ECB-sources-buffer by this name, e.g. by a call
   of `set-buffer'.

   Changes for this option at runtime will take affect only after
   deactivating and then activating ECB again!

 - User Option: ecb-sources-sort-method
   Defines how the source files are sorted.

    - `name': Sorting by name.

    - `extension': Sorting first by name and then by extension.

    - `nil': No sorting, means source files are displayed in the
      sequence returned by `directory-files' (called without sorting).


File: ecb.info,  Node: ecb-methods,  Next: ecb-history,  Prev: ecb-sources,  Up: Customizable options

Group ecb-methods
-----------------

This group contains the following options:

 - User Option: ecb-auto-update-methods-after-save
   Automatically updating the ECB method buffer after saving the current
   source-buffer.

 - User Option: ecb-bucket-token-display
   How ECB displays bucket tokens in the ECB methods buffer. Bucket
   tokens are tokens like "[+] Variables", "[+] Dependencies" etc. The
   name of the bucket-token comes from semantic but you can define a
   prefix, a suffix and a special face for the bucket token.

   The default are empty prefix/suffix-strings and
   'ecb-bucket-token-face'. But an alternative can be for example `("["
   "]" nil)' which means no special face and a display like "[+]
   [<bucket-name>]".

 - User Option: ecb-exclude-parents-regexp
   Regexp which parent classes should not be shown in the methods buffer
   (see also `ecb-show-parents'). If nil then all parents will be shown
   if `ecb-show-parents' is not nil.

 - User Option: ecb-font-lock-tokens
   Adds font-locking (means highlighting) to the ECB-method buffer.

 - User Option: ecb-highlight-token-header-after-jump
   If not nil then highlight the token line in the source-buffer after
   jumping to this method by clicking in the ECB-method-buffer onto this
   method. For highlighting `ecb-token-header-face' is used.

 - User Option: ecb-highlight-token-with-point
   How to highlight the method or variable under the cursor.

    - `highlight-scroll': Always scroll the method buffer, so the
      current method of the edit-window is highlighted in the
      method-window.

    - `highlight': Only highlight the current method of the edit window
      in the method window if the method is visible in the
      method-window.

    - `nil': No highlighting is done.

   See also `ecb-highlight-token-with-point-delay'.

 - User Option: ecb-highlight-token-with-point-delay
   Time Emacs must be idle before current token is highlighted. If nil
   then there is no delay, means current token is highlighted
   immediately. A small value of about 0.25 seconds saves CPU resources
   and you get even though almost the same effect as if you set no
   delay.  But such a delay prevents also "jumping backward/forward"
   during scrolling within java-classes if point goes out of
   method-definition into class-definition. Therefore the default value
   is a delay of 0.25 seconds.

 - User Option: ecb-token-jump-narrow
   When jumping to a token from the ECB methods buffer narrows the
   buffer to only show that token. To display the entire buffer again,
   click on a source file or call `widen' `C-x n w'.

 - User Option: ecb-token-jump-sets-mark
   Jumping to a token from the ECB-method buffer now sets the mark so
   the user can easily jump back.

 - User Option: ecb-methods-buffer-name
   Name of the ECB methods buffer. Because it is not a normal buffer for
   editing you should enclose the name with stars, e.g. " *ECB
   Methods*".

   If it is necessary for you you can get emacs-lisp access to the
   buffer-object of the ECB-methods-buffer by this name, e.g. by a call
   of `set-buffer'.

   Changes for this option at runtime will take affect only after
   deactivating and then activating ECB again!

 - User Option: ecb-post-process-semantic-tokenlist
   Define mode-dependend postprocessing for the semantic-tokenlist. This
   is an alist where the car is a major-mode symbol and the cdr is a
   function-symbol of a function which should be used for
   post-processing the tokenlist (returned by
   `semantic-bovinate-toplevel') for a buffer in this major-mode. Such
   a function is called with current semantic tokenlist of current
   buffer and must return a valid tokenlist again.

   For oo-programming languages where the methods of a class can be
   defined outside the class-definition (e.g. C++, Eieio) the function
   `ecb-group-function-tokens-with-parents' can be used to get a much
   better method-display in the methods-window of ECB, because all
   method implementations of a class are grouped together.

 - User Option: ecb-scroll-window-after-jump
   How to scroll the window when jumping to a token.

 - User Option: ecb-show-only-positioned-tokens
   Show only nodes in the method-buffer which are "jumpable". If not nil
   then ECB displays in the method-buffer only nodes which are
   "jumpable", i.e. after selecting it by clicking or with RET then ECB
   jumps to the corresponding location in the edit-window. Example: With
   CLOS or Eieio source-code there can exist some positionless nodes
   like variable-attributes in a `defclass' form which are only
   displayed if this option is nil. Displaying such nodes can be
   sensefull even if they can not be jumped.

 - User Option: ecb-show-tokens
   How to show tokens in the methods buffer. This variable is a list
   where each element represents a type of tokens:

      (<token type> <display type> <sort method>)

   The tokens in the methods buffer are displayed in the order as they
   appear in this list.

  `<token type>'
      A Semantic token type symbol (function, variable, rule, include
      etc.)  or one of the following:

       - `t': All token types not specified anywhere else in the list.

       - `parent': The parents of a type.

  `<display type>'
      A symbol which describes how the tokens of this type shall be
      shown:

       - `expanded': The tokens are shown in an expanded node.

       - `collapsed': The tokens are shown in a collapsed node.

       - `flattened': The tokens are added to the parent node.

       - `hidden': The tokens are not shown.

  `<sort method>'
      A symbol describing how to sort the tokens of this type:

       - `name': Sort by the token name.

       - `access': Sort by token access (public, protected, private)
         and then by name.

       - `nil': Don't sort tokens. They appear in the same order as in
         the source buffer.


 - User Option: ecb-token-display-function
   Function to use for displaying tokens in the methods buffer. This
   functionality is set on major-mode base, i.e. for every major-mode a
   different function can be used. The value of this option is a list of
   cons-cells:

    - The car is either a major-mode symbol or the special symbol
      'default which means if no function for a certain major-mode is
      defined then the cdr of the 'default cons-cell is used.

    - The cdr is the function used for displaying a token in the related
      major-mode.

   Every function is called with 3 arguments:

   1. The token

   2. The parent-token of token (can be nil)

   3. The value of `ecb-font-lock-tokens'.

   Every function must return the display of the token as string,
   colorized if the third argument is not nil.

   The following functions are predefined:

    * All functions of `semantic-token->text-functions'.

    * For every function in `semantic-token->text-functions' with name
      "semantic-XYZ" a function with name "ecb-XYC" is predefined. The
      differences between the semantic- and the ECB-version are:

       - The ECB-version displays for type tokens only the type-name
         and nothing else (exception: In c++-mode a template specifier
         is appended to the type-name if a template instead a normal
         class).

       - The ECB-version displays type-tokens according to the setting
         in `ecb-type-token-display'. This is useful for better
         recognizing different classes, structs etc. in the ECB-method
         window.

      For all tokens which are not types the display of the ECB-version
      is identical to the semantic version. Example: For
      `semantic-name-nonterminal' the pendant is `ecb-name-nonterminal'.

   This functionality also allows the user to display tokens as UML. To
   enable this functionality set the function for a major-mode (e.g.
   `jde-mode') to `semantic-uml-concise-prototype-nonterminal',
   `semantic-uml-prototype-nonterminal', or
   `semantic-uml-abbreviate-nonterminal' or the ECB-versions of these
   functions.

   If the value is `nil', i.e. neither a function for a major-mode is
   defined nor the special 'default, then
   `semantic-prototype-nonterminal' is used for displaying the tokens.

 - User Option: ecb-token-jump-narrow
   When jumping to a token from the ECB methods buffer narrows the
   buffer to only show that token. To display the entire buffer again,
   click on a source file or call `widen' (`C-x n w').

 - User Option: ecb-token-jump-sets-mark
   Jumping to a token from the ECB-method buffer now sets the mark so
   the user can easily jump back.

 - User Option: ecb-type-token-display
   How to display semantic type-tokens in the methods buffer. Normally
   all token displaying, colorizing and facing is done by semantic
   according to the value of `semantic-face-alist' and the semantic
   display-function (e.g. one from `semantic-token->text-functions').
   But sometimes a finer distinction in displaying the different type
   specifiers of type-tokens can be usefull. For a description when
   this option is evaluated look at `ecb-token-display-function'!

   This functionality is set on a major-mode base, i.e. for every
   major-mode a different setting can be used. The value of this option
   is a list of cons-cells:

    * The car is either a major-mode symbol or the special symbol
      'default which means if no setting for a certain major-mode is
      defined then the cdr of the 'default cons-cell is used.

    * The cdr is a list of 3-element-lists:

      1. First entry is a semantic type specifier in string-form.
         Current available type specifiers are for example "class",
         "interface", "struct", "typedef" and "enum". In addition to
         these ones there is also a special ECB type specifier "group"
         which is related to grouping tokens (see
         `ecb-post-process-semantic-tokenlist' and
         `ecb-group-function-tokens-with-parents'). Any arbitrary
         specifier can be set here but if it is not "group" or not
         known by semantic it will be useless.

      2. Second entry is a flag which indicates if the type-specifier
         string from (1.) itself should be removed (if there is any)
         from the display.

      3. Third entry is the face which is used in the ECB-method window
         to display type-tokens with this specifier. ECB has some
         predefined faces for this (`ecb-type-token-class-face',
         `ecb-type-token-struct-face', `ecb-type-token-typedef-face',
         `ecb-type-token-enum-face' and `ecb-type-token-group-face')
         but any arbitrary face can be set here. This face is merged
         with the faces semantic already uses to display a token, i.e.
         the result is a display where all face-attributes of the
         ECB-face take effect plus all face-attributes of the
         semantic-faces which are not set in the ECB-face (with XEmacs
         this merge doesn't work so here the ECB-face replaces the
         semantic-faces; this may be fixed in future versions).

   The default value is nil means there is no special ECB-displaying of
   type-tokens in addition to the displaying and colorizing semantic
   does. But a value like the following could be a usefull setting:

      ((default
         ("class" t ecb-type-token-class-face)
         ("group" nil ecb-type-token-group-face))
       (c-mode
        ("struct" nil ecb-type-token-struct-face)
        ("typedef" nil ecb-type-token-typedef-face)))

   This means that in `c-mode' only "struct"s and "typedef"s are
   displayed with special faces (the specifiers itself are not removed)
   and in all other modes "class"es and grouping-tokens (see
   `ecb-token-display-function',
   `ecb-group-function-tokens-with-parents') have special faces and the
   "class" specifier-string is removed from the display.


File: ecb.info,  Node: ecb-history,  Next: ecb-layout,  Prev: ecb-methods,  Up: Customizable options

Group ecb-history
-----------------

This group contains the following options:

 - User Option: ecb-clear-history-behavior
   Defines which entries of the history buffer should be deleted if
   `ecb-clear-history' is called. Three options are available:

    - `not-existing-buffers': All entries which represent a buffername
      not existing anymore in the bufferlist will be cleared. Probably
      the most senseful value.

    - `existing-buffers': The opposite of 'not-existing-buffers.

    - `all': The whole history will be cleared.

 - User Option: ecb-history-buffer-name
   Name of the ECB history buffer. Because it is not a normal buffer for
   editing you should enclose the name with stars, e.g. "*ECB History*".

   If it is necessary for you you can get emacs-lisp access to the
   buffer-object of the ECB-history-buffer by this name, e.g. by a call
   of `set-buffer'.

   Changes for this option at runtime will take affect only after
   deactivating and then activating ECB again!

 - User Option: ecb-history-item-name
   The name to use for items in the history buffer.

 - User Option: ecb-kill-buffer-clears-history
   Define if `kill-buffer' should also clear the history. There are
   three options:

    - `auto': Removes automatically the corresponding history-entry
      after the buffer has been killed.

    - `ask': Asks, if the history-entry should be removed after the
      kill.

    - `nil': `kill-buffer' does not affect the history (this is the
      default).

 - User Option: ecb-sort-history-items
   Sorts the items in the history buffer.

