Commits

Anonymous committed f354059

Synced up with latest author version ECB 1.92.1

  • Participants
  • Parent commits 1732989

Comments (0)

Files changed (15)

+2003-03-06  Klaus Berndl  <klaus.berndl@sdm.de>
+
+	* package-info.in
+	(provides): added additional sources for next ECB
+
+	* Makefile (ELCS): Added additional sources for next ECB
+
+	* NEWS:
+	New file: Renamed previous HISTORY to NEWS and formated it for
+	outline-mode 
+
+	* Sync with current upstream 1.92.1
+
 2003-03-02  Norbert Koch  <nk@viteno.net>
 
 	* Makefile (VERSION): XEmacs package 1.03 released.
 # Boston, MA 02111-1307, USA.
 
 VERSION = 1.03
-AUTHOR_VERSION = 1.91.1
+AUTHOR_VERSION = 1.92.1
 MAINTAINER = Klaus Berndl <klaus.berndl@sdm.de>
 PACKAGE = ecb
 PKG_TYPE = regular
 	ecb-help.elc ecb-layout.elc ecb-mode-line.elc ecb-navigate.elc \
 	ecb-util.elc tree-buffer.elc ecb-buffertab.elc ecb-speedbar.elc \
 	ecb-upgrade.elc ecb-layout-defs.elc ecb-tod.elc silentcomp.elc \
-	ecb-create-layout.elc ecb-examples.elc
+	ecb-create-layout.elc ecb-examples.elc ecb-autogen.elc ecb-jde.elc
 
-EXTRA_SOURCES = HISTORY README RELEASE_NOTES
+EXTRA_SOURCES = NEWS README RELEASE_NOTES
 
 INFO_FILES = $(PACKAGE).info*
 HTML_FILES = $(PACKAGE)*.html

Makefile.upstream

 
 # For the ECB-maintainers: Change the version-number here and not
 # elsewhere!
-ecb_VERSION=1.91.1
+ecb_VERSION=1.92.1
 
 
 RM=rm -f
 MV=mv -f
 MKDIR=mkdir -p
 
+EBATCH=$(EMACS) -batch -no-site-file
+
 ecb_LISP_EL=tree-buffer.el ecb-util.el ecb-mode-line.el ecb-help.el \
             ecb-layout.el ecb-layout-defs.el ecb-navigate.el ecb.el \
             ecb-eshell.el ecb-cycle.el ecb-face.el ecb-compilation.el \
             ecb-upgrade.el ecb-create-layout.el silentcomp.el \
-            ecb-speedbar.el ecb-examples.el ecb-tod.el
+            ecb-speedbar.el ecb-examples.el ecb-tod.el ecb-autogen.el \
+	    ecb-jde.el
 
 ecb_LISP_ELC=$(ecb_LISP_EL:.el=.elc)
 
-ecb_ETC=HISTORY README RELEASE_NOTES Makefile make.bat
+ecb_AUTOLOADS=ecb-autoloads.el
+
+ecb_ETC=NEWS README RELEASE_NOTES Makefile make.bat
 
 ecb_TEXI=ecb.texi
 
 ecb_PS=$(ecb_TEXI:.texi=.ps)
 ecb_PDF=$(ecb_TEXI:.texi=.pdf)
 
-ecb_DISTRIB_FILES=$(ecb_LISP_EL) $(ecb_TEXI) $(ecb_ETC)
+ecb_DISTRIB_FILES=$(ecb_LISP_EL) $(ecb_AUTOLOADS) $(ecb_TEXI) $(ecb_ETC)
 
 ecb: $(ecb_LISP_EL)
 	@echo "Byte-compiling ECB with LOADPATH=${LOADPATH} ..."
 	fi
 	@echo "(require 'ecb)" >> ecb-compile-script
 	@echo "(setq debug-on-error t)" >> ecb-compile-script
-	$(EMACS) -batch -no-site-file -l ecb-compile-script --eval '(ecb-byte-compile t)'
+	$(EBATCH) -l ecb-compile-script --eval '(ecb-byte-compile t)'
 	@$(RM) ecb-compile-script
 
 all: ecb online-help
 
 $(ecb_INFO_DIR)/$(ecb_INFO): online-help
 
-# updates RELEASE_NOTES, README, HISTORY, ecb.texi and ecb.el to the
+# updates RELEASE_NOTES, README, NEWS, ecb.texi and ecb.el to the
 # version-number of $(ecb_VERSION).
 prepversion:
 	@$(MV) RELEASE_NOTES RELEASE_NOTES.tmp
 	@$(MV) README README.tmp
 	@sed "1s/version.*/version $(ecb_VERSION)/" README.tmp > README
 	@$(RM) README.tmp
-	@$(MV) HISTORY HISTORY.tmp
-	@sed "1s/Version.*/Version $(ecb_VERSION)/" HISTORY.tmp > HISTORY
-	@$(RM) HISTORY.tmp
+	@$(MV) NEWS NEWS.tmp
+	@sed "1s/version.*/version $(ecb_VERSION)/" NEWS.tmp > NEWS
+	@$(RM) NEWS.tmp
 	@$(MV) ecb.el ecb.el.tmp
 	@sed "s/^(defconst ecb-version.*/(defconst ecb-version \"$(ecb_VERSION)\"/" ecb.el.tmp > ecb.el
 	@$(RM) ecb.el.tmp
 	  echo "q") | ed -s $(ecb_TEXI) 1> /dev/null
 
 
+autoloads:
+	$(EBATCH) -l ecb-autogen -f ecb-update-autoloads
+
+
 # builds the distribution file $(ecb_VERSION).tar.gz
-distrib: $(ecb_INFO_DIR)/$(ecb_INFO) prepversion ecb
+distrib: $(ecb_INFO_DIR)/$(ecb_INFO) prepversion autoloads ecb
 	@$(RM) ecb-$(ecb_VERSION).tar.gz
 	@$(RM) -R ecb-$(ecb_VERSION)
 	@$(MKDIR) ecb-$(ecb_VERSION)
-Readme for the Emacs Code Browser (ECB) version 1.91.1
-------------------------------------------------------
+Readme for the Emacs Code Browser (ECB) version 1.92.1
+
 
 About
 -----
 Installation
 ------------
 
-*IMPORTANT*: The following steps 1., 2., 3., 7. and 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 regular XEmacs-package (e.g. downloaded and
-installed by the net-installer of XEmacs) then the steps 1., 2., 3., 7. and 8.
-are not necessary for you; please start reading at point 4.
+*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 regular XEmacs-package (e.g. downloaded and installed by the
+net-installer of XEmacs) then there is nothing to do for you, just start ECB
+with `ecb-activate' or read the online-help with `ecb-show-help'.
 
 
 1. Unpack the ECB archive (probably you have already done this :-)
 4. Load ECB by adding code to your `.emacs':
 
    If you want to load the complete ECB at (X)Emacs-loadtime (Advantage: All
-   ECB-options available after loading (X)Emacs. Disadvantage: Increasing
+   ECB-options available after loading ECB). Disadvantage: Increasing
    loadtime):
 
       (require 'ecb)
    (Advantage: Fast loading. Disadvantage: ECB- and semantic-options first
    available after starting ECB):
 
-      (autoload 'ecb-activate "ecb" "Activate ECB" t)
-      (autoload 'ecb-byte-compile "ecb" "Byte-compile ECB" t)
-      (autoload 'ecb-show-help "ecb-help" "Show the online help of ECB" t)
+      (require 'ecb-autoloads)
+
+   This loads all available autoloads (e.g. `ecb-activate', `ecb-minor-mode',
+   `ecb-show-help' or `ecb-byte-compile') of current ECB.
 
 5. Restart (X)Emacs.
 
-This file contains some important release-notes for ECB version 1.91.1
+This file contains some important release-notes for ECB version 1.92.1
 
 General:
 --------
 No special notes beyond the contents of README.
 
 
-Upgrading from version 1.90:
-----------------------------
+Upgrading from versions >= 1.90:
+--------------------------------
 
