\input texinfo   @c -*-texinfo-*-
@c

@c Copyright (C) 2002 Klaus Berndl

@c Author: Klaus Berndl <klaus.berndl@sdm.de>
@c Keywords: java, class, browser
@c Created: Mar 2001

@c This manual covers the tool "ECB", and is a part of it's
@c distribution.

@c This manual is free software; you can redistribute it and/or modify
@c it under the terms of the GNU General Public License as published by
@c the Free Software Foundation; either version 2, or (at your option)
@c any later version.

@c This manual is distributed in the hope that it will be useful,
@c but WITHOUT ANY WARRANTY; without even the implied warranty of
@c MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@c GNU General Public License for more details.

@c You should have received a copy of the GNU General Public License
@c along with GNU Emacs; see the file COPYING.  If not, write to the
@c Free Software Foundation, Inc., 59 Temple Place - Suite 330,
@c Boston, MA 02111-1307, USA.

@c $Id: ecb.texi,v 1.11 2003/07/18 12:55:08 berndl Exp $

@setfilename ecb.info

@settitle ECB - the Emacs Code Browser

@c If we want only one index for concepts, functions and variables
@c @syncodeindex vr cp
@c @syncodeindex fn cp

@c in info we do not want paragraph indenting
@ifinfo
@paragraphindent 0
@end ifinfo

@exampleindent   3

@footnotestyle end

@c The version number is auto-frobbed from the Makefile, so you should
@c edit the Makefile to change the version number. mechanism stolen
@c from Tramp
@macro ecbver{}
1.95.1
@end macro


@dircategory GNU Emacs Lisp
@direntry
* ECB: (ecb).           Emacs Code Browser
@end direntry

@titlepage
@sp 10
@center @titlefont{ECB version @ecbver{} - User manual}
@vskip 0pt plus 1 fill
Copyright @copyright{} 2000, 2001, 2002 Jesper Nordenberg, Klaus Berndl
@end titlepage

@node Top, Install and first steps, (dir), (dir)
@comment  node-name,  next,  previous,  up

@ifnottex
This is the user manual for ECB version @ecbver{}.
@end ifnottex

ECB stands for ``Emacs Code Browser'' and is a source code browser for
(X)Emacs. It is a global minor-mode which displays a couple of windows
that can be used to browse directories, files and file-contents like
methods and variables. It supports source-code parsing for
semantic-supported languages like Java, C, C++, Elisp and Scheme as well
as for source-types supported ``only'' by imenu or etags (e.g. perl,
TeX, LaTeX etc.).

@iftex
@sp 1
@end iftex

@strong{NOTE}: Experienced ECB users find a complete alphabetical list
of all commands and user-options in @ref{Interactive ECB commands} and
@ref{Customizable options}.