-No special notes beyond the contents of README.
+The type of the option `ecb-truncate-lines' has changed.
+ECB autom. upgrades the old value of this option to its new type!
 
 
 Upgrading from version 1.80:

ecb-compilation.el

               ;;else it isn't a complication buffer
               nil)))))))
 
+;; Klaus Berndl <klaus.berndl@sdm.de>: The following mechanism is necessary to
+;; avoid eating up whole CPU for updating the menu-entries for the
+;; compilation-buffers. Especially if you have opened a lot of buffers this
+;; can slow down Emacs/ECB dramatically. Now we add an idle-times
+;; check-function `ecb-compilation-buffer-list-changed-p' which checks if the
+;; buffer-list has changed. If yes, then the variable
+;; `ecb-compilation-update-menu-p' is set to t. Only if this variable if not
+;; nil the menu-bar-update-hook `ecb-compilation-update-menu' updates the
+;; ECB-menu.
+
+(defvar ecb-compilation-update-menu-p nil)
+(defvar ecb-compilation-buffer-list-cache nil)
+(defvar ecb-compilation-update-idle-time 0.25)
+
+(defun ecb-compilation-buffer-list-init ()
+  "Initialize the compilation buffer list cache."
+  (setq ecb-compilation-update-menu-p nil)
+  (setq ecb-compilation-buffer-list-cache nil)
+  (ecb-compilation-buffer-list-changed-p))
+
+(defun ecb-compilation-buffer-list-changed-p ()
+  "Check if current active buffer list has changed - i.e. if a new buffer has
+been created or a buffer has been deleted. If yes then
+`ecb-compilation-update-menu-p' is set to not nil and the cache is updated."
+  (let ((new-buffer-list (buffer-list)))
+    (when (not (equal new-buffer-list
+                      ecb-compilation-buffer-list-cache))
+      (setq ecb-compilation-buffer-list-cache new-buffer-list)
+      ;; Nowhere else this variable will be set to t.
+      (setq ecb-compilation-update-menu-p t))))
+
 (defun ecb-compilation-update-menu()
   "Create an install a menu that allows the user to navigate buffers that are
-valid ECB compilation buffers.  See `ecb-compilation-buffer-p' for more
-information about compilation buffers."
+valid ECB compilation buffers. This is only done if
+`ecb-compilation-update-menu-p' is not nil; see
+`ecb-compilation-buffer-list-changed-p'. For more information about
+compilation buffers see `ecb-compilation-buffer-p'."
 
-  (let((submenu nil)
-       (buffers (ecb-compilation-get-buffers)))
-
-    (dolist(buffer buffers)
-      (setq submenu
-            (append submenu
-                    (list (vector (car buffer)
-                                  `(funcall (if (ecb-compile-window-live-p)
-                                                'switch-to-buffer
-                                              'switch-to-buffer-other-window)
-                                            ,(car buffer))
-                                    :active t)))))
-
-    ;;TODO: Klaus Berndl <klaus.berndl@sdm.de>: Seems not to work with Emacs 20.X
-    (easy-menu-change (list ecb-menu-name)
-                      "Compilation Buffers"
-                      submenu
-                      "Navigate")))
+  (when ecb-compilation-update-menu-p
+    (let ((submenu nil)
+          (buffers (ecb-compilation-get-buffers)))
+      (condition-case nil
+          (progn
+            (setq ecb-compilation-update-menu-p nil)
+            (dolist(buffer buffers)
+              (setq submenu
+                    (append submenu
+                            (list (vector (car buffer)
+                                          `(funcall (if (ecb-compile-window-live-p)
+                                                        'switch-to-buffer
+                                                      'switch-to-buffer-other-window)
+                                                  ,(car buffer))
+                                          :active t)))))
+            
+            ;;TODO: Klaus Berndl <klaus.berndl@sdm.de>: Seems not to work with
+            ;;Emacs 20.X
+            (easy-menu-change (list ecb-menu-name)
+                              "Compilation Buffers"
+                              submenu
+                              "Navigate")
+            t)
+        (error nil)))))
+      
 
 
 (silentcomp-provide 'ecb-compilation)
 (defun ecb-problem-report-list-all-variables()
   "List all variables starting with `ecb-' and some other variables which
 could be interesting for support."
-  (let ((emacs-vars (sort `(pre-command-hook
-                            post-command-hook
-                            after-save-hook
-                            help-mode-hook
-                            compilation-mode-hook
-                            truncate-partial-width-windows
-                            truncate-lines
-                            system-type
-                            window-system
-                            ,(if (boundp 'ediff-quit-hook)
-                                 'ediff-quit-hook))
+  (let ((emacs-vars (sort (delete nil
+                                  `(pre-command-hook
+                                    post-command-hook
+                                    after-save-hook
+                                    help-mode-hook
+                                    compilation-mode-hook
+                                    truncate-partial-width-windows
+                                    truncate-lines
+                                    auto-mode-alist
+                                    ,(if (boundp 'c-mode-hook)
+                                         'c-mode-hook)
+                                    ,(if (boundp 'c++-mode-hook)
+                                         'c++-mode-hook)
+                                    ,(if (boundp 'c-mode-common-hook)
+                                         'c-mode-common-hook)
+                                    ,(if (boundp 'java-mode-hook)
+                                         'java-mode-hook)
+                                    ,(if (boundp 'jde-mode-hook)
+                                         'jde-mode-hook)
+                                    system-type
+                                    window-system
+                                    ,(if (boundp 'ediff-quit-hook)
+                                         'ediff-quit-hook)))
                           (function (lambda (l r)
                                       (string< (symbol-name l)
                                                (symbol-name r))))))
 ;; - `delete-windows-on'
 ;; - `split-window-horizontally'
 ;; - `split-window-vertically'
+;; - `split-window'
 ;; - `switch-to-buffer'
 ;; - `switch-to-buffer-other-window'
 ;; - `other-window-for-scrolling'
 (require 'ecb-compilation)
 (require 'ecb-create-layout)
 
-(silentcomp-defvar jde-open-class-at-point-find-file-function)
 ;; XEmacs
 (silentcomp-defvar scrollbars-visible-p)
 ;; Emacs
 (silentcomp-defvar scroll-bar-mode)
+;; only Emacs 21 has this
+(silentcomp-defvar window-size-fixed)
 
 ;; ecb-speedbar is only loaded if ecb-use-speedbar-for-directories is set to
 ;; true
 layout with `ecb-redraw-layout'"
   :group 'ecb-layout
   :initialize 'custom-initialize-default
-  :set ecb-layout-option-set-function
+  :set (function (lambda (symbol value)
+                   (ecb-set-window-size-fixed nil)
+                   (funcall ecb-layout-option-set-function
+                            symbol value)))
   :type '(radio (const :tag "No compilation window" nil)
                 (number :tag "Window height" :value 5)))
 
   :set ecb-layout-option-set-function
   :type 'number)
 
+
+(defcustom ecb-fix-window-size nil
+  "*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. In the latter case there is an additional value 'auto
+which choose autom. the senseful fix-type depending on the current
+layout-type: For top-layouts the fix-type 'height and for all other
+layout-types the fix-type 'width.
+
+For a detailed description of the valid values see documentation of
+`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 `window-size-fixed' in the elisp-info-manual is more
+detailled than the description offered by \[C-h v]!
+
+Note2: With current Emacs 21.2.X there seems to be no distinction between
+'width, 'height and t. Therefore this option takes no effect \(means all
+ecb-windows have always unfixed sizes) if `ecb-compile-window-height' is not
+nil.
+
+Per default no window-size fixing has been done."
+  :group 'ecb-directories
+  :initialize 'custom-initialize-default
+  :set (function (lambda (sym value)
+                   (set sym value)
+                   (ecb-set-window-size-fixed
+                    (ecb-get-window-fix-type ecb-layout-name))))
+  :type '(radio (choice :tag "Fix type for all layouts"
+                        :menu-tag "Fix type for all layouts"
+                        (const :tag "Automatic" :value auto)
+                        (const :tag "Fix only width" :value width)
+                        (const :tag "Fix only height" :value height)
+                        (const :tag "Fix both" :value t)
+                        (const :tag "No fixing" :value nil))
+                (repeat :tag "With these layouts"
+                        (cons (string :tag "Layout name")
+                              (choice :tag "Fix type"
+                                      :menu-tag "Fix type for all layouts"
+                                      (const :tag "Fix only width" :value width)
+                                      (const :tag "Fix only height" :value height)
+                                      (const :tag "Fix both" :value t)
+                                      (const :tag "No fixing" :value nil))))))
+
+(defun ecb-get-window-fix-type (layout-name)
+  "Determine which value of `window-size-fixed' we must set in all ecb-buffers
+of layout LAYOUT-NAME."
+  (if (symbolp ecb-fix-window-size)
+      (if (equal ecb-fix-window-size 'auto)
+          (if (equal (ecb-get-layout-type ecb-layout-name) 'top)
+              'height
+            'width)
+        ecb-fix-window-size)
+    (cdr (assoc layout-name ecb-fix-window-size))))
+
+(defun ecb-set-window-size-fixed (fix)
+  "Set the buffer-local value of `window-size-fixed' in each visible
+ecb-window to FIX. If `ecb-compile-window-height' is not nil then set always
+nil!"
+  (when ecb-running-emacs-21
+    (let ((l (ecb-canonical-ecb-windows-list)))
+      (dolist (w l)
+        (save-excursion
+          (set-buffer (window-buffer w))
+          (setq window-size-fixed (if ecb-compile-window-height
+                                      nil
+                                    fix)))))))
+
+
+(defmacro ecb-do-with-unfixed-ecb-buffers (&rest body)
+  "Evaluate BODY with unfixed size of all current-visible ecb-buffers and
+ensure that at the end \(either after finishing of BODY or after an error
+occurs during BODY) all now current visible ecb-buffers get the value of their
+buffer-local `window-size-fixed' from the setting in `ecb-fix-window-size'."
+  `(unwind-protect
+       (progn
+         (ecb-set-window-size-fixed nil)
+         ,@body)
+     (ecb-set-window-size-fixed (ecb-get-window-fix-type ecb-layout-name))))
+  
+
+
 (defcustom ecb-other-window-jump-behavior 'all
   "*Which windows of ECB should be accessible by the ECB-adviced function
 `other-window', an intelligent replacement for the Emacs standard version of
                                          delete-windows-on
                                          split-window-horizontally
                                          split-window-vertically
+                                         split-window
                                          switch-to-buffer
                                          switch-to-buffer-other-window)
   "*Use the intelligent windows functions of ECB instead of the standard
 - `delete-windows-on'
 - `split-window-horizontally'
 - `split-window-vertically'
+- `split-window'
+  If this is enabled then `split-window-vertically' and
+  `split-window-horizontally' are autom. enabled too!
 - `switch-to-buffer'
 - `switch-to-buffer-other-window'
 - `other-window-for-scrolling'
   :group 'ecb-layout
   :initialize 'custom-initialize-default
   :set (function (lambda (symbol value)
-		   (set symbol value)
-		   (if (and (boundp 'ecb-minor-mode)
-			    ecb-minor-mode)            
-		       (ecb-activate-adviced-functions value))))
+                   (when (member 'split-window value)
+                     (add-to-list 'value 'split-window-vertically)
+                     (add-to-list 'value 'split-window-horizontally))
+                   (set symbol value)
+                   (if (and (boundp 'ecb-minor-mode)
+                            ecb-minor-mode)            
+                       (ecb-activate-adviced-functions value))))
   :type '(set (const :tag "other-window"
                      :value other-window)
               (const :tag "delete-window"
                      :value split-window-horizontally)
               (const :tag "split-window-vertically"
                      :value split-window-vertically)
+              (const :tag "split-window"
+                     :value split-window)
               (const :tag "switch-to-buffer"
                      :value switch-to-buffer)
               (const :tag "switch-to-buffer-other-window"
                      :value split-window-horizontally)
               (const :tag "split-window-vertically"
                      :value split-window-vertically)
+              (const :tag "split-window"
+                     :value split-window)
               (const :tag "switch-to-buffer"
                      :value switch-to-buffer)
               (const :tag "switch-to-buffer-other-window"
 `ecb-store-window-sizes'. Next time the layout is redrawn the values stored in
 this option will be used.
 
-If `ecb-store-window-sizes' is used then the windows sizes are stored as
-fractions of current frame-width and -height of the ecb-frame, so the stored
-values will \"work\" for other frame sizes too.
+If `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
+`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 `ecb-store-window-sizes') then
 the following is important:
 
 ;; =========== intelligent window function advices ===================
 
+;; TODO: Klaus Berndl <klaus.berndl@sdm.de>: offer window-size-fixed for Emacs
+;; 21. For this we have probably to advice enlarge-window, shrink-window,
+;; split-window-vertically, split-window-horizontally, split-window. The last
+;; one should be adviced anyway.
+
 (defconst ecb-adviceable-functions
   '(other-window
     split-window-vertically
     split-window-horizontally
+    split-window
     delete-window
     delete-other-windows
     delete-windows-on
 ;; here come the advices
 
 ;; Important: `other-window', `delete-window', `delete-other-windows',
-;; `split-window-horizontally' and `split-window-vertically' need none of the
-;; other advices and can therefore be used savely by the other advices (means,
-;; other functions or advices can savely (de)activate these "basic"-advices!
+;; `split-window' need none of the other advices and can therefore be used
+;; savely by the other advices (means, other functions or advices can savely
+;; (de)activate these "basic"-advices!
 
 (defadvice other-window (around ecb)
   "The ECB-version of `other-window'. Works exactly like the original function
                  (switch-to-buffer (other-buffer buf-name
                                                  nil ecb-frame))))
             (select-frame curr-frame)))))))
-               
 
 
 (defadvice delete-window (around ecb)
   (if (not (equal (selected-frame) ecb-frame))
       ad-do-it
     
-    (if (null (ad-get-arg 0))
-        (when (and (member 'delete-window ecb-layout-always-operate-in-edit-window)
-                   ;; this is needed because otherwise we would also select the 1.
-                   ;; edit-window if point stays in the second one!
-                   (not (ecb-point-in-edit-window)))
-          (ecb-select-edit-window))
-      (if (window-live-p (ad-get-arg 0))
-          (select-window (ad-get-arg 0))))
-    
-    (if (not (ecb-point-in-edit-window))
-        (ecb-error "Only an edit-window can be deleted!"))
-    (ad-with-originals 'delete-window
-      (if (ecb-edit-window-splitted)
-          (funcall (intern (format "ecb-delete-window-in-editwindow-%s"
-                                   ecb-layout-name))
-                   (ecb-edit-window-splitted))))))
+    (ecb-do-with-unfixed-ecb-buffers
+     (if (null (ad-get-arg 0))
+         (when (and (member 'delete-window ecb-layout-always-operate-in-edit-window)
+                    ;; this is needed because otherwise we would also select the 1.
+                    ;; edit-window if point stays in the second one!
+                    (not (ecb-point-in-edit-window)))
+           (ecb-select-edit-window))
+       (if (window-live-p (ad-get-arg 0))
+           (select-window (ad-get-arg 0))))
+     
+     (if (not (ecb-point-in-edit-window))
+         (ecb-error "Only an edit-window can be deleted!"))
+     (ad-with-originals 'delete-window
+       (if (ecb-edit-window-splitted)
+           (funcall (intern (format "ecb-delete-window-in-editwindow-%s"
+                                    ecb-layout-name))
+                    (ecb-edit-window-splitted)))))))
 
 (defadvice delete-other-windows (around ecb)
   "The ECB-version of `delete-other-windows'. Works exactly like the
 If optional argument WINDOW is a live window \(i.e. called from program):
 If WINDOW is an edit-window then this window is maximized \(i.e. the other
 edit-window is deleted), otherwise an error is reported."
+  
   (if (not (equal (selected-frame) ecb-frame))
       ad-do-it
 
-    (if (null (ad-get-arg 0))
-        (when (and (member 'delete-other-windows
-                           ecb-layout-always-operate-in-edit-window)
-                   ;; this is needed because otherwise we would also select the 1.
-                   ;; edit-window if point stays in the second one!
-                   (not (ecb-point-in-edit-window)))
-          (ecb-select-edit-window))
-      (if (window-live-p (ad-get-arg 0))
-          (select-window (ad-get-arg 0))))
-    
-    (if (not (ecb-point-in-edit-window))
-        (ecb-error "Only an edit-window can be maximized!"))
-    (ad-with-originals 'delete-window
-      (if (ecb-edit-window-splitted)
-          (funcall (intern (format "ecb-delete-other-windows-in-editwindow-%s"
-                                   ecb-layout-name))
-                   (ecb-edit-window-splitted))))))
-
-;; (defadvice delete-windows-on (around ecb)
-;;   ""
-  
-;; )
+    (ecb-do-with-unfixed-ecb-buffers
+     (if (null (ad-get-arg 0))
+         (when (and (member 'delete-other-windows
+                            ecb-layout-always-operate-in-edit-window)
+                    ;; this is needed because otherwise we would also select the 1.
+                    ;; edit-window if point stays in the second one!
+                    (not (ecb-point-in-edit-window)))
+           (ecb-select-edit-window))
+       (if (window-live-p (ad-get-arg 0))
+           (select-window (ad-get-arg 0))))
+     
+     (if (not (ecb-point-in-edit-window))
+         (ecb-error "Only an edit-window can be maximized!"))
+     (ad-with-originals 'delete-window
+       (if (ecb-edit-window-splitted)
+           (funcall (intern (format "ecb-delete-other-windows-in-editwindow-%s"
+                                    ecb-layout-name))
+                    (ecb-edit-window-splitted)))))))
   
 (defadvice split-window-horizontally (around ecb)
   "The ECB-version of `split-window-horizontally'. Works exactly like the
                (not (ecb-point-in-edit-window)))
       (ecb-select-edit-window))
     
-    (let ((p (ecb-point-in-edit-window)))
-      (if (not p)
-          (ecb-error "Only the edit-window of ECB is splitable!")
-        ;; point either in first or second edit-window
-        (if (not (ecb-edit-window-splitted))
-            ad-do-it
-          ;; if already splitted return the "other" edit-window
-          (setq ad-return-value
-                (if (= p 1) (next-window) ecb-edit-window)))))))
+    (ecb-with-adviced-functions
+     ad-do-it)))
 
 (defadvice split-window-vertically (around ecb)
   "The ECB-version of `split-window-vertically'. Works exactly like the
                (not (ecb-point-in-edit-window)))
       (ecb-select-edit-window))
     
-    (let ((p (ecb-point-in-edit-window)))
-      (if (not p)
-          (ecb-error "Only the edit-window of ECB is splitable!")
-        ;; point either in first or second edit-window
-        (if (not (ecb-edit-window-splitted))
-            ad-do-it
-          ;; if already splitted return the "other" edit-window
-          (setq ad-return-value
-                (if (= p 1) (next-window) ecb-edit-window)))))))
+    (ecb-with-adviced-functions
+     ad-do-it)))
+
+;; (defadvice split-window-vertically (around ecb)
+;;   "The ECB-version of `split-window-vertically'. Works exactly like the
+;; original function with the following ECB-ajustment:
+
+;; Called in an unsplitted edit-window then the edit window will be splitted
+;; vertically. If called in an already splitted edit-window then nothing is done.
+;; If called in any other window of the current ECB-layout it stops with an error
+;; if this function is not contained in `ecb-layout-always-operate-in-edit-window'."
+;;   (if (not (equal (selected-frame) ecb-frame))
+;;       ad-do-it
+
+;;     (when (and (member 'split-window-vertically
+;;                        ecb-layout-always-operate-in-edit-window)
+;;                (not (ecb-point-in-edit-window)))
+;;       (ecb-select-edit-window))
+    
+;;     (let ((p (ecb-point-in-edit-window)))
+;;       (if (not p)
+;;           (ecb-error "Only the edit-window of ECB is splitable!")
+;;         ;; point either in first or second edit-window
+;;         (if (not (ecb-edit-window-splitted))
+;;             ad-do-it
+;;           ;; if already splitted return the "other" edit-window
+;;           (setq ad-return-value
+;;                 (if (= p 1) (next-window) ecb-edit-window)))))))
+
+(defadvice split-window (around ecb)
+  "The ECB-version of `split-window'. The meaning of WINDOW must be one of the
+edit-windows of ECB otherwise an error is reported. If the edit-window is
+already splitted then nothing will be done. Besides this it behaves like the
+original version."
+  (if (not (equal (selected-frame) ecb-frame))
+      ad-do-it
+    ;; if called interactively and WINDOW is nil (i.e. selected window is
+    ;; used) then we maybe must first go to the edit-window.
+    ;; The check for interactiv-p prevents that we jump to the edit-window if
+    ;; called from within `split-window-vertically' for example.
+    (when (and (interactive-p)
+               (null (ad-get-arg 0))
+               (member 'split-window
+                       ecb-layout-always-operate-in-edit-window)
+               (not (ecb-point-in-edit-window)))
+      (ecb-select-edit-window))
+
+    ;; now perform the splitting task
+    (let ((window (or (ad-get-arg 0) (selected-window))))
+      (if (not (ecb-edit-window-splitted))
+          ;; we allow only an unsplitted edit-window to be splitted
+          (if (not (equal window ecb-edit-window))
+              (ecb-error "Only the edit-window of ECB is splitable!")
+            ad-do-it)
+        ;; if already splitted return the "other" edit-window
+        (setq ad-return-value
+              (cond ((equal window ecb-edit-window)
+                     (next-window ecb-edit-window))
+                    ((equal window (next-window ecb-edit-window))
+                     ecb-edit-window)
+                    (t
+                     (ecb-error "Only the edit-window of ECB is splitable!"))))))))
 
 (defadvice switch-to-buffer-other-window (around ecb)
   "The ECB-version of `switch-to-buffer-other-window'. Works exactly like the
     (let ((other-window-scroll-buffer (window-buffer ecb-edit-window)))
       ad-do-it)))
     
-(defun ecb-jde-open-class-at-point-ff-function (filename &optional wildcards)
-  "Special handling of the class opening at point JDE feature. This function
-calls the value of `jde-open-class-at-point-find-file-function' with activated
-ECB-adviced functions."
-  (ecb-with-adviced-functions
-   (if (and (boundp 'jde-open-class-at-point-find-file-function)
-            (fboundp jde-open-class-at-point-find-file-function))
-       (funcall jde-open-class-at-point-find-file-function
-                filename wildcards))))
-
 ;; here come the prefixed equivalents to the adviced originals
 (defun ecb-switch-to-buffer ()
   "Acts like the adviced version of `switch-to-buffer'."
   (ecb-with-adviced-functions
    (call-interactively 'split-window-horizontally)))
 
+(defun ecb-split-window ()
+  "Acts like the adviced version of `split-window'."
+  (interactive)
+  (ecb-with-adviced-functions
+   (call-interactively 'split-window)))
+
 
 ;;======= Helper-functions ===========================================
 
           (tree-buffer-deactivate-follow-mouse)
           (if (not (ecb-point-in-edit-window))
               (ecb-select-edit-window))
+          ;; we have to unfix all our ECB windows!!
+          (ecb-set-window-size-fixed nil)
           (ecb-with-original-functions
            (let* ((config (ecb-edit-window-configuration))
                   (split-before-redraw (car (nth 0 config)))
                                (get-buffer "*scratch*")
                                (current-buffer))))
        
-       ;; Do some actions regardless of the choosen layout
-       (delete-other-windows)
-       (set-window-dedicated-p (selected-window) nil)
-       
-       ;; we force a layout-function to set both of these windows
-       ;; correctly.
-       (setq ecb-edit-window nil
-             ecb-compile-window nil)
-       
-       ;; Now we call the layout-function
-       (funcall (intern (format "ecb-layout-function-%s" ecb-layout-name)))
-       (select-window
-        (if ecb-edit-window
-            ecb-edit-window
-          (error "Edit-window not set in function 'ecb-layout-function-%s"
-                 ecb-layout-name)))
+       (ecb-do-with-unfixed-ecb-buffers
+        ;; Do some actions regardless of the choosen layout
+        (delete-other-windows)
+        (set-window-dedicated-p (selected-window) nil)
+        
+        ;; we force a layout-function to set both of these windows
+        ;; correctly.
+        (setq ecb-edit-window nil
+              ecb-compile-window nil)
+        
+        ;; Now we call the layout-function
+        (funcall (intern (format "ecb-layout-function-%s" ecb-layout-name)))
+        (select-window
+         (if ecb-edit-window
+             ecb-edit-window
+           (error "Edit-window not set in function 'ecb-layout-function-%s"
+                  ecb-layout-name)))
+        );; end ecb-do-with-unfixed-ecb-buffers
        
        ;; Now all the windows must be created and the editing window must not
        ;; be splitted! In addition the variables `ecb-edit-window' and
       (setq ecb-toggle-layout-state next-index)
       (ecb-layout-switch layout-name))))
 
-(defun ecb-store-window-sizes ()
+(defun ecb-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 `ecb-redraw-layout' or
 `ecb-restore-window-sizes' is called. To reset the window sizes to their
 default values call `ecb-restore-default-window-sizes'. Please read also the
-documentation of `ecb-layout-window-sizes'!"
-  (interactive)
+documentation of `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 FIX is not nil \(means called with a prefix argument)
+then the fixed values of current width and height are stored!"
+  (interactive "P")
   (when (equal (selected-frame) ecb-frame)
     (let ((a (ecb-find-assoc ecb-layout-window-sizes ecb-layout-name)))
       (unless a
 	(setq a (cons ecb-layout-name nil))
 	(setq ecb-layout-window-sizes (ecb-add-assoc ecb-layout-window-sizes a)))
-      (setcdr a (ecb-get-window-sizes))
+      (setcdr a (ecb-get-window-sizes fix))
       (customize-save-variable 'ecb-layout-window-sizes ecb-layout-window-sizes))))
 
 
 	  (ecb-remove-assoc ecb-layout-window-sizes ecb-layout-name))
     (customize-save-variable 'ecb-layout-window-sizes ecb-layout-window-sizes)))
 
-;; Now always returns fractions of the ecb-frame; thanks to Geert Ribbers
+;; Now per default returns fractions of the ecb-frame; thanks to Geert Ribbers
 ;; [geert.ribbers@realworld.nl] for a first implementation.
-(defun ecb-get-window-size (window)
+(defun ecb-get-window-size (window &optional fix)
   "Return the sizes of WINDOW as a cons where the car is the width and the cdr
-is the height. Both values are fractions of the frame-width (resp. height) of
-the `ecb-frame'."
+is the height. Per default both values are fractions of the frame-width (resp. height) of
+the `ecb-frame' unless FIX is not nil."
   (when window
-    (cons (/ (window-width window) (* 1.0 (frame-width ecb-frame)))
-          (/ (window-height window) (* 1.0 (frame-height ecb-frame))))))
+    (cons (/ (window-width window)
+             (if fix
+                 1
+               (* 1.0 (frame-width ecb-frame))))
+          (/ (window-height window)
+             (if fix
+                 1
+               (* 1.0 (frame-height ecb-frame)))))))
 
 
-(defun ecb-get-window-sizes ()
+(defun ecb-get-window-sizes (&optional fix)
+  "Get all window-sizes of current visible ecb-windows. If FIX is not nil then
+fixed sizes are used otherwise fractions of current frame-width resp. -height."
   (mapcar (function (lambda (window)
-                      (ecb-get-window-size window)))
+                      (ecb-get-window-size window fix)))
           (ecb-canonical-ecb-windows-list)))
 
 
             (enlarge-window (- (round absolut-height) (window-height window))))))))
 
 (defun ecb-set-window-sizes (sizes)
-  (when sizes
-    (let ((windows (ecb-canonical-ecb-windows-list)))
-      (if (= (length windows) (length sizes))
-          (dolist (size sizes)
-            (ecb-set-window-size (car windows) size)
-            (setq windows (cdr windows)))
-        (ecb-error "Stored sizes of layout %s not applicable for current window layout!"
-                   ecb-layout-name)))))
+  (ecb-do-with-unfixed-ecb-buffers
+   (when sizes
+     (let ((windows (ecb-canonical-ecb-windows-list)))
+       (if (= (length windows) (length sizes))
+           (dolist (size sizes)
+             (ecb-set-window-size (car windows) size)
+             (setq windows (cdr windows)))
+         (ecb-error "Stored sizes of layout %s not applicable for current window layout!"
+                    ecb-layout-name))))))
 
 (defun ecb-toggle-enlarged-compilation-window (&optional arg)
   "Toggle whether the `ecb-compile-window' is enlarged or not. If ARG > 0
 
 (defun ecb-toggle-compile-window (&optional arg)
   "Toggle the visibility of the compile-window of ECB. With prefix argument
-ARG, make display a compile-window, otherwise not. The height of the
+ARG, make visible if positive, otherwise invisible. The height of the
 compile-window is always the current *saved* \(for future sessions) value of
 `ecb-compile-window-height', i.e. this command can only display a
 compile-window if `ecb-compile-window-height' has such a saved value of not
               (not (equal (selected-frame) ecb-frame)))
     (let ((new-state (if (null arg)
                          (not (ecb-compile-window-live-p))
-                       (<= (prefix-numeric-value arg) 0))))
+                       (>= (prefix-numeric-value arg) 0))))
       (if new-state
           (let ((height (car (get 'ecb-compile-window-height 'saved-value))))
             (when (numberp height)
               (customize-set-variable 'ecb-compile-window-height height)))
         (customize-set-variable 'ecb-compile-window-height nil)))))
 
+
 (silentcomp-provide 'ecb-layout)
 
 ;;; ecb-layout.el ends here
     "Use `scroll-all-mode' to scroll both edit-windows of ECB simultaneously - and no other windows are scrolled!"
     "You can toggle having a compile window with `ecb-toggle-compile-window' if `ecb-compile-window-height' is not nil."
     "Start ECB automatically after Emacs is started. Use option `ecb-auto-activate'"
+    "Easy horizontal scrolling the tree-buffers with the mouse with [M-mouse-1] and [M-mouse-3]; see `ecb-tree-easy-hor-scroll'."
     )
   "List of all available tips of the day.")
 
     (ecb-layout-nr . (ecb-layout-name ecb-upgrade-layout-nr))
     (ecb-toggle-layout-sequence . (ecb-toggle-layout-sequence
                                    ecb-upgrade-toggle-layout-sequence))
-;;     (ecb-layout-window-sizes . (ecb-layout-window-sizes
-;;                                 ecb-upgrade-layout-window-sizes))
     (ecb-major-modes-activate . (ecb-major-modes-activate
                                  ecb-upgrade-major-modes-activate))
     (ecb-cache-directory-contents . (ecb-cache-directory-contents
                                      ecb-upgrade-cache-directory-contents))
     (ecb-source-file-regexps . (ecb-source-file-regexps
-                                ecb-upgrade-source-file-regexps)))
+                                ecb-upgrade-source-file-regexps))
+    (ecb-truncate-lines . (ecb-truncate-lines
+                           ecb-upgrade-truncate-lines)))
   
   "Alist of all options which should be upgraded for current ECB-version.
 There are several reasons why an option should be contained in this alist:
           old-val))
 
 ;; not used anymore beginning with ECB 1.91.1
-(defun ecb-upgrade-layout-window-sizes (old-val)
-  (let ((l (copy-tree old-val)))
-    (dolist (elem l)
-      (setcar elem
-              (ecb-upgrade-layout-nr2name (car elem)))
-      (setcdr elem
-              (mapcar (function (lambda (e)
-                                  (if (consp e)
-                                      e
-                                    (cons nil nil))))
-                      (cdr elem)))
-      )
-    l))
+;; (defun ecb-upgrade-layout-window-sizes (old-val)
+;;   (let ((l (copy-tree old-val)))
+;;     (dolist (elem l)
+;;       (setcar elem
+;;               (ecb-upgrade-layout-nr2name (car elem)))
+;;       (setcdr elem
+;;               (mapcar (function (lambda (e)
+;;                                   (if (consp e)
+;;                                       e
+;;                                     (cons nil nil))))
+;;                       (cdr elem)))
+;;       )
+;;     l))
 
 (defun ecb-upgrade-major-modes-activate (old-val)
   (if (not (listp old-val))
 (defun ecb-upgrade-source-file-regexps (old-val)
   (list (cons ".*" old-val)))
 
+(defun ecb-upgrade-truncate-lines (old-val)
+  (if old-val
+      '(t t t t)
+    '(nil nil nil nil)))
+
+
 ;; ----------------------------------------------------------------------
 ;; internal functions. Dot change anything below this line
 ;; ----------------------------------------------------------------------
 ;; Cause of the need of wget we can assume the the user has cygwin installed!
 (defmacro ecb-create-shell-argument (arg)
   `(if (eq system-type 'windows-nt)
-       (if (executable-find "cygpath.exe")
-           ;; if bash is used as shell-file-name then the command must
-           ;; not contain newlines!
-           (ecb-trim
-            (ecb-subst-char-in-string ?\n 32
-                                  (shell-command-to-string
-                                   (concat "cygpath -u " ,arg))))
-         (ecb-error "Cannot find the cygpath utility!"))
+       (progn
+         (require 'executable)
+         (if (executable-find "cygpath.exe")
+             ;; if bash is used as shell-file-name then the command must
+             ;; not contain newlines!
+             (ecb-trim
+              (ecb-subst-char-in-string ?\n 32
+                                        (shell-command-to-string
+                                         (concat "cygpath -u " ,arg))))
+           (ecb-error "Cannot find the cygpath utility!")))
      ,arg))
 
 
 
       ;; checking if all necessary tools are available
 
+      ;; Emacs 20.X does not autoload executable-find :-(
+      (require 'executable)
       (if (not (and (executable-find
                      (if (eq system-type 'windows-nt) "wget.exe" "wget"))
                     (executable-find
         (version-list nil)
         process-result)
 
+    (require 'executable)
     (if (not (executable-find
               (if (eq system-type 'windows-nt) "wget.exe" "wget")))
         (ecb-error
   (require 'silentcomp))
 
 
-;; JDE
-(silentcomp-defun jde-gen-class-buffer)
 ;; XEmacs
 (silentcomp-defun mswindows-cygwin-to-win32-path)
 (silentcomp-defun frame-property)
 (defun ecb-confirm (text)
   (yes-or-no-p text))
 
-;; Klaus TODO: Making this function more general, means useable for non java
-;; code!!
-
 
 (defun ecb-create-source-internal (dir)
-  (let ((filename (read-from-minibuffer "Source name: ")))
+  (let* ((use-dialog-box nil)
+         (filename (file-name-nondirectory (read-file-name "Source name: "
+                                                           (concat dir "/")))))
     (ecb-select-edit-window)
-    (jde-gen-class-buffer (concat dir
-                                  "/"
-                                  filename
-                                  (if (not (string-match "\\." filename))
-                                      ".java")))))
+    (if (string-match "\\.java$" filename)
+        (ecb-jde-gen-class-buffer dir filename)
+      (find-file (concat dir "/" filename)))))
 
 
 (defun ecb-create-directory-source (node)
 If VAL is a positive integer then WINDOW is enlarged so that its new height is
 VAL lines. If VAL is > 0 and < 1 then WINDOW is enlarged so that its new
 height is that fraction of the frame."
-
   (if (and window (window-live-p window))
       (let* ((norm-val (if val
                            (ecb-normalize-number val (1- (frame-height)))
 
 ;; IMPORTANT: The version-number is auto-frobbed from the Makefile. Do not
 ;; change it here!
-(defconst ecb-version "1.91.1"
+(defconst ecb-version "1.92.1"
   "Current ECB version.")
 
 ;; This program is free software; you can redistribute it and/or modify it under
 ;; To use the Emacs code browser add the ECB files to your load path and add the
 ;; following line to your .emacs file:
 ;;
-;; (require 'ecb)
+;; If you want autoloading ECB after first start:
+;;
+;;    (require 'ecb-autoloads)
+;;
+;; or if you want loading the complete ECB:
+;;
+;;    (require 'ecb)
 ;;
 ;; Optional: You can byte-compile ECB with `ecb-byte-compile' after the
 ;;           ECB-package is loaded
 ;;
 ;; ECB requires:
-;; - Semantic, version 1.4 or higher
+;; - Semantic, author-version between 1.4 and 1.4.9
 ;;   (http://cedet.sourceforge.net/semantic.shtml).
-;; - Eieio, version 0.17 or higher
+;; - Eieio, author-version between 0.17 and 0.17.9
 ;;   (http://cedet.sourceforge.net/eieio.shtml).
 ;;
 ;; If Java code is edited the ECB works best when the JDE package
 
 ;; ecb loads
 (require 'tree-buffer)
+(require 'ecb-jde)
 (require 'ecb-layout)
 (require 'ecb-create-layout)
 (require 'ecb-mode-line)
 (require 'ecb-face)
 (require 'ecb-upgrade)
 (require 'ecb-tod)
+(require 'ecb-autogen)
 ;;(require 'ecb-profile)
 
 ;; various loads
 (silentcomp-defun force-mode-line-update)
 
 (silentcomp-defvar dired-directory)
-(silentcomp-defun jde-show-class-source)
 (silentcomp-defun add-submenu)
 (silentcomp-defun semanticdb-minor-mode-p)
 (silentcomp-defun semanticdb-find-nonterminal-by-name)
   :group 'ecb-general
   :type 'boolean)
 
-(defcustom ecb-truncate-lines t
+(defcustom ecb-truncate-lines '(t t t t)
   "*Truncate lines in ECB buffers. If you change this during ECB is activated
 you must deactivate and activate ECB again to take effect."
   :group 'ecb-general
-  :type 'boolean)
+  :type '(list (boolean :tag "Directories buffer")
+               (boolean :tag "Sources buffer")
+               (boolean :tag "Methods buffer")
+               (boolean :tag "History buffer")))
+
+(defcustom ecb-tree-easy-hor-scroll 5
+  "*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
+`scroll-left' and `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
+\[M-mouse-1] and \[M-mouse-3] are bound to scrolling left resp. right with
+scroll-step S. Additionally \[C-M-mouse-1] and \[C-M-mouse-3] are bound to
+scrolling left resp. right with scroll-step `window-width' - 2. Default is a
+scroll-step of 5. If the value is nil then no keys for horizontal scrolling
+are bound."
+  :group 'ecb-general
+  :type '(radio :value 5
+                (const :tag "No hor. mouse scrolling" :value nil)
+                (integer :tag "Scroll step")))
 
 (defcustom ecb-truncate-long-names t
   "*Truncate long names that don't fit in the width of the ECB windows. If you
       ;; the edit-window because then the METHODS buffer would be
       ;; immediately updated with the methods of the edit-window.
       (save-excursion
-	(set-buffer (find-file-noselect ecb-path-selected-source))
+	(set-buffer (find-file-noselect filename))
 	(ecb-update-methods-buffer--internal 'scroll-to-begin))
     ;; open the selected source in the edit-window and do all the update and
     ;; parsing stuff with this buffer
 (defvar ecb-auto-expand-token-tree-old 'expand-spec)
 (defun ecb-toggle-auto-expand-token-tree (&optional arg)
   "Toggle auto expanding of the ECB-methods-buffer.
-With prefix argument ARG, make switch on if positive, otherwise switch off.
-If the effect is that auto-expanding is switched off then the current value of
+With prefix argument ARG, switch on if positive, otherwise switch off. If the
+effect is that auto-expanding is switched off then the current value of
 `ecb-auto-expand-token-tree' is saved so it can be used for the next switch on
 by this command."
   (interactive "P")
      ((= type 2)
       (set-buffer (get-file-buffer ecb-path-selected-source))
       ;; Try to find source using JDE
-      (when (eq major-mode 'jde-mode)
-        (condition-case nil
-            (progn
-              (jde-show-class-source data)
-              (setq found t))
-          (error nil)))
+      (setq found (ecb-jde-show-class-source data))
       ;; Try to find source using Semantic DB
       (when (and (not found) (featurep 'semanticdb) (semanticdb-minor-mode-p))
         (let ((parent (semanticdb-find-nonterminal-by-name data)))
            'equal
            (list (cons 0 ecb-directories-menu) (cons 1 ecb-sources-menu)
                  (cons 2 ecb-source-path-menu))
-           ecb-truncate-lines
+           (nth 0 ecb-truncate-lines)
            t
            ecb-tree-indent
            ecb-tree-incremental-search
            ecb-tree-navigation-by-arrow
+           ecb-tree-easy-hor-scroll
            (list (cons 1 ecb-source-in-directories-buffer-face))
            ecb-tree-expand-symbol-before
            ecb-directory-face
            'ecb-mouse-over-source-node
            'equal
            (list (cons 0 ecb-sources-menu))
-           ecb-truncate-lines
+           (nth 1 ecb-truncate-lines)
            t
            ecb-tree-indent
            ecb-tree-incremental-search
            ecb-tree-navigation-by-arrow
+           ecb-tree-easy-hor-scroll
            nil
            nil
            ecb-source-face
                      (eq (ecb-semantic-token-start l) (ecb-semantic-token-start r))
                      (eq (ecb-semantic-token-end l) (ecb-semantic-token-end r))))))
            nil
-           ecb-truncate-lines
+           (nth 2 ecb-truncate-lines)
            t
            ecb-tree-indent
            ecb-tree-incremental-search
            ecb-tree-navigation-by-arrow
+           ecb-tree-easy-hor-scroll
            nil
            ecb-tree-expand-symbol-before
            ecb-method-face
            'ecb-mouse-over-history-node
            'equal
            (list (cons 0 ecb-history-menu))
-           ecb-truncate-lines
+           (nth 3 ecb-truncate-lines)
            t
            ecb-tree-indent
            ecb-tree-incremental-search
            ecb-tree-navigation-by-arrow
+           ecb-tree-easy-hor-scroll
            nil
            nil
            ecb-history-face
                                        'ecb-token-sync)
       (ecb-activate-ecb-sync-functions ecb-window-sync-delay
                                        'ecb-window-sync-function)
+      (ecb-activate-ecb-sync-functions ecb-compilation-update-idle-time
+                                       'ecb-compilation-buffer-list-changed-p)
       (ecb-activate-ecb-sync-functions nil 'ecb-layout-post-command-hook)
       (add-hook 'pre-command-hook 'ecb-layout-pre-command-hook)
       (add-hook 'after-save-hook 'ecb-update-methods-after-saving)
       (add-hook 'kill-buffer-hook 'ecb-kill-buffer-hook)
 
+      ;; running the compilation-buffer update first time
+      (ecb-compilation-buffer-list-init)
+      
       ;; ediff-stuff; we operate here only with symbols to avoid bytecompiler
       ;; warnings
       (if (boundp 'ediff-quit-hook)
 
 ;; three easy-entry functions for the history menu for conveniance
 ;; Note: The node argument in the first two functions is not used.
+
+(defun ecb-add-history-buffers-popup (node)
+  (ecb-add-all-buffers-to-history))
+
 (defun ecb-clear-history-only-not-existing (node)
   "Removes all history entries from the ECB history buffer where related
 buffers does not exist anymore."
-  (ecb-clear-history -1))
+  (let ((ecb-clear-history-behavior 'not-existing-buffers))
+    (ecb-clear-history)))
 
 (defun ecb-clear-history-all (node)
   "Removes all history entries from the ECB history buffer."
-  (ecb-clear-history 0))
+  (let ((ecb-clear-history-behavior 'all))
+    (ecb-clear-history)))
 
 (defun ecb-clear-history-node (node)
   "Removes current entry from the ECB history buffer."
         ("Delete File" ecb-delete-source-2)
         ("Kill Buffer" ecb-history-kill-buffer)
         ("---")
+        ("Add all filebuffer to history" ecb-add-history-buffers-popup)
+        ("---")
 	("Remove Current Entry" ecb-clear-history-node)
 	("Remove All Entries" ecb-clear-history-all)
 	("Remove Non Existing Buffer Entries" ecb-clear-history-only-not-existing)))
 
 (defvar ecb-last-major-mode nil)
 
+
 (defun ecb-handle-major-mode-activation ()
   "Added to `post-command-hook' after loading the ecb-library. Handles the
 values of `ecb-major-modes-activate' and `ecb-major-modes-deactivate'.
 @c edit the Makefile to change the version number. mechanism stolen
 @c from Tramp
 @macro ecbver{}
-1.91.1
+1.92.1
 @end macro
 
 
 * 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
 * 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
 
 Entry points for elisp programmers
 
 @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 ECB archive from 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 by the package-manager of XEmacs)
-then there is nothing to do for you; just start ECB with
-@code{ecb-activate} or read the help with @code{ecb-show-help}.
+@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
 
 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 (X)Emacs. Disadvantage:
-Increasing loadtime@footnote{Cause of full loading of ECB itself and
-also the packages semantic and eieio regardless if ECB is started.}):
+All ECB-options available after loading ECB. Disadvantage: Increasing
+loadtime@footnote{Cause of full loading of ECB itself and also the
+packages semantic and eieio regardless if ECB is started.}):
 
 @example
 (require 'ecb)
 
 If you want to load the ECB first after starting it by
 @code{ecb-activate} (Advantage: Fast loading@footnote{ECB, semantic
-and eieio are first loaded after starting ECB}. Disadvantage:
-ECB- and semantic-options first available after starting ECB):
+and eieio 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
-(autoload 'ecb-activate "ecb" "Activate ECB" t)
-(autoload 'ecb-byte-compile "ecb" "Byte-compile ECB" t)
-(autoload 'ecb-show-help "ecb-help" "Show the online help of ECB" t)
+(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
 
 @node Setting up Emacs, First steps, Installation, Install and first steps
 @section How to set up Emacs for file parsing
 
+@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. 
+
 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:
 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
+
 @item Activating the correct major-mode
 
 ECB is for browsing source-files and therefore you have to setup your
 @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:
+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:
 
 @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
 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}).
 
-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 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.
 
+@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.
+
+So if @code{ecb-tree-easy-hor-scroll} is a positive integer-value S
+then 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. 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.
+
+This is NOT done for XEmacs cause of its horizontal scrollbars. If you
+want scroll 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
 @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}
 * 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
 
 See also the hooks @code{ecb-redraw-layout-after-hook} and
 @code{ecb-redraw-layout-before-hook}!
 
-@node Changing window sizes, Creating a new ECB-layout, Redrawing the ECB-layout, The ECB-layout
+@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
 until you call @code{ecb-restore-default-window-sizes} during layout
 ``left1'' is active.
 
-@strong{NOTE}: @code{ecb-store-window-sizes} always stores the width
-and height of the windows as fractions of the width (resp. height) of
-the ECB-frame, so the stored sizes are always correct regardless of
-the current frame-size!
-
-@node Creating a new ECB-layout, , Changing window sizes, The ECB-layout
+@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
 Make the ECB-sources window the current 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 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
 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
 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
 
 @deffn Command toggle-compile-window &optional arg
 Toggle the visibility of the compile-window of ECB. With prefix
-argument @var{ARG}, make display a compile-window, otherwise not. The
+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
 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. 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
 @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}
 @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}.
 values stored in this option will be used.
 
 If @code{ecb-store-window-sizes} is used then the windows sizes are
-stored as fractions of current frame-width and -height of the
-ecb-frame, so the stored values will ``work'' for other frame sizes
-too.
+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:
 * 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
 @end menu
 
 @node Changing faces, Small screens, Tips and tricks, Tips and tricks
 mouse or keyboard) onto the related directory-node in the
 directories-buffer of ECB (@pxref{Using the mouse}).
 
-@node Using eshell, , Large directories, Tips and tricks
+@node Using eshell, Grepping directories, Large directories, Tips and tricks
 @section Optimal using of eshell in ECB
 
 @cindex 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, , 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 Elisp programming, Conflicts and bugs, Tips and tricks, Top
 @chapter Entry points for elisp programmers
 
 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
 
 @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}.
+
 @end multitable
 
 
    filename FILENAME
    md5sum MD5SUM
    size SIZE
-   provides (ecb-buffertab ecb-compilation ecb-create-layout ecb-cycle ecb ecb-eshell ecb-examples ecb-face ecb-help ecb-layout ecb-layout-defs ecb-mode-line ecb-navigate ecb-speedbar ecb-tod ecb-upgrade ecb-util silentcomp tree-buffer)
+   provides (ecb-buffertab ecb-compilation ecb-create-layout ecb-cycle ecb ecb-eshell ecb-examples ecb-face ecb-help ecb-layout ecb-layout-defs ecb-mode-line ecb-navigate ecb-speedbar ecb-tod ecb-autogen ecb-jde ecb-upgrade ecb-util silentcomp tree-buffer)
    requires (REQUIRES)
    type regular
 ))
 (defvar tree-buffer-incr-searchpattern nil)
 (defvar tree-buffer-last-incr-searchpattern nil)
 (defvar tree-buffer-incr-search nil)
+(defvar tree-buffer-hor-scroll-step nil)
 
 ;; tree-buffer-local data-storage with get- and set-function
 (defvar tree-buffer-data-store nil)
             (window-width window)))))
 
 (defun tree-buffer-scroll-hor (amount)
-  (let ((current-prefix-arg amount))
-    (call-interactively 'scroll-left)))
+  (ignore-errors
+    (let ((current-prefix-arg amount))
+      (call-interactively 'scroll-left))))
 
-(defvar tree-buffer-current-hor-scroll-amount 0)
+
 (defun tree-buffer-recenter (node window)
   "If NODE is not visible then first recenter the window WINDOW so NODE is
 best visible, means NODE is displayed in the middle of the window if possible.
                        (tree-buffer-line-beginning-pos)))
          (point-lines-before (count-lines (point-min) node-point))
          (point-lines-after (1- (count-lines node-point (point-max)))))
+    (if (not tree-buffer-running-xemacs)
+        (ignore-errors (tree-buffer-scroll-hor -1000)))
     ;; first make point best visible, means display node in the middle of the
     ;; window if possible (if there are enough lines before/after the node).
     (when (not (pos-visible-in-window-p node-point window))
                                     (goto-char (window-start window))
                                     (forward-line (- full-lines-in-window w-height))
                                     (tree-buffer-line-beginning-pos)))))))
-
-  ;; now we have to hor. recenter the whole window/buffer to the last computed
-  ;; value
-;;   (tree-buffer-scroll-hor tree-buffer-current-hor-scroll-amount)
-  
-;;   ;; now we optimize the horizontal display of the tree-buffer, so that at
-;;   ;; least of NODE and all its visible subnodes the expand/collapse-button
-;;   ;; is visible and as much as possible of the nodenames.
-;;   (let ((node-end-point (save-excursion
-;;                           (goto-line (tree-buffer-find-node node))
-;;                           (tree-buffer-line-end-pos))))
-;;     (when (not (tree-buffer-pos-hor-visible-p node-end-point window))
-;;       (setq tree-buffer-current-hor-scroll-amount
-;;             (+ 5 tree-buffer-current-hor-scroll-amount))
-;;       (tree-buffer-scroll-hor tree-buffer-current-hor-scroll-amount)))
-
     ))
 
 ;; Klaus: Now we use overlays to highlight current node in a tree-buffer. This
                                 node-expanded-fn node-mouse-over-fn
                                 node-data-equal-fn
                                 menus tr-lines read-only tree-indent
-                                incr-search arrow-navigation
+                                incr-search arrow-navigation hor-scroll
                                 &optional type-facer expand-symbol-before
                                 highlight-node-face general-face
                                 after-create-hook)
              Three choices: 'prefix, 'substring, nil. See
              `tree-buffer-incremental-node-search'.
 ARROW-NAVIGATION: If not nil then smart navigation with horizontal arrow keys.
+HOR-SCROLL: Number of columns a hor. scroll in the tree-buffer should scroll.
+            If not nil then M-mouse-1 and M-mouse-2 scroll left and right and
+            also M-<left-arrow> and M-<right-arrow>.
 TYPE-FACER: Nil or a list of one or two conses, each cons for a node-type \(0
             or 1). The cdr of a cons can be:
             - a symbol of a face
     (make-local-variable 'tree-buffer-incr-searchpattern)
     (make-local-variable 'tree-buffer-last-incr-searchpattern)
     (make-local-variable 'tree-buffer-incr-search)
+    (make-local-variable 'tree-buffer-hor-scroll-step)
 
     ;; initialize the user-data-storage for this tree-buffer.
     (set (make-local-variable 'tree-buffer-data-store) nil)
-    
+
     (setq truncate-lines tr-lines)
     (setq truncate-partial-width-windows tr-lines)
     (setq buffer-read-only read-only)
     (setq tree-buffer-incr-searchpattern "")
     (setq tree-buffer-last-incr-searchpattern "")
     (setq tree-buffer-incr-search incr-search)
+    (setq tree-buffer-hor-scroll-step hor-scroll)
 
     ;; set a special syntax table for tree-buffers
     (set-syntax-table tree-buffer-syntax-table)
                   (mouse-set-point e)
                   (tree-buffer-select 1 nil t))))
 
+    
     (define-key tree-buffer-key-map [drag-mouse-1] nop)
     (define-key tree-buffer-key-map [mouse-1] nop)
     (define-key tree-buffer-key-map [double-mouse-1] nop)
     (define-key tree-buffer-key-map [double-mouse-3] nop)
     (define-key tree-buffer-key-map [triple-mouse-3] nop)
 
+    ;; scrolling horiz.
+    (when (and (not tree-buffer-running-xemacs)
+               tree-buffer-hor-scroll-step)
+      (define-key tree-buffer-key-map
+        [M-down-mouse-1]
+        (function (lambda(e)
+                    (interactive "e")
+                    (mouse-set-point e)
+                    (tree-buffer-scroll-hor (- tree-buffer-hor-scroll-step)))))
+
+      (define-key tree-buffer-key-map
+        [M-down-mouse-3]
+        (function (lambda(e)
+                    (interactive "e")
+                    (mouse-set-point e)
+                    (tree-buffer-scroll-hor tree-buffer-hor-scroll-step))))
+      
+      (define-key tree-buffer-key-map
+        [C-M-down-mouse-1]
+        (function (lambda(e)
+                    (interactive "e")
+                    (mouse-set-point e)
+                    (tree-buffer-scroll-hor (- (- (window-width) 2))))))
+      
+      (define-key tree-buffer-key-map
+        [C-M-down-mouse-3]
+        (function (lambda(e)
+                    (interactive "e")
+                    (mouse-set-point e)
+                    (tree-buffer-scroll-hor (- (window-width) 2)))))
+      
+      (define-key tree-buffer-key-map [M-mouse-1] nop)
+      (define-key tree-buffer-key-map [M-mouse-3] nop)
+      (define-key tree-buffer-key-map [C-M-mouse-1] nop)
+      (define-key tree-buffer-key-map [C-M-mouse-3] nop))
+    
     (use-local-map tree-buffer-key-map)
 
     (setq tree-buffers (cons (current-buffer) tree-buffers))