@c In the following two paragraphs we distinct between HTML-, info-,
@c and tex-format concerning the display of the URLs.
@ifinfo
The latest version of ECB can always be found at the URL
@url{http://ecb.sourceforge.net}.

To send bug reports, or participate in discussions about ECB, use the
mailing list @email{ecb-list@@lists.sourceforge.net} via the URL
@url{http://lists.sourceforge.net/lists/listinfo/ecb-list}.
@end ifinfo

@iftex
@sp 1

The latest version of ECB can always be found at the URL @*
@url{http://ecb.sourceforge.net}.

@sp 1

To send bug reports, or participate in discussions about ECB, use the
mailing list @*@email{ecb-list@@lists.sourceforge.net} via the URL @*
@url{http://lists.sourceforge.net/lists/listinfo/ecb-list}.
@end iftex

@ifhtml
The latest version of ECB can always be found at 
@uref{http://ecb.sourceforge.net}

To send bug reports, or participate in discussions about ECB, use the
mailing list @email{ecb-list@@lists.sourceforge.net} via 
@uref{http://lists.sourceforge.net/lists/listinfo/ecb-list}
@end ifhtml

@menu
* Install and first steps::     Installing ECB and first steps
* Overview::                    Introduce basic concepts
* Activation and Deactivation:: How to start and end ECB
* Usage of ECB::                How to use ECB
* Customizing::                 How to customize ECB
* Submitting problem report::   What to do when problems occur
* Upgrading::                   Upgrading and downloading packages
* Tips and tricks::             Useful hints and tips
* Elisp programming::           Entry points for elisp programmers
* Conflicts and bugs::          Known Conflicts with other packages and bugs
* FAQ::                         Frequently asked questions
* Command Index::               Index for interactive commands
* Option Index::                Index for user options
* Concept Index::               Index for concepts and terms
@comment * Index::

@detailmenu
 --- The Detailed Node Listing ---

Installation and first steps of ECB

* Installation::                Installation of ECB
* Setting up Emacs::            How to set up Emacs for file parsing with ECB
* First steps::                 First steps after activating ECB first time

How to set up Emacs for file parsing with ECB

* General hints::               General hints for a correct setup
* Setting up semantic::         How to setup semantic correctly
* Non-semantic files::          Setup for file types not supported by semantic

Overview

* ECB Directories-buffer::      Contents of the ECB Directories-buffer
* ECB Sources-buffer::          Contents of the ECB Sources/history-buffer
* ECB Methods-buffer::          Contents of the ECB Methods-buffer

Activation and Deactivation

* Standard activation::         How to manually (de)activate ECB
* Automatic activation::        Automaticaly (de)activating ECB

Usage of ECB

* Using the mouse::             Working with the mouse
* Using the keyboard::          Working with the keyboard
* The edit-window::             How to use the edit-window(s)
* Temp- and compile-buffers::   Displaying temp- and compilation-buffers
* The Methods buffer::          Using and customizing he Methods-buffer
* The ECB-layout::              Changing, customizing, redrawing, creating
* Hiding the ECB windows::      Hiding/Showing the ECB-windows
* Maximizing the ECB windows::   Maximizing the ECB-windows
* Back/forward navigation::     Back- and forward navigation like a browser
* ECB-window synchronizing::    Auto./manual synchronizing the ECB-windows
* Interactive ECB commands::    All interactive user-commands of ECB

Working with the keyboard in the ECB-windows

* Navigation/Selection::        Keyboard navigation/selection in a tree-buffer
* Incremental search::          Find nodes as fast as possible
* Personal keybindings::        Adding personal keybindings to a tree-buffer

Using and customizing the ECB-Methods buffer

* Expanding::                   Explicit and automatic expanding
* Customizing the display::     How to customize the Methods-buffer display
* Rebuilding the Methods::      When to rebuild the Methods-buffer      

Changing, customizing, redrawing and creating layouts

* Changing the ECB-layout::     How to change and customize the layout
* Redrawing the ECB-layout::    How and when redrawing the layout
* Changing window sizes::       Changing sizes of the ECB-windows
* Fixing window sizes::         Fixing sizes of the ECB-windows
* Creating a new ECB-layout::   Interactively creating new layouts

Customizing ECB

* General aspects::             General aspects for customizing ECB
* Most important options::      Which option you must know
* Customizable options::        All customizable options of ECB

All customizable options of ECB

* 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-compilation-content::     Customizing the compile-window contents
* ecb-create-layout::           Customizing options for creating layouts
* 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
* ecb-eshell::                  Customizing the eshell-integration
* ecb-non-semantic::            Customizing parsing non-semantic sources

Upgrading and downloading packages

* Downloading new versions::    How to download newer versions of packages
* Auto. option-upgrading::      ECB can auto. upgrade your options

Automatic upgrading of options

* User interface::              Options and commands you should know
* Background information::      Maybe some interesting informations

Tips and tricks

* Changing faces::              Changing faces in the ECB tree-buffers
* Small screens::               Working with small screens
* Big screens::                 Working with big screens
* Simulating speedbar::         Simulating speedbar without an extra frame
* Integrating speedbar::        Integrating speedbar in the ECB-frame
* Optimize scrolling::          Optimize scrolling in the edit-window
* Large directories::           Working with large directories
* Using eshell::                Optimal using of eshell in ECB
* Grepping directories::        Grepping directories with ECB
* Working with JDEE::           Working best with ECB and JDEE
* Compile-window on demand::    Displaying the compile-window on demand
* Non-semantic sources::        Parsing and displaying non-semantic sources
* Hide-show::                   Using hide-show from the methods-buffer-menu

Entry points for elisp programmers

* List of variables::           Which variables an elisp-program can use
* List of hooks::               All available hooks
* tree-buffer::                 Some words to the tree-buffer-library
* Adviced functions::           How to deal with the adviced functions
* The layout-engine::           Programming new layouts and special windows

How to program new layouts and new special windows

* Programming a new layout::    How to program a new layout
* Programming special windows:: Aspects of programming special windows
* Possible layout-outlines::    The wide range of possible layouts
* The layout-engine API::       The complete layout-engine API

Known conflicts and bugs of ECB

* Conflicts::                   Known conflicts with other packages
* Bugs::                        Known bugs

@end detailmenu
@end menu

@node Install and first steps, Overview, Top, Top
@chapter Installation and first steps of ECB

This chapter describes how to install ECB and setup (X)Emacs correctly
and what are the first steps after activation of ECB.

@menu
* Installation::                Installation of ECB
* Setting up Emacs::            How to set up Emacs for file parsing with ECB
* First steps::                 First steps after activating ECB first time
@end menu

@node Installation, Setting up Emacs, Install and first steps, Install and first steps
@section Installation of ECB

@strong{IMPORTANT}: The following steps 1 to 8. describe installation
tasks if you got the archive in the format available at the ECB
website. If you use XEmacs and got ECB as a regular XEmacs-package
(e.g. downloaded and installed by the net-installer or package-manager
of XEmacs) then there is nothing to do for you, but you can
immediately start ECB with @code{ecb-activate} or read the online-help
with @code{ecb-show-help}!

@enumerate

@item
Unpack the ECB archive (probably you have already done this :-)

@item
Read the file @file{README} in the ECB-directory and install the
required semantic-, eieio- and speedbar-version. The latter one is
only needed if you want to parse source-types not supported by
semantic (perl, LaTeX...)@footnote{The speedbar-version shipped with
GNU Emacs <= 21.3 does not satisfy the requirements for this feature -
download a newer one!}.

@strong{Note}: ECB maybe requires a newer version of these libraries
than shipped with (X)Emacs. You have to install exactly a version ECB
requires and also to make sure that the correct version is loaded into
(X)Emacs!

But ECB performs two autom checks:

@itemize @minus
@item At load-time:
It checks if the packages semantic, eieio and speedbar are at least
installed so ECB can be loaded. If not it offers to download and
install them.

@item At start-time:
It checks if the correct versions of semantic, eieio and speedbar are
installed and gives you proper feedback. @xref{Download required
packages}.
@end itemize

So if you are not sure if you have installed the required packages at
all or if you have installed the correct versions of these packages
then do not worry about this, just go on with the following
installation steps: If ECB is missing something it will give you
proper feedback and support not later than at load-time or start-time!

@item
Add the new ECB-directory to your @code{load-path} variable.

You @strong{MUST} add the ECB-install-directory to the
@code{load-path} either by changing the @code{load-path} variable
directly in your @file{.emacs} or @file{site-lisp/site-start.el} or by
working with a file @file{subdirs.el}@footnote{This works at least for
Emacs 20.X and Emacs 21.X but XEmacs may have slightly different
mechanisms; see the XEmacs documentation}.

@strong{ATTENTION}:
ECB is NOT properly installed if it's directory is not added to
@code{load-path} and for example just loaded by

@example
(load-file "/path/to/ecb/ecb.el")
@end example

Do not do this!

@item
Load ECB by adding code to your @file{.emacs}:

If you want to load the complete ECB at (X)Emacs-loadtime (Advantage:
All ECB-options available after loading ECB. Disadvantage: Increasing
loadtime@footnote{Cause of full loading of ECB itself and also the
packages semantic, eieio and speedbar regardless if ECB is started.}):

@example
(require 'ecb)
@end example

If you want to load the ECB first after starting it by
@code{ecb-activate} (Advantage: Fast loading@footnote{ECB, semantic,
eieio and speedbar are first loaded after starting ECB or with other
words: ECB and semantic are not loaded if you do not use/need them}.
Disadvantage: ECB- and semantic-options first available after starting
ECB):

@example
(require 'ecb-autoloads)
@end example

This loads all available autoloads of ECB, e.g. @code{ecb-activate},
@code{ecb-minor-mode}, @code{ecb-byte-compile} and
@code{ecb-show-help}.

@item Restart (X)Emacs.
@end enumerate

ECB is now ready for use and can be activated by calling @code{M-x
ecb-activate} or @code{ecb-minor-mode}. Now you can either starting
using ECB or you can do these optional installation steps:

@enumerate 6

@item Reading the online help with @code{ecb-show-help}

Maybe you are interested to read the online-help of ECB before first
start.

@item Bytecompiling ECB with @code{ecb-byte-compile}

This byte compiles ECB. You can safely ignore all messages if there
are any. (You can also bytecompile ECB from the command-line either by
using the @file{Makefile} or by using the batch-file @file{make.bat};
just read the comments in that file you choose.)

@item Installing the Info-help of ECB

The ECB distribution contains a subdirectory @file{info-help} which
contains the online-help of ECB in Info-format. You can install this
online help so it's available in the Top-directory of Info. There are
two ways to do this:

@itemize @minus
@item Use ``install-info'' (recommended):

@enumerate
@item
Copy the files of the subdirectory @file{info-help} into the
info-directory of Emacs

@item
Install the file @file{info-help/ecb.info} with the command
``install-info'' (if available on your system) in the @file{dir}-file.
@end enumerate

The supplied @file{Makefile} offers a target @code{install-help} which
does both of these steps. You have just to call @code{make
install-help} with the correct EMACSINFOPATH set (see the comment in
@file{Makefile}). Here is an example:

@example
make EMACSINFOPATH=/path/to/emacs/info install-help
@end example

@item Manual Installation:

Copy the files of the subdirectory @file{info-help} into the
info-directory of Emacs and modify the file @file{dir} manually.
@end itemize

But it doesn't matter if you do not execute this step (8.) because the
online help of ECB is always available though, see
@code{ecb-show-help} (@pxref{Interactive ECB commands}).

@end enumerate

@node Setting up Emacs, First steps, Installation, Install and first steps
@section How to set up Emacs for file parsing with ECB

@strong{NOTE}: Normally it should not necessary for you to bother with
the following stuff unless you have problems getting ECB working
correctly for you.

@menu
* General hints::               General hints for a correct setup
* Setting up semantic::         How to setup semantic correctly
* Non-semantic files::          Setup for file types not supported by semantic
@end menu

@node General hints, Setting up semantic, Setting up Emacs, Setting up Emacs
@subsection General hints for a correct setup

ECB is for browsing files and therefore you have to setup your
Emacs-configuration properly so the file-parsing engines like
semantic, imenu or etags can be activated automatically for parsing
your Emacs-Lisp, C, C++ or Java buffers@footnote{semantic supports
some more ``languages'' like Makefiles etc. but these are the most
important ones.}. For this Emacs must activate the correct
@code{major-mode} for the source-files and Emacs can only do this if
the option @code{auto-mode-alist} is setup correctly. The correct
major-modes and possible file-extensions@footnote{Especially for C++
and C you can use any extension you want but these are the most common
ones!} are:

@multitable @columnfractions 0.20 0.50 0.30

@item
@ifnotinfo
@strong{Language}
@end ifnotinfo
@ifinfo
LANGUAGE
@end ifinfo
@tab
@ifnotinfo
@strong{Major-mode}
@end ifnotinfo
@ifinfo
MAJOR-MODE
@end ifinfo
@tab
@ifnotinfo
@strong{Extension(s)}
@end ifnotinfo
@ifinfo
EXTENSION(S)
@end ifinfo

@item Emacs Lisp @tab @code{emacs-lisp-mode} @tab .el

@item C @tab @code{c-mode} @tab .h, .c

@item C++ @tab @code{c++-mode} @tab .h, .hxx, .hh, .HH, .cxx, .cpp,
.cc, .CC

@item Java @tab @code{java-mode} or @code{jde-mode} (if you use JDEE)
@tab .java
@end multitable

Example: If you want files with extension ``.cpp'' being c++-parsed by
semantic and ECB, your @code{auto-mode-alist} must contain an entry
like:

@example
("\\.cpp\\'" . c++-mode)
@end example

After this ECB will correctly parse your ``.cpp''-sources and display
all the parsing information in the ECB-methods buffer.

@node Setting up semantic, Non-semantic files, General hints, Setting up Emacs
@subsection Setting up semantic

To ensure ECB and semantic are working correctly for all by semantic
supported languages you have to pay attention to the following aspects
concerning your Emacs-setup:

@enumerate
@item Setting up semantic itself

For all semantic-supported file-types parsing files is done completely
by semantic. ECB just displays the parsing results. For all needs of
ECB semantic is completely setup by ECB itself, i.e. ECB sets up
semantic for you! You have only to add the installation directory of
semantic to your @code{load-path} (in an appropriate way)!

@strong{NOTE}: If you setup semantic for yourself following the
recommendations in the installation instructions of semantic then you
have probably added code to your startup-file like:

@example
(setq semantic-load-turn-everything-on t)
(require 'semantic-load)
@end example

Be aware that this also enables the minor-modes
@code{semantic-show-dirty-mode} and
@code{semantic-show-unmatched-syntax-mode} where the former one
highlights all code which has to be reparsed with dark background
(which results in large portions of dark background ;-) and the latter
one underlines all syntax which can not be parsed. Especially the
former one can be really annoying.

To switch off these modes you can add to your startup-file:

@example
(global-semantic-show-dirty-mode -1)
(global-semantic-show-unmatched-syntax-mode -1)
@end example

@anchor{Checking your hooks}
@item Checking your hooks

If you have already checked point (1.) and if you have still problems
getting ECB/semantic working properly for your sources you should
check the related major-mode hook. Every major-mode X has a hook with
name ``X-hook'' which is evaluated after activating the major-mode
(see above, 2.), e.g. the hook for the major-mode @code{c++-mode} is
@code{c++-mode-hook}.

Semantic adds automatically during load-time a special
``semantic-setup'' to these major-mode hooks@footnote{Of course only
for major-modes supported by semantic!} in form of a
``setup-function''. Example: For c and c++ modes semantic adds
@code{semantic-default-c-setup} to @code{c-mode-hook} and
@code{c++-mode-hook}.

If your own Emacs-setup (e.g. in @file{.emacs} or
@file{site-lisp/site-start.el}) overwrites such a major-mode-hook then
semantic can not be activated for this major-mode and in consequence
ECB can not work properly too!

Check if your Emacs-setup uses somewhere @code{setq} for adding code
to a major-mode-hook. @strong{IMPORTANT}: Use @code{add-hook} instead of
@code{setq}@footnote{@code{setq} replaces/overwrites the current
value of a hook with the new value whereas @code{add-hook}
@strong{adds} the new value to the old-value of the hook!}!

@end enumerate

If your source-files are ``running'' with correct @code{major-mode}
and correct major-mode hooks ECB and semantic will do what you expect
them doing!

@node Non-semantic files, , Setting up semantic, Setting up Emacs
@subsection Setup for file types not supported by semantic

From version 1.94 on ECB supports also parsing and displaying
file-contents for file-types not supported by semantic (i.e. there is
no semantic-grammar available for such file-types).

Such non-semantic file-types can often be parsed by imenu and/or
etags. Both of these parsing methods are now supported: ECB can
display the results of imenu and/or etags in its Method-buffer. ECB
uses for this speedbar-logic. Therefore the following speedbar options
takes effect for this feature:

@itemize @minus
@item @code{speedbar-dynamic-tags-function-list}
@item @code{speedbar-tag-split-minimum-length}
@item @code{speedbar-tag-regroup-maximum-length}
@item @code{speedbar-tag-hierarchy-method}
@end itemize

Normally ther should no need for you to bother with these options,
because the default values are suitable for most situations! But if
you are not satisfied with the parsing/display results then you can
change some of these options.

@node First steps, , Setting up Emacs, Install and first steps
@section First steps after activating ECB first time

This section of the ECB online-help is displayed automatically by ECB
after activating ECB first time and describes what are the first basic
steps:

@enumerate

@item Configure where ECB can find your sources:

Call @code{M-x customize-option RET ecb-source-path RET}@footnote{This
means first hitting the keys @kbd{M} (Meta- or Alt-key) and @kbd{x}
simultaniously, inserting ``customize-option'' in the minibuffer,
hitting RETURN, inserting ``ecb-source-path'' in the minibuffer and
finally hitting RETURN again}. This lets you customize the option
@code{ecb-source-path} with the customize-feature of Emacs. This opens
a customize-buffer where you can insert all the directories where ECB
can find your source-files. Save your changes with the button ``Save
for future sessions'' and then throw away this customize-buffer either
by killing it with @code{M-x kill-buffer} or clicking at the button
``Finish''.

@item Read the online-help of ECB:

The online-help of ECB is available via

@itemize @minus
@item calling @code{M-x ecb-show-help},
@item pressing @kbd{C-c . o} or
@item using the menu ``ECB''.
@end itemize

(The section you are currently reading is part of the online-help of
ECB)

@item Start working with ECB.
@end enumerate

@node Overview, Activation and Deactivation , Install and first steps, Top
@chapter Overview

@cindex tree-buffer
@cindex ECB-windows
ECB is a global minor-mode which offers a couple of @dfn{ECB-windows}
for browsing your sources comfortable with the mouse and the keyboard.
These ``special'' windows are also called @dfn{tree-buffer} in this
manual. Every @dfn{item} in such a tree-buffer, i.e. every line, is
also called a @dfn{node} of this tree-buffer. There are currently
three different types of ECB-windows/tree-buffers:

@itemize @minus
@item ECB-Directories
@item ECB-Sources
@item ECB-Methods
@end itemize

In addition to these ``special'' ECB-windows you have always one or
two @dfn{edit-windows} (@pxref{The edit-window}) in the ECB-frame and
at the bottom a @dfn{compilation-window} (optional), where all the
output of Emacs-compilation (compile, grep etc.) is shown
(@pxref{Temp- and compile-buffers}).

The following ``ascii-screenshot'' illustrates the typical layout of
the ECB-frame@footnote{This is only one example of the layouts ECB
offers, see @ref{Changing the ECB-layout}}:

@example
@group
------------------------------------------------------------------
|              |                                                 |
|  Directories |                                                 |
|              |                                                 |
|--------------|                                                 |
|              |                                                 |
|  Sources     |                                                 |
|              |                                                 |
|--------------|                 Edit-window(s)                  |
|              |        (can be splitted in two windows)         |
|  Methods     |                                                 |
|              |                                                 |
|--------------|                                                 |
|              |                                                 |
|  History     |                                                 |
|              |                                                 |
------------------------------------------------------------------
|                                                                |
|                 Compilation-window (optional)                  |
|                                                                |
------------------------------------------------------------------
@end group
@end example

In the following subsections the ``special'' ECB-windows will be
explained in detail.

@menu
* ECB Directories-buffer::      Contents of the ECB Directories-buffer
* ECB Sources-buffer::          Contents of the ECB Sources/history-buffer
* ECB Methods-buffer::          Contents of the ECB Methods-buffer
@end menu

@node ECB Directories-buffer, ECB Sources-buffer, Overview, Overview
@section ECB Directories-buffer

@cindex Directories
@itemize @bullet
@item
Select directories (and - if enabled - source files) in the
@dfn{ECB-Directories} buffer by clicking a mouse button on the directory
name or by hitting RETURN when the cursor is placed on the item line,
see @ref{Usage of ECB}.

IMPORTANT: If you use the POWER-click (i.e. hold down the SHIFT-key
while clicking with the primary mouse button (@pxref{Using the mouse})
or RETURN (@pxref{Using the keyboard})) on a directory node in the
this buffer then the directory-contents-cache for this directory will
be refreshed and actualized.

@item
Directory names with a ``[+]'' symbol after (or before) them can be
expanded/collapsed by clicking on the symbol, pressing the TAB key
(@pxref{Using the keyboard}) when the cursor is placed on the package
line or clicking a mouse button on the item, see @ref{Using the mouse}.

@item
Right clicking on an item will open a popup menu where different
operations on the item under the mouse cursor can be performed.

@item
Pressing F2 will open the ECB customization group
(@pxref{Customizing}) in the edit window. F3 shows the online help in
the edit-window. Pressing F4 in the ECB-directories buffer will offer
adding a new source-path.
@end itemize

@node ECB Sources-buffer, ECB Methods-buffer, ECB Directories-buffer, Overview
@section ECB Sources-buffer

@cindex Sources
@cindex History
@itemize @bullet
@item
Source files can be selected by clicking a mouse button (@pxref{Using
the mouse}) or hitting RETURN (@pxref{Using the keyboard}) on the
source row in the @dfn{ECB-Sources} or @dfn{ECB- History} windows.

IMPORTANT: If you use the POWER-click (i.e. hold down the SHIFT-key
while clicking with the primary mouse button (@pxref{Using the mouse})
or RETURN (@pxref{Using the keyboard})) on a source row in the
ECB-Sources or ECB-History windows then the source will not be
displayed in the edit-window but it will be scanned in the background
and all its contents (e.g. methods and variables) are listed in the
@dfn{ECB Methods} window (@pxref{ECB Methods-buffer}. So you can get an
overlook over the source without changing the buffer in the
edit-window.

@item
Clicking on the source file with the secondary mouse button or
C-RETURN (@pxref{Usage of ECB}) will open the source file in
the other edit window.

@item
Right clicking on a source file will open a popup menu where different
operation on the item under the mouse cursor can be performed.
@end itemize

@node ECB Methods-buffer, , ECB Sources-buffer, Overview
@section ECB Methods-buffer

@cindex Methods
The @dfn{ECB-Methods} buffer contains all parsed and recognized tokens
of the current source-buffer. It is called ``Method-buffer'' because
ECB is mostly designed for browsing sourcecode files and for
programming-languages these tokens are often methods (and variables
etc.) To simplify explanations we talk in the following only about
methods and variables - but in general the method-buffer can contain
any kind of tokens (e.g. sections and subsections for texinfo
buffers).

@itemize @bullet
@item
When a method/variable is selected with the primary mouse button
(@pxref{Using the mouse}) or RETURN (@pxref{Using the keyboard}) the
edit buffer will jump to the method/variable.

IMPORTANT: If you use the POWER-click (i.e. hold down the SHIFT-key
while clicking with the primary mouse button (@pxref{Using the mouse})
or RETURN (@pxref{Using the keyboard})) on a node in this buffer then
the edit-buffer will be narrowed to the selected token (see also
option @code{ecb-token-jump-narrow}). But this works only for sources
parsed by semantic, not by imenu or etags!

@item
Clicking on a method/variable with the secondary mouse button or C-RETURN
(@pxref{Usage of ECB}) will jump to the method in the other edit window.

@item
Right clicking on a method/variable will open a popup menu where
different operation on the item under the mouse cursor can be
performed.
@end itemize

@node Activation and Deactivation, Usage of ECB, Overview, Top
@chapter Activation and Deactivation

@noindent
This chapter describes all aspects of activating and deactivating ECB.

@menu
* Standard activation::         How to manually (de)activate ECB
* Automatic activation::        Automaticaly (de)activating ECB
@end menu

@node Standard activation, Automatic activation, Activation and Deactivation, Activation and Deactivation
@section Standard activation and deactivation

Call @kbd{M-x ecb-activate} and @kbd{M-x ecb-deactivate} to activate
or deactivate ECB@footnote{Activation is also possible via the menu
``Tools --> Start Code Browser (ECB)''.}. If you want ECB started in a
new frame see the option @code{ecb-new-ecb-frame} (default is nil).
@code{ecb-activate} always raises and selects the ECB-frame even if
ECB is already started.

@cindex minor mode
Because ECB is a global minor-mode it can also be
(de)activated/toggled by @kbd{M-x ecb-minor-mode}.

@cindex Activation hook-sequence
@anchor{Activation hook-sequence}
The following sequence of hooks is evaluated during activation of ECB:
@enumerate
@item @code{ecb-before-activate-hook}
@item <All actions for activation but no layout drawing>
@item @code{ecb-activate-before-layout-draw-hook}
@item @code{ecb-redraw-layout-before-hook}
@item <Drawing the layout>
@item @code{ecb-redraw-layout-after-hook}
@item @code{ecb-activate-hook}
@end enumerate

@anchor{Deactivation hook-sequence}
@cindex Deactivation hook-sequence
The following sequence of hooks is evaluated during deactivation of
ECB:
@enumerate
@item @code{ecb-before-deactivate-hook}
@item <All actions for deactivation of ECB>
@item @code{ecb-deactivate-hook}
@end enumerate

@node Automatic activation, , Standard activation, Activation and Deactivation
@section Automatic activation and deactivation

@cindex Automatic activation
@cindex Automatic deactivation
There are three options for auto. (de)activation ECB after Emacs-start
and also major-mode based.

@table @code
@item ecb-auto-activate
This option is for auto. activating ECB after Emacs-startup. Set this
to not nil and ECB will automaticaly be started after Emacs comes up.

@item ecb-major-modes-activate
@itemx ecb-major-modes-deactivate
These option give you the possibility to activate (rsp. deactivate)
ECB on a major-mode basis, means you can define for which major-modes
ECB should be activated and for which modes it should deactivated (See
@ref{Activation hook-sequence} and @ref{Deactivation hook-sequence}).

If activating or deactivating is too strong you can also customize ECB
with these two option only hiding/showing it's ECB-windows
(tree-buffers) on a major-mode basis. At last this is nothing more
than auto. calling @code{ecb-toggle-ecb-windows} (@pxref{Interactive
ECB commands}) depending which major-mode is active.
@end table

If you activate ECB on a major-mode basis you probably want switch off
displaying the tip of the day. You can do this with the option
@code{ecb-tip-of-the-day}.

@node Usage of ECB, Customizing, Activation and Deactivation, Top
@chapter Usage of ECB

This chapter describes in a detailed manner all aspects of using the
Emacs Code Browser.

@menu
* Using the mouse::             Working with the mouse
* Using the keyboard::          Working with the keyboard
* The edit-window::             How to use the edit-window(s)
* Temp- and compile-buffers::   Displaying temp- and compilation-buffers
* The Methods buffer::          Using and customizing he Methods-buffer
* The ECB-layout::              Changing, customizing, redrawing, creating
* Hiding the ECB windows::      Hiding/Showing the ECB-windows
* Maximizing the ECB windows::   Maximizing the ECB-windows
* Back/forward navigation::     Back- and forward navigation like a browser
* ECB-window synchronizing::    Auto./manual synchronizing the ECB-windows
* Interactive ECB commands::    All interactive user-commands of ECB
@end menu

@node Using the mouse, Using the keyboard, Usage of ECB, Usage of ECB
@section Working with the mouse in the ECB-windows

@cindex primary button
@cindex secondary button
@cindex mouse button
Normally you get best usage if you use ECB with a mouse. ECB
distinguishes between a @dfn{primary} and a @dfn{secondary}
mouse-button.

With the option @code{ecb-primary-secondary-mouse-buttons} the following
combinations of primary and secondary mouse-buttons are possible:

@itemize @minus
@item
primary: mouse-2, secondary: C-mouse-2@footnote{means mouse-2 while CTRL-key
is pressed.}. This is the default.

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

@item
primary: mouse-1, secondary: mouse-2
@end itemize

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

@subsection The primary mouse-button

A click with the primary button causes the main effect in each ECB-buffer:

@itemize @minus
@item ECB Directories:
Expanding/collapsing nodes and displaying files in the ECB-Sources
buffer.

@item ECB sources/history:
Opening the file in that edit-window specified by the option
@code{ecb-primary-mouse-jump-destination}.

@item ECB Methods:
Jumping to the method in that edit-window specified by the option
@code{ecb-primary-mouse-jump-destination}.
@end itemize

@subsection The POWER- or SHIFT-click

@cindex SHIFT-click
@cindex POWER-click
A click with the primary mouse-button while the SHIFT-key is pressed
is called the POWER-click and does the following (depending on the
ECB-buffer where the POWER-click occurs):

@itemize @minus
@item ECB Directory:
Refreshing the directory-contents-cache (see
@code{ecb-cache-directory-contents}).

@item ECB sources/history:
Only displaying the source-contents in the method-buffer but not
displaying the source-file in the edit-window. This means it opens the
clicked source only in the background and shows all its
methods/variables in ECB-Methods; the buffer of the edit-window is not
changed! This is very useful to get only an overlook for a certain
source.

@item ECB Methods:
Narrowing to the clicked method/variable/ect... (see
@code{ecb-token-jump-narrow}). But this works only for sources parsed
by semantic, not by imenu or etags!
@end itemize

Per default the complete node-name of an item in a tree-buffer is
displayed in the echo-area if the mouse moves over it, regardless if
the related window is the active one or not. You get the same effect
always after a POWER-click. In general: Via
@code{ecb-show-node-info-in-minibuffer} you can specify in a detailled
manner for every ECB tree-buffer when and which node-info should be
displayed in the minibuffer.

@subsection The secondary mouse-button

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

@subsection The right mouse-button

In each ECB-buffer mouse-3 (= right button) opens a special context popup-menu
for the clicked item where you can choose several senseful actions.

With the options @code{ecb-directories-menu-user-extension},
@code{ecb-sources-menu-user-extension},
@code{ecb-methods-menu-user-extension} and
@code{ecb-history-menu-user-extension} you can add new commands to the
popup-menues.

With the options @code{ecb-directories-menu-sorter},
@code{ecb-sources-menu-sorter}, @code{ecb-methods-menu-sorter} and
@code{ecb-history-menu-sorter} you can even re-arrange all the entries
of the popup-menues.

@subsection Horizontal scrolling with the mouse

In each tree-buffer of ECB you can easily scroll left and right with
the mouse if the option @code{ecb-tree-easy-hor-scroll} is not
@code{nil}.

The reason for this is: XEmacs has horizontal scroll-bars so invisible
parts beyond the right window-border of a tree-buffer can always made
visible very easy.

GNU Emacs does not have hor. scroll-bars so especially with the mouse
it is quite impossible to scroll smoothly right and left. The
functions @code{scroll-left} and @code{scroll-right} can be annoying
and are also not bound to mouse-buttons.

ECB offers three ways for smoothly hor. scrolling with GNU Emacs if
@code{ecb-tree-easy-hor-scroll} is a positive integer-value S:

@itemize @bullet
@item
In all ECB-tree-buffers the keys @kbd{M-mouse-1} and @kbd{M-mouse-3}
are bound to scrolling left resp. right with scroll-step S.

@item
Clicking with mouse-1 or mouse-2 onto the edge of the modeline has the
same effect, i.e. if you click with mouse-1 onto the left \(resp
right) egde of the modeline you will scroll left \(resp. right) with
scroll-step S.

@item
Additionally @kbd{C-M-mouse-1} and @code{C-M-mouse-3} are bound to
scrolling left resp. right with scroll-step @code{window-width} - 2.
@end itemize

This is NOT done for XEmacs cause of its horizontal scrollbars. If you
want scrolling left and right with the mouse in XEmacs then activate
the horizontal scrollbars.


@node Using the keyboard, The edit-window, Using the mouse, Usage of ECB
@section Working with the keyboard in the ECB-windows

ECB offers the @code{ecb-mode-map} which binds the most important
functions of ECB to keys so you can easily use ECB in every
window@footnote{Regardless if a tree-window or an edit-window} without
a mouse.

IMPORTANT: Do not modify @code{ecb-mode-map} directly! The option
@code{ecb-key-map} defines all ECB keybindings, including a common
prefixkey (This is by default @kbd{C-c .}). If there are conflicts
with other minor-modes or packages you can define very easy another
prefix. Please read carefully the description of @code{ecb-key-map}
(@pxref{ecb-general}).!

The following sections describe special topics about using the
keyboard in the ECB-tree-buffers:

@menu
* Navigation/Selection::        Keyboard navigation/selection in a tree-buffer
* Incremental search::          Find nodes as fast as possible
* Personal keybindings::        Adding personal keybindings to a tree-buffer
@end menu

@node Navigation/Selection, Incremental search, Using the keyboard, Using the keyboard
@subsection Navigation and Selection in a tree-buffer

@cindex RETURN key
@cindex TAB key
@cindex expanding
@cindex collapsing
In the ECB-buffers RETURN and TAB are the most important keys:

@itemize @bullet
@item
RETURN does the same as the primary button and C-RETURN does the same
as the secondary button. S-RETURN is the same as the SHIFT-click or
POWER-click. The terms ``primary'', ``secondary'', ``SHIFT-'' and
``POWER-click'' are explained in @ref{Using the mouse}. See also the
option @code{ecb-tree-RET-selects-edit-window} and the function
@code{ecb-toggle-RET-selects-edit-window} which is bound to @kbd{C-t}
in each tree-buffer of ECB!

@item
TAB always expands or collapses expandable nodes.
@end itemize

The RETURN and TAB keys can not be (re)defined with @code{ecb-key-map}!

If you set @code{ecb-tree-navigation-by-arrow} to not nil then the left- and
right-arrow keys work in the ECB tree-window in the following smart way:

@itemize @bullet
@item
Left-arrow: If node is expanded then it will be collapsed otherwise
(i.e. current node is either not expandable or not expanded) point
jumps to the next ``higher'' node in the hierarchical tree (higher
means the next higher level or - if no higher level available
- the next higher node on the same level).

@item
Right-arrow: If node is expandable but not expanded then it will be
expanded. Otherwise (i.e. current node is either not expandable or
already expanded) point jumps to the next following node (which is the
first subnode in case of an already expanded node or simply the next
node in the following line).
@end itemize


@node Incremental search, Personal keybindings, Navigation/Selection, Using the keyboard
@subsection Incremental search for a node in current tree-buffer

@cindex Incremental search
Each displayable key (e.g. all keys normally bound to @code{self-insert-command})
is appended to the current seach-pattern. The tree-buffer tries to jump to the
first node which matching the current search-pattern either as substring or as
prefix (see below). If no match is found then nothing is done. There are some
special keys:

@itemize @bullet
@item @kbd{backspace} and @kbd{delete}:
Delete the last character from the search-pattern.

@item @kbd{home}:
Delete the complete search-pattern

@item @kbd{end}:
Expand either to a complete node if current search-pattern is already
unique or expands to the greates common substring or prefix of the
nodes. If there are at least two nodes with the same greatest
common-prefix than every hit of @kbd{end} jumps to the next node with this
common prefix.
@end itemize

For better overlooking the current search-pattern is shown in the echo area.
After selecting a node with RET the search-pattern is cleared out. With
@code{ecb-tree-incremental-search} you can specify if the current search-pattern
must be a real prefix of the node (default) or if any substring is matched.

For faster and easier finding the right node in a ecb-window thi incremental
search ignores the following non interesting stuff:

@itemize @minus
@item any leading spaces
@item expand/collapse-buttons: [+] resp. [-]
@item protection-signs (+, -, #) in the method-window if uml-notation is used
@item variables types or returntypes in front of variable- or method-names.
@item const specifier for variables
@end itemize

This means: Just type in the prefix (resp. a substring) of a class-,
variable-, method-, directory- or filename and ECB will bring you as
fast as possible to the node you want. Incremental node-search uses
the value of @code{case-fold-search}.

Tip: The @code{ecb-minor-mode} offers you in the @code{ecb-mode-map}
(customizable via @code{ecb-key-map}) some keys for selecting every window
of the ecb-frame. This makes window-selection a childīs play. For
example you can jump into the method-window by hitting @kbd{C-c . gm}.

@node Personal keybindings, , Incremental search, Using the keyboard
@subsection Adding personal keybindings

There are five hooks which can be used for adding personal keybindings
to the ECB tree-buffers:

@itemize @minus
@item @code{ecb-common-tree-buffer-after-create-hook}
@item @code{ecb-directories-buffer-after-create-hook}
@item @code{ecb-sources-buffer-after-create-hook}
@item @code{ecb-methods-buffer-after-create-hook}
@item @code{ecb-history-buffer-after-create-hook}
@end itemize

These hooks are called directly after tree-buffer creation so they can
be used to add personal local keybindings@footnote{To be more general:
They can be used to run any arbitrary lisp code after a tree-buffer
creation!} either to all tree-buffers
(@code{ecb-common-tree-buffer-after-create-hook}) or just to a certain
tree-buffer. Here is a list which keys MUST NOT be rebound:

@itemize @bullet
@item @kbd{RET} and all combinations with @kbd{Shift} and @kbd{Ctrl}:
Used for selecting nodes in all tree-buffers.
@item @kbd{TAB}:
Used for expanding/collapsing nodes in all tree-buffers.
@item @kbd{C-t}:
Used for toggling ``jump after selection'' in all tree-buffers, see
command @code{ecb-toggle-RET-selects-edit-window}.
@item All self-inserting characters:
Used for easy and fast navigation in all tree-buffers,
@xref{Incremental search}.
@item @kbd{F2}, @kbd{F3}, @kbd{F4}:
Used for customizing ECB, adding source-path in the directories buffer.
@end itemize

The following example binds @kbd{C-a} to some useful code in ALL
tree-buffers and @kbd{C-d} to even more useful code ONLY in the
directories buffer:

@example
@group
(add-hook 'ecb-common-tree-buffer-after-create-hook
          (lambda ()
             (local-set-key (kbd "C-a")
                            (lambda ()
                               (interactive)
                               (message "ECB is great!")))))

(add-hook 'ecb-directories-buffer-after-create-hook
          (lambda ()
             (local-set-key (kbd "C-d")
                            (lambda ()
                               (interactive)
                               (message "ECB is wonderful!")))))
@end group
@end example

@node The edit-window, Temp- and compile-buffers, Using the keyboard, Usage of ECB
@section Working with the edit-window

@cindex edit-window
ECB offers you all what you need to work with the edit-window as if
the edit-window would be the only window of the ECB-frame.

@cindex Adviced functions
ECB offers you to advice the following functions so they work best with ECB:

@itemize @minus
@item @code{other-window}
@item @code{delete-window}
@item @code{delete-other-windows}
@item @code{delete-windows-on}
@item @code{split-window-horizontally}
@item @code{split-window-vertically}
@item @code{split-window}
@item @code{switch-to-buffer}
@item @code{switch-to-buffer-other-window}
@item @code{other-window-for-scrolling}
@end itemize

The behavior of the adviced functions is:

@itemize @bullet
@item
All these adviced functions behaves exactly like their corresponding
original functons but they always act as if the edit-window(s) of ECB
would be the only window(s) of the ECB-frame. So the edit-window(s) of
ECB seems to be a normal Emacs-frame to the user.

@item
If called in a not edit-window of ECB all these function jumps first
to the (first) edit-window, so you can never destroy the ECB-window
layout unintentionally.

@item
If called in another frame than the ECB-frame these functions behave
exactly like the not adviced original versions!
@end itemize

ATTENTION: If you want to work within the edit-window with splitting
and unsplitting the edit-window(s) it is highly recommended to use the
adviced-functions of ECB instead of the original Emacs-functions (see
above). Per default ECB does advice all of the functions mentioned
above but with the option @code{ecb-advice-window-functions} you can
customizes which functions should be adviced by ECB. Please read
carefully the documentation of this option!

Another interesting option in the context of the edit-window and these
adviced functions is @code{ecb-layout-always-operate-in-edit-window}!

@node Temp- and compile-buffers, The Methods buffer, The edit-window, Usage of ECB
@section Temp- and compile-buffers display in ECB

@cindex temporary buffers
@cindex help buffers
@cindex compilation buffers
@cindex grep buffers
If you call any help in Emacs, e.g. by calling @code{describe-function}, or
if you do a completion in the minibuffer, then Emacs displays the
result-buffer in another window. This behavior you have also in ECB.

@subsection Standard Emacs behavior

If the edit-window is already splitted then the temp-buffer is
displayed in the ``other'' edit-window otherwise the edit-window will be
splitted first. The variables @code{temp-buffer-max-height} and
@code{temp-buffer-resize-mode} work also correctly with ECB.

Same for all compilation output-buffers (e.g. after a @code{compile} or
@code{grep}) and the variable @code{compilation-window-height}.

This is default behavior of ECB. But there is also another way to
display such buffers: Using a durable extra window at the bottom of
the ECB-frame:

@subsection Using a durable compile window

With the option @code{ecb-compile-window-height} you can define if the
ECB layout should contain per default a compile-window at the
bottom (just specify the number of lines which should be used for the
compile-window at the bottom of the frame). If ``yes'' ECB displays
all output of compilation-mode (compile, grep etc.) in this special
window. Same for displaying help-buffers or similar stuff.

In general: With the options @code{ecb-compilation-buffer-names},
@code{ecb-compilation-major-modes} and
@code{ecb-compilation-predicates} you can define which buffers should
be displayed in the compile-window of ECB for example if you call
@code{switch-to-buffer}.

With the command @code{ecb-toggle-compile-window} you can toggle the
visibility of the compile-window (@pxref{Interactive ECB commands}).

There are some more useful options and commands related to the
compile-window of ECB:

@itemize @bullet
@item
With the option @code{ecb-compile-window-temporally-enlarge} you can
allow Emacs to enlarge temporally the ECB-compile-window in some
situations. Please read the comment of this option. See also the
description of the function
@code{ecb-toggle-enlarged-compilation-window}.

@item
With the option @code{ecb-layout-switch-to-compilation-window} you can
modify the switch-to-buffer...-functions to work best if your layout
contains a compile-window. See the docstring of this option.

But because ECB works best @strong{without} such a durable
compile-window you should read the documentation of these two options
carefully!

@item
With the command @code{ecb-cycle-through-compilation-buffers}
(@pxref{Interactive ECB commands}) you can cycle through all current
open compilation-buffers in the sense of
@code{ecb-compilation-buffer-p} very fast.
@end itemize


@node The Methods buffer, The ECB-layout, Temp- and compile-buffers, Usage of ECB
@section Using and customizing the ECB-Methods buffer

ECB is mostly designed to display parsing information for files
supported by semantic. But from version 1.94 on it also supports other
parsing engines like imenu and etags, so also files not supported by
semantic but by imenu/etags can be displayed in the Method-buffer of
ECB. Therefore we have to intruduce some terminology:

@cindex semantic-sources
@anchor{Definiton of semantic- and non-semantic-sources}
@itemize @minus
@item @dfn{semantic-sources}:
These are filestypes for which a semantic grammar is available, so the
files are parsable by semantic. These sources are supported best by
ECB and most of the following options and descriptions are related to
these filetypes. Examples are programming-sources like C++, C, Java,
Emacs-Lisp and Texinfo-file and some more.

@cindex non-semantic-sources
@item @dfn{non-semantic-sources}:
For these files there is no semantic-grammar available so they can not
be parsed by semantic. Examples are Perl-, LaTeX- and TeX-files. But
for many of these files imenu and/or etags parsers exist. ECB supports
now parsing and displaying these file-types too and it uses for this
some speedbar-logic.
@end itemize

This chapter describes how to use and customize the Methods-buffer of
ECB.

@menu
* Expanding::                   Explicit and automatic expanding
* Customizing the display::     How to customize the Methods-buffer display
* Rebuilding the Methods::      When to rebuild the Methods-buffer      
@end menu

@node Expanding, Customizing the display, The Methods buffer, The Methods buffer
@subsection Explicit and automatic expanding of the ECB-methods-buffer

@subsubsection Explicit expanding to a certain expanding level

With the command @code{ecb-expand-methods-nodes} (bound to @kbd{C-c .
x}) you can get a fast overlook of the contents of the source-buffer,
because this command allows precisely expanding tokens with a certain
indentation-level. So you can either expand no tokens (or with other
words collapse all tokens) or expand all tokens so see the contents of
a buffer at one glance. Or you can expand exactly that tokens of a
certain indentation level.

Which node-types are expanded (resp. collapsed) by this command
depends for semantic-sources on the options
@code{ecb-methods-nodes-expand-spec} and
@code{ecb-methods-nodes-collapse-spec}! For non-sematic-sources always
all node-types are expanded/collapsed, i.e. the two options above
takes no effect for these files.

@subsubsection Automatic expanding the ECB-methods-buffer

If the option @code{ecb-highlight-token-with-point} is switched on,
then then always that node in the method-buffer is highlighted which
belongs to the current semantic-token under point in the edit-window.
But if this node is invisible (probably because its parent node is
collapsed) then no node is highlighted if the auto. expanding feature
is switched off.

You can either switch on this feature with the option
@code{ecb-auto-expand-token-tree} or even easier with the command
@code{ecb-toggle-auto-expand-token-tree}.

There is another option
@code{ecb-expand-methods-switch-off-auto-expand} which makes both
explicit and auto. expanding best working together. See the
documentation of this option to get the details.

The autom. expanding feature is only available for semantic-sources!

@node Customizing the display, Rebuilding the Methods, Expanding, The Methods buffer
@subsection Customizing the display of the Methods-buffer

@cindex semantic token
@cindex token
The ECB-Methods buffer is probably the most important browsing window
offered by ECB. It displays all parsing informations of the current
source-buffer (the buffer displayed in the edit-window).

Normally ECB gets all informations displayed in this Methods-buffer
from the semantic-library - at least for semantic-sources. This
library parses auto. the current source-buffer in the edit-window of
ECB and returns all information in form of @dfn{tokens} to ECB which
displays them in a browsable form in its Method-buffer. See @ref{ECB
Methods-buffer} for information how to use the Methods-buffer.

There are several options to customize which tokens ECB should display
in general, if the tokens should be collapsed or expanded, how to
fontify them (i.e. syntax-highlighting) and something more.

@table @code
@item ecb-show-tokens
Which semantic-tokens (e.g. types, methods, variables etc.) should be
displayed and should they be collapsed, flattened or expanded. Sorting
is also possible.

@item ecb-font-lock-tokens
@itemx ecb-type-token-display
How to fontify the tokens in the Method-buffer

@item ecb-token-display-function
ECB and semantic offer several predefined functions for displaying the
tokens. Here you can customize, what informations tokens should
contain (only the method-name or the whole signature or something
else) and what notation should be used, e.g. UML or not.

@end table

These are the most important options for this topic but it is
recommended to have a look into the customize-group @code{ecb-methods}
(@pxref{ecb-methods}) and check all the options offered there!

All these options are only relevant for semantic-sources and take no
effect for non-sematic-sources!

@node Rebuilding the Methods, , Customizing the display, The Methods buffer
@subsection Rebuilding the Methods-buffer

In almost all cases there is @strong{NO} need to manually rebuild the
method-buffer, because it is always done automatically if necessary;
the mechanism depends on the sources:

@itemize @minus
@item semantic-sources:
The command @code{global-semantic-auto-parse-mode} switches on autom.
reparsing of semantic-sources.

@item non-sematic-sources (imenu supported):
You can switch on autom. rescanning/reparsing with the option
@code{imenu-auto-rescan}. But nevertheless you have to manually
rebuild the Method-buffer (with the autom. updated imenu-tags) via the
command @code{ecb-rebuild-methods-buffer} (bound to @kbd{C-c . r}).

@item non-sematic-sources (etags supported):
For these sources there is no builtin auto-rescan mechanism, because
etags is an external tool it can only operate on the saved
file-contents. So rescanning the buffer contents would need to save
the buffer before. Therefore there is no builtin auto-rescan mechanism
because this would always result in saving the buffer and running an
external tool. But of course you can program such a an
etags-auto-rescan mechanism for yourself!
@end itemize

Besides for etags-supported non-sematic-sources there exist a few rare
scenarios also for the other sources where a complete manual rebuild
can be necessary. Here is one example:

Depending on the semantic-version: If an elisp-file is parsed which
contains a defun X in the middle where the closing ) is missing, then
semantic parses only until this defun X is reached and you will get an
incomplete ECB-method buffer. In such a case you must complete the
defun X and then completely reparse the elisp-file and rebuild the ECB
method buffer!

A complete manually rebuild is done by
@code{ecb-rebuild-methods-buffer}. For etags-parsed
non-sematic-sources this causes an automatic saving of the
source-buffer because otherwise etags would not operate with the
latest contents!

@node The ECB-layout, Hiding the ECB windows, The Methods buffer, Usage of ECB
@section Changing, customizing, redrawing and creating layouts

@cindex layout
@cindex ECB-layout
The term @dfn{ECB-layout} means in which windows the ECB-frame is
divided. This chapter describes all aspects concerning this layout,
especially changing, customizing, redrawing and also creating new
layouts.

@menu
* Changing the ECB-layout::     How to change and customize the layout
* Redrawing the ECB-layout::    How and when redrawing the layout
* Changing window sizes::       Changing sizes of the ECB-windows
* Fixing window sizes::         Fixing sizes of the ECB-windows
* Creating a new ECB-layout::   Interactively creating new layouts
@end menu

@node Changing the ECB-layout, Redrawing the ECB-layout, The ECB-layout, The ECB-layout
@subsection Changing and customizing the ECB-layout

ECB offers several predefined layouts with different sets and also
different locations of ECB-windows. See below the ``ascii-screenshot''
of all currently buildin layouts@footnote{The command
@code{ecb-show-layout-help'} shows the outline-picture for all buildin
layouts.}.

In addition to these predefined layouts you can either interactively
create new layouts ``by example'' (@pxref{Creating a new ECB-layout})
or program new layouts with the macro @code{ecb-layout-define}
(@pxref{The layout-engine}). The former method is the recommened
one!

There are two ways to interactively change the layout:
@itemize @bullet
@item Changing permanently:
Customize the option @code{ecb-layout-name} and store it for future
Emacs sessions.

@item Switching between several layouts at runtime:
If you want to switch fast between a certain sequence of layouts see
the option @code{ecb-toggle-layout-sequence} and the command
@code{ecb-toggle-layout} (@pxref{Simulating speedbar}). For just
selecting another layout during current Emacs-session use the command
@code{ecb-change-layout}.
@end itemize

With the option @code{ecb-show-sources-in-directories-buffer} you can
define if sources are displayed in the directory-window of a layout
(@pxref{ECB Directories-buffer}).

In addition to the general layout you can specify if the layout should
contain a durable compilation-window at the bottom of the frame, see
@code{ecb-compile-window-height} (@pxref{Temp- and compile-buffers}).

Maybe you want also change the look&feel of the tree-buffers. Then you
can change the location of the collapse- and expand-symbols and the
indendation of sub-nodes in a tree. See @code{ecb-tree-indent} and
@code{ecb-tree-expand-symbol-before}.

Here are all currently available layouts (for creating own new layouts
see @ref{Creating a new ECB-layout}); just customize the option
@code{ecb-layout-name} to the related name:

@table @asis
@item Layout ``left1''
@example
@group
-------------------------------------------------------
|              |                                      |
|  Directories |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|--------------|                                      |
|      |       |                                      |
| Sour | Hist  |                 Edit                 |
|      |       |                                      |
|      |       |                                      |
|--------------|                                      |
|              |                                      |
|  Methods     |                                      |
|              |                                      |
|              |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example
   
@item Layout ``left2''
@example
@group
-------------------------------------------------------
|              |                                      |
|              |                                      |
|              |                                      |
|  Directories |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|--------------|                 Edit                 |
|              |                                      |
|              |                                      |
|              |                                      |
|  Sources     |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left3''
@example
@group
-------------------------------------------------------
|              |                                      |
|  Directories |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|--------------|                                      |
|              |                                      |
|  Sources     |                 Edit                 |
|              |                                      |
|              |                                      |
|--------------|                                      |
|              |                                      |
|  Methods     |                                      |
|              |                                      |
|              |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left4''
@example
@group
-------------------------------------------------------
|              |                                      |
|              |                                      |
|              |                                      |
|  Directories |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|--------------|                 Edit                 |
|      |       |                                      |
|      |       |                                      |
|      |       |                                      |
| Sour | Hist  |                                      |
|      |       |                                      |
|      |       |                                      |
|      |       |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left5''
@example
@group
-------------------------------------------------------
|              |                                      |
|  Directories |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|--------------|                                      |
|              |                                      |
|  Sources     |                 Edit                 |
|              |                                      |
|              |                                      |
|--------------|                                      |
|              |                                      |
|  History     |                                      |
|              |                                      |
|              |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``right1''
@example
@group
-------------------------------------------------------
|                                      |              |
|                                      |  Directories |
|                                      |              |
|                                      |              |
|                                      |--------------|
|                                      |              |
|                                      |              |
|             Edit                     |  Sources     |
|                                      |              |
|                                      |              |
|                                      |--------------|
|                                      |              |
|                                      |  Methods     |
|                                      |              |
|                                      |              |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left6''
@example
@group
-------------------------------------------------------
|  Sources     |                                      | 
|--------------|                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|  Methods     |                 Edit                 |
|              |                                      | 
|              |                                      |
|              |                                      |
|--------------|                                      |
|  History     |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``top1''
@example
@group
-------------------------------------------------------
|                        |             |              |
|                        |             |              |
|      Directories       |  Sources    |  Methods     |
|                        |             |              |
|                        |             |              |
|-----------------------------------------------------|
|                                                     |
|                                                     |
|                                                     |
|                                                     |
|                    Edit                             |
|                                                     |
|                                                     |
|                                                     |
|                                                     |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left7''
@example
@group
-------------------------------------------------------
|              |                                      |
|  Directories |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|--------------|                 Edit                 |
|              |                                      |
|  History     |                                      |
|              |                                      |
|--------------|                                      |
|              |                                      |
|  Methods     |                                      |
|              |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left8''
@example
@group
-------------------------------------------------------
|              |                                      |
|  Directories |                                      |
|              |                                      |
|--------------|                                      |
|              |                                      |
|  Sources     |                                      |
|              |                                      |
|--------------|                 Edit                 |
|              |                                      |
|  Methods     |                                      |
|              |                                      |
|              |                                      |
|--------------|                                      |
|  History     |                                      |
|              |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``top2''
@example
@group
-------------------------------------------------------
|                                                     |
|                                                     |
|                    Methods                          |
|                                                     |
|                                                     |
|-----------------------------------------------------|
|                                                     |
|                                                     |
|                                                     |
|                                                     |
|                    Edit                             |
|                                                     |
|                                                     |
|                                                     |
|                                                     |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left9''
@example
@group
-------------------------------------------------------
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|   Methods    |                 Edit                 |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left10''
@example
@group
-------------------------------------------------------
|              |                                      |
|              |                                      |
|              |                                      |
|  Methods     |                 Edit                 |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|--------------|                                      |
|      |       |                                      |
| Sou  | Hist  |                                      |
|      |       |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left11''
@example
@group
-------------------------------------------------------
|              |                                      |
|              |                                      |
|              |                                      |
|  Methods     |                 Edit                 |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|--------------|                                      |
|              |                                      |
|  History     |                                      |
|              |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left12''
@example
@group
-------------------------------------------------------
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|   History    |                 Edit                 |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left13''
@example
@group
-------------------------------------------------------
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
| Directories  |                 Edit                 |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left14''
@example
@group
-------------------------------------------------------
|              |                                      |
|              |                                      |
|              |                                      |
| Directories  |                 Edit                 |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|--------------|                                      |
|              |                                      |
|  History     |                                      |
|              |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left15''
@example
@group
-------------------------------------------------------
|              |                                      |
|  Directories |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
|--------------|                 Edit                 |
|              |                                      |
|              |                                      |
|              |                                      |
|  Methods     |                                      |
|              |                                      |
|              |                                      |
|              |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``leftright1''
@example
@group
-------------------------------------------------------
|             |                         |             |
| Directories |                         |  Methods    |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|-------------|          Edit           |             |
|             |                         |             |
| Sources     |                         |             |
|             |                         |             |
|-------------|                         |             |
|             |                         |             |
| History     |                         |             |
|             |                         |             |
-------------------------------------------------------
|                                                     |
|                   Compilation                       |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``leftright2''
@example
@group
-------------------------------------------------------
|             |                         |             |
| Directories |                         |  Methods    |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|             |          Edit           |             |
|-------------|                         |-------------|
|             |                         |             |
| Sources     |                         |  History    |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|             |                         |             |
-------------------------------------------------------
|                                                     |
|                   Compilation                       |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``leftright3''
@example
@group
-------------------------------------------------------
|             |                         |             |
| Directories |                         |  Methods    |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|             |          Edit           |             |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|             |                         |             |
|             |                         |             |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@item Layout ``left-dir-plus-speedbar''
@example
@group
-------------------------------------------------------
|             |                                       |
| Directories |                                       |
|             |                                       |
|             |                                       |
|             |                                       |
|             |                                       |
|             |                                       |
|-------------|                                       |
|             |                                       |
|             |                                       |
|             |                                       |
| Speedbar    |                                       |
|             |                                       |
|             |                                       |
|             |                                       |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@end table

@node Redrawing the ECB-layout, Changing window sizes, Changing the ECB-layout, The ECB-layout
@subsection Redrawing the ECB-layout

@cindex Redraw
If you have unintenionally destroyed the ECB-layout, you can always
restore the layout with calling @code{ecb-redraw-layout}. This is even
true, if you get messages like ``wrong-type-argument window-live-p
#<window 222>''.

If the variable @code{ecb-redraw-layout-quickly} is not nil then the redraw
is done by the @code{ecb-redraw-layout-quickly} function, otherwise by
@code{ecb-redraw-layout-full}. But it's strongly recommended to use the
quick redraw only if you have really slow machines where a full redraw
takes several seconds because the quick redraw is not really safe and
may have some drawbacks! On normal machines the full redraw should be
done in << 1s!

See also the hooks @code{ecb-redraw-layout-after-hook} and
@code{ecb-redraw-layout-before-hook}!

@node Changing window sizes, Fixing window sizes, Redrawing the ECB-layout, The ECB-layout
@subsection Changing the sizes of the special ECB-windows

The standard width and height of the special ECB-windows is defined
with the options @code{ecb-windows-width} and
@code{ecb-windows-height}. But changing these options always
influences all layouts which is not always desired.

ECB offers to re-adjust the width and height of the ECB-windows (e.g. by
dragging the windows-borders via the mouse) and then saving exactly
these current window-sizes for the current layout so after activating
this layout all windows have autom. the stored sizes.

This is done via the option @code{ecb-layout-window-sizes} and the
commands @code{ecb-store-window-sizes},
@code{ecb-restore-window-sizes} and
@code{ecb-restore-default-window-sizes}.

Here is an example how to resize and store the sizes of the
ECB-windows of layout ``left1'':

@enumerate
@item
Switch to layout ``left1'' via @code{ecb-change-layout} (@kbd{C-c . lc})
@item
Resize the ECB-windows by dragging the window-borders with the mouse
@item
Call @code{ecb-store-window-sizes}
@end enumerate

After this layout ``left1'' will be always drawn with the new sizes
until you call @code{ecb-restore-default-window-sizes} during layout
``left1'' is active.

@strong{NOTE}: @code{ecb-store-window-sizes} stores the width and
height of the windows per default as fractions of the width (resp.
height) of the ECB-frame, so the stored sizes are always correct
regardless of the current frame-size! But if called with a prefix
argument then fixed sizes are stored.

@node Fixing window sizes, Creating a new ECB-layout, Changing window sizes, The ECB-layout
@subsection Fixing the sizes of the special ECB-windows

GNU Emacs 21 introduced a new feature which can fix the sizes of a
window displaying a certain buffer even after resizing the frame. This
new feature is driven by the new buffer-local variable
@code{window-size-fixed}.

ECB offers an option @code{ecb-fix-window-size} for fixing the sizes
of the special ECB-windows/buffers even after frame-resizing. The fix
type (valid values are @code{nil}, @code{t}, @code{width} and
@code{height}) can either be set on a layout-basis (means a different
value for each layout) or one value can be set for all layouts. In the
latter case there is an additional value @code{auto} which choose
autom. the senseful fix-type depending on the current layout-type: For
top-layouts the fix-type @code{height} and for all other layout-types
the fix-type @code{width}.

Probably the most senseful value is @code{auto} for all layouts
because it makes less sense to fix the height of the ecb-windows in a
left-, right- or leftright-layout. Same for fixing the width in a
top-layout.

Note: With current Emacs 21.2.X there seems to be no distinction
between @code{width}, @code{height} and @code{t}. Therefore this
option takes no effect (means all ecb-windows have always unfixed
sizes) if @code{ecb-compile-window-height} is not @code{nil}.

@node Creating a new ECB-layout, , Fixing window sizes, The ECB-layout
@subsection Interactively creating new layouts

@cindex New layouts
@cindex Creating new layouts

If you want to create your own ECB-layout then you can do this very
easy ``by example'' with the command @code{ecb-create-new-layout}.
This command creates a new empty frame and offers a small set of keys
to create the new layout by splitting windows.
@code{ecb-create-new-layout} and this couple of keys are your guide
during the layout-creation-process@footnote{During the creation
process you will be asked in the minibuffer for several options; here
you can use TAB-completion and an ``empty'' RET chooses always the
first option!}.

After calling @code{ecb-create-new-layout} you will be asked which
type of layout you want to create: ``left'', ``right'', ``top'' or
``left-right''. Here you specify where the ECB-tree-windows/buffers
should be located in the ECB-frame:

@itemize @minus
@item left: All ECB-tree-windows are located on the left side
@item right: All ECB-tree-windows are located on the right side
@item top: All ECB-tree-windows are located on the top side
@item left-right: All ECB-tree-windows are located on the left and
right side
@end itemize

Depending on the type you choose the window is splitted by the values
of the options @code{ecb-windows-width} (types ``left'', ``right'' and
``left-right'') or @code{ecb-windows-height} (type ``top'').

Afterwards you will see a frame like follows (here the layout-type is
``left-right''):

@example
@group
-----------------------------------------------------------------
|<point>       |                                   |            |
|              | ECB-layout creation mode          |            |
|              | ========================          |            |
|              |                                   |            |
|              | <This is a durable help-screen>   |            |
|              |                                   |            |
|              |                                   |            |
|              |                                   |            |
|              |                                   |            |
|              |                                   |            |
|              |                                   |            |
|              |                                   |            |
|              |                                   |            |
|              |                                   |            |
|              |                                   |            |
-----------------------------------------------------------------
               |
               |   ,---
               `---| Splitted by the value of @code{ecb-windows-width}.
                   `---
@end group
@end example

The big window (here the middle window) will be the edit-window of the
new layout and can not be selected, deleted or splitted during the
creation process. It displays the help-screen for the layout-creation
mode. Here all the available commands are displayed.

The small window(s) (here the left and right windows) can be splitted
by you wherever you want (@kbd{C-s}). The left one contains the point.
You must give every ECB-tree-window you create a type (@kbd{C-t})
which can be either

@itemize @bullet
@item One of the builtin types

This can be either ``directories'', ``sources'', ``methods'',
``history'' or ``speedbar''.

@item Any user-defined type:

In this case you insert ``other'' after hitting @kbd{C-t} and you will
then be asked for the name of the user-defined type. You can insert
any arbitray type name X. But to get this layout working you have to
define a function with name @code{ecb-set-X-buffer} whereas X is the
name of the user-defined type you have specified during
layout-creation.

This function @code{ecb-set-X-buffer} has first to switch to the
buffer you want to display in this window and then making this window
dedicated. You have to use the macro @code{ecb-with-dedicated-window}
in such a function!

Here is an example: Suppose you have inserted as type name ``example''
then you have to define and load a function
@code{ecb-set-example-buffer} which could be defined like follows:

@example
(defun ecb-set-example-buffer ()
  (ecb-with-dedicated-window
    " *ECB example-buffer*"
    'ecb-set-example-buffer
      (switch-to-buffer (get-buffer-create " *ECB example-buffer*"))))
@end example

If you forget to define such a function for the user-defined type then
nevertheless ECB will draw this layout but it will use the
default-function @code{ecb-set-default-ecb-buffer} instead.
@end itemize

If you are satisfied with your new layout just hit @kbd{C-q}. You will
be asked for a new layout-name (TAB-completion is offered to get a
list of all names already in use) and after inserting a new(!) name
the new layout is saved in the file defined by the option
@code{ecb-create-layout-file}. The new layout is now available via the
option @code{ecb-layout-name}.

There is no need for you to load the file
@code{ecb-create-layout-file} manually into your Emacs because it's
automatically loaded by ECB!

@strong{NOTE}: During the layout-creation process only the commands
displayed in the help-screen are available. ALL other commands are
temporaly disabled (even the mouse-commands).

For programming new layouts with emacs-lisp see @ref{The layout-engine}.

With the command @code{ecb-delete-new-layout} you can delete
previously created layouts (TAB-completion is offered for all names of
user created layouts).

@node Hiding the ECB windows, Maximizing the ECB windows, The ECB-layout, Usage of ECB
@section Hiding/Showing the ECB windows

@cindex Hide windows
@cindex Show windows
With @code{ecb-toggle-ecb-windows}, @code{ecb-hide-ecb-windows} and
@code{ecb-show-ecb-windows} you can hide/show all the ECB windows
without changing the activation state of ECB and also without
deactivating the advices for @code{delete-other-windows} and/or
@code{delete-window}. This is most useful if you use a layout like
``top2'' (@pxref{Tips and tricks}) or if you want to have maximum space
for editing and you don't need the browsing windows all the time.

The following sequence of hooks is evaluated during showing again the
hidden ECB-windows:
@enumerate
@item @code{ecb-show-ecb-windows-before-hook}
@item @code{ecb-redraw-layout-before-hook}
@item <Redrawing the layout to show the hidden ECB-windows>
@item @code{ecb-redraw-layout-after-hook}
@item @code{ecb-show-ecb-windows-after-hook}
@end enumerate

The following sequence of hooks is evaluated during hidding the
ECB-windows:
@enumerate
@item @code{ecb-hide-ecb-windows-before-hook}
@item <Hidding the ECB-windows>
@item @code{ecb-hide-ecb-windows-after-hook}
@end enumerate

@node Maximizing the ECB windows, Back/forward navigation, Hiding the ECB windows, Usage of ECB
@section Maximizing the ECB windows

To get a better overlook about the contents of a certain ECB-window
every ECB-window can be ``maximized'', means all other ECB-windows are
deleted so only the edit-window(s) and this maximized ECB-window are
visible (and maybe a compile-window if active). There are several ways
to do this:

@itemize @bullet
@item
Via the popup-menus of the ECB-windows

@item
Via the main ``ECB''-menu and here ``Display window maximized''

@item
Via calling the adviced version of
@code{delete-other-windows}@footnote{This command is adviced per
default, see @ref{The edit-window}.} (bound to @kbd{C-x 1}) in one of
the ECB windows.

@item
Via one of the commands @code{ecb-maximize-window-directories},
@code{ecb-maximize-window-sources}, @code{ecb-maximize-window-methods},
@code{ecb-maximize-window-history} or
@code{ecb-maximize-window-speedbar} or the bound short-cuts for those
commands.

@item
Via the new command @code{ecb-cycle-maximized-ecb-buffers} which
cycles through all ecb-buffers of current layout by maximizing exactly
one of the ecb-windows after every cycle-step.
@end itemize

Minimizing such a maximized ECB-window, i.e. bringing back to its
original size, can simply be done by redrawing the layout via the
command @code{ecb-redraw-layout} (bound to @kbd{C-c . lr}).

@node Back/forward navigation, ECB-window synchronizing, Maximizing the ECB windows, Usage of ECB
@section Back- and forward navigation like a browser

With ECB you can ``browse'' in your source-files like with a
web-browser. This means ECB stores the current buffer- and
window-position relative to the current token@footnote{e.g. a method,
a variable or any other semantic token} in the edit-window after

@itemize @minus
@item selecting a token in the ECB-methods buffer or
@item selecting a source-file in the ECB-sources/history-buffer.
@end itemize

ECB offers two commands @code{ecb-nav-goto-next} (@kbd{C-c . n}) and
@code{ecb-nav-goto-previous} (@kbd{C-c . p}) to go forward and
backward within this navigation historylist. These commands are also
available via the menu ``ECB --> Navigate''.

Aside normal ``location-browsing'' this is usefull for example in a
scenario where @code{ecb-token-jump-narrow} is activated:

@enumerate
@item You edit a function
@item Goto another function above the current in the same file
@item Add a few lines
@item Call ecb-nav-goto-previous

Now you will edit at the same place in the function.
@end enumerate

@node ECB-window synchronizing, Interactive ECB commands, Back/forward navigation, Usage of ECB
@section Synchronization of the ECB-windows

Per default ECB synchronizes automatically the contents of the
ECB-windows/tree-buffers with the current active edit-window (rsp. the
current buffer of the edit window):

@itemize @bullet

@item ECB-directories:

This windows is synchronized to display the directory where the
source-file which is displayed in the edit-window is located. If the
source-path (i.e. an element of the option @code{ecb-source-path})
containing this directory is not expanded it will be auto. expanded
according to the value of the option
@code{ecb-auto-expand-directory-tree} (@pxref{ecb-directories}).

@item ECB-sources:

The ECB-sources-buffer contains after synchronizing all the sources of
the directory of the ``current'' source-file displayed in the
edit-window. The entry of the ``current'' source-file is highlighted.

@item ECB-methods:

Contains after synchronizing all the tokens of the buffer in the
edit-window, i.e. all methods, variables etc... depending of the
major-mode.

@item ECB-history:

Highlights the entry of the buffer displayed in the edit-window if
this buffer is a source-file.

@end itemize

This feature can be customized with the option @code{ecb-window-sync}:

If active then the synchronization takes place always a buffer changes
in the edit window, if deactivated then never. But you can also set
this option to a list of major-modes and then the sync. will only be
done if the major-mode of the current buffer belongs NOT to this list.

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

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

@strong{NOTE}: With the command @code{ecb-current-buffer-sync} you can
do a manually synchronization if the automatic one is switched off or
if you just want to do this!

@node Interactive ECB commands, , ECB-window synchronizing, Usage of ECB
@section Interactive ECB commands

@noindent
ECB offers a lot of interactive commands. Some of these commands
prompt the user in the minibuffer if called with a prefix argument.

Example: If @code{ecb-clear-history} is called with a prefix argument
then you will be prompted in the minibuffer with:

@example
Clear from history: [all, not-existing-buffers, existing-buffers]
@end example 

You can choose one of the options enclosed in brackets with
TAB-completion; hitting RET direct after the prompt chooses auto. the
first offered option (in the example above ``all'').

@strong{Note}: The following interactive commands of ECB are listed
without the prefix ``ecb-'' (e.g. the command @code{ecb-activate} is
listed with name ``activate''). This has been done for a better
readable command index. @xref{Command Index}.

@deffn Command activate
Activates the ECB and creates all the buffers and draws the ECB-screen
with the actually choosen layout (see @code{ecb-layout-name}). This function
raises always the ECB-frame if called from another frame. This is the
same as calling @code{ecb-minor-mode} with a positive argument.
@end deffn

@deffn Command add-all-buffers-to-history
Add all current file-buffers to the history-buffer of ECB. If
@code{ecb-sort-history-items} is not nil then afterwards the history
is sorted alphabetically. Otherwise the most recently used buffers are
on the top of the history and the seldom used buffers at the bottom.
@end deffn

@deffn Command change-layout &optional preselect-type
Select a layout-name from all current available layouts
(TAB-completion is offered) and change the layout to the selected
layout-name. If optional argument PRESELECT-TYPE is not nil then you
can preselect a layout-type \(TAB-completion is offered too) and then
you will be asked only for layouts of that preselected type. Note:
This function works by changing the option @code{ecb-layout-name} but
only for current Emacs-session.
@end deffn

@deffn Command clear-history &optional clearall
Clears the ECB history-buffer. If @var{CLEARALL} is @code{nil} then
the behavior is defined in the option
@code{ecb-clear-history-behavior} otherwise the user is prompted what
buffers should be cleared from the history-buffer. For further
explanation see @code{ecb-clear-history-behavior}.
@end deffn

@deffn Command create-new-layout
Start process for interactively creating a new ECB-layout
(@pxref{Creating a new ECB-layout}).
@end deffn


@deffn Command current-buffer-sync &optional force
Synchronizes the current buffer with any other buffers.

Depending on the contents of current buffer this function performs different
synchronizing tasks but only if ECB is active and point stays in an
edit-window. If this is true under the following additional conditions some
tasks are performed:

@itemize @bullet
@item
Current buffer is a file-buffer and either @var{force} is not nil or
the buffer is different from the source-file currently displayed in
the ECB-tree-buffers:

Synchronizing all @code{tree-buffers} with the current buffer

@item Current buffer is a dired-buffer:

Synchronizing the directory- and sources-tree-buffer if visible

@item Always:

Running the hooks in @code{ecb-current-buffer-sync-hook}.
@end itemize
@end deffn

@deffn Command cycle-maximized-ecb-buffers
Cycles through all ecb-buffers of current layout by maximizing exactly
one of the ecb-windows after every cycle-step.
@end deffn

@deffn Command cycle-through-compilation-buffers &optional choose-buffer
Cycle through all compilation buffers currently open and display them
within the compilation window @code{ecb-compile-window}. If the
currently opened buffer within the compilation window is not a
compilation buffer, we jump to the first compilation buffer. If not we
try to loop through all compilation buffers. If we hit the end we go
back to the beginning.

If @var{CHOOSE-BUFFER} is not @code{nil} then the user will be
prompted for the compilation-buffer to swtich to.

See also the option @code{ecb-layout-switch-to-compilation-window}!
The difference is that this cycling-function offers only
compilation-buffers in the sense of @code{ecb-compilation-buffer-p}
whereas the adviced version of @code{switch-to-buffer} offers any
buffer but switches to @code{ecb-compile-window} if a
compilation-buffer!
@end deffn

@deffn Command deactivate
Deactivates the ECB and kills all ECB buffers and windows.
@end deffn

@deffn Command delete-new-layout
Select a layout-name for a layout created by
@code{ecb-create-new-layout} and delete this layout. This means the
layout-definiton is removed from the file
@code{ecb-create-layout-file} and the layout-function and associated
aliases are unbound.
@end deffn

@deffn Command display-upgraded-options
Display a message-buffer which options have been upgraded or reset.
@end deffn

@deffn Command download-ecb
Download ECB from the ECB-website and install it. For this the option
@code{ecb-download-url} must be set correct, whereas the default value of
this option should always be correct.

If @code{ecb-download-package-version-type} is set to -1 (means asking
for a version) then you will be ask in the minibuffer for the version
to download. Otherwise ECB downloads autom. the latest version
available for the type specified in
@code{ecb-download-package-version-type}. If no newer version than the
current one is available no download will be done.

For details about downloading and what requirements must be satisfied
see function @code{ecb-package-download} and option
@code{ecb-download-package-version-type}!

After sucessfull downloading the new ECB will be installed in a
subdirectory of @code{ecb-download-install-parent-dir}. After adding
this subdirectory to @code{load-path} and restarting Emacs the new ECB
version can be activated by @code{ecb-activate}.

If current running ECB is installed as regular XEmacs-package and not
with the archive available at the ECB website then this function asks
for proceeding!
@end deffn

@deffn Command download-semantic
Download semantic from the semantic-website and install it. For this
the variable @code{ecb-cedet-url} must be set correct,
whereas the default value of this variable should always be correct.

If @code{ecb-download-package-version-type} is set to -1 (means asking
for a version) then you will be ask in the minibuffer for the version
to download. Otherwise ECB downloads autom. the latest version
available for the type specified in
@code{ecb-download-package-version-type}. If no newer version than the
current one is available no download will be done.

For details about downloading and what requirements must be satisfied
see function @code{ecb-package-download} and option
@code{ecb-download-package-version-type}!

After sucessfull downloading the new semantic will be installed in a
subdirectory of @code{ecb-download-install-parent-dir}. After adding
this new subdirectory to @code{load-path} and restarting Emacs the new
semantic version is loaded and is used after next start of ECB.

If current running semantic is installed as regular XEmacs-package and
not with the archive available at the semantic website then this
function asks for proceeding!
@end deffn

@deffn Command expand-methods-nodes &optional force-all
Set the expand level of the nodes in the ECB-methods-buffer.

This command asks in the minibuffer for an indentation level LEVEL. With this
LEVEL you can precisely spezify which level of nodes should be expanded. LEVEL
means the indentation-level of the nodes.

A LEVEL value X means that all nodes with an indentation-level <= X are
expanded and all other are collapsed. A negative LEVEL value means all visible
nodes are collapsed.

Nodes which are not indented have indentation-level 0!

Which node-types are expanded (resp. collapsed) by this command
depends on the options @code{ecb-methods-nodes-expand-spec} and
@code{ecb-methods-nodes-collapse-spec}! With optional argument
@var{FORCE-ALL} all tokens will be expanded/collapsed regardless of
the values of these options.

Examples:
@itemize @minus
@item LEVEL = 0
expands only nodes which have no indentation itself.
@item LEVEL = 2
expands nodes which are either not indented or indented indented once
or twice
@item LEVEL ~ 10
should normally expand all nodes expect there are nodes which are
indented deeper than 10.
@end itemize

Note 1: This command switches off auto. expanding of the method-buffer
if @code{ecb-expand-methods-switch-off-auto-expand} is not nil. But it
can be switched on again quickly with
@code{ecb-toggle-auto-expand-token-tree} or @kbd{[C-c . a]}.

Note 2: All this is only valid for file-types parsed by semantic. For
other file types which are parsed by imenu or etags (see
@code{ecb-process-non-semantic-files}) @var{FORCE-ALL} is always true!
@end deffn

@deffn Command expand-directory-nodes
Set the expand level of the nodes in the ECB-directories-buffer. For
argument LEVEL see @code{ecb-expand-methods-nodes}.

Be aware that for deep structured paths and a lot of source-paths this
command can last a long time - depending of machine- and
disk-performance.
@end deffn

@deffn Command goto-window-compilation
Goto the ecb compilation window @code{ecb-compile-window}.
@end deffn

@deffn Command goto-window-directories
Make the ECB-directories window the current window. If
@code{ecb-use-speedbar-instead-native-tree-buffer} is @code{dir} then
goto to the speedbar-window.
@end deffn

@deffn Command goto-window-edit1
Make the (first) edit-window window the current window.
@end deffn

@deffn Command goto-window-edit2
Make the second edit-window (if available) window the current window.
@end deffn

@deffn Command goto-window-history
Make the ECB-history window the current window.
@end deffn

@deffn Command goto-window-methods
Make the ECB-methods window the current window. If
@code{ecb-use-speedbar-instead-native-tree-buffer} is @code{method}
then goto to the speedbar-window.
@end deffn

@deffn Command goto-window-sources
Make the ECB-sources window the current window. If
@code{ecb-use-speedbar-instead-native-tree-buffer} is @code{source}
then goto to the speedbar-window.
@end deffn

@deffn Command jde-display-class-at-point
Display in the ECB-methods-buffer the contents (methods, attributes
etc...) of the class which contains the definition of the ``thing''
under point (this can be a variablename, classname, methodname,
attributename). This function needs the same requirements to work as
the method-completion feature of JDEE (see
@code{jde-complete})!. The source-file is searched first in
@code{jde-sourcepath}, then in @code{jde-global-classpath}, then in
@var{$CLASSPATH}, then in current-directory.

Works only for classes where the source-code (i.e. the *.java-file) is
available.
@end deffn

@deffn Command maximize-window-directories
Maximize the ECB-directories-window, i.e. delete all other
ECB-windows, so only one ECB-window and the edit-window(s) are visible
(and maybe a compile-window). Works also if the ECB-directories-window
is not visible in current layout.
@end deffn

@deffn Command maximize-window-sources
Maximize the ECB-sources-window, i.e. delete all other ECB-windows, so
only one ECB-window and the edit-window(s) are visible (and maybe a
compile-window). Works also if the ECB-sources-window is not visible
in current layout.
@end deffn

@deffn Command maximize-window-methods
Maximize the ECB-methods-window, i.e. delete all other ECB-windows, so
only one ECB-window and the edit-window(s) are visible (and maybe a
compile-window). Works also if the ECB-methods-window is not visible
in current layout.
@end deffn

@deffn Command maximize-window-history
Maximize the ECB-history-window, i.e. delete all other ECB-windows, so
only one ECB-window and the edit-window(s) are visible (and maybe a
compile-window). Works also if the ECB-history-window is not visible
in current layout.
@end deffn

@deffn Command maximize-window-speedbar
Maximize the ECB-speedbar-window, i.e. delete all other ECB-windows,
so only one ECB-window and the edit-window(s) are visible (and maybe a
compile-window). Does nothing if the speedbar-window is not visible
within the ECB-frame.
@end deffn

@deffn Command minor-mode &optional arg
Toggle ECB minor mode. With prefix argument @var{ARG}, turn on if
positive, otherwise off. Return non-@code{nil} if the minor mode is
enabled.
@end deffn

@deffn Command nav-goto-previous
Go backward in the navigation historylist, see @ref{Back/forward
navigation}.
@end deffn

@deffn Command nav-goto-next
Go forward in the navigation historylist, see @ref{Back/forward
navigation}.
@end deffn

@deffn Command rebuild-methods-buffer
Updates the methods buffer with the current buffer after deleting the
complete previous parser-information, means no semantic-cache is used!
Point must stay in an edit-window otherwise nothing is done. This
method is merely needed for semantic parsed buffers if semantic parses
not the whole buffer because it reaches a not parsable code or for
buffers not supported by semantic but by imenu or etags.

Examples when a call to this function can be necessary:

@itemize
@item
If an elisp-file is parsed which contains in the middle a defun X
where the closing ) is missing then semantic parses only until this
defun X is reached and you will get an incomplete ECB-method buffer.
In such a case you must complete the defun X and then call this
function to completely reparse the elisp-file and rebuild the ECB
method buffer!

@item
For not semantic supported buffers which can be parsed by imenu or
etags (see @code{ecb-process-non-semantic-files}) because for these
buffers there is no builtin auto-rebuild mechanism. For these buffers
this command calls @code{ecb-rebuild-methods-buffer-for-non-semantic}.
@end itemize
@end deffn

@deffn Command redraw-layout
Redraw the ECB screen. If the variable @code{ecb-redraw-layout-quickly} is
not nil then the redraw is done by the @code{ecb-redraw-layout-quickly}
function, otherwise by @code{ecb-redraw-layout-full}. But it's strongly
recommended to use the quick redraw only if you have really slow
machines where a full redraw takes several seconds because the quick
redraw is not really safe and may have some drawbacks! On normal
machines the full drawback should be done in << 1s!
@end deffn

@deffn Command restore-default-window-sizes
Resets the sizes of the ECB windows to their default values.
@end deffn

@deffn Command restore-window-sizes
Sets the sizes of the ECB windows to their stored values. See option
@code{ecb-layout-window-sizes} and command
@code{ecb-store-window-sizes}.
@end deffn

@deffn Command show-help &optional format
Shows the online help of ECB either in Info or in HTML format
depending of the value of @code{ecb-show-help-format}. If called with
prefix argument, i.e. if @var{FORMAT} is not nil then the user is
prompted to choose the format of the help (Info or HTML). If an error
about not finding the needed help-file occurs please take a look at
the options @code{ecb-help-info-start-file} and
@code{ecb-help-html-start-file}!

Note: If you got ECB as a standard XEmacs-package maybe the
HTML-online-documentation is not included.
@end deffn

@deffn Command show-layout-help
Select a name of a layout and shows the documentation of the
associated layout-function. At least for the buildin layouts the
documentation contains a picture of the outline of the choosen layout.
@end deffn

@deffn Command show-tip-of-the-day
Show tip of the day if @code{ecb-tip-of-the-day} is not nil or if
called interactively.
@end deffn

@deffn Command store-window-sizes &optional fix
Stores the sizes of the ECB windows for the current layout. The size
of the ECB windows will be set to their stored values when
@code{ecb-redraw-layout} or @code{ecb-restore-window-sizes} is called.
To reset the window sizes to their default values call
@code{ecb-restore-default-window-sizes}. Please read also the
documentation of @code{ecb-layout-window-sizes}!

The windows sizes are stored per default as fractions of current
frame-width and -height of the ecb-frame, so the stored values will
``work'' for other frame sizes too. But if @var{FIX} is not nil (means
called with a prefix argument) then the fixed values of current width
and height are stored!
@end deffn

@deffn Command submit-problem-report
Submit a problem report for the ECB to the ECB mailing-list. This
command generates in the edit-window a problem-report which contains
already the current values of all ECB options, the current
backtrace-buffer if there is any and the current message-buffer. You
will be asked for a problem-report subject and then you must insert a
description of the problem. Please describe the problem as detailed as
possible!
@end deffn

@deffn Command toggle-auto-expand-token-tree &optional arg
Toggle auto expanding of the ECB-methods-buffer. With prefix argument
@var{ARG}, make switch on if positive, otherwise switch off. If the
effect is that auto-expanding is switched off then the current value
of @code{ecb-auto-expand-token-tree} is saved so it can be used for
the next switch on by this command.
@end deffn

@deffn Command toggle-compile-window &optional arg
Toggle the visibility of the compile-window of ECB. With prefix
argument @var{ARG}, make visible if positive, otherwise invisible. The
height of the compile-window is always the current @strong{saved} (for
future sessions) value of @code{ecb-compile-window-height}, i.e. this
command can only display a compile-window if
@code{ecb-compile-window-height} has such a saved value of not
@code{nil}!
@end deffn

@deffn Command toggle-ecb-windows &optional arg
Toggle visibilty of the ECB-windows. With prefix argument @var{ARG},
make visible if positive, otherwise invisible. This has nothing to do
with (de)activating ECB but only affects the visibility of the ECB
windows. ECB minor mode remains active!
@end deffn

@deffn Command toggle-enlarged-compilation-window &optional arg
Toggle whether the @code{ecb-compile-window} is enlarged or not. If
@var{ARG} > 0 then enlarge to a sensefull value (see below), if
@var{ARG} <= 0 then shrink @code{ecb-compile-window} to
@code{ecb-compile-window-height} and if @var{ARG} is nil then toggle the
enlarge-state.

The @code{ecb-compile-window} is enlarged to the value of
@code{ecb-enlarged-compilation-window-max-height}.!
@end deffn

@deffn Command toggle-layout
Toggles between the layouts defined in
@code{ecb-toggle-layout-sequence} (See also option
@code{ecb-show-sources-in-directories-buffer}). Note: This function
works by changing the options @code{ecb-layout-name} but only for
current Emacs-session.
@end deffn

@deffn Command update-directories-buffer
Updates the ECB directories buffer.
@end deffn

@deffn Command upgrade-options
Check for all ECB-options if their current value is compatible to the
defined type. If not upgrade it to the new type or reset it to the
default-value of current ECB. Try also to upgrade renamed options.
Displays all upgraded or reset options with their old (before the
upgrade/reset) and new values.
@end deffn


Most of these functions are also available via the menu ``ECB'' and
also via the ECB keymap with prefix @kbd{C-c .} (see
@code{ecb-minor-mode} for a complete list of the keybindings).

@node Customizing, Submitting problem report, Usage of ECB, Top
@chapter Customizing ECB

This chapter describes how to customize ECB for your personal taste.
The first section introduces some general aspects (which you should
really know!), the second one gives an overview of the most important
options and the third one lists all options of ECB (divided into the
customize groups).

@menu
* General aspects::             General aspects for customizing ECB
* Most important options::      Which option you must know
* Customizable options::        All customizable options of ECB
@end menu

@node General aspects, Most important options, Customizing, Customizing
@section General aspects for customizing ECB

The best way to customize all the options of ECB is via the
customize-feature of (X)Emacs, i.e. means calling the commands
@code{customize-option} or @code{customize-group} etc. This is also
the strongly recommended way!

But of course you can also use @code{setq} or some elisp-code to
change the values of many but not all of the options. The values of
the following options @strong{MUST NOT} be changed via @code{setq} or
elisp-code but only with the customize-feature!

@multitable @columnfractions 0.5 0.5

@item @code{ecb-advice-window-functions}
@tab @code{ecb-bucket-token-display}
@item @code{ecb-compile-window-height}
@tab @code{ecb-compile-window-temporally-enlarge}
@item @code{ecb-exclude-parents-regexp}
@tab @code{ecb-font-lock-tokens}
@item @code{ecb-highlight-token-with-point-delay}
@tab @code{ecb-key-map}
@item @code{ecb-layout-name}
@tab @code{ecb-layout-window-sizes}
@item @code{ecb-mode-line-prefixes}
@tab @code{ecb-show-node-info-in-minibuffer}
@item @code{ecb-show-tokens}
@tab @code{ecb-source-path}
@item @code{ecb-token-display-function}
@tab @code{ecb-tree-RET-selects-edit-window}
@item @code{ecb-type-token-display}
@tab @code{ecb-windows-height}
@item @code{ecb-window-sync-delay}
@tab @code{ecb-windows-width}
@item @code{ecb-use-speedbar-instead-native-tree-buffer}
@tab @code{ecb-toggle-layout-sequence}
@item @code{ecb-mode-line-data}
@end multitable

@strong{NOTE}: If you are the administrator for an Emacs-site, means
you are responsible for the basic customization of a lot of Emacs
users, then you maybe need a way to customize Emacs and ECB without
changing everyones @file{.emacs}-file and normally you will do this
with the file @file{site-start.el}. You can customize all options of
ECB in a central @file{site-start.el} (even the options mentioned
above!) but you @strong{MUST NOT} do this via @code{setq} but you have
to use @code{custom-set-variables}@footnote{At least for the options
for which @code{setq} is explicitly forbidden, but it is recommended
to use always @code{custom-set-variables}!}! Here is a short example
how this can be done:

@example
@group
(custom-set-variables '(ecb-show-tokens ((include collapsed nil)
                                         (parent collapsed nil)
                                         (type flattened nil)
                                         (variable collapsed name)
                                         (function flattened name)
                                         (rule flattened name)
                                         (section flattened nil)
                                         (def collapsed name)
                                         (t collapsed name)))
                      '(ecb-font-lock-tokens t)
                      ;; add here more options of ECB it you want
                      )
@end group
@end example

But ensure that you customize the options with the correct lisp
format. Read carefully the docstrings of the options you want
to customize from within elisp-code!

@node Most important options, Customizable options, General aspects, Customizing
@section 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):

@table @code
@item ecb-source-path
Where ECB can find your sources. You must set this option!
@item 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.
@item  ecb-auto-activate
@itemx ecb-major-modes-activate
@itemx ecb-major-modes-deactivate
Auto. (de)activation of ECB
@item ecb-key-map
All ECB-keybindings incl. a common prefixkey (@pxref{Using the
keyboard}).
@item ecb-new-ecb-frame
Should ECB create a new frame at activation time.
@item  ecb-primary-secondary-mouse-buttons
@itemx ecb-primary-mouse-jump-destination
Define how to use the mouse (@pxref{Using the mouse}).
@item  ecb-tree-expand-symbol-before
@itemx 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
(@pxref{Changing the ECB-layout}).
@item ecb-source-file-regexps
Which files will (not) be shown in ECB.
@item ecb-show-node-info-in-minibuffer
When and which node-info should be displayed in the minibuffer?
@item ecb-layout-name
The ECB layout, means which windows you want to be displayed in the
ECB-frame and also the location of these windows (@pxref{Changing the
ECB-layout}).
@item  ecb-token-display-function
@itemx ecb-type-token-display
@itemx ecb-show-tokens
How to display the entries in the ECB-method window for semantic
supported sources (@pxref{Customizing the display}). These options
take only effect for semantic-sources (@pxref{Definiton of semantic-
and non-semantic-sources}).
@item ecb-process-non-semantic-files
Displaying file-contents for not by semantic supported files too, e.g.
for LaTeX- and perl-sources.
@end table

But to make ECB working best for you it is also recommened to have a
look at @ref{Customizable options}!

@node Customizable options, ,Most important options, Customizing
@section All customizable options of ECB

@noindent
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.

@strong{Note}: All options in the following subsections are listed
without the prefix ``ecb-'' (e.g. the option @code{ecb-layout-name} is
listed with name ``layout-name''). This has been done for a better
readable option index. @xref{Option Index}.

@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-compilation-content::     Customizing the compile-window contents
* ecb-create-layout::           Customizing options for creating layouts
* 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
* ecb-eshell::                  Customizing the eshell-integration
* ecb-non-semantic::            Customizing parsing non-semantic sources
@end menu

@node ecb-general, ecb-directories, Customizable options, Customizable options
@subsection Group ecb-general

@noindent
This group contains the following options:

@defopt activate-before-layout-draw-hook
Normal hook run at the end of activating the ecb-package by running
@code{ecb-activate}. This hooks are run after all the internal setup
process but directly before(!) drawing the layout specified in
@code{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
@code{ecb-activate-hook}.

IMPORTANT: The difference between this hook and
@code{ecb-redraw-layout-before-hook} is that the latter one is
evaluated always before the layout is redrawn (for example after
calling @code{ecb-redraw-layout}) whereas the former one (this hook)
is only evaluated exactly once during the activation-process of ECB.
So during the activation process there is the following sequence of
hooks:
@enumerate
@item @code{ecb-activate-before-layout-draw-hook} \(this one)
@item @code{ecb-redraw-layout-before-hook}
@item <Drawing the layout>
@item @code{ecb-redraw-layout-after-hook}
@item @code{ecb-activate-hook}
@end enumerate
@end defopt

@defopt activate-hook
Normal hook run at the end of activating the ecb-package by running
@code{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
@code{ecb-activate-before-layout-draw-hook}.
@end defopt

@defopt auto-activate
Automatically startup ECB when Emacs starts up. This should only be
true if you always want to run @code{ecb-activate}.
@end defopt

@defopt 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 @code{ecb-upgrade-options} and
@code{ecb-display-upgraded-options}. If this option is off then the
user can perform the check and reset manually with
@code{ecb-upgrade-options}.
@xref{Auto. option-upgrading}.
@end defopt

@defopt before-activate-hook
Normal hook run at the beginning of activating the ecb-package by
running @code{ecb-activate}. These hooks run before any other tasks of
the activating process are performed. If any of these hooks returns
nil then ECB will not be activated!

This can be used to check some conditions and then only start ECB if
all conditions are true. For example a function could be added which
returns only nil if Gnus is running. Then calling @code{ecb-activate}
or @code{ecb-minor-mode} will only start ECB if Gnus is not already
running.
@end defopt

@defopt before-deactivate-hook
Normal hook run at the beginning of deactivating ECB by running
@code{ecb-deactivate}. These hooks run before any other tasks of the
deactivating process are performed. If any of these hooks returns nil
then ECB will not be deactivated! See also
@code{ecb-before-activate-hook}.
@end defopt


@defopt common-tree-buffer-after-create-hook
Local hook running at the end of each tree-buffer creation. Every
function of this hook is called once without arguments direct after
creating a tree-buffer of ECB and it's local keymap. So for example a
function could be added which performs calls of @code{local-set-key}
to define new keybindings for EVERY tree-buffer.

The following keys must not be rebind in all tree-buffers:
@itemize @minus
@item @kbd{RET} and all combinations with @kbd{Shift} and @kbd{Ctrl}
@item @kbd{TAB}
@item @code{C-t}
@end itemize
@end defopt


@defopt current-buffer-sync-hook
Normal hook run at the end of @code{ecb-current-buffer-sync}.

See documentation of @code{ecb-current-buffer-sync} for conditions when
synchronization takes place and so in turn these hooks are evaluated.

Precondition for such a hook:
Current buffer is the buffer of the current selected edit-window.

Postcondition for such a hook:
Point must stay in the same edit-window as before evaluating the hook.

Important note: If @code{ecb-window-sync} is not nil
@code{ecb-current-buffer-sync} is running either every time Emacs is
idle or even after every command (see @code{ecb-window-sync-delay}).
So these hooks can be really called very often! Therefore each
function of this hook should/must check in an efficient way at
beginning if its task have to be really performed and then do them
only if really necessary! Otherwise performance of Emacs could slow
down dramatically!

It is strongle recommended that each function added to this hook uses
the macro @code{ecb-do-if-buffer-visible-in-ecb-frame} at beginning!
See @code{ecb-speedbar-current-buffer-sync} and
@code{ecb-eshell-current-buffer-sync} for examples how to use this
macro!
@end defopt



@defopt deactivate-hook
Normal hook run at the end of deactivating (but before the ecb-layout
is cleared!) ECB by running @code{ecb-deactivate}.
@end defopt

@defopt 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 (@code{ecb-submit-problem-report}) after getting the
error again!
@end defopt

@defopt 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:

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

@table @code
@item <common-prefix-flag>
If t then the common-prefixkey defined as car of the value (see above)
is used.

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

@item <function>:
The function to bind to the key. This can also be a lambda-expression
.
@end table

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 @code{read-kbd-macro} or @code{kbd}. This means you
can insert the key in the same manner @kbd{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 @kbd{C-c SPC}.

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

@item
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.

@item
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 ĸ.

@item
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.

@item
The @code{^} notation for control characters also works: ^M = C-m.
@end itemize

@end defopt

@defopt major-modes-activate
List of major-modes for which ECB shoulb be activated or shown. Do not
mistake this option with @code{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 @code{ecb-layout-name}:

@itemize @minus
@item @code{default}:
The value customized with @code{ecb-layout-name} is choosen.
@item a string:
ECB is activated with this layout-name. This changes the value of
@code{ecb-layout-name} 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!
@end itemize

There are two additional options:

@itemize @minus
@item @code{none}:
No major-modes should activate ECB automatically.
@item a regexp:
This means all major-modes which are not listed in
@code{ecb-major-modes-deactivate} activate ECB except the symbol-name
of @code{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.
@end itemize

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.
@end defopt

@defopt 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:

@itemize @minus
@item @code{hide}:
ECB just hides all the ECB windows like with @code{ecb-hide-ecb-windows}.
@item @code{deactivate}:
ECB is completely deactivated after activating the major-mode.
@end itemize

There are two additional options:

@itemize @bullet
@item @code{none}:
No major-modes should deactivate/hide ECB automatically.

@item A cons for the meaning ``All except the activated modes of
@code{ecb-major-modes-activate}''. The car of this cons can be:

@itemize @minus
@item @code{hide-all-except-activated}:
All major-modes which are not listed in
@code{ecb-major-modes-activate} hide the ECB-windows.
@item @code{deactivate-all-except-activated}:
All major-modes which are not listed in
@code{ecb-major-modes-activate} deactivate ECB.
@end itemize

The cdr of this cons is a regexp: This means all major-modes which are
not listed in @code{ecb-major-modes-activate} deactivate/hide ECB
except the symbol-name of @code{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.
@end itemize

If a major-mode is listed in @code{ecb-major-modes-activate} as well
as in @code{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.

There is one exception from this rule: If the edit-window is splitted
and one window contains a dired-buffer and a ``ECB-deactivating''-file
is openend via dired then opening this file deactivates ECB (resp.
hides the ECB-windows).
@end defopt

@defopt 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.)
@end defopt

@defopt mode-line-data
Data shown in the modelines of the standard ECB tree-buffers. For
every ECB-tree-buffer there are two predefined values:

@itemize @minus
@item ECB-directories:
@code{selected} (current selected directory) and nil (Nothing).
@item ECB-sources:
@code{selected} (current selected directory) and nil (Nothing).
@item ECB-methods:
@code{selected} (current selected source) and nil (Nothing).
@item ECB-history:
nil (Nothing).
@end itemize

In addition for every tree-buffer a function can be specified which
gets three args (name of the tree-buffer, current selected directory
and current selected source-file) and must return a string which will
be displayed in the modeline.

The whole modeline of the tree-buffer consists of the prefix of
@code{ecb-mode-line-prefixes} and the data of
@code{ecb-mode-line-data}.
@end defopt


@defopt 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.
@end defopt

@defopt primary-mouse-jump-destination
Jump-destination of a primary mouse-button click (see
@code{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:

@itemize @minus
@item @code{left-top}:
Does the ``right'' action always in the left/topmost edit-window.
@item @code{last-point}:
Does the ``right'' action always in that edit-window which had the point
before.
@end itemize

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

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

@defopt 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:

@itemize @bullet
@item ECB Directories:
Expanding/collapsing nodes and displaying files in the ECB
Sources buffer.

@item ECB sources/history:
Opening the file in that edit-window specified by the option
@code{ecb-primary-mouse-jump-destination}.

@item ECB Methods:
Jumping to the method in that edit-window specified by the option
@code{ecb-primary-mouse-jump-destination}.
@end itemize

A click with the primary mouse-button while the SHIFT-key is pressed called
the POWER-click and does the following (depending on the ECB-buffer where the
POWER-click occurs):

@itemize @bullet
@item ECB Directories:
Refreshing the directory-contents-cache (see
@code{ecb-cache-directory-contents}).

@item ECB sources/history:
Only displaying the source-contents in the method-buffer but not
displaying the source-file in the edit-window.

@item ECB Methods:
Narrowing to the clicked method/variable/ect... (see
@code{ecb-token-jump-narrow}). This works only for semantic supported
sources but not for imenu- or etags-supported ones!
@end itemize

In addition always the whole node-name is displayed in the minibuffer after a
POWER-click \(for this see also `ecb-show-node-info-in-minibuffer').

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

The following combinations are possible:

@itemize @minus
@item
primary: mouse-2, secondary: C-mouse-2 (means mouse-2 while CTRL-key is
pressed). This is the default setting.
@item
primary: mouse-1, secondary: C-mouse-1
@item
primary: mouse-1, secondary: mouse-2
@end itemize

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

@defopt 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:

@itemize @minus
@item @code{always}:
Node info is displayed by moving with the mouse over a node.
@item @code{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 @code{ecb-source-path}).
@item @code{shift-click}:
Node info is only displayed after a shift click with the primary mouse
button onto the node.
@item @code{never}:
Node info is never displayed.
@end itemize

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

@itemize @bullet
@item Directory-buffer:
@itemize @minus
@item @code{name}: Only the full node-name is displayed.
@item @code{path}: The full-path of the node is displayed.
@end itemize

@item Sources-buffer:
@itemize @minus
@item @code{name}: Only the full node-name is displayed.
@item @code{file-info}: File infos for this file are displayed.
@item @code{file-info-full}: Fill infos incl. full path for this file are
displayed.
@end itemize
@item History-buffer: see Directories-buffer.
@item Methods-buffer:
@itemize @minus
@item @code{name}: Only the full node name is displayed.
@item @code{name+type}: The full name + the type of the node (function, class,
variable) is displayed.
@end itemize
@end itemize

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

@defopt tip-of-the-day
Show tip of the day at start time of ECB.
@end defopt

@defopt tip-of-the-day-file
File where tip-of-the-day cursor is stored.
@end defopt

@defopt 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 @code{ecb-directories-buffer-name}: Of course
here the edit-window is only selected if
@code{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 @code{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!
@end defopt


@defopt tree-easy-hor-scroll
Scroll step for easy hor. scrolling via mouse-click in tree-buffers.
XEmacs has horizontal scroll-bars so invisible parts beyond the right
window-border of a tree-buffer can always made visible very easy.

GNU Emacs does not have hor. scroll-bars so especially with the mouse
it is quite impossible to scroll smoothly right and left. The
functions @code{scroll-left} and @code{scroll-right} can be annoying
and are also not bound to mouse-buttons.

If this option is a positive integer S then in all ECB-tree-buffers
the keys @kbd{M-mouse-1} and @code{M-mouse-3} are bound to scrolling
left resp. right with scroll-step S - clicking with @kbd{mouse-1} or
@kbd{mouse-2} onto the edge of the modeline has the same effect, i.e.
if you click with mouse-1 onto the left (resp right) egde of the
modeline you will scroll left (resp. right).

Additionally @code{C-M-mouse-1} and @code{C-M-mouse-3} are bound to
scrolling left resp. right with scroll-step @code{window-width} - 2.

Default is a scroll-step of 5. If the value is @code{nil} then no keys
for horizontal scrolling are bound.
@end defopt


@defopt tree-expand-symbol-before
Show the expand symbol before the items in a tree.
@end defopt

@defopt tree-incremental-search
Enable incremental search in the ECB-tree-buffers. For a detailed
explanation see @ref{Using the keyboard}. If you change this
during ECB is activated you must deactivate and activate ECB again to
take effect.
@end defopt

@defopt 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.
@end defopt

@defopt 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:

@itemize @bullet
@item 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).

@item 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.
@end itemize

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

@defopt tree-use-image-icons
Use icons for expand/collapse tokens instead of the ascii-strings. If
true the ECB displays in its tree-buffers the expand- and collapse
symbols with appropriate icons - the icons are the same as used by
speedbar.
@end defopt


@defopt 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.
@end defopt

@defopt 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.
@end defopt

@defopt use-recursive-edit
Tell ECB to use a recursive edit so that it can easily be deactivated
by (keyboard-escape-quit).
@end defopt

@defopt version-check
If not @code{nil} ECB checks at start-time if the required versions of
semantic, eieio and speedbar are installed and loaded into Emacs. It
is strongly recommended to set this option to not @code{nil}!
@end defopt

@defopt window-sync
Synchronize the ECB-windows automatically with current edit window.
The real synchronization is done by @code{ecb-current-buffer-sync}. If
@code{always} then the synchronization by
@code{ecb-current-buffer-sync} takes place always a buffer changes in
the edit window, if @code{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 by
@code{ecb-current-buffer-sync} 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,
@code{Info-mode} too, an example for the latter one is
@code{dired-mode}. For all major-modes related to
non-file/directory-buffers like @code{help-mode},
@code{customize-mode} and others never an autom. synchronization will
be done!

It's recommended to exclude at least @code{Info-mode} because it makes
no sense to synchronize the ECB-windows after calling the Info help.
Per default also @code{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.

IMPORTANT NOTE: The synchronization is done by
@code{ecb-current-buffer-sync} and therefore the hook
@code{ecb-current-buffer-sync-hook} is evaluated every time
@code{ecb-current-buffer-sync} is called (see above and documentation
of @code{ecb-current-buffer-sync})!
@end defopt


@defopt 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.
@end defopt

@node ecb-directories, ecb-sources, ecb-general, Customizable options
@subsection Group ecb-directories

@noindent
This group contains the following options:

@defopt add-path-for-not-matching-files
Add path of a file to @code{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
@code{ecb-source-path} at least temporally for the current Emacs
session. This option defines two things:

@enumerate
@item
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 @code{ecb-source-path} or the whole directory-part?
@item
Should this path be added for future sessions too?
@end enumerate

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 @code{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.
@end defopt

@defopt auto-expand-directory-tree
Automatically expand the directory tree to the current source file.
There are three options:

@itemize @minus
@item @code{best}: Expand the best-matching source-path
@item @code{first}: Expand the first matching source-path
@item @code{nil}: Do not automatically expand the directory tree.
@end itemize
@end defopt

@defopt cache-directory-contents
Cache contents of directories.

This can be useful if @code{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 is a cons-cell
and looks like:

@example
  (<dir-regexp> . <filenumber threshold>) with
@end example

@table @code
@item <dir-regexp>:
Regular expression a directory must match to be cached.
@item <filenumber threshold>:
Number of directory contents must exceed this number.
@end table

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

The cache entry for a certain directory will be refreshed and
actualized only by using the POWER-click (see
@code{ecb-primary-secondary-mouse-buttons}) in the directories-buffer
of ECB (@pxref{Using the mouse}).

Examples:

A value of @code{("~/bigdir*" . 1000)} means the contents of every
subdirectory of the home-directory will be cached if the directory
contains more than 1000 entries and its name begins with ``bigdir''.

A value of @code{(".*" . 1000)} caches every directory which has more
than 1000 entries.

A value of @code{(".*" . 0)} caches every directory regardless of the
number of entries."
@end defopt

@defopt directories-buffer-after-create-hook
Local hook running after the creation of the directories-buffer. Every
function of this hook is called once without arguments direct after
creating the directories-buffer of ECB and it's local keymap. So for
example a function could be added which performs calls of
@code{local-set-key} to define new keybindings only for the
directories-buffer of ECB.

The following keys must not be rebind in the directories-buffer:
@kbd{F2}, @kbd{F3} and @kbd{F4}
@end defopt


@defopt 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 @code{set-buffer}.

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

@defopt directories-menu-sorter
Function which re-sorts the menu-entries of the directories buffer.

If a function then this function is called to re-arrange the
menu-entries of the combined menu-entries of the user-menu-extensions
of @code{ecb-directories-menu-user-extension} and the builtin-menu
@code{ecb-directories-menu}. If nil then no special sorting will be
done and the user-extensions are placed in front of the
builtin-entries.

The function get one argument, a list of menu-entries. For the format
of this argument see @code{ecb-directories-menu-user-extension}. The
function must return a new list in the same format. Of course this
function can not only re-arrange the entries but also delete entries
or add new entries.
@end defopt



@defopt directories-menu-user-extension
User extensions for the popup-menu of the directories buffer.

Value is a list of elements of the following type: Each element
defines a new menu-entry and is a list containing two subelements,
whereas the first is the name of the menu-entry and the second the
function (a function symbol or a lambda-expression) being called if
the menu-entry is selected. If there is no second subelement and the
first one is the string ``---'' then a non-selectable menu-separator
is displayed.

The function must follow the following guidelines: It takes one
argument which is the tree-buffer-node of the selected node (means the
node for which the popup-menu has been opened). With the function
@code{tree-node-get-data} the related data of this node is accessible
and returns in case of the directories buffer the directory for which
the popup-menu has been opened. The function can do any arbitrary
things with this directory.

Example for such a menu-function:

@example
(defun ecb-my-special-dir-popup-function (node)
  (let ((node-data=dir (tree-node-get-data node)))
     (message "Dir under node: %s" node-data=dir)))
@end example

Per default the user-extensions are added at the beginning of the
builtin menu-entries of @code{ecb-directories-menu} but the whole menu
can be re-arranged with @code{ecb-directories-menu-sorter}.

If you change this option you have to restart ECB to take effect.
@end defopt



@defopt excluded-directories-regexp
Specifies directories that should not be included in the directories
list. The value of this variable should be a regular expression.
@end defopt

@defopt grep-function
Function used for performing a grep. The popup-menu of the
tree-buffers ``Directories'', ``Sources'' and ``History'' offer to
grep the ``current'' directory:
@itemize @minus
@item
Directory-buffer: The grep is performed in the current popup-directory
after clicking the right mouse-button onto a node.
@item
Sources-buffer: The grep is performed in the current selected directory.
@item
History-buffer: The grep is performed in the directory of the current
popup-source after clicking the right mouse-button onto a node.
@end itemize
@end defopt

@defopt grep-find-function
Function used for performing a recursive grep. For more Details see
option `ecb-grep-function' and replace ``grep'' with ``recursive
grep''.
@end defopt


@defopt show-sources-in-directories-buffer
Show source files in directories buffer.
@end defopt

@defopt 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.
@end defopt

@defopt use-speedbar-instead-native-tree-buffer
If true then uses speedbar for directories, sources or methods. This
means that speedbar is integrated in the ECB-frame and is displayed in
that window normally displaying the standard ECB-directories-buffer,
ECB-sources-buffer or ECB-methods-buffer.

This option takes effect in all layouts which contain either a
directory window, a sources window or a method window.

This option can have four valid values:
@itemize @minus
@item @code{nil}: Do not use speedbar (default)
@item @code{dir}: Use speedbar instead of the standard directories-buffer
@item @code{source}: Use speedbar instead of the standard sources-buffer
@item @code{method}: Use speedbar instead of the standard methods-buffer
@end itemize

Note: For directories and sources a similar effect and useability is
available by setting this option to @code{nil} (or @code{method}) and
setting @code{ecb-show-sources-in-directories-buffer} to not
@code{nil}, because this combination displays also directories and
sources in one window.

@code{ecb-use-speedbar-instead-native-tree-buffer} is for people who
like the speedbar way handling directories and source-files or methods
and want it in conjunction with ECB.
@end defopt


@node ecb-sources, ecb-methods, ecb-directories, Customizable options
@subsection Group ecb-sources

@noindent
This group contains the following options:

@defopt show-source-file-extension
Show the file extension of source files.
@end defopt

@defopt source-file-regexps
Specifies which files are shown as source files.

This is done on directory-base, which means for each directory-regexp
the files to display can be specified. If more than one
direcory-regexp matches the current selected directory then always the
first one (and its related file-exclude/include-regexps) is used! If
no directory-regexp matches then all files are displayed for the
currently selected directory.

Important note: It is recommended that the *LAST* element of this list
should contain an always matching directory-regexp (@code{".*"})!

So the value of this option is a list of cons-cells where the car is a
directory regexp and the cdr is a 2 element list where the first
element is a exclude regexp and the second element is a 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.

But regardless of the value of this option a file F is never displayed
in the sources-buffer if the directory matches
@code{ecb-sources-exclude-cvsignore} and the directory contains a file
.cvsignore which contains F as an entry!

There are three predefined and useful combinations of an exclude and
include regexp:

@itemize @bullet
@item All files

@item 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)

@item Common source file types (.c, .java etc.)
@end itemize

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

Tips for the directory- and file-rexexps: @code{"$^"} matches no
files/directories, @code{".*"} matches all files/directories.
@end defopt

@defopt sources-buffer-after-create-hook
Local hook running after the creation of the sources-buffer. Every
function of this hook is called once without arguments direct after
creating the sources-buffer of ECB and it's local keymap. So for
example a function could be added which performs calls of
@code{local-set-key} to define new keybindings only for the
sources-buffer of ECB.
@end defopt


@defopt 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 @code{set-buffer}.

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


@defopt sources-exclude-cvsignore
Specify if files contained in a @file{.cvsignore} should be
excluded.

Value is a list of regular expressions or nil. If you want to exclude
files listed in a @file{.cvsignore}-file from being displayed in the
ecb-sources-buffer then specify a regexp for such a directory.

If you want to exclude the contents of @file{.cvsignore}-files for
every directory then you should add one regexp ``.*'' which matches
every directory.

If you never want to exclude the contents of @file{.cvsignore}-files
then set this option to nil.
@end defopt


@defopt sources-menu-sorter
Function which re-sorts the menu-entries of the directories buffer.

If a function then this function is called to sort the menu-entries of
the combined menu-entries of the user-menu-extensions of
@code{ecb-sources-menu-user-extension} and the builtin-menu
@code{ecb-sources-menu}. If nil then no special sorting will be done
and the user-extensions are placed in front of the builtin-entries.

For the guidelines for such a sorter-function see
@code{ecb-directories-menu-sorter}.
@end defopt



@defopt sources-menu-user-extension
User extensions for the popup-menu of the sources buffer.

For further explanations see
@code{ecb-directories-menu-user-extension}.

The node-argument of a menu-function contains as data the filename of
the source for which the popup-menu has been opened.

Per default the user-extensions are added at the beginning of the
builtin menu-entries of @code{ecb-sources-menu} but the whole menu can
be re-arranged with @code{ecb-sources-menu-sorter}.

If you change this option you have to restart ECB to take effect.
@end defopt


@defopt sources-sort-method
Defines how the source files are sorted.

@itemize @minus
@item @code{name}:
Sorting by name.
@item @code{extension}:
Sorting first by name and then by extension.
@item @code{nil}:
No sorting, means source files are displayed in the sequence returned
by @code{directory-files} (called without sorting).
@end itemize
@end defopt


@node ecb-methods, ecb-history, ecb-sources, Customizable options
@subsection Group ecb-methods

@noindent
This group contains the following options:

@defopt auto-expand-token-tree
Expand the methods-token-tree automatically if node invisible.

This option has only an effect if option @code{ecb-highlight-token-with-point} is
switched on too. There are three possible choices:
@itemize @minus
@item @code{nil}:
No auto. expanding of the method buffer.
@item @code{expand-spec}:
Auto expand the method-buffer nodes if the node belonging to current
token under point is invisible because its parent-node is collapsed.
But expanding is only done if the type of the token under point in the
edit-buffer is contained in @code{ecb-methods-nodes-expand-spec}.
@item @code{all}:
Like expand-spec but expands all tokens regardess of the setting in
@code{ecb-methods-nodes-expand-spec}.
@end itemize

This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt


@defopt auto-update-methods-after-save
Automatically updating the ECB method buffer after saving the current
source-buffer.
@end defopt

@defopt 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 @code{("["
"]" nil)} which means no special face and a display like ``[+]
[<bucket-name>]''.

This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt

@defopt exclude-parents-regexp
Regexp which parent classes should not be shown in the methods buffer
(see also @code{ecb-show-parents}). If nil then all parents will be
shown if @code{ecb-show-parents} is not nil.

This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt

@defopt expand-methods-switch-off-auto-expand
Switch off auto expanding in the ECB-method buffer after explicit
expanding or collapsing by @code{ecb-expand-methods-nodes}.

This is done with @code{ecb-toggle-auto-expand-token-tree} so after
the switch off the auto expanding feature can again switched on
quickly.

But after explicitly expanding/collapsing the methods-buffer to a
certain level the auto. expanding could undo this when the node
belonging to current token under point in the edit-window is invisible
after @code{ecb-expand-methods-nodes} - then the auto. expand feature
would make this node immediatelly visible and destroys the explicitly
set expand-level.
@end defopt


@defopt font-lock-tokens
Adds font-locking (means highlighting) to the ECB-method buffer.

This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt

@defopt 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 @code{ecb-token-header-face} is used.
@end defopt

@defopt highlight-token-with-point
How to highlight the method or variable under the cursor.

@itemize @minus
@item @code{highlight-scroll}:
Always scroll the method buffer, so the current method of the
edit-window is highlighted in the method-window.
@item @code{highlight}:
Only highlight the current method of the edit window in the
method window if the method is visible in the method-window.
@item @code{nil}:
No highlighting is done.
@end itemize

See also @code{ecb-highlight-token-with-point-delay}.

This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt

@defopt 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.

This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt

@defopt methods-buffer-after-create-hook
Local hook running after the creation of the methods-buffer. Every
function of this hook is called once without arguments direct after
creating the methods-buffer of ECB and it's local keymap. So for
example a function could be added which performs calls of
@code{local-set-key} to define new keybindings only for the
methods-buffer of ECB.
@end defopt


@defopt 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 @code{set-buffer}.

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

@defopt methods-menu-sorter
Function which re-sorts the menu-entries of the directories buffer.

If a function then this function is called to sort the menu-entries of
the combined menu-entries of the user-menu-extensions of
@code{ecb-methods-menu-user-extension} and the builtin-menu
@code{ecb-methods-menu}. If nil then no special sorting will be done
and the user-extensions are placed in front of the builtin-entries.

For the guidelines for such a sorter-function see
@code{ecb-directories-menu-sorter}.
@end defopt



@defopt methods-menu-user-extension
User extensions for the popup-menu of the methods buffer.

For further explanations see
@code{ecb-directories-menu-user-extension}.

The node-argument of a menu-function contains as data the
semantic-token of the method/variable/token for which the popup-menu
has been opened.

Per default the user-extensions are added at the beginning of the
builtin menu-entries of @code{ecb-methods-menu} but the whole menu can
be re-arranged with @code{ecb-methods-menu-sorter}.

If you change this option you have to restart ECB to take effect.
@end defopt



@defopt methods-nodes-collapse-spec
Semantic token-types collapsed by @code{ecb-expand-methods-nodes}.
For valid values of this option see @code{ecb-methods-nodes-expand-spec}!

This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt


@defopt methods-nodes-expand-spec
Semantic token-types expanded by @code{ecb-expand-methods-nodes}.

The value of this option is either the symbol @code{all} (all tokens
are expanded regardless of their type) or a list of symbols where each
symbol is a valid semantic token-type. For a description of semantic
token types see option @code{ecb-show-tokens}.

But this option also defines if bucket-nodes in the ECB-method-buffer (e.g.
``[Variables]'') should be expanded. Therefore valid symbols for this list
are also all cars of the variable @code{semantic-symbol->name-assoc-list}.

If there is a bucket-name (the node-name stripped of the settings in
@code{ecb-bucket-token-display}) which is not contained as cdr in
@code{semantic-symbol->name-assoc-list} then the symbol with this bucket-name as
name is also a valid symbol for this list. Example: In ECB there are buckets
``[Parents]''. The bucket-name is ``Parents'' and the valid symbol-name is
then @code{Parents}.

This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt



@defopt 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 @code{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
@code{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.

This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt

@defopt scroll-window-after-jump
How to scroll the window when jumping to a token.
@end defopt

@defopt 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 @code{defclass} form which are only displayed
if this option is nil. Displaying such nodes can be sensefull even if
they can not be jumped.

This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt

@defopt show-tokens
How to show tokens in the methods buffer first time after find-file.
This variable is a list where each element represents a type of
tokens:

@example
(<token type> <display type> <sort method>)
@end example

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

@table @code
@item <token type>
A Semantic token type symbol (function, variable, rule, include etc.)
or one of the following:

@itemize @minus
@item @code{t}: All token types not specified anywhere else in the list.
@item @code{parent}: The parents of a type.
@end itemize

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

@itemize @minus
@item @code{expanded}: The tokens are shown in an expanded node.
@item @code{collapsed}: The tokens are shown in a collapsed node.
@item @code{flattened}: The tokens are added to the parent node.
@item @code{hidden}: The tokens are not shown.
@end itemize

@item <sort method>
A symbol describing how to sort the tokens of this type:

@itemize @minus
@item @code{name}:
Sort by the token name.
@item @code{access}:
Sort by token access (public, protected, private) and then by name.
@item @code{nil}:
Don't sort tokens. They appear in the same order as in the source
buffer.
@end itemize
@end table


This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt

@defopt 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:

@itemize @minus
@item
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.
@item
The cdr is the function used for displaying a token in the related
major-mode.
@end itemize

Every function is called with 3 arguments:

@enumerate
@item The token
@item The parent-token of token (can be nil)
@item The value of @code{ecb-font-lock-tokens}.
@end enumerate

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

The following functions are predefined:

@itemize @bullet
@item
All functions of @code{semantic-token->text-functions}.

@item
For every function in @code{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:

@itemize @minus
@item
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).
@item
The ECB-version displays type-tokens according to the setting in
@code{ecb-type-token-display}. This is useful for better recognizing
different classes, structs etc. in the ECB-method window.
@end itemize

For all tokens which are not types the display of the ECB-version is
identical to the semantic version. Example: For @code{semantic-name-nonterminal}
the pendant is @code{ecb-name-nonterminal}.
@end itemize

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

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

This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt

@defopt 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 @code{widen} (@kbd{C-x n w}).

Note: The same effect can be achieved by using the POWER-click in the
methods-buffer (@pxref{Using the mouse}).

This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt

@defopt token-jump-sets-mark
Jumping to a token from the ECB-method buffer now sets the mark so the
user can easily jump back.
@end defopt

@defopt 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 @code{semantic-face-alist} and the semantic
display-function (e.g. one from
@code{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 @code{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:

@itemize @bullet
@item
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.

@item
The cdr is a list of 3-element-lists:

@enumerate
@item
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 @code{ecb-post-process-semantic-tokenlist} and
@code{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.
@item
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.
@item
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 (@code{ecb-type-token-class-face},
@code{ecb-type-token-struct-face}, @code{ecb-type-token-typedef-face},
@code{ecb-type-token-enum-face} and @code{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).
@end enumerate
@end itemize

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:

@example
@group
((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)))
@end group
@end example

This means that in @code{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
@code{ecb-token-display-function},
@code{ecb-group-function-tokens-with-parents}) have special faces and
the ``class'' specifier-string is removed from the display.

This options takes only effect for semantic-sources - means sources
supported by semantic!
@end defopt


@node ecb-history, ecb-layout, ecb-methods, Customizable options
@subsection Group ecb-history

@noindent
This group contains the following options:

@defopt clear-history-behavior
Defines which entries of the history buffer should be deleted if
@code{ecb-clear-history} is called. Three options are available:

@itemize @minus
@item @code{not-existing-buffers}:
All entries which represent a buffername not existing
anymore in the bufferlist will be cleared. Probably the most senseful value.
@item @code{existing-buffers}:
The opposite of 'not-existing-buffers.
@item @code{all}:
The whole history will be cleared.
@end itemize
@end defopt

@defopt history-buffer-after-create-hook
Local hook running after the creation of the history-buffer. Every
function of this hook is called once without arguments direct after
creating the history-buffer of ECB and it's local keymap. So for
example a function could be added which performs calls of
@code{local-set-key} to define new keybindings only for the
history-buffer of ECB.
@end defopt


@defopt 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 @code{set-buffer}.

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

@defopt history-item-name
The name to use for items in the history buffer.
@end defopt

@defopt history-menu-sorter
Function which re-sorts the menu-entries of the directories buffer.

If a function then this function is called to sort the menu-entries of
the combined menu-entries of the user-menu-extensions of
@code{ecb-history-menu-user-extension} and the builtin-menu
@code{ecb-history-menu}. If nil then no special sorting will be done
and the user-extensions are placed in front of the builtin-entries.

For the guidelines for such a sorter-function see
@code{ecb-directories-menu-sorter}.
@end defopt



@defopt history-menu-user-extension
User extensions for the popup-menu of the history buffer.

For further explanations see
@code{ecb-directories-menu-user-extension}.

The node-argument of a menu-function contains as data the filename of
the source for which the popup-menu has been opened.

Per default the user-extensions are added at the beginning of the
builtin menu-entries of @code{ecb-history-menu} but the whole menu can
be re-arranged with @code{ecb-history-menu-sorter}.

If you change this option you have to restart ECB to take effect.
@end defopt


@defopt kill-buffer-clears-history
Define if @code{kill-buffer} should also clear the history. There are
three options:

@itemize @minus
@item @code{auto}:
Removes automatically the corresponding history-entry after the buffer
has been killed.
@item @code{ask}:
Asks, if the history-entry should be removed after the kill.
@item @code{nil}:
@code{kill-buffer} does not affect the history (this is the default).
@end itemize
@end defopt

@defopt sort-history-items
Sorts the items in the history buffer.
@end defopt

@node ecb-layout, ecb-compilation-content, ecb-history, Customizable options
@subsection Group ecb-layout

@noindent
This group contains the following options:

@defopt activate-before-new-frame-created-hook
Normal hook run before the new ECB-frame is created if
@code{ecb-new-ecb-frame} is not nil (otherwise this hook is not
evaluated).
@end defopt

@defopt advice-window-functions
Use the intelligent windows functions of ECB instead of the standard
Emacs functions. You can choose the following functions to be adviced
by ECB so they behave as if the edit-window(s) of ECB would be the
only windows(s) of the ECB-frame:

@itemize @bullet
@item @code{other-window}
For this one see also the option @code{ecb-other-window-jump-behavior}!
@item @code{delete-window}
@item @code{delete-other-windows}
@item @code{delete-windows-on}
@item @code{split-window-horizontally}
@item @code{split-window-vertically}
@item @code{split-window}
If this advice is enabled then @code{split-window-vertically} and
@code{split-window-horizontally} are autom. enabled too!
@item @code{switch-to-buffer}
@item @code{switch-to-buffer-other-window}
@item @code{other-window-for-scrolling}
If this advice is enabled then the following functions scroll always
the first edit-window if the edit-window is splitted, point stays in
the ``other'' edit-window and there is no durable compilation-window
(see @code{ecb-compile-window-height}):

@itemize @minus
@item @code{scroll-other-window}
@item @code{scroll-other-window-down}
@item @code{beginning-of-buffer-other-window}
@item @code{end-of-buffer-other-window}
@end itemize

This advice is per default not enabled.
@end itemize

For working most conveniantly with ECB it is the best to advice all
these functions, because then all the standard shortcuts of these
functions are also usable with ECB without doing anything else. Also
other packages can interact best with ECB if these functions are all
adviced. If these adviced functions are called in another frame than
the ECB-frame they behave all exactly like the not adviced versions!

But please read also the following:

Normally all packages should work correct with ECB and itīs adviced
functions but if there occur problems with a package cause of some of
these adviced functions ECB offers the following fall-back solution:

@enumerate
@item
Deactivate in @code{ecb-advice-window-functions} all the
adviced-functions which make problems with other packages.
@item
For every of the adviceable functions <adv-func> ECB offers a
interactively function named ``ecb-<adv-func>'' which does exactly the
same as the adviced version of <adv-func>. Use ``ecb-<adv-func>''
instead the original one to get the proper ECB behavior even if the
function is not adviced anymore.
@item
You can bind in @code{ecb-activate-hook} the standard-shortcut of
<adv-func> to ``ecb-<adv-func>'' and rebind it in
@code{ecb-deactivate-hook} to <adv-func>.
@item 
Now you have the best of both worlds: The problematic package works
and you have the ECB-behavior of <adv-func> as if it would be adviced.
@end enumerate

Here is an example: Suppose you must deactivating the advice for
@code{switch-to-buffer-other-window}. Then you deactivate this
function with this option and you can use
@code{ecb-switch-to-buffer-other-window} instead. Bind the shortcut
you normally use for @code{switch-to-buffer-other-window} to
@code{ecb-switch-to-buffer-other-window} (use @code{ecb-activate-hook}
for this) and rebind it to the original function in the
@code{ecb-deactivate-hook}.
@end defopt

@defopt compile-window-enlarge-by-select
The compile-window is auto. enlarged after selecting it. If not nil
then selecting the @code{ecb-compile-window} auto. enlarges it and
deselecting (means selecting another window after point was in
@code{ecb-compile-window}) auto. shrinks it. Enlarging and shrinking
the @code{ecb-compile-window} is done with
@code{ecb-toggle-enlarged-compilation-window}. See also the
documentation of this function!
@end defopt

@defopt compile-window-height
If you want a compilation window shown at the bottom of the ECB-layout
then set here the height of it (Default is a height of 5). If you
redraw the current layout with @code{ecb-redraw-layout} then the
compilation window (if any) has the heigth you set here. If the number
is less than 1.0 the height is a fraction of the frame height.

If you do not set a durable compilation window then doing a
compilation splits temporally the edit window vertically if the edit
window is not splitted already or uses the ``other'' edit window
temporally for comilation output if the edit window is already
splitted. This is the recommended value for this option!

Beware: If you set a durable compilation window then ECB can not
guarantee always behaving like a standard Emacs concerning displaying
temp-buffers and compilation-buffers. It should work in most cases but
maybe not in all. Just try it out.

See also the option @code{ecb-compile-window-temporally-enlarge} and
also the function @code{ecb-toggle-enlarged-compilation-window}!

@xref{Temp- and compile-buffers}.

Regardless of the settings you define here: If you have destroyed or
changed the ECB-screen-layout by any action you can always go back to
this layout with @code{ecb-redraw-layout}
@end defopt

@defopt compile-window-temporally-enlarge
Let Emacs temporally enlarge the compile-window of the ECB-layout.

This option has only an effect if @code{ecb-compile-window-height} is
not nil!

The following values are possible:

@itemize @minus
@item @code{after-compilation}:
After finishing the compilation-output and during jumping to the
errors ECB let temporally enlarge all compilation-buffers in
@code{ecb-compile-window} (e.g. compile- and grep-buffers) to
@code{compilation-window-height}. But be aware this setting is
currently not meaningful for temporary buffers like help-buffers
because these buffers currently enlarge always to
@code{temp-buffer-max-height}.

@item @code{after-selection}:
Selecting the @code{ecb-compile-window} auto. enlarges it and
deselecting (means leaving @code{ecb-compile-window}) auto. shrinks
it. Enlarging and shrinking the @code{ecb-compile-window} is done with
@code{ecb-toggle-enlarged-compilation-window}. See also the
documentation of this function! This is possible for all buffers in
@code{ecb-compile-window} not only for compilation-buffers!

@item @code{both}:
The combination of 'after-compilation and 'after-selection.

@item @code{nil}:
ECB tries to fix always the height of the @code{ecb-compile-window} at
the value of @code{ecb-compile-window-height}. But for all temporary
buffers (e.g. help-buffers) this is currently not possible.
@end itemize

To restore the ECB-layout after such a buffer-enlarge just call
@code{ecb-toggle-enlarged-compilation-window} or
@code{ecb-redraw-layout}.
@end defopt

@defopt enlarged-compilation-window-max-height
The max height of the compilation window after enlarging it by
@code{ecb-toggle-enlarged-compilation-window}. The following values
are allowed:

@itemize @minus
@item best:
Minimum is the value of @code{ecb-compile-window-height} and max. the half
of the frame-height of the ECB-frame, best depending on the values of
@code{compilation-window-height} (before ECB was started!) and the number
of lines of current buffer in @code{ecb-compile-window}. If
@code{compilation-window-height} is set before ECB was started then ECB
never enlarges the @code{ecb-compile-window} over the value of
@code{compilation-window-height}! Changing @code{compilation-window-height}
during activated ECB takes first effect after restarting ECB!
@item half:
1/2 the frame-height of the ECB-frame
@item any number:
Max height in lines. If the number is less than 1.0 the height
is a fraction of the frame height (e.g. 0.33 results in a
max-height of 1/3 the frame-height).
@end itemize
@end defopt

@defopt fix-window-size
Fix size of the ECB-windows/buffers even after frame-resizing. The fix
type (valid values are nil, t, width and height) can either be set on
a layout-basis (means a different value for each layout) or one value
can be set for all layouts.

For a detailed description of the valid values see description of
@code{window-size-fixed} which is newly introduced in GNU Emacs 21 and
is only available there. Therefore this option takes only effect with
GNU Emacs 21.

Note1: The description of @code{window-size-fixed} in the
elisp-info-manual is more detailled than the description offered by
@kbd{C-h v}!

Note2: With current Emacs 21.2.X there seems to be no distinction
between @code{width}, @code{height} and @code{t}. Therefore this
option takes no effect (means all ecb-windows have always unfixed
sizes) if @code{ecb-compile-window-height} is not @code{nil}.

Per default no window-size fixing has been done.
@end defopt


@defopt hide-ecb-windows-after-hook
Hooks run direct after the ECB windows have been hidden
either by @code{ecb-toggle-ecb-windows} or @code{ecb-hide-ecb-windows}.
@end defopt

@defopt hide-ecb-windows-before-hook
Hooks run direct before the ECB windows will be hidden either by
@code{ecb-toggle-ecb-windows} or @code{ecb-hide-ecb-windows}. This means that at runtime
of this hook all the ECB-tree-windows of current layout are visible.
@end defopt

@defopt layout-always-operate-in-edit-window
Adviced window functions work always in the edit-window. If we are in
an ECB special buffer (methods, directories, etc), and any of the
adviced windowing functions is called (see
@code{ecb-advice-window-functions}), we will select the
@code{ecb-edit-window} first. This is useful if you have any functions
that use such functions and you don't want them to just error with a
method complaining that the current buffer can not be split, or
something similar.

Because this may not be desirable in all situations and all adviced
functions this can be enabled separately for every advisable function
(see also @code{ecb-advice-window-functions}). If the symbol of an
adviced function is contained in the value of this option, then the
edit-window is first selected otherwise either an error is reported or
some other special reaction; see the documentation of the adviced
functions for this.

For @code{other-window}, @code{other-window-for-scrolling} and
@code{switch-to-buffer-other-window} this makes no sense, therefore
you can not enable this for them.

Per default this is enabled for @code{delete-window},
@code{delete-other-windows}, @code{switch-to-buffer}.
@end defopt


@defopt layout-name
Select a window layout of ECB. Value is any arbitary string. There are
four different types of layouts: left, right, top and left-right,
which means the location of the ECB-tree-windows in the ECB-frame.
Currently there are 20 predefined layouts; names see below. You can
savely try out any of them by changing this value and saving it only
for the current session. If you are sure which layout you want you can
save it for future sessions. To get a picture of the layout for name
<name> call `ecb-show-layout-help'. @code{ecb-layout-function-9}.

Currently available layouts:

@itemize @bullet
@item Left layouts:
left1 left2 left3 left4 left5 left6 left7 left8 left9 left10 left11
left12 left13 left14 left15

@item Right layouts:
right1

@item Top layouts:
top1 top2

@item Left-right layouts:
leftright1 leftright2
@end itemize

Regardless of the settings you define here: If you have destroyed or
changed the ECB-screen-layout by any action you can always go back to
this layout with @code{ecb-redraw-layout}
@end defopt

@defopt layout-switch-to-compilation-window
Switching buffer functions switch always in @code{ecb-compile-window}.

If the buffer argument of such functions (e.g.
@code{switch-to-buffer}) is a compilation buffer as defined with
@code{ecb-compilation-buffer-p} we will select the
@code{ecb-compile-window} and display there the buffer. This is useful
if you always want your compilation buffers within the compilation
window and not within the edit window.

Note the difference between
@code{ecb-layout-always-operate-in-edit-window} and this option: If a
buffer-switching function is contained in the former one, then we
always jump first into the edit-window regardless of the destination
buffer. If also contained in this option then ECB checks the
destination buffer and then selects the @code{ecb-compile-window} if
it is a compilation-buffer in the meaning of
@code{ecb-compilation-buffer-p}!

Currently this seemes only making sense for @code{switch-to-buffer}.
@end defopt


@defopt layout-window-sizes
Specifies the sizes of the ECB windows for each layout. The easiest
way (and also the strongly recommended way) to change this variable is
to change the window sizes by dragging the window borders using the
mouse and then store the window sizes by calling the command
@code{ecb-store-window-sizes}. Next time the layout is redrawn the
values stored in this option will be used.

If @code{ecb-store-window-sizes} is used then the windows sizes are
stored per default as fractions of current frame-width and -height of
the ecb-frame, so the stored values will ``work'' for other frame
sizes too. But if you call @code{ecb-store-window-sizes} with a
prefix-argument then the fixed values of current width and height are
stored!

If this option is set ``by hand'' (i.e. not by
@code{ecb-store-window-sizes}) then the following is important:
@itemize @minus
@item
It is recommended to use fractions of frame-width and -height!.
@item
The order of the sequence of the inserted window sizes must be the same as
@code{other-window} (the not-adviced version!) would walk!
@end itemize
@end defopt

@defopt new-ecb-frame
Create a new frame at activation time of ECB.
@end defopt

@defopt other-window-jump-behavior
Which windows of ECB should be accessible by the ECB-adviced function
@code{other-window}, an intelligent replacement for the Emacs standard
version of @code{other-window}. The following settings are possible:

@itemize @minus
@item @code{all}:
ECB will cycle through all windows of ECB, means it behaves like the
original @code{other-window}.
@item @code{only-edit}:
ECB will only cycle through the (max. 2) edit-windows of ECB.
@item @code{edit-and-compile}:
Like 'only-edit plus the compile window if any.
@end itemize
@end defopt

@defopt redraw-layout-after-hook
Hooks run direct before the ECB windows will be shown either by
@code{ecb-toggle-ecb-windows} or @code{ecb-show-ecb-windows}. This
means that at runtime of this hook the ECB-windows are already
visible.
@end defopt

@defopt redraw-layout-before-hook
Hooks run direct before the ECB-layout will be redrawn by either
@code{ecb-redraw-layout}.
@end defopt

@defopt redraw-layout-quickly
If non-nil, we will attempt to redraw the layout quickly. Please read
also carefully the documentation of @code{ecb-redraw-layout}.
@end defopt

@defopt select-edit-window-on-redraw
Select the first edit window on @code{ecb-redraw-layout}.
@end defopt

@defopt show-ecb-windows-after-hook
Hooks run direct before the ECB windows will be shown either by
@code{ecb-toggle-ecb-windows} or @code{ecb-show-ecb-windows}. This
means that at runtime of this hook the ECB-windows are already
visible.

IMPORTANT: Showing the hidden ECB-windows is internally done by
calling @code{ecb-redraw-layout} and therefore also the hooks
@code{ecb-redraw-layout-before-hook} and
@code{ecb-redraw-layout-after-hook} are evaluated. So there is the
following sequence of hooks during the process of showing the hidden
ECB-windows:
@enumerate
@item @code{ecb-show-ecb-windows-before-hook}
@item @code{ecb-redraw-layout-before-hook}
@item <redrawing the layout to show the hidden ECB-windows>
@item @code{ecb-redraw-layout-after-hook}
@item @code{ecb-show-ecb-windows-after-hook}
@end enumerate
So be aware which code you add to which hook!
@end defopt

@defopt show-ecb-windows-before-hook
Hooks run direct before the ECB windows will be shown either by
@code{ecb-toggle-ecb-windows} or @code{ecb-show-ecb-windows}. This
means that at runtime of this hook the ECB-windows are still hidden.

IMPORTANT: Showing the hidden ECB-windows is internally done by
calling @code{ecb-redraw-layout} and therefore also the hooks
@code{ecb-redraw-layout-before-hook} and
@code{ecb-redraw-layout-after-hook} are evaluated. So there is the
following sequence of hooks during the process of showing the hidden
ECB-windows:
@enumerate
@item @code{ecb-show-ecb-windows-before-hook}
@item @code{ecb-redraw-layout-before-hook}
@item <redrawing the layout to show the hidden ECB-windows>
@item @code{ecb-redraw-layout-after-hook}
@item @code{ecb-show-ecb-windows-after-hook}
@end enumerate
So be aware which code you add to which hook!
@end defopt



@defopt split-edit-window
Sets how and if the edit window should be splitted. But be aware: This
option determines only if the edit-window should be splitted at
start-time of ECB.
@end defopt

@defopt toggle-layout-sequence
Toggle sequence for layout toggling with @code{ecb-toggle-layout}.
Every element of this list has to be a valid layout-name i.e. either
one of the predefined layouts or one of the user-defined layouts.

You can add here as many layouts as you want but to use this option
most effective you should not add more than 2 or 3 layouts so every
layout can be accessed very fast by toggling with
@code{ecb-toggle-layout}. It is also senseful to add layouts which
have the same principal outline, i.e. all their tree-buffers are on
the same side of the frame and the tree-buffer-''column'' (or
-''row'') has identical size for the layouts.

Recommended values are for example:

@itemize @minus
@item (``left10'' ``left15''), toggles between methods and directories/history
@item (``left10'' ``left13''), toggles between methods and directories
@item (``left10'' ``left14''), toggles between methods and history
@item (``left10'' ``left13'' ``left14''), toggles between methods, history and directories
@end itemize

See also option @code{ecb-show-sources-in-directories-buffer}.

This option makes only sense if the value is a list with more than 1
element!
@end defopt

@defopt windows-height
The height of the ECB windows in lines when they are placed above or
below the edit window. If the number is less than 1.0 the width is a
fraction of the frame height.
@end defopt

@defopt windows-width
The width of the ECB windows in columns when they are placed to the
left or right of the edit window. If the number is less than 1.0 the
width is a fraction of the frame width.
@end defopt

@node ecb-compilation-content, ecb-create-layout, ecb-layout, Customizable options
@subsection Group ecb-compilation-content

@noindent
This group contains the following options:

@defopt compilation-buffer-names
Additional buffer names that should be displayed in the compilation
window of ECB even if @code{compilation-buffer-p} says nil.
@end defopt


@defopt compilation-major-modes
Additional major-mode that should be displayed in the compilation
window of ECB even if @code{compilation-buffer-p} says nil.
@end defopt


@defopt compilation-predicates
Predicate when a buffer should be treated as compilation-buffer - even
if @code{compilation-buffer-p} says nil. Every element of this list
has to be a function or lambda-expression which gets as argument a
buffer-object and which has to return not nil when this buffer should
be treated as compilation-buffer and therefore displayed in the
compile-window of ECB (if there is any).

In combination with the values of @code{ecb-compilation-buffer-names}
and @code{ecb-compilation-major-modes} ECB decides when a buffer has
to be displayed in the compile-window.

Default value is the function @code{comint-check-proc} which returns
not nil if the buffer-argument is related to a living process.
@end defopt



@node ecb-create-layout, ecb-face-options, ecb-compilation-content, Customizable options
@subsection Group ecb-create-layout

@noindent
This group contains the following options:

@defopt create-layout-file
File where all layouts created by @code{ecb-create-new-layout} are
stored.
@end defopt

@defopt ecb-create-layout-frame-height
Frame height of the layout creation frame.
@end defopt

@defopt ecb-create-layout-frame-width
Frame width of the layout creation frame.
@end defopt

@node ecb-face-options, ecb-faces, ecb-create-layout, Customizable options
@subsection Group ecb-face-options

@noindent
This group contains the following options:

@defopt directories-general-face
Basic face for the ECB directories buffer. This defines the basic face
the whole directory buffer should displayed with. If the face
@code{ecb-default-general-face} is used then the display of all
ECB-tree-buffers can be changed by modifying only the face
@code{ecb-default-general-face}.

Changes take first effect after finishing and reactivating ECB!
@end defopt

@defopt directory-face
Face used for highlighting current directory in the directories
buffer. If the face @code{ecb-default-highlight-face} is used then the
display of all ECB-tree-buffers can be changed by modifying only the
face @code{ecb-default-highlight-face}.

Changes take first effect after finishing and reactivating ECB!
@end defopt

@defopt history-face
Face used for highlighting current history-entry in the history
buffer. If the face @code{ecb-default-highlight-face} is used then the
display of all ECB-tree-buffers can be changed by modifying only the
face @code{ecb-default-highlight-face}.

Changes take first effect after finishing and reactivating ECB!
@end defopt

@defopt history-general-face
Basic face for the ECB directory buffer. This defines the basic face
the whole history buffer should displayed with. If the face
@code{ecb-default-general-face} is used then the display of all
ECB-tree-buffers can be changed by modifying only the face
@code{ecb-default-general-face}.

Changes take first effect after finishing and reactivating ECB!
@end defopt

@defopt method-face
Face used for highlighting current method, class or variable in the
methods buffer. If the face @code{ecb-default-highlight-face} is used
then the display of all ECB-tree-buffers can be changed by modifying
only the face @code{ecb-default-highlight-face}.

Changes take first effect after finishing and reactivating ECB!
@end defopt

@defopt method-non-semantic-face
Face used for for displaying tokens of sources not supported by
semantic.

Changes take first effect after finishing and reactivating ECB!
@end defopt


@defopt methods-general-face
Basic face for the ECB methods buffer. This defines the basic face the
whole methods buffer should displayed with. If the face
@code{ecb-default-general-face} is used then the display of all
ECB-tree-buffers can be changed by modifying only the face
@code{ecb-default-general-face}.

Changes take first effect after finishing and reactivating ECB!
@end defopt

@defopt source-face
Face used for highlighting current source in the sources buffer. If
the face @code{ecb-default-highlight-face} is used then the display of
all ECB-tree-buffers can be changed by modifying only the face
@code{ecb-default-highlight-face}.

Changes take first effect after finishing and reactivating ECB!
@end defopt

@defopt source-in-directories-buffer-face
Face for source files in the directories buffer.
@end defopt

@defopt sources-general-face
Basic face for the ECB sources buffer. This defines the basic face the
whole sources buffer should displayed with. If the face
@code{ecb-default-general-face} is used then the display of all
ECB-tree-buffers can be changed by modifying only the face
@code{ecb-default-general-face}.

Changes take first effect after finishing and reactivating ECB!
@end defopt

@defopt token-header-face
Face used for highlighting the token header after jumping to it by
clicking onto a node in the methods buffer.
@end defopt



@node ecb-faces, ecb-download, ecb-face-options, Customizable options
@subsection Group ecb-faces

@noindent
This group contains the following faces:

@table @code
@item ecb-bucket-token-face:
Face which can be used for displaying bucket tokens in the methods
buffer. See also `ecb-bucket-token-display'.

@item ecb-default-general-face:
Basic face for all ECB tree-buffers.
It's recommended to define here the font-family, the font-size, the basic
color etc.

In GNU Emacs 21.X all faces (even the face
@code{ecb-default-highlight-face}) used in the ECB tree-buffers inherit
from this face. Therefore the default attributes like font etc. of a
face used in a tree-buffer can be very easily changed with face
@code{ecb-default-general-face}.

With XEmacs and GNU Emacs 20.X there is no inheritance-feature but the
options @code{ecb-directories-general-face},
@code{ecb-sources-general-face}, @code{ecb-methods-general-face} and
@code{ecb-history-general-face} offer the choice to use the face
@code{ecb-default-general-face} so also with XEmacs and GNU Emacs 20.X
the basic face-settings can be easily changed just by customizing the
face @code{ecb-default-general-face}!

@item ecb-default-highlight-face:
Define basic face for highlighting the selected node in an ECB
tree-buffer.

In GNU Emacs 21.X all highlighting faces in the ECB tree-buffers
inherit from this face. Therefore the default attributes like font
etc. of a face used in a tree-buffer for highlighting the current
token can be very easily changed with face
@code{ecb-default-highlight-face}.

With XEmacs and GNU Emacs 20.X there is no inheritance-feature but the
options @code{ecb-directory-face}, @code{ecb-source-face},
@code{ecb-method-face} and @code{ecb-history-face} offer the choice to
use the face @code{ecb-default-highlight-face} so also with XEmacs and
GNU Emacs 20.X the basic face-settings can be easily changed just by
customizing the face @code{ecb-default-highlight-face}!

@item ecb-directories-general-face:
Basic face for the ECB directories buffer. Itīs recommended to define
here the font-family, the font-size, the basic color etc.

@item ecb-directory-face:
Define face used for highlighting current directory in the directories
buffer.

@item ecb-history-face:
Define face used for highlighting current history-entry in the history
buffer.

@item ecb-history-general-face:
Basic face for the ECB history buffer. Itīs recommended to define here
the font-family, the font-size, the basic color etc.

@item ecb-method-face:
Define face used for highlighting current method, class or variable in
the methods buffer.

@item ecb-methods-general-face:
Basic face for the ECB methods buffer. Itīs recommended to define here
the font-family, the font-size, the basic color etc.

@item ecb-method-non-semantic-face:
Define face used for displaying tokens of sources not supported by semantic.

@item ecb-source-face:
Define face used for highlighting current source in the sources
buffer.

@item ecb-source-in-directories-buffer-face:
Define a face for displaying sources in the directories buffer.

@item ecb-sources-general-face:
Basic face for the ECB sources buffer. Itīs recommended to define here
the font-family, the font-size, the basic color etc.

@item ecb-token-header-face:
Define face used for highlighting the token header after jumping to it
by clicking onto a node in the methods buffer.

@item ecb-type-token-class-face:
Define face used with option @code{ecb-type-token-display}.

@item ecb-type-token-enum-face:
Define face used with option @code{ecb-type-token-display}.

@item ecb-type-token-group-face:
Define face used with option @code{ecb-type-token-display}.

@item ecb-type-token-interface-face:
Define face used with option @code{ecb-type-token-display}.

@item ecb-type-token-struct-face:
Define face used with option @code{ecb-type-token-display}.

@item ecb-type-token-typedef-face:
Define face used with option @code{ecb-type-token-display}.

@end table

Just call @code{customize-face <face-name>} to customize these faces
for your personal taste. Or customize the related option in the group
@ref{ecb-face-options}.

@node ecb-download, ecb-help, ecb-faces, Customizable options
@subsection Group ecb-download

@noindent
This group contains the following options:

@defopt download-delete-archive
Should the downloaded archive be deleted after successfull
installation or after failure during the installation-process.
Possible values are:

@itemize @minus
@item @code{only-after-success}:
Archive is only deleted after successfull installation
but not if a failure occurs during the installation process.
@item @code{always}:
Archive is also deleted if an error occurs.
@item @code{nil}:
Archive will never be deleted.
@end itemize
@end defopt

@defopt download-install-parent-dir
Parent directory where downloaded packages are installed.

ECB installs a downloaded package in this directory, i.e. the downloaded
archive X.tar.gz will be extracted in this directory so afterwards this
directory contains a new subdirectory X which contains the downloaded package.

This directory must be writeable!
@end defopt

@defopt download-package-version-type
Version type ECB is allowed to download for upgrading.

If you want to upgrade to a newer ECB-version via
@code{ecb-download-ecb} or if you must upgrade to newer semantic-
eieio- and/or speedbar-versions (because ECB requires these newer
versions) then this option specifies which version-types are allowed.
ECB checks on the download-sites of ECB/semantic/eieio/speedbar which
versions are currently available and then downloads always the latest
version matching the specified type:

@itemize @minus
@item 2: Get the newest version of all stable versions available.
@item 1: Get the newest version of all stable and beta versions available.
@item 0: Get the newest version of all stable, beta and alpha versions
available.
@item -1: Ask before downloading in the minibuffer for a version
(TAB-completion of all available versions is possible).
@end itemize

So, 2 means stable, 1 means stable and betas, 0 means stable, betas and alphas
and -1 means ask the user for a version.

Per default stable and beta-versions are allowed (value 1).

But all versions must match the restrictions of the specified min- and
max-versions of the required packages. For this see the file README!
@end defopt

@defopt download-url
URL where downloadable ECB-versions are located. The ECB-archive-file
(e.g. ecb-1.70.tar.gz) will be appended to this URL and
@code{ecb-download-ecb} will try to download this archive.

Note: Normally this URL should never change but who knows...
@end defopt


@node ecb-help, ecb-eshell, ecb-download, Customizable options
@subsection Group ecb-help

@noindent
This group contains the following options:


@defopt help-html-path
Path where the ECB online help in HTML format resides. This must be
the location of the @file{ecb.html} which comes with the ECB
distribution. If is installed by unpacking the archive available on
the ECB website then this is the subdir @code{ecb-help-html-subdir} of
the installation directory of ECB. If it is installed as
XEmacs-package (e.g. via the package manager of XEmacs) then this is
probably either the directory ``../../html/'' or
``../../etc/ecb/html/'' (both relativ to the elisp directory of ECB).

The path can either be an absolute path or a path relativ to the directory
where the elisp files of ECB are.

Normally there should be no need to change this option!
@end defopt


@defopt help-info-path
Path where the ECB online help in info format resides. This must be
the location of the @file{ecb.info} which comes with the ECB
distribution. If is installed by unpacking the archive available on
the ECB website then this is the subdir @code{ecb-help-info-subdir} of
the installation directory of ECB. If it is installed as
XEmacs-package (e.g. via the package manager of XEmacs) then this is
probably the directory ``../../info/'' (relativ to the elisp directory
of ECB).

The path can either be an absolute path or a path relativ to the directory
where the elisp files of ECB are.

Normally there should be no need to change this option!
@end defopt


@defopt show-help-format
The format @code{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 @code{browse-url-browser-function} says which
browser is used.

Note: If you got ECB as a standard XEmacs-package maybe the
HTML-online-documentation is not included.
@end defopt

@node ecb-eshell, ecb-non-semantic, ecb-help, Customizable options
@subsection Group ecb-eshell

@noindent
This group contains the following options:

@defopt eshell-auto-activate
Startup the eshell when the ECB is activated and display it in the
compile-window. If current layout does not display a compile-window (see
@code{ecb-compile-window-height}) then nothing is done.
@end defopt

@defopt eshell-enlarge-when-selecting
Enlarge the compile-window if it displays the eshell and
if it is selected by @code{ecb-eshell-goto-eshell}.
@end defopt

@defopt eshell-synchronize
Synchronize the eshell with the default-directory of current
source-buffer. The synchronization is done by
@code{ecb-eshell-current-buffer-sync} which can be called
interactively but normally it is called autom. by the
@code{ecb-current-buffer-sync-hook}.
@end defopt

@node ecb-non-semantic, , ecb-eshell, Customizable options
@subsection Group ecb-non-semantic

@defopt auto-save-before-etags-methods-rebuild
Automatic saving of current buffer before rebuilding its methods.

This option is only relevant for sources which are supported and
parsed by etags (see @code{ecb-process-non-semantic-files}). Because
etags is an external tool a source-buffer can only be reparsed if the
buffer is saved to disk. So the command
@code{ecb-rebuild-methods-buffer} checkes for sources which are not
supported by semantic or imenu if either this option is t or if the
major-mode of the source-buffer is contained in this list: In both
cases ECB saves the current source-buffer before it re-runs etags for
reparsing the source. If nil or if the major-mode is not contained
then no automatic saving will be done!

For all source supported by semantic or by imenu this option takes no
effect.
@end defopt

@defopt non-semantic-exclude-modes
Exclude modes from parsing with imenu or etags. Per default, ECB tries
to parse all file-types not supported by semantic with imenu or etags
or some other method (for details see the option
@code{ecb-non-semantic-parsing-function}). If a file-type can not be
parsed by semantic, imenu or etags than this simply results in an
empty method-buffer for this file. But nevertheless you will get a
message ``Sorry, no support for a file of that extension'' which comes
from the speedbar-library and can not switched off. Therefore if a
@code{major-mode} is known as not parsable by semantic, imenu or etags
it can be added to this option and then it will be excluded from being
tried to parsed.
@end defopt

@defopt non-semantic-methods-initial-expand
Initially expand all tokens for not by semantic supported sources.
This option can be customized on a major-mode basis, i.e. if a
@code{major-mode} is contained in this option then al tokens for this
modes will be initially expanded - otherwise not.
@end defopt

@defopt non-semantic-parsing-function
Define mode-dependend parsing functions for non-semantic files. 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 parsing a
non-semantic buffer, i.h. a buffer for which no semantic grammar
exists. Such a function gets one argument - the filename of current
buffer - and has to generate and return a token/tag list which is
understandable by @code{speedbar-insert-generic-list}. speedbar has
already included two functions @code{speedbar-fetch-dynamic-imenu} and
@code{speedbar-fetch-dynamic-etags} which can be used for parsing
buffers with imenu resp. etags.

This option takes only effect if @code{ecb-process-non-semantic-files}
is not nil: Then ECB checks for non-semantic buffers if current
@code{major-mode} is contained in this option and if yes, then the
specified parsing function is called; if not then the cars of the
elements of @code{speedbar-dynamic-tags-function-list} are called in
that sequence they are listed in this variable. See option
@code{speedbar-dynamic-tags-function-list} for further details.

In most cases imenu-parsing is preferable over etags-parsing because
imenu operates on Emacs-buffers and needs no external tool and
therefore parsing works also if current contents of a buffer are not
saved to disk. But maybe sometimes etags may return better parsing
results

IMPORTANT: if imenu-parsing should be used then the option
@code{speedbar-use-imenu-flag} must be set to not nil!
@end defopt

@defopt process-non-semantic-files
Display content of non-semantic-files in the ECB-methods-buffer. See
also @code{ecb-non-semantic-parsing-function}.
@end defopt

@defopt rebuild-non-semantic-methods-before-hook
Hook running at beginning of the function
@code{ecb-rebuild-methods-buffer-for-non-semantic}. This function is
always called by the command @code{ecb-rebuild-methods-buffer} for not
semantic supported source-types.

Every function of this hook gets one argument: The complete filename
of the current source-buffer in the edit-window. The Method-buffer is
only rebuild by @code{ecb-rebuild-methods-buffer-for-non-semantic} if
either the hook contains no function (the default) or if no function
of this hook returns nil! See @code{run-hook-with-args-until-failure}
for description how these function are processed.
@end defopt


@node Submitting problem report, Upgrading, Customizing, Top
@chapter Submitting a problem report

@cindex Bug report
@cindex Problem report
If you run into problems with ECB you should first take a look into

@itemize @minus
@item @ref{FAQ} or
@item @ref{Conflicts and bugs} or
@item @ref{Tips and tricks} or
@item the appropriate section of this online-manual.
@end itemize

If your problem(s) still remain you can/should send a problem report
to the ECB mailing list @email{ecb-list@@lists.sourceforge.net}. ECB
offers you a command which does all necessary for you to send a
problem report. Just call @code{ecb-submit-problem-report}! Please
read the documentation of this command, see @ref{Interactive ECB
commands}.

This command creates a problem-report buffer for you. After that you
get a menu ``Mail'' (dependend on the mail-package used, the menu can
have a different name) with commands to send the problem report. But
for this the varibale @code{mail-user-agent} must be configured right for
your system. If you canīt get working this mechanism you can simply
copy the whole problem-report buffer after filling it out and sending
it with your standard mail-client to
@email{ecb-list@@lists.sourceforge.net}!

Please read also the documentation of the option @code{ecb-debug-mode} and
switch on the debug mode of ECB (also available in the Help-menu of
ECB!) before submitting a problem-report!

@node Upgrading, Tips and tricks, Submitting problem report, Top
@chapter Upgrading and downloading packages

This chapter describes all aspects of upgrading to a newer version of
ECB.

The first section describes how to download and install a new
package from the web, where ``package'' means either ECB itself or the
required libraries semantic, eieio and speedbar.

After installing a new ECB-version ECB checks if the values of the
customized ECB-options are still compatible. If not ECB does some
smart things. This is the topic of the second section.

@menu
* Downloading new versions::    How to download newer versions of packages
* Auto. option-upgrading::      ECB can auto. upgrade your options
@end menu

@node Downloading new versions, Auto. option-upgrading, Upgrading, Upgrading
@section Downloading new versions of ECB and/or required packages

@cindex Download
ECB offers the possibility to upgrade to newer versions direct from
the ECB-website. This can be done if the following requirements are
satisfied:

@enumerate
@item A connection to the web is available
@item The tools ``wget'', ``tar'' and ``gzip'' are installed

With unix-systems these tools are in the
standard-distribution. If you are running any Microsoft Windows system
then you need cygwin@footnote{cygwin is available at
@ifhtml
@uref{http://cygwin.com/}
@end ifhtml
@ifnothtml
@url{http://cygwin.com/}
@end ifnothtml
} which offers these tools too. On every
system these tools must reside in the @env{PATH} environment-variable!

If you are behind a firewall and you have to use a proxy you maybe
need the following wget-configuration in your file @file{~/.wgetrc}:

@example
@group
# Define your proxies (where 8080 and 8081 are examples
# for the portnumbers)
http_proxy = http://your.proxy.com:8080
ftp_proxy  = http://your.ftpproxy.com:8081
  
# If you do not want to use proxy at all, set this to off.
use_proxy = on
@end group
@end example
@end enumerate

If these requirements are satisfied you can download and install both
ECB itself and also the required versions of semantic, eieio and
speedbar:

@itemize @bullet
@item Download a new ECB-version with @code{ecb-download-ecb}:

A description for this command you will find in @ref{Interactive ECB
commands}. Check also the options of the customize-group
'ecb-download' (@pxref{ecb-download}).

@anchor{Download required packages}
@item Download and install of required packages:

ECB checks at load-time if the packages semantic, eieio and speedbar
are at least installed and at start-time if the required versions of
semantic, eieio and speedbar (see @file{README}) are installed and
loaded into Emacs. If not you will be asked if you want auto. download
and install them. If you confirm this then ECB does the following:

@enumerate
@item
Checking which versions are available at the download-site of the
required packages. With the option
@code{ecb-download-package-version-type} you can specify which type of
versions (only stable, stable and betas or stable, betas and alphas)
you allow to download and install. This option offers also the choice
of asking you for a certain version. Depending of this setting ECB
either ask you which version it should download and install or chooses
autom. the newest version available which is matching both its
min-max-requirements and the setting in
@code{ecb-download-package-version-type}.

NOTE: Currently there are only beta-versions of speedbar available
therefore this option has to be set to 1 (allow stable and beta
versions). But the speedbar beta-versions are very stable!

@item
Downloading and installing the right version (see 1.) of the required
packages. ECB downloads and installs the new package versions in
subdirectories of @code{ecb-download-install-parent-dir}.
@end enumerate

If both of these actions succeed then you will get a message-buffer
which tells you something like:

@example
@group
-----------------------------------------------------------------
Current state of the required packages semantic, eieio, speedbar:

- semantic author-version must be [1.4, 1.4.9]:
  Installed in /usr/local/lib/site-lisp/semantic-1.4
  
- eieio author-version must be [0.17, 0.17.9]:
  Correct version already loaded!

- speedbar author-version must be [0.14beta1, 0.15.9]:
  Correct version already loaded!

After adding the new directory to your @code{load-path} and then
restarting Emacs the new package(s) can be activated.
-----------------------------------------------------------------

@end group
@end example

@strong{Note1}: "P author-version must be [x y]" means, that ECB requires
package P in a version-number >= x and <= y.

@strong{Note2}: By setting the option @code{ecb-version-check} to
@code{nil} you can prevent ECB from checking correct versions of
semantic, eieio and speedbar but it's strongly recommended not to do
this!
@end itemize

@node Auto. option-upgrading, , Downloading new versions, Upgrading
@section Automatic upgrading of options

@menu
* User interface::              Options and commands you should know
* Background information::      Maybe some interesting informations
@end menu

@node User interface, Background information, Auto. option-upgrading, Auto. option-upgrading
@subsection User interface for option-upgrading

There are two interactive commands (@pxref{Interactive ECB commands}):

@itemize @minus
@item @code{ecb-upgrade-options}:
Does all necessary beginning with a incompatibility-check for all
options, upgrading/resetting incompatible options and ending with the
display of all upgraded or reset options.

@item @code{ecb-display-upgraded-options}:
Displays a temp. buffer with all upgraded or resetted ECB-options with
their old and new values.
@end itemize

If the option @code{ecb-auto-compatibility-check} has a non-nil value
(which is the default) then ECB does all this stuff automatically at
startup. This is very recommended!

If you are interested in some background information, read
@ref{Background information}!

@node Background information, , User interface, Auto. option-upgrading
@subsection Background information

Big packages like ECB will be enhanced and developed continously so
sometimes a new version must be released. Such packages offer in
general a lot of customizable options so probably some of these
options change the type or are renamed because the old type and/or
name of the option makes no sense in the new release.

Especially options which have changed the type of their value are now
a problem for the user which want to upgrade to the latest
ECB-version: If the user has saved a certain value for option X in its
file @file{.emacs} but the type of this saved value doesn't match the
new defined type in the defcustom-form after an ECB-upgrade then there
can occur serious problems like ECB can not be started anymore or even
Emacs can not be startet without errors.

Until now there was only one way to fix these problems: The user must
manually edit his file @file{.emacs} and remove all entries for
options which have now another type. After this and after restarting
Emacs the new default-values of the type-changed options in the new
ECB-release are active and the user can go on using Emacs and ECB. But
this approach to fix the incompatible-option-problem has two serious
drawbacks:

@enumerate
@item
The user must manually edit the customize-section in his file
@file{.emacs}. This should normally not be done and if then only by
old-handed Emacs-users.

@item
The customized value of the option X in the old-release (with the old
type) is lost because after removing the related entry from the
file @file{.emacs} the new default-value is active, so the user must
re-customize the option X.
@end enumerate

Ok, this is one half of the option-upgrade-problem but a new ECB-release
can also rename a option from name X to name Y because the new name Y makes
much more sense and/or is more mnemonic. If only the name has changed but
not the type this is not a serious problem like above but also annoying
because the customized value of the old-option X takes no effect in the new
release but instead the default-value of the new-option Y is now active.
But nevertheless this problem has the drawback number 2 (see above).

The last category of upgrade-problems is a renamed option which has also
changed its type.

@noindent
ECB has a solution for all these problems:

@itemize @bullet

@item
It checks all customized values of all ECB-optons if they are still
type-compatible. If not then it tries to upgrade the old-value to the
new value-type and if this is not possible then it resets the option
to the new default value and store it via customize in the .emacs-file
(or in any file which is used for customized options).

@item
It offers a special constant @code{ecb-upgradable-option-alist} which
allows the ECB-maintainers to define special transformings for renamed
options so even the value of an old-option X can be savely transformed
to the new-option Y and the old setting is not lost.
@end itemize

All these checks and transformings are done at beginning of activating
ECB - if the option @code{ecb-auto-compatibility-check} is not nil. If
ECB has recognized incompatible or renamed options it does its
upgrading/reseting-job so all ECB-options have correct types so ECB
can start correct. After ECB is started it displays a list of all
upgraded or resetted option with their old and new values.


@node Tips and tricks, Elisp programming, Upgrading, Top
@chapter Tips and tricks

This chapter contains some tips and tricks how to deal best with some
situations.

@menu
* Changing faces::              Changing faces in the ECB tree-buffers
* Small screens::               Working with small screens
* Big screens::                 Working with big screens
* Simulating speedbar::         Simulating speedbar without an extra frame
* Integrating speedbar::        Integrating speedbar in the ECB-frame
* Optimize scrolling::          Optimize scrolling in the edit-window
* Large directories::           Working with large directories
* Using eshell::                Optimal using of eshell in ECB
* Grepping directories::        Grepping directories with ECB
* Working with JDEE::           Working best with ECB and JDEE
* Compile-window on demand::    Displaying the compile-window on demand
* Non-semantic sources::        Parsing and displaying non-semantic sources
* Hide-show::                   Using hide-show from the methods-buffer-menu
@end menu

@node Changing faces, Small screens, Tips and tricks, Tips and tricks
@section Changing faces in the ECB tree-buffers

@cindex Faces
There are two basic faces:

@itemize @bullet
@item @code{ecb-default-general-face}:
Basic face for displaying an ECB-tree-buffer.

Itīs recommended to define the font-family, the font-size, the basic
color etc. with this face.

In GNU Emacs 21.X all faces (even the face
@code{ecb-default-highlight-face}) used in the ECB tree-buffers
inherit from this face. Therefore the default attributes like font
etc. of a face used in a tree-buffer can be very easily changed with
face @code{ecb-default-general-face}.

With XEmacs and GNU Emacs 20.X there is no inheritance-feature but the
options @code{ecb-directories-general-face},
@code{ecb-sources-general-face}, @code{ecb-methods-general-face} and
@code{ecb-history-general-face} offer the choice to use the face
@code{ecb-default-general-face} so also with XEmacs and GNU Emacs 20.X
the basic face-settings can be easily changed just by customizing the
face @code{ecb-default-general-face}.

@item @code{ecb-default-highlight-face}:
Basic face for highlighting the current node in an ECB-tree-buffer.

In GNU Emacs 21.X all highlighting faces used in the ECB tree-buffers
inherit from this face. Therefore the default attributes like font
etc. of a highlighting face used in a tree-buffer can be very easily
changed with face @code{ecb-default-highlight-face}.

With XEmacs and GNU Emacs 20.X there is no inheritance-feature but the
options @code{ecb-directory-face}, @code{ecb-source-face},
@code{ecb-method-face} and @code{ecb-history-face} offer the choice to
use the face @code{ecb-default-highlight-face} so also with XEmacs and
GNU Emacs 20.X the basic face-settings can be easily changed just by
customizing the face @code{ecb-default-highlight-face}.

@end itemize

With these faces you can change the basic attributes easily and fast
for ALL ECB-tree-buffers. But you are also able to display each
ECB-tree-buffer with different faces, see the different options for
every tree-buffer mentioned above.

@strong{NOTE} (only for XEmacs users): Cause of the lack of the
font-inheritance feature using ONE other font for the ECB-methods
buffer can NOT be achieved just by setting
@code{ecb-methods-general-face} to @code{ecb-default-general-face} and
changing the font of this default face. In addition you have to set
the same font also for the face @code{ecb-bucket-token-face} like in
the following example:

@example
(defconst my-ecb-font
          "-outline-Courier-normal-normal-13-97-96-96-c-*-iso8859-1")
(set-face-font 'ecb-default-general-face my-ecb-font)
(set-face-font 'ecb-bucket-token-face my-ecb-font)
@end example

This code sets the new defined font @code{my-ecb-font} as font for
all@footnote{Of course @code{ecb-directories-general-face},
@code{ecb-sources-general-face}, @code{ecb-methods-general-face} and
@code{ecb-history-general-face} must be set to
@code{ecb-default-general-face}!} ECB-tree-buffers (incl. the methods
buffer).

@node Small screens, Big screens, Changing faces, Tips and tricks
@section Working with small screens

@cindex Small screen
If your screen is very small so you need every sqare-centimeter for
displaying the buffer which you want to edit, ECB offers you a special
layouts, where only the ECB-methods buffer is displayed on top or on
left-side. Here comes what you should/can do to work best with ECB in
such a situation:

@itemize @bullet
@item First customize your ECB:

@enumerate
@item
Customize @code{ecb-layout-name} to layout-name ``top2'' (on top) or
``left9'' (on left-side)

@item
Ensure that @code{ecb-compile-window-height} is nil.

@item
Optional: Ajust the @code{ecb-windows-height} resp. @code{ecb-windows-width}.

@item
Save your changes.
@end enumerate

@item To edit your buffers:
Call @code{ecb-toggle-ecb-windows} (also available via the menu ``ECB'' and
by @kbd{C-c . lw}) or @code{ecb-hide-ecb-windows} to hide the ECB-method buffer
so you get all the place of your screen for editing.

@item To browse and select functions:
Call @code{ecb-toggle-ecb-windows} or @code{ecb-show-ecb-windows} to
make the ECB-method buffer visible if not already. If you want select
a method/variable with the keyboard instead with the mouse you should
read the section @ref{Using the keyboard} in this online help!
@end itemize

The possibility of hiding temporally the ECB windows like described
above is also useful for all the other layouts.


@node Big screens, Simulating speedbar, Small screens, Tips and tricks
@section Working with big screens

ECB offers a layout type ``left-right'' with special ECB-tree-windows
on the left and right side of the edit-window. The layouts
``leftright1'' and ``leftright2''are examples for this layout type.
See @ref{Creating a new ECB-layout} and @ref{The layout-engine}
for details about how to create or program more layouts of this type.

Such a layout is eventually the best choice for big screens because
the several ECB-tree-windows are bigger and can display more
informations without scrolling.

With such a layout it can could be senseful to reduce the value of the
option @code{ecb-windows-width} compared to layouts of type left or
right. A value of max. 0.25 should be enough.

@node Simulating speedbar, Integrating speedbar, Big screens, Tips and tricks
@section Simulating speedbar without an extra frame

@cindex Speedbar
You can simulate a speedbar-like layout within ONE frame by doing the
following:

@enumerate
@item
Customize @code{ecb-layout-name} to layout name ``left9'', ``left12'',
``left13'' or ``left14'' dependend to what you like.

@item
Optional: Ensure that @code{ecb-compile-window-height} is nil.

@item
Optional: Ajust the @code{ecb-windows-width}.

@item
Optional: Customize @code{ecb-toggle-layout-sequence} and toggle very fast
between several layouts by @code{ecb-toggle-layout}. See the doc-strings!

@item
Optional: Customize @code{ecb-show-sources-in-directories-buffer} to
not nil if the choosen layout (see 1. and 4.) contains a
directories-tree-buffer.

@item
Save your changes.
@end enumerate

But not only simulating speedbar is possible but also full integrating
it into the ECB and the ECB-frame, @xref{Integrating speedbar}.

@node Integrating speedbar, Optimize scrolling, Simulating speedbar, Tips and tricks
@section Integrating speedbar in the ECB-frame

It is very easy to integrate speedbar into ECB. There are two
different ways to do this:

@enumerate
@item
You can either use speedbar in the directories-, sources- or
methods-window of ECB instead of the builtin directory-, sources- or
methods-browser of ECB. This can be done via the option
@code{ecb-use-speedbar-instead-native-tree-buffer}.

@item
Or you can integrate an extra speedbar-window into a layout
independent of the existence of a directory-, sources- or
methods-window. For this you can either use the builtin layout
``left-dir-plus-speedbar'' or you have to create your own layout
interactively with the command @code{ecb-create-new-layout}. This way
is not described in more details because there is nothing more to
describe - just create your layout.
@end enumerate

In general integrating speedbar into the ECB-frame makes sense for
people...

@itemize @bullet
@item
...who like the speedbar way of handling directories and source-files
but also like the ECB-way of displaying the buffer-contents (like
methods and variables in a source-file). This people should use the
option @code{ecb-use-speedbar-instead-native-tree-buffer} and set it
to @code{dir}.

@item
...who like the speedbar way of browsing things like directories,
files, file-contents etc. but who dislike the extra speedbar-frame.
@end itemize

Note: It is not necessary to integrate speedbar if you only want
parsing sources not supported by semantic. From version 1.94 on ECB
supports native parsing and displaying of such sources
(@pxref{Non-semantic sources})!

Regardles the group you belong, with the speedbar-integration feature
of ECB you can combine both worlds, the speedbar- and the ECB-world:

@enumerate
@item Choose a layout which either contains a directories- or a
sources-window but not both of them@footnote{Only one of them is
needed if you use speedbar because speedbar displays directories and
sources in one window. But if you like wasting space then you can also
use a layout with both windows...}.

Because speedbar has also display-modes for buffers and info-nodes and
some other useful things (which can be changed by the speedbar-command
@code{speedbar-change-initial-expansion-list} we recommend layouts
like ``left15'' or ``leftright3'' for using with speedbar.

@item Set the option
@code{ecb-use-speedbar-instead-native-tree-buffer} to not nil. After
this the choosen window of ECB will contain a full featured speedbar
(the only difference to standard speedbar is not residing in an extra
frame).
@end enumerate

Note: If you belong to the first group of people (s.a.) a similar
effect and useability is available by setting
@code{ecb-use-speedbar-instead-native-tree-buffer} to nil and setting
@code{ecb-show-sources-in-directories-buffer} to not nil, because this
combination displays also directories and sources in one window.

So with the option @code{ecb-use-speedbar-instead-native-tree-buffer}
you have the choice which way of displaying and handling ``things''
(directories, sources, methods...) you want (the speedbar- or the
ECB-way).

During speedbar is running within ECB (i.e.
@code{ecb-use-speedbar-instead-native-tree-buffer} is not nil) the
speedbar-command @code{speedbar} is disabled and the speedbar-command
@code{speedbar-get-focus} switches between the speedbar-window and the
edit-window@footnote{The standard behavior is switching between the
speedbar-frame and the attached frame, but this make obviously no
sense during running speedbar with ECB.}.

@strong{NOTE}: ECB can only integrate speedbar-versions >= 0.14beta1!
If you use lower versions of speedbar
@code{ecb-use-speedbar-for-directories} has no effect.

@node Optimize scrolling, Large directories, Integrating speedbar, Tips and tricks
@section Optimize scrolling in the edit-window

@cindex Scrolling
Emacs 20.X seems to slow down scrolling if there is a horizontal split
in the frame and/or a lot of overlays in the buffer which is scrolled.
This is independend of ECB! But because almost all layouts of ECB uses
horizontal splits of the frame and because ECB is based on semantic
which uses overlays intensively there can be poor scrolling
performance in large buffers, especially with java-buffers in
@code{jde-mode}.

This scrolling performance can be increased a lot if the options
@code{scroll-conservatively} and @code{scroll-step} are set
appropriatelly: The former one should have a value of 0 during ECB is
active and the latter one a value of either 0 or > 1 (the exact value
depends on the power of your machine).

As far as we know this is not a problem of Emacs 21.X or XEmacs. With
these versions of Emacs there should be no scrolling problem even with
@code{scroll-step} has value 1.


@node Large directories, Using eshell, Optimize scrolling, Tips and tricks
@section Working with large directories

If @code{ecb-source-path} contains directories with many files and
subdirs, especially if these directories are mounted net-drives
(``many'' means here something > 1000, dependend on the speed of the
net-connection and the machine), actualizing the sources- and/or
directories- buffer of ECB (if displayed in current layout!) can slow
down dramatically. If this is a problem the contents of certain
directories and also the contents of the sources-buffer can be cached
which increases the speed a lot. See
@code{ecb-cache-directory-contents}.

IMPORTANT: The full speed-advantage of this cache-mechanism is only
available if @code{ecb-show-sources-in-directories-buffer} is
@code{nil}, i.e. sources of a directory are displayed in the
ECB-sources-window. The reason is that only with a sources window the
tree-buffer contents for the sources can be cached (i.e. the
buffer-content of the ECB-sources-window) whereas with sources
displayed in the directories buffer only the disk-contents of a
directory are cached - which increases speed too but not so much as
with sources displayed in the extra window ECB-sources.

The cache of a directory can be only refreshed by a POWER-click (with
mouse or keyboard) onto the related directory-node in the
directories-buffer of ECB (@pxref{Using the mouse}).

@node Using eshell, Grepping directories, Large directories, Tips and tricks
@section Optimal using of eshell in ECB

@cindex eshell
ECB offers a very smart integration of the ``eshell'' if you are using
a compile window (@pxref{Temp- and compile-buffers})@footnote{Of
course you can use eshell also if there is no compile-window. Then it
is just displayed in the edit-window and there is no special
integration.}

Here is a short summary of provided features:

@itemize @bullet
@item
Ability to jump to the eshell buffer within the compilation window
@kbd{C-c . e}. If the eshell isn't running it will be started.

@item
Expands the compilation window when you run commands. So for example
it allows you to view the eshell in minimized mode and then when you
run ``ls'' the window automatically expands (but always depending of
the output of the command you run).

@item
Sychronizes the current directory of the eshell with the current
buffer in the edit-window of ECB.

@item
Provides smart window layout of the eshell buffer. This makes sure
that the eshell is taking up the exact amount of space and that
nothing is hidden.
@end itemize

Here comes a detailled explanation of these features and how to use it:

Just call @code{ecb-eshell-goto-eshell} (bound to @kbd{C-c . e}) and
eshell will displayed in the compile-window of ECB (if eshell is not
already alive then it will be started automatically).

ECB tries to display the contents of the eshell-buffer as best as
possible, means ECB can autom. enlarge and shrink the compile-window
so the contents of the eshell are fitting the window. See option
@code{ecb-eshell-enlarge-when-selecting}. Normally this is done autom.
but you can also do it on demand with the command
@code{ecb-eshell-enlarge}.

ECB tries also to recenter the eshell-buffer as best as possible.
Normally this is done autom but you can do it on demand with the
command @code{ecb-eshell-recenter}.

If option @code{ecb-eshell-synchronize} is true then ECB always
syncronizes the command prompt of eshell with the directory of current
source-buffer of the edit-window.

With the option @code{ecb-eshell-auto-activate} you can start eshell
autom. in the compile-window when ECB is started but of course if a
compile-window exists.

@node Grepping directories, Working with JDEE, Using eshell, Tips and tricks
@section Grepping directories with ECB

ECB offers in the popup-menus in the directories- and
sources-tree-buffer commands for easy (recursive) grepping the current
directory under point (directory-buffer) resp. the current-directory
(sources-buffer). In every case just the function of the options
@code{ecb-grep-function} resp. @code{ecb-grep-find-function} is called
and the @code{default-directory} is tempor. set to the choosen
directory so the grep will performed in this directory regardless of
the @code{default-directory} of current buffer in the edit-window.

Other smart things beyond that are not done by ECB, see also
@code{ecb-grep-function}!

So, how to exclude some subdirectories or files from the grep?

Basically this has to be done with the ``-prune'' option of the
find-utility: If the standard-grep facility of Emacs is used then this
is not easy but with the library @file{igrep.el} there is a conveniant
way to exclude things like CVS- or RCS-directories from the find-call:
See the variable @code{igrep-find-prune-clause} of the library
@file{igrep.el}.

@node Working with JDEE, Compile-window on demand, Grepping directories, Tips and tricks
@section Working best with ECB and JDEE

ECB is completely language independent, i.e. it works with any
language supported by semantic (e.g. C, C++, Java, Elisp etc.).

But there are some special integrations for the great
Java-Development-Environment JDEE:

@itemize @bullet
@item Displaying contents of class under point

With the command @code{ecb-jde-display-class-at-point} you can display
the contents of the class which contains the definition of the
``thing'' at point (which can be a method, variable etc.).

@item Creating new source-files

The popup-menues in the directories- and the sources-buffer offer a
command ``Create Source'' which allows easy creating new java-sources
by calling the command @code{jde-gen-class-buffer}.
@end itemize

@node Compile-window on demand, Non-semantic sources, Working with JDEE, Tips and tricks
@section Displaying the compile-window on demand

If you like displaying all output of compile/grep/etc. in an extra
compile-window (@pxref{Temp- and compile-buffers}) but you dislike
wasting the space of this compile-window if you are just editing then
you can get a compile-window ``on demand''. Just do the following:

@enumerate
@item
Customize @code{ecb-compile-window-height} to not nil and save it for
future sessions. This gives you an extra compile-window at the
bottom.

@item
Add the following to your .emacs:

@example
(add-hook 'ecb-activate-hook
          (lambda ()
             (ecb-toggle-compile-window -1)))
@end example

This hides the extra compile-window direct after the start of ECB
because there is no need for a compile-window at this moment.

@end enumerate

This is all you have to do. Now if you run @code{compile} (or
@code{grep} or other compile-modes) then ECB autom. displays the
compile-window at the bottom an display the compile-output there.

If you have finished with using the compile-output (e.g. fixing
errors) then you can throw away the compile-window just by
@code{ecb-toggle-compile-window} - ECB will reactivate it autom.
before next compilation!

@node Non-semantic sources, Hide-show, Compile-window on demand, Tips and tricks
@section Parsing and displaying non-semantic sources

ECB is mostly designed to display parsing information for files
supported by semantic. But from version 1.94 on it also supports other
parsing engines like imenu and etags, so also files not supported by
semantic but by imenu/etags can be displayed in the Method-buffer of
ECB. See @ref{Definiton of semantic- and non-semantic-sources} for a
description of ``semantic-sources'' and ``non-semantic-sources''.

If support of non-semantic-sources is enabled then ECB will display
the contents of all sources which can be displayed by speedbar too.
This comes from the fact that ECB uses speedbar-logic to parse sources
with imenu or etags.

In most cases imenu-parsing is preferable over etags-parsing because
imenu operates on Emacs-buffers and needs no external tool and
therefore parsing works also if current contents of a buffer are not
saved to disk.

This section describes all important aspects about parsing and
displaying file-contents of file-types not supported by semantic but
by imenu and/or etags.

@subsection Enabling parsing and displaying of non-semantic-sources

Enabling is simply done with the option @code{ecb-process-non-semantic-files}.

ECB offers an option @code{ecb-non-semantic-parsing-function} to
specify on a major-mode basis which parsing-method should be used:
imenu or etags. Normaly there should be no need to change this option
but read the documentation of this option (@pxref{ecb-non-semantic})
for further details.

IMPORTANT:

@itemize
@item
If imenu-parsing should be used then the option
@code{speedbar-use-imenu-flag} must be set to not @code{nil}!

@item
If some non-semantic-sources are not parsed (i.e. there is an empty
Methods-buffer) and you think that they should then maybe they are neither
supported by imenu nor by etags or you have to check the options
@code{ecb-non-semantic-parsing-function} and
@code{speedbar-dynamic-tags-function-list} and - especially for etags -
@code{speedbar-fetch-etags-parse-list}, @code{speedbar-fetch-etags-arguments}
and @code{speedbar-fetch-etags-command}.

@item
Even with support for semantic-, imenu- and etags-parsing there will
remain some file-types resp. @code{major-modes} which are not
parsable, neither by semantic, imenu nor etags. This is no problem
because these files simply have an empty Methods-buffer. But
nevertheless you will get a message ``Sorry, no support for a file of
that extension'' which comes from the speedbar-library and can not
switched off. Therefore if a @code{major-mode} is known as not
parsable by semantic, imenu or etags it can be added to the option
@code{ecb-non-semantic-exclude-modes} and then it will be excluded
from being tried to parsed and this (annoying) message will not occur.
@end itemize

@subsection Automatic rescanning/reparsing of non-semantic-sources

In contrast to semantic (see @code{global-semantic-auto-parse-mode})
there is no builtin mechanism for autom. reparsing
non-semantic-sources and then updating the contens of the
Methods-buffer.

For non-semantic-sources you have always at least to call
@code{ecb-rebuild-methods-buffer} (bound to @kbd{C-c . r}) or saving
the source-file (if @code{ecb-auto-update-methods-after-save} is true)
to update the Method-buffer@footnote{Maybe future versions of ECB (>
1.94) will offer an autom. mechanism for this.}.

Depending on the parsing-mechanism the following options have to be
switched on so ECB can rebuild the methods-buffer for
non-semantic-sources:

@itemize @bullet
@item imenu:

The imenu-option @code{imenu-auto-rescan} must be enabled and
@code{imenu-auto-rescan-maxout} has to be set big enough to auto-parse
big files too! But this results not directly in an autom. updated
Method-buffer. This is first done after calling the command
@code{ecb-rebuild-methods-buffer} or saving the source-file (if
@code{ecb-auto-update-methods-after-save} is true).

@item etags:

Only if @code{ecb-auto-save-before-etags-methods-rebuild} is switched on
the command @code{ecb-rebuild-methods-buffer} rebuilds the
method-buffer with current source-contents. See description of this
option for an explanation.
@end itemize

Tip: If you want to program your own real. automatic
rescan/reparse/rebuild mechanism for non-semantic-sources you can do:

Adding to @code{after-change-functions} a function F which either runs
itself @code{ecb-rebuild-methods-buffer-for-non-semantic} or which
adds only another function FF to an idle-timer and the function FF
runs @code{ecb-rebuild-methods-buffer-for-non-semantic}. The latter
approach has the advantage that the reparse/rebuild is not performed
immediately after every change but first after Emacs is idle for a
senseful interval (e.g. 4 seconds) after last change. Of course the
function FF has to cancel its own idle-timer at the end, so the next
idle-timer is first started again after the next change (i.e. by
function F which is still contained in @code{after-change-functions}.

@subsection Customizing the display of the tokens

For non-semantic-sources ECB uses does no special organizing of tokens
in groups and subtokens but it completely uses the token-hierarchy the
imenu- and etags-parsers of speedbar return. So the displayed token
hierarchy can only be customized with some options speedbar offers for
this:

@code{speedbar-tag-hierarchy-method},
@code{speedbar-tag-group-name-minimum-length},
@code{speedbar-tag-split-minimum-length} and
@code{speedbar-tag-regroup-maximum-length}. See the speedbar
documentation for details about these options.

With the option @code{ecb-method-non-semantic-face} you can define the
face used for displaying the tokens in the Method-buffer for
non-semantic-sources.

@code{ecb-non-semantic-methods-initial-expand} can be useful too.


@node Hide-show, , Non-semantic sources, Tips and tricks
@section Using hide-show from the methods-buffer-menu

The popup-menu of the Methods-buffer offer two entries for either
hiding or showing the block which is related to the selected token
(that token for which the popup-menu was opened):

@itemize @bullet
@item ``Jump to token and hide block'':
Jumps to the token and calls @code{hs-hide-block} from the
hideshow-library which is shipped with (X)Emacs. After that the block
is hidden, i.e. only the header-line of that token (method, variable
etc.) is visible, the rest is hidden behind the ``...''.

@item ``Jump to token and show block'':
Jumps to the token and calls @code{hs-show-block}. This shows the related
hidden block if the block was hidden via @code{hs-hide-block} or the
menu-entry ``Jump to token and hide block'' (s.a.).
@end itemize

For this feature the library @file{hideshow.el} is used which should
normally being included in the (X)Emacs-distribution. If this library
is not loaded into Emacs, ECB does this automatically before the first
call to one of these menu-entries.

IMPORTANT: If in some @code{major-mode} hiding and showing does not
work as you expect it to work then you must probably add an entry for
this @code{major-mode} to the hideshow-variable
@code{hs-special-modes-alist}. See the documentation of this variable
for further details. One example of such a @code{major-mode} is
@code{jde-mode} of the Java Development Environment JDEE; just add an
entry for it like the already contained entries for @code{c++-mode} or
@code{java-mode} and hiding and showing will work for you with JDEE
too.

@node Elisp programming, Conflicts and bugs, Tips and tricks, Top
@chapter Entry points for elisp programmers

This chapter describes how ECB can be used/programmed/driven by an
elisp-program. This contains:

@menu
* List of variables::           Which variables an elisp-program can use
* List of hooks::               All available hooks
* tree-buffer::                 Some words to the tree-buffer-library
* Adviced functions::           How to deal with the adviced functions
* The layout-engine::           Programming new layouts and special windows
@end menu

@node List of variables, List of hooks, Elisp programming, Elisp programming
@section Variables for elisp-programs

Variables an elisp-program can use beyond those ones mentioned in
@ref{The layout-engine}:

@itemize @bullet
@item @code{ecb-source-path-functions}
@end itemize

Look at the documentation of these variables to get a description.

@node List of hooks, tree-buffer, List of variables, Elisp programming
@section Available hooks of ECB

The following hooks are available:

@cindex Hooks
@itemize @bullet
@item @code{ecb-activate-before-new-frame-created-hook}
@item @code{ecb-activate-before-layout-draw-hook}
@item @code{ecb-activate-hook}
@item @code{ecb-before-activate-hook}
@item @code{ecb-before-deactivate-hook}
@item @code{ecb-common-tree-buffer-after-create-hook}
@item @code{ecb-current-buffer-sync-hook}
@item @code{ecb-deactivate-hook}
@item @code{ecb-directories-buffer-after-create-hook}
@item @code{ecb-hide-ecb-windows-after-hook}
@item @code{ecb-hide-ecb-windows-before-hook}
@item @code{ecb-history-buffer-after-create-hook}
@item @code{ecb-methods-buffer-after-create-hook}
@item @code{ecb-redraw-layout-after-hook}
@item @code{ecb-redraw-layout-before-hook}
@item @code{ecb-show-ecb-windows-after-hook}
@item @code{ecb-show-ecb-windows-before-hook}
@item @code{ecb-sources-buffer-after-create-hook}
@end itemize

Look at the documentation of these hooks to get a detailled description.

@node tree-buffer, Adviced functions, List of hooks, Elisp programming
@section The library tree-buffer.el

The library tree-buffer.el is ECB independent and can be used for
other applications too. But such an application is not allowed to use
any of the variables of tree-buffer.el especially not the variable
@strong{tree-buffers}!

@code{tree-buffers}: Only for internal use. It contains all
tree-buffers of current Emacs-instance, means @strong{all}
tree-buffers of @strong{all} applications which uses currently
tree-buffers. Every application must store its own collection of
tree-buffers in an own variable! For example: ECB stores its
tree-buffer set in @code{ecb-tree-buffers}!

An application may only use the methods tree-buffer.el provides but no
internal variables!

@node Adviced functions, The layout-engine, tree-buffer, Elisp programming
@section How to deal with the adviced window-functions

ECB offers for packages which work during activated ECB three macros
for easy temporally@footnote{I.e. regardless of the settings in
@code{ecb-advice-window-functions}!} using all original-functions, all
adviced functions or only some adviced functions:

@itemize @minus
@item @code{ecb-with-original-functions}
@item @code{ecb-with-adviced-functions}
@item @code{ecb-with-some-adviced-functions}
@end itemize

For a detailed explanation of each macro read the documentation with
@code{describe-function}!

@node The layout-engine, , Adviced functions, Elisp programming
@section How to program new layouts and new special windows

There are two aspects concerning this topic:

@enumerate
@item
Programming a new layout which contains several special ECB-windows
like directories, sources, methods, history or other special windows
and arranging them in a new outline.

@item
Creating complete new special windows (e.g. a local-variable window
for a graphical debugger like JDEbug of JDEE), adding them to a layout
and synchronizing them with the edit-window.
@end enumerate

The former one covers merely the layout-programming aspect which is
explained in the first subsection of this chapter whereas the latter one
covers all aspects of creating new special windows and what is
necessary to synchronize it with the edit-window of ECB. This is
explained in the second subsection which will refers to the first
subsection.

@menu
* Programming a new layout::    How to program a new layout
* Programming special windows:: Aspects of programming special windows
* Possible layout-outlines::    The wide range of possible layouts
* The layout-engine API::       The complete layout-engine API
@end menu

@node Programming a new layout, Programming special windows, The layout-engine, The layout-engine
@subsection How to program a new layout

If you just want creating a new layout with the standard ECB-windows
like directories, sources, methods, history and speedbar it's is
strongly recommended to define the new layout interactively with the
command @code{ecb-create-new-layout} (@pxref{Creating a new
ECB-layout}).

If you want creating a new layout and if this layout should contain
other special windows than the standard ECB-windows then it's still
recommended to define this layout interactively with
@code{ecb-create-new-layout} and using the option to give the created
windows user-defined types. For every user defined type you have then
just to program the necessary buffer-set function. For all the details
see @ref{Creating a new ECB-layout}.

But if you do not like the interactive way (because you are tough and
brave) but you want programming the new layout with elisp then use the
macro @code{ecb-layout-define} (the following definiton has stripped
the prefix ``ecb-'' for better indexing this manual):

@defmac layout-define name type &rest create-code
Creates a new ECB-layout with name @var{NAME}. @var{TYPE} is the type
of the new layout and is literal, i.e. not evaluated. It can be left,
right, top or left-right. @var{DOC} is the docstring for the new
layout-function ``ecb-layout-function-<name>''. @var{CREATE-CODE} is
all the lisp code which is necessary to define the
ECB-windows/buffers. This macro adds the layout with @var{NAME} and
@var{TYPE}to the internal variable @code{ecb-available-layouts}.

Preconditions for @var{CREATE-CODE}:
@enumerate
@item
Current frame is splitted at least in one edit-window and the
``column'' (for layout types left, right and left-right) resp. ``row''
(for a top layout) for the special ECB-windows/buffers. The width of
the ``column'' resp. the height of the ``row'' is always defined with
the option @code{ecb-windows-width} resp. @code{ecb-windows-height}.
Depending on the value of the option @code{ecb-compile-window-height}
there is also a compile window at the bottom of the frame which is
stored in @code{ecb-compile-window}.

@item
All windows are not dedicated.

@item
Neither the edit-window nor the compile-window (if there is one) are
selected for types left, right and top. For type left-right the left
column-window is selected

@item
All ECB-advices for the functions in
@code{ecb-advice-window-functions} are disabled!
@end enumerate

Things @var{CREATE-CODE} has to do:
@enumerate
@item
Splitting the ECB-tree-windows-column(s)/row (s.a.) in all the
ECB-windows the layout should contain (directories, sources, methods
and history). The split must not be done with other functions than
@code{ecb-split-hor} and @code{ecb-split-ver}! It is recommened not to
to use a ``hard'' number of split-lines or -rows but using fractions
between -0.9 and +0.9! Tip: It is recommended to spilt from right to
left and from bottom to top or with other words: First create the
right-most and bottom-most special windows!

@item
Making each special ECB-window a dedicated window. This can be done with
one of the following functions:
@itemize @minus
@item @code{ecb-set-directories-buffer}
@item @code{ecb-set-sources-buffer}
@item @code{ecb-set-methods-buffer}
@item @code{ecb-set-history-buffer}
@item @code{ecb-set-speedbar-buffer}
@end itemize
Each layout can only contain one of each tree-buffer-type!

In addition to these functions there is a general macro
@code{ecb-with-dedicated-window}. This macro performs any arbitrary
code in current window and makes the window autom. dedicated at the
end. This can be used by third party packages like JDEE to create
arbitrary ECB-windows besides the standard tree-windows.

To make a special ECB-window a dedicated window either one of the five
functions above must be used or a function(!) which calls in turn the
macro @code{ecb-with-dedicated-window}. See the documentation of this
macro how to use it!

Such a function is called a ``dedicated setter'' and must(!) use
@code{ecb-with-dedicated-window} to make the window dedicated!

@item
Every(!) special ECB-window must be dedicated as described in 2.

@item
@var{CREATE-CODE} must work correctly regardless if there is already a
compile-window (stored in @code{ecb-compile-window}) or not
(@code{ecb-compile-window} is nil).
@end enumerate

Things @var{CREATE-CODE} can do or can use:
@enumerate
@item
The value of @code{ecb-compile-window} which contains the compile-window (if
there is one). Using the values of @code{ecb-compile-window-height},
@code{ecb-windows-width}, @code{ecb-windows-height}.
@end enumerate

Things @var{CREATE-CODE} must NOT do:
@enumerate
@item Splitting the edit-window
@item Creating a compile-window
@item
Deleting the edit-window, the compile-window (if there is any) or the
ECB-windows-column(s)/row (see Precondition 1.)
@item
Referring to the value of @code{ecb-edit-window} because this is always nil
during @var{CREATE-CODE}.
@end enumerate

Postconditions for @var{CREATE-CODE}:
@enumerate
@item
The edit-window must be the selected window and must not be dedicated
and not be splitted.

@item
Every window besides the edit-window \(and the compile-window) must be
a dedicated window \(e.g. a ECB-tree-window).
@end enumerate
@end defmac

Use this macro to program new layouts within your @file{.emacs} or any
other file which is loaded into your Emacs. After loading the file(s)
with all the new layout-definitions you can use it by customizing the
option @code{ecb-layout-name} to the appropriate name or with the
command @code{ecb-change-layout}.

With the function @code{ecb-layout-undefine} you can remove a layout
from the list of available layouts:

@defun layout-undefine name
Unbind ecb-layout-function-<NAME>,
ecb-delete-window-ecb-windows-<NAME>,
ecb-delete-other-windows-ecb-windows-<NAME> and remove @code{NAME}
from @code{ecb-available-layouts}.
@end defun

Here is an example for a new layout programmed with
@code{ecb-layout-define}:

@example
@group
(ecb-layout-define "my-own-layout" left nil
  ;; The frame is already splitted side-by-side and point stays in the
  ;; left window (= the ECB-tree-window-column)

  ;; Here is the creation code for the new layout
  
  ;; 1. Defining the current window/buffer as ECB-methods buffer
  (ecb-set-methods-buffer)
  ;; 2. Splitting the ECB-tree-windows-column in two windows
  (ecb-split-ver 0.75 t)
  ;; 3. Go to the second window
  (other-window 1)
  ;; 4. Defining the current window/buffer as ECB-history buffer
  (ecb-set-history-buffer)
  ;; 5. Make the ECB-edit-window current (see Postcondition above)
  (select-window (next-window)))
@end group
@end example

This layout definition defines a layout with name ``my-own-layout''
which looks like:

@example
@group
-------------------------------------------------------
|              |                                      |
|              |                                      |
|              |                                      |
|  Methods     |                                      |
|              |                                      |
|              |                                      |
|              |               Edit                   |
|              |                                      |
|              |                                      |
|--------------|                                      |
|              |                                      |
|  History     |                                      |
|              |                                      |
-------------------------------------------------------
|                                                     |
|                    Compilation                      |
|                                                     |
-------------------------------------------------------
@end group
@end example

@node Programming special windows, Possible layout-outlines, Programming a new layout, The layout-engine
@subsection All aspects of programming special windows

ECB offers a flexible programmable layout-engine for other packages to
display their own contents and informations in special ECB-windows. An
example could be a graphical debugger which offers a special window for
displaying local variables and another special window for messages
from the debugger-process (like JDEbug of JDEE@footnote{JDEE is
available at
@ifhtml
@uref{http://jdee.sunsite.dk/}
@end ifhtml
@ifnothtml
@url{http://jdee.sunsite.dk/}
@end ifnothtml
}).

This section explains all aspects of programming new special windows,
adding them to a new layout and synchronizing them with edit-window of
ECB. This can be done best with an easy example which nevertheless
covers all necessary aspects to be a good example and skeleton for
complex tools (like a graphical debugger) which want to use the
layout-engine of ECB do display their own information.

Here comes the example:

@subsubsection The outline of the example layout:

@example
@group
-------------------------------------------------------
|Bufferinfo for <filename>:            |[prior]       |
|Type: file                            |[next]        |
|Size: 23456                           |              |
|Modes: rw-rw-rw-                      |              |
|-----------------------------------------------------|
|                                                     |
|                                                     |
|                                                     |
|                                                     |
|                 edit-window                         |
|                                                     |
|                                                     |
|                                                     |
|                                                     |
-------------------------------------------------------
|                                                     |
|                 compilation-window                  |
|                                                     |
-------------------------------------------------------
@end group
@end example

@subsubsection The description of the layout-contents

The top-left window always displays informations about the current
buffer in the selected edit-window. This window demonstrates how
autom. synchronizing a special window/buffer of a layout with current
edit-window.

The top-right window contains an read-only ``action-buffer'' and
offers two buttons which can be used with the middle mouse-button to
scroll the edit-window. This is not very senseful but it demonstrates
how to control the edit-window with actions performed in a special
window/buffer of a layout.

(If you have not set a compilation-window in
@code{ecb-compile-window-height} then the layout contains no durable
compilation window and the other windows get a little more place).

@subsubsection The example code

Now let have us a look at the several parts of the elisp-program
needed to program this new example layout. ECB contains a library
@file{ecb-examples.el} which contains the full working code of this
example. To test this example and to play with it you can load this
library into Emacs (with @code{load-library} for example) and then
calling @code{ecb-change-layout} (bound to @kbd{C-c . lc}) and
inserting ``example-layout1'' as layout-name. An alternative is
calling @code{ecb-examples-activate} and
@code{ecb-examples-deactivate}. For details see file
@file{ecb-examples.el}.

The following steps only contain code-skeletons to demonstrate the
principle. The full working code is available in
@file{ecb-examples.el}.

@subsubsection The bufferinfo buffer of the example

The name of the bufferinfo buffer:

@lisp
(defconst ecb-examples-bufferinfo-buffer-name " *ECB buffer info*")
@end lisp

Two helper functions for displaying infos in a special buffer:


@lisp
@group
(defun ecb-examples-print-file-attributes (buffer filename)
  (ecb-with-readonly-buffer buffer
    (erase-buffer)
    (insert (format "Bufferinfo for %s:\n\n" filename))
    ;; insert with the function `file-attributes' some 
    ;; informations about FILENAME.
    ))

(defun ecb-examples-print-non-filebuffer (buffer buffer-name)
  (ecb-with-readonly-buffer buffer
    (erase-buffer)
    ;; analogous to `ecb-examples-print-file-attributes'
    ))
@end group
@end lisp

The main synchronizing function added to
@code{ecb-current-buffer-sync-hook} for autom. evaluation by
@code{ecb-current-buffer-sync} which runs dependend on the values of
@code{ecb-window-sync} and @code{ecb-window-sync-delay}. This function
synchronizes the bufferinfo buffer with the current buffer of the
edit-window if that buffer has changed.

@lisp
@group
(defun ecb-examples-bufferinfo-sync ()
  (ecb-do-if-buffer-visible-in-ecb-frame
      'ecb-examples-bufferinfo-buffer-name

    ;; here we can be sure that the buffer with name
    ;; `ecb-examples-bufferinfo-buffer-name' is displayed in a 
    ;; window of `ecb-frame'

    ;; The macro `ecb-do-if-buffer-visible-in-ecb-frame' locally 
    ;; binds the variables visible-buffer and visible-window!! See
    ;; documentation of this macro!

    (let ((filename (buffer-file-name (current-buffer))))
     
      (if (and filename (file-readable-p filename))
            
          ;; real filebuffers
          ;; here we could add a smarter mechanism;
          ;; see ecb-examples.el
          (ecb-examples-print-file-attributes visible-buffer
                                              filename)
        
        ;; non file buffers like help-buffers etc...
        (setq ecb-examples-bufferinfo-last-file nil)
        (ecb-examples-print-non-filebuffer visible-buffer
                                           (buffer-name
                                             (current-buffer)))
        ))))
@end group
@end lisp

The function which makes the bufferinfo-buffer dedicated to a window.

@lisp
@group
(defun ecb-examples-set-bufferinfo-buffer ()
  (ecb-with-dedicated-window
      ecb-examples-bufferinfo-buffer-name
      'ecb-examples-set-bufferinfo-buffer
    (switch-to-buffer (get-buffer-create
                       ecb-examples-bufferinfo-buffer-name))
    (setq buffer-read-only t)))
@end group
@end lisp


This is all what we need for the special bufferinfo buffer. We have
demonstrated already three of the important functions/macros of the
layout-engine API of ECB: @code{ecb-with-readonly-buffer},
@code{ecb-do-if-buffer-visible-in-ecb-frame} and
@code{ecb-with-dedicated-window} (@pxref{The layout-engine
API}. Especially the second macro is strongly recommended for
programming good synchronizing functions which do not waste CPU!

@subsubsection The action buffer of the example

The name of the action-buffer:

@lisp
(defconst ecb-examples-action-buffer-name " *ECB action buffer*")
@end lisp

Two helper functions for creating a readonly action-buffer with a
special local keymap for the middle-mouse-button and two buttons
[prior] and [next]:

@lisp
@group
(defun ecb-examples-insert-text-in-action-buffer (text)
  (let ((p (point)))
    (insert text)
    (put-text-property p (+ p (length text)) 'mouse-face
                                             'highlight)))

(defun ecb-examples-action-buffer-create ()
  (save-excursion
    (if (get-buffer ecb-examples-action-buffer-name)
        (get-buffer ecb-examples-action-buffer-name)

      (set-buffer (get-buffer-create
                    ecb-examples-action-buffer-name))

      ;; we setup a local keymap and bind middle-mouse-button
      ;; see ecb-examples.el for the full code        

      ;; insert the action buttons [prior] und [next] and
      ;; make it read-only
      
      (ecb-with-readonly-buffer (current-buffer)
        (erase-buffer)
        (ecb-examples-insert-text-in-action-buffer "[prior]")
        ;; analogous for the [next] button
        )
      
      (current-buffer))))
@end group
@end lisp

The function which performs the actions in the action-buffer if
clicked with the middle-mouse button onto a button [next] or [prior].

@lisp
@group
(defun ecb-examples-action-buffer-clicked (e)
  (interactive "e")
  (mouse-set-point e)
  (let ((line (buffer-substring (ecb-line-beginning-pos)
                                (ecb-line-end-pos))))
    (cond ((string-match "prior" line)
           (ecb-select-edit-window)
           (call-interactively 'scroll-down))
          ((string-match "next" line)
           ;; analogous for [next]
           ))))
@end group
@end lisp

The function which makes the action-buffer dedicated to a window.

@lisp
@group
(defun ecb-examples-set-action-buffer ()
  (let ((buf-name (buffer-name (ecb-examples-action-buffer-create))))
    (ecb-with-dedicated-window buf-name 'ecb-examples-set-action-buffer
      (switch-to-buffer (buffer-name
                         (ecb-examples-action-buffer-create))))))
@end group
@end lisp

We do not need more code for the action buffer. All of the code is
standard emacs-lisp which would also needed if used without ECB.

@subsubsection Adding the bufferinfo- and action-buffer to a new layout

Now we add the bufferinfo- and the action-buffer to a new layout of
type top with name ``example-layout1'':

@lisp
@group
(ecb-layout-define "example-layout1" top
  
  ;; dedicating the bufferinfo window to the bufferinfo-buffer
  (ecb-examples-set-bufferinfo-buffer)

  ;; creating the action-window
  (ecb-split-hor 0.75)
  
  ;; dedicate the action window to the action-buffer
  (ecb-examples-set-action-buffer)

  ;; select the edit-window
  (select-window (next-window)))
@end group
@end lisp

This all what we need to define the new layout. See @ref{Programming a
new layout} for more details of the pure layout-programming task.

@subsubsection Synchronizing the bufferinfo-buffer automatically

The last thing we have to do is to synchronize the bufferinfo-buffer
with current edit-window. We do this by adding
@code{ecb-examples-bufferinfo-sync} to the hook
@code{ecb-current-buffer-sync-hook'} (The file @file{ecb-examples.el}
shows a smarter mechanism for (de)activating the new layout and the
synchronization but this works also very well).

@lisp
(add-hook 'ecb-current-buffer-sync-hook 'ecb-examples-bufferinfo-sync)
@end lisp

@subsubsection Activating and deactivating new layouts

Because a set of new special windows integrated in a new layout is
often just the GUI of a complete tool (like a graphical debugger) we
demonstrate here the complete activation and deactivation of such a
tool or at least of the tool-GUI. We decide that the GUI of our
example ``tool'' needs a compile-window with height 5 lines and the
height of the special windows ``row'' on top should be exactly 6 lines
(normally width and height of the special windows should be a fraction
of the frame, but here we use 6 lines@footnote{You can change the code
in the file @file{ecb-examples.el} to use a frame-fraction of 0.2
instead of 6 hard lines, just try it!}

Here comes the (de)activation code.

The code for saving and restoring the state before activation (the
full code is available in @file{ecb-examples.el}:

@lisp
@group
(defun ecb-examples-preactivation-state(action)
  (cond ((equal action 'save)
         ;; code for saving the state
         )
        ((equal action 'restore)
        ;; code for restoring the state
        )))
@end group
@end lisp

The following function activates the GUI of our example tool:

@lisp
@group
(defun ecb-examples-activate ()
  (interactive)
  
  ;; activating the synchronization of the bufferinfo-window
  (add-hook 'ecb-current-buffer-sync-hook
            'ecb-examples-bufferinfo-sync)
  
  ;; saving the state
  (ecb-examples-preactivation-state 'save)

  ;; switch to our prefered layout
  (setq ecb-windows-height 6)
  (setq ecb-compile-window-height 5)
  (ecb-layout-switch "example-layout1"))
@end group
@end lisp

This function deactivates the GUI of our example-tool and restores the
state as before activation:

@lisp
@group
(defun ecb-examples-deactivate ()
  (interactive)
  
  (remove-hook 'ecb-current-buffer-sync-hook
               'ecb-examples-bufferinfo-sync)
  (ecb-examples-preactivation-state 'restore)
  (ecb-layout-switch ecb-layout-name))
@end group
@end lisp


Now we have all code for the new layout and the new layout-buffers.
The example is ready for use; just load @file{ecb-examples.el} (s.a.).

@node Possible layout-outlines, The layout-engine API, Programming special windows, The layout-engine
@subsection The wide range of possible layout-outlines

In the two previous sections @ref{Programming a new layout} and
@ref{Programming special windows} we have explained in detail how to
program new layouts and how to program new special windows/buffers and
adding them to a new layout.

The intention of this section is to be a summary what are the real
restrictions for a new layout-outline programmed with
@code{ecb-layout-define}. This is necessary because until now we just
programmed ``obvious'' layouts, means layout which are in principle
very similar to the standard ones which means one big edit-window and
some special windows ``around'' this edit-window. This section will
show you that a layout can have also very different outlines.

Ok, here are the real restrictions and conditions for a layout
programmed with @code{ecb-layout-define}:
@enumerate
@item
It must have exactly one edit-window regardless of its size.

@item
All other windows created within the @var{CREATE-CODE} body of
@code{ecb-layout-define} (@pxref{Programming a new layout}) must be
dedicated to their buffers.

@item
All the dedicated windows must (exclusive!) either reside on the left,
right, top or left-and-right side of the edit-window. This will be
defined with the @var{TYPE}-argument of @code{ecb-layout-define}
(@pxref{Programming a new layout}).
@end enumerate

You see, there are only three restrictions/conditions. These and only
these must be fullfilled at layout-programming.

Demonstrating what this really means and how flexible the
layout-engine of ECB really is, can be done best with some
``pathological'' layout-outlines. All the following are correct
layouts (working code is added below each layout):

The following is a top layout with three vertical layered special
windows.

@example
@group
------------------------------------------------------------------
|                                                                |
|                 Upper special window                           |
|                                                                |
|----------------------------------------------------------------|
|                                                                |
|                 Middle special window                          |
|                                                                |
|----------------------------------------------------------------|
|                                                                |
|                 Lower special window                           |
|                                                                |
|================================================================|
|                                                                |
|                         Edit-window(s)                         |
|                 (can be splitted in two windows)               |
------------------------------------------------------------------
|                                                                |
|                 Compilation-window (optional)                  |
|                                                                |
------------------------------------------------------------------
@end group
@end example

Here is the code for that top layout (all buffers are dummy-buffers):

@lisp
@group

;; The "dedicated setter" functions:

(defun ecb-set-usw-buffer ()
  (ecb-with-dedicated-window
    "Upper special window"
    'ecb-set-usw-buffer
      (switch-to-buffer (get-buffer-create "Upper special window"))))

(defun ecb-set-msw-buffer ()
  (ecb-with-dedicated-window
    "Middle special window"
    'ecb-set-msw-buffer
      (switch-to-buffer (get-buffer-create "Middle special window"))))

(defun ecb-set-lsw-buffer ()
  (ecb-with-dedicated-window
    "Lower special window"
    'ecb-set-lsw-buffer
      (switch-to-buffer (get-buffer-create "Lower special window"))))

;; The layout itself:

(ecb-layout-define "example-layout3" top
  nil

  ;; here we have an edit-window and above one top window which we can
  ;; now split in several other windows. Dependend on the value of
  ;; `ecb-compile-window-height' we have also a compile-window at the
  ;; bottom.

  (ecb-set-usw-buffer)
  (ecb-split-ver 0.33)
  (ecb-set-msw-buffer)
  (ecb-split-ver 0.5)
  (ecb-set-lsw-buffer)

  ;; select the edit-window.
  (select-window (next-window)))
@end group
@end lisp


The following is a left-right layout which has six special windows in
the left-''column'' and one big special window in the
right-''column''. For left-right layouts the left-''column'' and the
right-''column'' have always the same width.

@example
@group
------------------------------------------------------------------
|             |       |                   |                      |
| Left1       | Left5 |                   |                      |
|             |       |                   |                      |
|-------------|       |                   |                      |
|      |      |       |                   |                      |
|      |      |       |                   |                      |
|      |      |       |                   |                      |
| Left2| Left3|-------|  Edit-window(s)   |   Right1             |
|      |      |       | (can be splitted  |                      |
|      |      |       |  in two windows)  |                      |
|      |      |       |                   |                      |
|-------------|       |                   |                      |
|             |       |                   |                      |
| Left4       | Left6 |                   |                      |
|             |       |                   |                      |
------------------------------------------------------------------
|                                                                |
|                 Compilation-window (optional)                  |
|                                                                |
------------------------------------------------------------------
@end group
@end example

Here is the code for that left-right layout, again with dummy-buffers
(depending to your screen-resolution you will need a quite big value
for @code{ecb-windows-width}, e.g. 0.4):

Here is one of the ``dedicated setter'' functions@footnote{The
``dedicated setter functions'' for all these ecb-windows/buffers are
not explicitly described - they look all like
@code{ecb-set-left1-buffer}
- of course with different buffer-names!}:

@lisp
@group
(defun ecb-set-left1-buffer ()
  (ecb-with-dedicated-window
    "Left1"
    'ecb-set-left1-buffer
      (switch-to-buffer (get-buffer-create "Left1"))))
@end group
@end lisp

Here is the layout-definition itself:

@lisp
@group
(ecb-layout-define "example-layout2" left-right
  nil

  ;; here we have an edit-window and left and right two windows each
  ;; with width `ecb-windows-width'. Dependend to the value of
  ;; `ecb-compile-window-height' we have also a compile-window at the
  ;; bottom.

  (ecb-set-left1-buffer)
  (ecb-split-hor 0.66 t)
  (ecb-split-ver 0.75)
  (ecb-set-left4-buffer)
  (select-window (previous-window (selected-window) 0))
  (ecb-split-ver 0.25 nil t)
  (ecb-set-left2-buffer)
  (ecb-split-hor 0.5)
  (ecb-set-left3-buffer)
  (select-window (next-window (next-window)))
  (ecb-set-left5-buffer)
  (ecb-split-ver 0.5)
  (ecb-set-left6-buffer)
  (select-window (next-window (next-window)))
  (ecb-set-right1-buffer))

  ;; select the edit-window
  (select-window (previous-window (selected-window) 0)))
@end group
@end lisp

Especially the last example should demonstrate that even very
complicated layouts are easy to program with @code{ecb-layout-define}.
If such layouts are senseful is another topic ;-)

@node The layout-engine API, , Possible layout-outlines, The layout-engine
@subsection The complete layout-engine API of ECB

This section lists all functions, macros, variables and user-options
the layout-engine API of ECB offers foreign packages. Call
@code{describe-function} resp. @code{describe-variable} to get a
detailed description.

Functions for programming with layouts and special ecb-windows:
@itemize @minus
@item ecb-available-layouts-member-p
@item ecb-canonical-ecb-windows-list
@item ecb-compile-window-live-p
@item ecb-do-if-buffer-visible-in-ecb-frame
@item ecb-edit-window-live-p
@item ecb-get-current-visible-ecb-buffers
@item ecb-layout-define
@item ecb-layout-switch
@item ecb-layout-undefine
@item ecb-point-in-compile-window
@item ecb-point-in-ecb-window
@item ecb-point-in-edit-window
@item ecb-select-edit-window
@item ecb-split-hor
@item ecb-split-ver
@item ecb-with-dedicated-window
@end itemize

Utility functions/macros:
@itemize @minus
@item ecb-enlarge-window
@item ecb-fix-filename
@item ecb-window-live-p
@item ecb-with-readonly-buffer
@end itemize

Some other maybe usefull functions/macros:
@itemize @minus
@item ecb-with-adviced-functions
@item ecb-with-original-functions
@item ecb-with-some-adviced-functions
@end itemize

Some useful @strong{READONLY} variables:
@itemize @minus
@item ecb-compile-window
@item ecb-edit-window
@item ecb-last-edit-window-with-point
@item ecb-last-source-buffer
@end itemize

User-options and hooks related to the layout-engine API:
@itemize @minus
@item ecb-current-buffer-sync-hook
@item ecb-hide-ecb-windows-after-hook
@item ecb-hide-ecb-windows-before-hook
@item ecb-redraw-layout-after-hook
@item ecb-redraw-layout-before-hook
@item ecb-show-ecb-windows-after-hook
@item ecb-show-ecb-windows-before-hook
@item ecb-windows-height
@item ecb-windows-width
@item ecb-compile-window-height
@end itemize

@node Conflicts and bugs, FAQ, Elisp programming, Top
@chapter Known conflicts and bugs of ECB

This chapter describes all already known conflicts with other packages
and also the known (and currently unfixed) bugs of ECB. If possible
then a practicable solution or workaround is described.

@menu
* Conflicts::                   Known conflicts with other packages
* Bugs::                        Known bugs
@end menu

@node Conflicts, Bugs, Conflicts and bugs, Conflicts and bugs
@section Known conflicts with other packages

Here is a list of known conflicts of ECB with other packages and
helpful solutions/hints/workarounds:

@subsection Package avoid.el

@cindex avoid package
With GNU Emacs 20.X ECB must deactivate @code{mouse-avoidance-mode} if the
option @code{ecb-show-node-info-in-minibuffer} activates for at least one
ECB tree-buffer 'if-too-long or 'always. This is done automatically
but only as long ECB is activated.

@subsection Package calculator.el

@cindex calculator package
If the edit-window is already splitted then calling @code{calculator} uses
the whole ``other'' edit-window for the calculator. With an unsplitted
edit-window the calculator window has itīs normal size of about 2
lines. Therefore itīs recommended to set @code{calculator-electric-mode}
during ECB activation to not nil so calculator uses always the
echo-area instead of creating a new small window!

@subsection Package calendar.el

@cindex calendar package
With activated ECB @code{calendar} does not shrink itīs window to the small
size but splits the window equally. But if you add this to your
@file{.emacs} it works:

@example
@group
(add-hook 'initial-calendar-window-hook
          (function (lambda ()
                      (when (and ecb-minor-mode
                                 (ecb-point-in-edit-window))
                        ;; if no horizontal split then nothing
                        ;; special to do
                        (or (= (frame-width) (window-width))
                            (shrink-window (- (window-height) 9))))
                     )))
@end group
@end example

@subsection Package cygwin-mount.el

@cindex cygwin-mount package
There can be a conflict between ECB and cygwin-mount.el if the
following conditions are true:

@itemize @minus
@item You are working with cygwin-mount.el (sounds clear :-)
@item You have set @code{cygwin-mount-build-mount-table-asynch} to not
nil
@item ECB is automatically started after starting Emacs (e.g. with
@code{ecb-auto-activate} or calling @code{ecb-activate} in
@code{window-setup-hook})
@item Your Emacs-setup contains a call of @code{cygwin-mount-activate}.
@end itemize

Under these circumstances Emacs 21.X sometimes eats up the whole CPU (at
least with Windows XP) and the cygwin-mount-table is never build.

But there is an easy work-around: Call @code{cygwin-mount-activate}
first *AFTER* ECB is activated. This can be done with the hook
@code{ecb-activate-hook}:

@example
@group
(add-hook 'ecb-activate-hook
          (function (lambda ()
                      (require 'cygwin-mount)
                      (setq cygwin-mount-build-mount-table-asynch t)
                      (cygwin-mount-activate))))

@end group
@end example

@subsection Package follow-mouse.el

@noindent
The following is only relevant for Emacs 20.X!

@cindex follow-mouse package
ECB works very well with follow-mouse if follow-mouse is turned on
@strong{BEFORE} ECB is activated (e.g. within the
@code{ecb-activate-hook}). But if you activate follow-mouse first
after ECB is already activated, then the follow-mouse stuff prevents
the complete node-name to be displayed in the echo-area if mouse moves
over it. Because ECB has a much more intelligent mouse tracking
mechanism than follow-mouse the follow-mouse stuff profit from ECB and
works even better and saver as without activated ECB!

@subsection Package Gnus (Newsreader)

@cindex Gnus
It is recommended not to use Gnus and ECB simultaniously in one frame
because each of them has its own window-management and probably there
will be conflicts. Use different frames for ECB and Gnus!

@subsection Package BBDB

@cindex BBDB
It is recommended not to use BBDB and ECB simultaniously in one frame
because each of them has its own window-management and probably there
will be conflicts. Use different frames for ECB and BBDB!

@subsection Package VC (Version Control)

@cindex VC package
@cindex Version control
The variable @code{vc-delete-logbuf-window} must be set to nil during
active ECB. This can be done with the hooks mentioned in @ref{Elisp
programming}.

@subsection Package winner.el (winner-mode)

@cindex winner-mode
@cindex winner
@code{winner-mode} is autom. disabled as long as ECB is running. ECB
has its own window-management which is completely incomatible with
@code{winner-mode}! But @code{winner-mode} makes also not really sense
with ECB.

@subsection Package scroll-all.el (scroll-all-mode)

@cindex scroll-all-mode
@cindex scroll-all
ECB advices @code{scroll-all-mode} so it is working correct during
running ECB. This means if point stays in an edit-window and the
edit-window is splitted then both edit-windows are scrolled by
@code{scroll-all-mode} and no other window! If point stays in any
other window just this selected window is scrolled. This is the only
senseful behavior of @code{scroll-all-mode} with ECB.

@subsection Package JDE (Java Development Environment)

@cindex JDE
JDEE has a lot of ``dialogs'' where the user can select among several
choices. An example is importing classes via the command
@code{jde-import-find-and-import}. These dialogs are strongly designed
to work in an environment where a new temporary window is created, the
contents of the dialog are displayed in the new window, the user
select his choice and hits [OK]. After that the new window is deleted
and the selection is performed (for example the choosen import
statement are inserted in the source-buffer.

ECB can be work very well with this dialogs but only if no
@strong{durable} compilation-window is used, i.e. if the option
@code{ecb-compile-window-height} is nil. See @ref{Temp- and
compile-buffers}.

If @code{ecb-compile-window-height} is not @code{nil} then these
JDE-dialogs will not work correct!

@node Bugs, , Conflicts, Conflicts and bugs
@section Known bugs

This section describes all currently known bugs of ECB. The
maintainers of ECB try to fix these bugs as soon as possible.

@subsection Following the source-file link in a help-buffer

This bug only occurs if a compile-window is used and visible!

If you call functions like @code{describe-function} which displays a
help-buffer in the compile-window, then you will often get an output
like this in the compile-window:

@example
ecb-activate is an interactive compiled Lisp function in `ecb'.
(ecb-activate)

Activates the ECB...
@end example

The link to `ecb' is normally a clickable link, means if you click
with the middle-mouse button onto it the file is opened (in our
example @file{ecb.el} would be opened.

If you click onto it when the help-buffer is already the current
buffer (i.e. the compile-window is already selected before the click!)
then all is working fine (i.e. the file is opened in the edit-window),
but if you click onto the link without selecting the compile-window
before (i.e. the edit-window is the current selected window) then the
file is openend in the compile-window which is probably not what you
want. Not a big problem but annoying.

The only available workaround is, first selecting the compile-window
and then clicking onto the link!

Probably this bug can never be fixed.

@subsection Extra history-entries for JDEE source-buffers

ECB on occasions creates an extra edit buffer for entries in the
history window. For example, let say there are three entries in the
history window:

@example
@group
Test1
Test2
Test3
@end group
@end example

In the edit window Test1 file is edited. When clicked on Test2 entry
in history, on occsion instead of switching to the existing buffer for
Test2, a new edit buffer is opened for Test2 file. At this point, there
are four entries in the history as follows:

@example
@group
Test2
Test2<2>
Test1
Test3
@end group
@end example

@node FAQ, Command Index, Conflicts and bugs, Top
@chapter Frequently asked questions

This is the Emacs Code Browser FAQ.

@c To produce prettier output we make a small empty column between the
@c question- and the answer-column. Therefore every Q/A-item must look
@c like:
@c
@c    @c an empty line between every Q/A-item
@c    @item @tab @tab
@c
@c    @c The Q/A-item
@c    @item
@c    <The text of the question?>
@c    @tab @tab
@c    <The text of the answer>

@multitable @columnfractions 0.40 0.01 0.59

@item
@ifnotinfo
@strong{Question}
@end ifnotinfo
@ifinfo
QUESTION
@end ifinfo
@tab @tab
@ifnotinfo
@strong{Answer}
@end ifnotinfo
@ifinfo
ANSWER
@end ifinfo

@c an empty line between every Q/A-item
@item @tab @tab

@c The Q/A-item
@item
What is the first step i should do if i have problems with ECB?
@tab @tab
Read carefully the related sections of the online-help of ECB.

@item @tab @tab

@item
What should i do, if a have a problem which can not be solved even
after reading the online-help?
@tab @tab
Send a problem-report to the ECB-mailing-list with the command
@code{ecb-submit-problem-report}.
@ifinfo
@*
@end ifinfo
See @ref{Submitting problem report}.

@item @tab @tab

@item
What should i do, if another package seems not to work correct with
ECB?
@tab @tab
Take a look into @ref{Conflicts}. If your package is not listed there
then submit a problem-report.

@item @tab @tab

@item
Can ECB parse and display source-contents not supported by semantic?
@tab @tab
Yes, in all version >= 1.94. ECB can now parse and display all
source-contents supported by semantic, imenu or etags - same as
speedbar. See @ref{Non-semantic sources}.

@item @tab @tab

@item
Why are the lines in the ECB-, temp- and compilation-buffers not
wrapped but truncated?
@tab @tab
Check the variable @code{truncate-partial-width-windows} and set it to
nil.

@item @tab @tab

@item
Why doesn't ECB work correct with VC?
@tab @tab
The variable @code{vc-delete-logbuf-window} must be set to nil during
active ECB. This can be done with the hooks of ECB.

@item @tab @tab

@item
Does ECB support C++ as well as Java?
@tab @tab
This depends strongly on the used semantic-version, but all
semantic-versions >= semantic-1.4.3 support C++ really well.

@item @tab @tab

@item
Does ECB support Perl?
@tab @tab
This depends completely on semantic. If there is a semantic-BNF for
Perl then semantic can parse Perl and then in turn ECB supports Perl.
Check semantic if Perl is supported or write your own Perl-BNF for
semantic.

@item @tab @tab

@item
Does ECB support language XYZ?
@tab @tab
See question ``Does ECB support Perl?'' and replace ``Perl'' with
``XYZ'' in the answer.

@item @tab @tab

@item
How to add new languages to ECB?
@tab @tab
Add the language XYZ to semantic (perform all necessary steps described in
the semantic-manual) and ECB will automatically support language XYZ!
There is nothing to do in ECB itself!

@item @tab @tab

@item
Why does ECB not recognize my source-files for C++?
@tab @tab
Your C++-files have probably an extension which is not mapped to
c++-mode in @code{auto-mode-alist} and/or your own Emacs-setup has
``destroyed'' the correct value of the hook-variable
@code{c++-mode-hook}.
@ifinfo
@*
@end ifinfo
See @ref{Setting up Emacs}.

@item @tab @tab

@item
Why doesn't ECB display the node name in the echo area if mouse moves
over it?
@tab @tab
There can be several reasons: First the value of the option
@code{ecb-show-node-name-in-minibuffer} must be either @code{always} or
@code{if-too-long}. If this is ok, then maybe you have turned on
follow-mouse AFTER activating ECB; follow-mouse must be turned on
BEFORE ECB is acivated, e.g. in the @code{ecb-activate-hook}! But with
Emacs 21.X and XEmacs there are no problems with this feature, just
activate it.

@item @tab @tab

@item
What is the reason for poor scrolling performance with GNU Emacs 20.X
in the edit-windows and what can i do?
@tab @tab
Set @code{scroll-conservatively} to 0 and @code{scroll-step} to a
value > 1. For the exact reason look at
@ifinfo
@*
@end ifinfo
@ref{Optimize scrolling}.

@item @tab @tab

@item
Is it possible to make the history of ECB persistent?
@tab @tab
You can use the library ``desktop.el'' which works very well with ECB.
Then all files of your recent Emacs-session will be opened
automatically after next Emacs-start and will be added automatically
to the ECB-history after ECB-start.

@item @tab @tab

@item
Is there an ``Intellisense''-mechanism like with other IDEs?
@tab @tab
For Java the JDEE@footnote{
@ifhtml
@uref{http://jdee.sunsite.dk/}
@end ifhtml
@ifnothtml
@url{http://jdee.sunsite.dk/}
@end ifnothtml
} has this feature and for all other languages
semantic offer something similar, see
@ifhtml
@uref{http://cedet.sourceforge.net/intellisense.shtml}
@end ifhtml
@ifnothtml
@url{http://cedet.sourceforge.net/intellisense.shtml}
@end ifnothtml

@item @tab @tab

@item
Can i use ECB in combination with Gnus within one frame?
@tab @tab
You can, but it is recommended not to use Gnus and ECB simultaniously
in one frame because each of them has it's own window-management and
probably there will be conflicts. Use different frames for ECB and
Gnus!

@item @tab @tab

@item
Can i speed up displaying the contents of big-size directories?
@tab @tab
Yes, see the option @code{ecb-cache-directory-contents}. Read the
section
@ifinfo
@*
@end ifinfo
@ref{Large directories}.

@item @tab @tab

@item
Is it possible to create/use other layouts than the buildin ones?
@tab @tab
Yes. @ref{Creating a new ECB-layout} and
@ifinfo
@*
@end ifinfo
@ref{The layout-engine} are the relevant sections. The former one
describes how to create interactively new layouts wheres the latter
one is for elisp-progammers.

@item @tab @tab

@item
Can i use speedbar as directory-browser within ECB?
@tab @tab
Yes, see @ref{Integrating speedbar}.

@item @tab @tab

@item
Can i exclude subdirectories from the recursive grep in the directories buffer?
@tab @tab
Yes, see @ref{Grepping directories}.

@item @tab @tab

@item
How can i prevent contaminating each directory with a file @file{semantic-cache}?
@tab @tab
Set @code{semanticdb-default-save-directory} to a directory.

@item @tab @tab

@item
Why ECB displays large portions of current source-file with dark background?
@tab @tab
This comes from semantic;
@ifinfo
@*
@end ifinfo
see @ref{Setting up Emacs}.

@item @tab @tab

@item
Why ECB underlines some parts of current source-file?
@tab @tab
This comes from semantic;
@ifinfo
@*
@end ifinfo
see @ref{Setting up Emacs}.

@item @tab @tab

@item
Can i add my own commands to the popup-menues of tree-buffers?
@tab @tab
Yes, see @ref{Using the mouse}.

@item @tab @tab

@item
Can ECB display the compile-window ``on demand''?
@tab @tab
Yes, see @ref{Tips and tricks}.

@item @tab @tab

@item
Which buffers are treated as compilation-buffers by ECB?
@tab @tab
See the docstring of the function @code{ecb-compilation-buffer-p}.

@item @tab @tab

@item
How can i change the modeline of an ECB-tree-buffer?
@tab @tab
You can change it with the options @code{ecb-mode-line-prefixes} and
@code{ecb-mode-line-data}.

@item @tab @tab

@item
How can i change the keybindings of ECB?
@tab @tab
You can do this with option @code{ecb-key-map} (@pxref{ecb-general}).

@item @tab @tab

@item
What can i do if hiding/showing from the methods-buffer does not work?
@tab @tab
Either the current @code{major-modes} is not supported by hideshow or
you have to add an entry to @code{hs-special-modes-alist}
@ifinfo
@*
@end ifinfo
(@pxref{Hide-show}).

@item @tab @tab

@item
Can i maximize one of the ECB-windows for better overlook?
@tab @tab
Yes, see @ref{Maximizing the ECB windows}.

@item @tab @tab

@item
Can i hide the ECB-windows for getting more editing-space?
@tab @tab
Yes, see @ref{Hiding the ECB windows}.

@end multitable


@node Command Index, Option Index, FAQ, Top
@unnumbered Command Index

@noindent
This index contains all user commands of ECB.

@strong{Note}: The commands in this index are listed without the
prefix ``ecb-'' (e.g. the command @code{ecb-activate} is listed with
name ``activate'').

@printindex fn

@node Option Index, Concept Index, Command Index, Top
@unnumbered Option Index

@noindent
This index contains all customizable options of ECB.

@strong{Note}: All options in this index are listed without the prefix
``ecb-'' (e.g. the option @code{ecb-layout-name} is listed with name
``layout-name'').

@printindex vr

@node Concept Index, , Option Index, Top
@unnumbered Concept Index

@printindex cp

@contents


@bye
