Commits

Anonymous committed 516bd27

Sync with current upstream 2.21

  • Participants
  • Parent commits 2fc8eab

Comments (0)

Files changed (10)

+2004-02-16  Klaus Berndl  <klaus.berndl@sdm.de>
+	
+	* Sync with current upstream 2.21
+
 2004-02-16  Norbert Koch  <viteno@xemacs.org>
 
 	* Makefile (VERSION): XEmacs package 1.16 released.
    define if and when `display-buffer-function' should be ignored: Always
    (default), when a compile-window is used or never.
 
+** Compatibility enhancements
+   In general the current layout-engine of ECB is so flexible that there
+   should be no - or at least very few - conflicts between ECB and any other
+   elisp-library - even when another lib is running during the ECB-windows are
+   visible.
+
+*** Commands like `bs-show' of the library bs.el now work correctly with ECB
+
+*** Xrefactory works even when all ECB-windows are visible (see Fixed Bugs).
+
+*** Applications like Gnus or BBDB run withing the ECB-frame without conflicts -
+    even when the ECB-windows are visible.
+
+*** Commands using `Electric-pop-up-window' now work correctly with ECB.
+    This ensures that the electric-* commands (e.g. `electric-buffer-list' or
+    `electric-command-history') work well with ECB. If the related
+    "display-buffer" of such an electric command is a "compilation-buffer" in
+    the sense of `ecb-compilation-buffer-p' then this buffer will be displayed
+    in the compile-window of ECB - if there is any shown.
+
 ** For XEmacs the package fsf-compat is no longer required by ECB.
    But it is still necessary to check if fsf-compat is required by the
    packages semantic, eieio and speedbar which in turn are required by ECB.
 
-** Compatibility enhancements
-
-*** Commands like bs-show of the library bs.el now work correctly with ECB
-
-*** Xrefactory works even when all ECB-windows are visible (see Fixed Bugs).
-    !!!TODO!!! When true and well tested then remoce the restriction in the
-    texi-file.
-
-*** Commands using `Electric-pop-up-window' now work correctly with ECB
-
 ** Fixed Bugs
 
 *** Fixed a fatal bug which prevents `other-window' from working with
     arguments < 0. This bug has also prevented Xrefactory from working correct
-    when ECB is active.
+    when ECB is active - see compatibility enhancements above.
 
 *** If point stays in the current source-buffer on a function argument then still
     ECB highlights the function in the Methods-buffer.
 
-*** ECB now uses `compilation-window-height' also correct when set buffer-local
-    as possible with latest CVS-version of GNU Emacs.
+*** ECB now uses `compilation-window-height' correctly when set buffer-local
+    as possible with latest CVS-version of GNU Emacs 21.
+
+*** Fixed a bug in `ecb-sources-filter' and `ecb-history-filter'.
     
 
 

ecb-compatibility.el

 ;; 2. Add the advice-code below.
 ;;
 ;; All advices of `ecb-compatibility-advices' will be autom. enabled when ECB
-;; starts and autom. disabled when ECB shuts down.
+;; starts and autom. disabled when ECB shuts down. No advice is enabled just
+;; by loading the ECB-library!
 
 (defvar ecb-compatibility-advices '((bs-show . before)
                                     (Electric-pop-up-window . around)
+                                    (electric-command-history . before)
+                                    (electric-buffer-list . before)
                                     (electric-buffer-list . after))
   "Contains all advices needed for package-compatibility.")
 
            (display-buffer (buffer-name my-bs-buffer)))))))
 
 (defadvice Electric-pop-up-window (around ecb)
-  (ecb-with-ecb-advice 'one-window-p 'around
+  "Ensures that the electric-* commands \(e.g. `electric-buffer-list') work
+well with ECB. If BUFFER is a \"compilation-buffer\" in the sense of
+`ecb-compilation-buffer-p' then BUFFER will be displayed in the compile-window
+of ECB - if there is any. If the compile-window is temporally hidden then the
+BUFFER is displayed in an edit-window!"
+  (if (and ecb-minor-mode
+           (equal (selected-frame) ecb-frame))
+      (if (and (ecb-compilation-buffer-p (ad-get-arg 0))
+               (equal (ecb-compile-window-state) 'visible))
+          (pop-to-buffer (ad-get-arg 0))
+        (let ((ecb-compilation-buffer-names nil)
+              (ecb-compilation-major-modes nil)
+              (ecb-compilation-predicates nil))
+          (ecb-with-ecb-advice 'one-window-p 'around
+            ad-do-it)))
     ad-do-it))
 
+(defadvice electric-command-history (before ecb)
+  "Ensures that the electric-* commands work well with ECB."
+  (when (and ecb-minor-mode
+             (equal (selected-frame) ecb-frame)
+             (ecb-point-in-ecb-window))
+    (ecb-select-edit-window)))
+
+(defadvice electric-buffer-list (before ecb)
+  "Ensures that the electric-* commands work well with ECB."
+  (when (and ecb-minor-mode
+             (equal (selected-frame) ecb-frame)
+             (ecb-point-in-ecb-window))
+    (ecb-select-edit-window)))
+
 (defadvice electric-buffer-list (after ecb)
+  "Ensures that the electric-* commands work well with ECB."
   (if (get-buffer "*Buffer List*")
       (bury-buffer (get-buffer "*Buffer List*"))))
 

ecb-compilation.el

 says nil for this buffer.
 
 It is not recommended to add the name of eshell-buffers to this list because
-ECB already handles the eshell-integration as best as possible."
+ECB already handles the eshell-integration as best as possible.
+
+See also the options `ecb-compilation-major-modes' and
+`ecb-compilation-predicates'."
   :group 'ecb-compilation
+  :group 'ecb-most-important
   :type '(repeat (cons (string :tag "Buffer name")
                        (boolean :tag "Handled as regexp"))))
 

ecb-file-browser.el

      (when (not (string= dir-before-update ecb-path-selected-directory))
        (tree-buffer-scroll (point-min) (point-min))))))
 
+(defun ecb-sources-filter-by-ext (ext-str)
+  "Filter the sources by extension EXT-STR."
+  (if (= (length ext-str) 0)
+      (ecb-apply-filter-to-sources-buffer
+       "^[^.]+$" ;; matches only filenames with no extension
+       "No ext.")
+    (ecb-apply-filter-to-sources-buffer
+     (format "\\.%s\\'" ext-str)
+     (format "*.%s" ext-str))))
 
-(tree-buffer-defpopup-command ecb-sources-filter-by-ext
-  "Filter the sources by extension from popup."
-  (let ((ext-str (read-string "Insert the filter-extension without leading dot: "
-                              (and node
-                                   (file-name-extension (tree-node-get-data node))))))
-    (if (= (length ext-str) 0)
-        (ecb-apply-filter-to-sources-buffer
-         "^[^.]+$" ;; matches only filenames with no extension
-         "No ext.")
-      (ecb-apply-filter-to-sources-buffer
-       (format "\\.%s\\'" ext-str)
-       (format "*.%s" ext-str)))))
-       
-  
-(tree-buffer-defpopup-command ecb-sources-filter-by-regexp
-  "Filter the sources by regexp from popup."
+(tree-buffer-defpopup-command ecb-popup-sources-filter-by-ext
+  "Filter the sources by extension by popup."
+  (ecb-sources-filter-by-ext
+   (read-string "Insert the filter-extension without leading dot: "
+                (and node
+                     (file-name-extension (tree-node-get-data node))))))
+
+(defun ecb-sources-filter-by-regexp ()
+  "Filter the sources by a regexp. Ask for the regexp."
   (let ((regexp-str (read-string "Insert the filter-regexp: ")))
     (if (> (length regexp-str) 0)
         (ecb-apply-filter-to-sources-buffer regexp-str))))
   
-(tree-buffer-defpopup-command ecb-sources-filter-none
+(tree-buffer-defpopup-command ecb-popup-sources-filter-by-regexp
+  "Filter the sources by regexp by popup."
+  (ecb-sources-filter-by-regexp))
+  
+(tree-buffer-defpopup-command ecb-popup-sources-filter-none
   "Remove any filter from the sources by popup."
   (ecb-apply-filter-to-sources-buffer nil))
   
   (let ((choice (ecb-query-string "Filter sources by:"
                                   '("extension" "regexp" "nothing"))))
     (cond ((string= choice "extension")
-           (ecb-sources-filter-by-ext nil))
+           (ecb-sources-filter-by-ext
+            (read-string "Insert the filter-extension without leading dot: ")))
           ((string= choice "regexp")
-           (ecb-sources-filter-by-regexp nil))
-          (t (ecb-sources-filter-none nil)))))
+           (ecb-sources-filter-by-regexp))
+          (t (ecb-apply-filter-to-sources-buffer nil)))))
 
 (defun ecb-sources-filter-modeline-prefix (buffer-name sel-dir sel-source)
   "Compute a mode-line prefix for the Sources-buffer so the current filter
          (ecb-dired-directory "Open Dir in Dired")
          (ecb-dired-directory-other-window "Open Dir in Dired other window"))
         ("Filter"
-         (ecb-sources-filter-by-ext "Filter by extension")
-         (ecb-sources-filter-by-regexp "Filter by a regexp")
-         (ecb-sources-filter-none "No filter"))
+         (ecb-popup-sources-filter-by-ext "Filter by extension")
+         (ecb-popup-sources-filter-by-regexp "Filter by a regexp")
+         (ecb-popup-sources-filter-none "No filter"))
         ("---")        
 	(ecb-create-source "Create Sourcefile")
         (ecb-delete-source "Delete Sourcefile")
     (when (get-file-buffer data)
       (kill-buffer (get-file-buffer data)))))
 
-(tree-buffer-defpopup-command ecb-history-filter-by-ext
+(defun ecb-history-filter-by-ext (ext-str)
   "Filter history entries by extension."
+  (if (= (length ext-str) 0)
+      (setq ecb-history-filter
+            (cons `(lambda (filename)
+                     (save-match-data
+                       (string-match "^[^.]+$" filename)))
+                  "No ext."))
+    (setq ecb-history-filter
+          (cons `(lambda (filename)
+                   (save-match-data
+                     (string-match ,(format "\\.%s\\'" ext-str)
+                                   filename)))
+                (format "*.%s" ext-str))))
+  (ecb-add-buffers-to-history))
+
+(tree-buffer-defpopup-command ecb-popup-history-filter-by-ext
+  "Filter history entries by extension by popup."
   (let ((ext-str (read-string "Insert the filter-extension without leading dot: "
                               (and node
                                    (file-name-extension (tree-node-get-data node))))))
-    (if (= (length ext-str) 0)
-        (setq ecb-history-filter
-         (cons `(lambda (filename)
-                  (save-match-data
-                    (string-match "^[^.]+$" filename)))
-               "No ext."))
-      (setq ecb-history-filter
-            (cons `(lambda (filename)
-                     (save-match-data
-                       (string-match ,(format "\\.%s\\'" ext-str)
-                                     filename)))
-                  (format "*.%s" ext-str)))))
-  (ecb-add-buffers-to-history))
-       
-  
-(tree-buffer-defpopup-command ecb-history-filter-by-regexp
+    (ecb-history-filter-by-ext ext-str)))
+
+(defun ecb-history-filter-by-regexp ()
   "Filter history entries by regexp."
   (let ((regexp-str (read-string "Insert the filter-regexp: ")))
     (if (> (length regexp-str) 0)
                          (string-match ,regexp-str filename)))
                     regexp-str))))
   (ecb-add-buffers-to-history))
+
+(tree-buffer-defpopup-command ecb-popup-history-filter-by-regexp
+  "Filter history entries by regexp by popup."
+  (ecb-history-filter-by-regexp))
   
-(tree-buffer-defpopup-command ecb-history-filter-all-existing
+(tree-buffer-defpopup-command ecb-popup-history-filter-all-existing
   "No history filter, i.e. add all existing file-buffers to the history."
   (ecb-add-all-buffers-to-history))
   
   (let ((choice (ecb-query-string "Filter history by:"
                                   '("extension" "regexp" "no filter"))))
     (cond ((string= choice "extension")
-           (ecb-history-filter-by-ext nil))
+           (ecb-history-filter-by-ext
+            (read-string "Insert the filter-extension without leading dot: ")))
           ((string= choice "regexp")
-           (ecb-history-filter-by-regexp nil))
-          (t (ecb-history-filter-all-existing nil)))))
+           (ecb-history-filter-by-regexp))
+          (t (ecb-add-all-buffers-to-history)))))
 
 (defvar ecb-history-menu nil
   "Built-in menu for the history-buffer.")
          (ecb-dired-directory "Open Dir in Dired")
          (ecb-dired-directory-other-window "Open Dir in Dired other window"))
 	("Filter"
-         (ecb-history-filter-by-ext "Filter by extension")
-         (ecb-history-filter-by-regexp "Filter by regexp")
-         (ecb-history-filter-all-existing "No filter (all file-buffers)"))
+         (ecb-popup-history-filter-by-ext "Filter by extension")
+         (ecb-popup-history-filter-by-regexp "Filter by regexp")
+         (ecb-popup-history-filter-all-existing "No filter (all file-buffers)"))
         ("---")
         (ecb-history-kill-buffer "Kill Buffer")
         (ecb-delete-source "Delete Sourcefile")
         (ecb-do-with-unfixed-ecb-buffers ad-do-it)
       ad-do-it))
 
+  ;; Klaus Berndl <klaus.berndl@sdm.de>: We can not use our
+  ;; Electric-pop-up-window advice instaed of this advice because otherwise
+  ;; some commands of the popup-menus of the ecb-buffers would not work - this
+  ;; comes from the save-window-excursion in the the tmm.
   (defadvice tmm-prompt (around ecb)
     "Make it compatible with ECB."
     (if (or (not ecb-minor-mode)
             (ecb-compilation-predicates nil))
         ad-do-it)))
 
+  
   (defadvice shrink-window-if-larger-than-buffer (around ecb)
     "Makes the function compatible with ECB."
     (or (ad-get-arg 0) (ad-set-arg 0 (selected-window)))

ecb-method-browser.el

 
 (defun ecb-method-browser-initialize ()
   (setq ecb-selected-tag nil)
-  (setq ecb-methods-root-node nil))
+  (setq ecb-methods-root-node nil)
+  (setq ecb-methods-user-filter-alist nil))
 
 ;;====================================================
 ;; Customization
     (dolist (fcn fcn-list)
       (if (fboundp fcn)
         (setq taglist (funcall fcn taglist))))
-    taglist))
+    ;; at the end we apply the user-filter if there is any.
+    (ecb-apply-user-filter-to-tags taglist)))
 
 (defun ecb-group-function-tags-with-parents (taglist)
   "Return a new taglist based on TAGLIST where all function-tags in
                     (function (lambda (x)
                                 (not (ecb--semantic-tag-get-attribute x 'prototype))))))))
 
+(defvar ecb-methods-user-filter-alist nil
+  "The filter currently applied to the methods-buffer by the user. It can be a
+regexp-string, or one of the symbols 'private, 'protected or 'public or one of
+the tag-type-symbols mentioned in the the option `ecb-tag-display-function'.
+This cache is an alist where the key is the buffer-object of that buffer the
+filter belongs and the value is the applied filter to that buffer.")
+
+
+;; TODO: Klaus Berndl <klaus.berndl@sdm.de>:
+;; - Fuer jede der 4 Funktionen unten ein tree-buffer-defpopup-command
+;;   schreiben (diese m�ssen tree-buffer-get-data-store verwenden!). Dabei
+;;   auch `ecb-sources-filter und ecb-history-filter fixen!
+;; - Filteranzeige in der Modeline des methods-buffers
+;; - Smartere und besser customizable Filterung:
+;;   + Ev. recursive absteigen - children von tags auch filtern
+;;   + Start-level bestimmbar (z.B. erst ab dem ersten children-level beginnen
+;;   + Oder Exclude-tag-classes customizable, z.B. Filterung bezieht sich nie
+;;     auf types: damit w�rden in Sprachen wie C++ oder Java die Klassen immer
+;;     angezeigt, nur ihre children w�rden gefiltert.
+;;   Ohne solche Mechanismen ist die Filterung bei OO-Sprachen fast nutzlos!
+
+(defun ecb-methods-filter-by-prot (source-buffer)
+  "Filter the Methods-buffer by protection."
+  (let ((choice (ecb-query-string "Protection filter: "
+                                  '("private" "protected" "public"))))
+    (ecb-methods-filter-apply (intern choice) source-buffer)))
+
+(defun ecb-methods-filter-by-tag-class (source-buffer)
+  "Filter the Methods-buffer by a tag-class."
+  (let ((choice (ecb-query-string "Tag-class filter: "
+                                  '("function" "variable" "type"
+                                    "include" "rule" "section" "def"))))
+    (ecb-methods-filter-apply (intern choice) source-buffer)))
+
+(defun ecb-methods-filter-by-regexp (source-buffer)
+  "Filter the Methods-buffer by a regular expression."
+  (let ((regexp-str (read-string "Insert the filter-regexp: ")))
+    (if (> (length regexp-str) 0)
+        (ecb-methods-filter-apply regexp-str source-buffer)
+      (ecb-methods-filter-apply nil source-buffer))))
+
+(defun ecb-methods-filter-none (source-buffer)
+  "Remove any filter from the Methods-buffer."
+  (ecb-methods-filter-apply nil source-buffer))
+
+(defun ecb-apply-user-filter-to-tags (taglist)
+  (save-match-data
+    (let ((filter (cdr (assoc (current-buffer) ecb-methods-user-filter-alist))))
+      (if (null filter)
+          taglist
+        (ecb-filter taglist
+                    (function
+                     (lambda (tag)
+                       (cond ((stringp filter)
+                              (if (string-match filter
+                                                (ecb--semantic-tag-name tag))
+                                  tag))
+                             ((member filter '(private protected public))
+                              (if (or (null (ecb--semantic-tag-protection tag))
+                                      (equal (ecb--semantic-tag-protection tag) filter))
+                                  tag))
+                             ((symbolp filter)
+                              (if (equal (ecb--semantic-tag-class tag) filter)
+                                  tag))
+                             (t tag)))))))))
+
+(defun ecb-methods-filter ()
+  "Apply a filter to the Methods-buffer to reduce the number of entries.
+So you get a better overlooking. There are four choices:
+- Filter by protection: Just insert the protection you want the Methods-buffer
+  being filtered: private, protected or public!
+- Filter by regexp: Insert the filter as regular expression.
+- Filter by tag-class: You can filter by the tag-classes include, type,
+  variable, function, rule, section \(chapters and sections in `info-mode'),
+  def \(definitions in `info-mode').
+- No filter: This means to display all tags specified with the option
+  `ecb-show-tokens'.
+
+Be aware that the tag-list specified by the option `ecb-show-tags' is the
+basis of all filters, i.e. tags which are excluded by that option will never
+be shown regardless of the filter type here!
+
+Such a filter is only applied to the current source-buffer, i.e. each
+source-buffer can have its own tag-filter."
+  (interactive)
+  (ecb-error "This command will be offered first in future-versions of ECB!")
+  (let ((source-buffer (if (ecb-point-in-edit-window)
+                           (current-buffer)
+                         (or ecb-last-source-buffer
+                             (ecb-error "There is no source-file to filter!"))))
+        (choice (ecb-query-string "Filter Methods-buffer by:"
+                                  '("regexp" "protection" "tag-class" "nothing"))))
+    (cond ((string= choice "protection")
+           (ecb-methods-filter-by-prot source-buffer))
+          ((string= choice "tag-class")
+           (ecb-methods-filter-by-tag-class source-buffer))
+          ((string= choice "regexp")
+           (ecb-methods-filter-by-regexp source-buffer))
+          (t (ecb-methods-filter-none source-buffer)))))
+
+
+(defun ecb-methods-filter-apply (filter source-buffer)
+  (let ((filter-elem (assoc source-buffer ecb-methods-user-filter-alist)))
+    (if filter-elem
+        (setcdr filter-elem filter)
+      (if filter
+          (setq ecb-methods-user-filter-alist
+                (cons (cons source-buffer filter)
+                      ecb-methods-user-filter-alist)))))
+  (if (get-buffer-window source-buffer ecb-frame)
+      (save-selected-window
+        (select-window (get-buffer-window source-buffer ecb-frame))
+        (ecb-rebuild-methods-buffer))))
+  
+
 (defun ecb-add-tags (node tags &optional parent-tag no-bucketize)
   "If NO-BUCKETIZE is not nil then TAGS will not bucketized by
 `ecb--semantic-bucketize' but must already been bucketized!"
     (let* ((norm-buffer-file-name (ecb-fix-filename
                                    (buffer-file-name (current-buffer))))
            (cache (assoc norm-buffer-file-name ecb-tag-tree-cache))
+           (curr-buff (current-buffer))
+           (curr-major-mode major-mode)
            new-tree non-semantic-handling)
       
       (if ecb-debug-mode
       ;; automatically.
       (save-excursion
         (ecb-buffer-select ecb-methods-buffer-name)
+        ;; we store in the tree-buffer the buffer and the major-mode for which
+        ;; the tree-buffer has been build
+        (tree-buffer-set-data-store (cons curr-buff curr-major-mode))
         (tree-buffer-set-root (cdr cache))
         (setq ecb-methods-root-node (cdr cache))
         (tree-buffer-update)))
 
 For non-semantic-sources supported by etags the option
 `ecb-auto-save-before-etags-methods-rebuild' is checked before rescanning the
-source-buffer and rebuilding the methods-buffer."
+source-buffer and rebuilding the methods-buffer.
+
+If point is in one of the ecb-windows or in the compile-window then this
+command rebuids the methods-buffer with the contents of the source-buffer the
+last selected edit-window."
   (interactive)
-  (if (ecb--semantic-active-p)
-      (ecb-rebuild-methods-buffer-for-semantic)
-    (ecb-rebuild-methods-buffer-for-non-semantic)))
+  (save-selected-window
+    (when (not (ecb-point-in-edit-window))
+      (let ((ecb-mouse-click-destination 'last-point))
+        (ecb-select-edit-window)))
+    (if (ecb--semantic-active-p)
+        (ecb-rebuild-methods-buffer-for-semantic)
+      (ecb-rebuild-methods-buffer-for-non-semantic))))
 
 
 (defvar ecb-auto-expand-tag-tree-old 'expand-spec)
 
 ;; Each NEWS-string should be a one-liner shorter than 70 chars
 (defconst ecb-upgrade-news
-  '(("2.20" . ("Fixed a bug preventing tree-buffers with expand-symbol \'before\' to work"
+  '(("2.21" . ("Advice for `balance-windows' so only the edit-windows are balanced."
+               "Gnus, BBDB, VM, Xrefactory etc. work even when ECB-windows are visible."
+               "Commands using `Electric-pop-up-window' now work correctly with ECB."
+               "Fixed some annoying bugs and one fatal bug."))
+    ("2.20" . ("Fixed a bug preventing tree-buffers with expand-symbol \'before\' to work"
                "'ecb-major-modes-\(de)activate' replaced by `ecb-major-modes-show-or-hide'"
                "New keybinding for the online-help: [C-c . h]"
                "The edit-area can be splitted in more than 2 windows."
   "Displays a warning."
   (message (concat "ECB " ecb-version " - Warning: " (apply 'format args))))
 
+(defun ecb-info-message (&rest args)
+  "Displays an information."
+  (message (concat "ECB " ecb-version " - Info: " (apply 'format args))))
+
 ;; trimming
 
 (defun ecb-excessive-trim (str)
 buffers there is no built-in auto-rebuild mechanism. For these buffers
 this command calls @code{ecb-rebuild-methods-buffer-for-non-semantic}.
 @end itemize
+
+For non-semantic-sources supported by etags the option
+@code{ecb-auto-save-before-etags-methods-rebuild} is checked before
+rescanning the source-buffer and rebuilding the methods-buffer.
+
+If point is in one of the ecb-windows or in the compile-window then
+this command rebuids the methods-buffer with the contents of the
+source-buffer the last selected edit-window.
 @end deffn
 
 @deffn Command redraw-layout &optional ARG
 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-compilation-buffer-names
+Which buffers should be treaten as ``compilation-buffers'' and
+therefore displayed in the compile-window of ECB - if there is any.
 @item  ecb-tag-display-function
 @itemx ecb-type-tag-display
 @itemx ecb-type-tag-expansion
 It is not recommended to add the eshell-buffer-names to this list
 because ECB already handles the eshell-integration as best as
 possible (@pxref{Using eshell}).
+
+See also the options @code{ecb-compilation-major-modes} and
+@code{ecb-compilation-predicates}.
 @end defopt
 
 @defopt compilation-major-modes
 As of version 2.20 the layout-engine of ECB is so flexible that
 normally there should be no conflicts with other packages unless these
 packages have their own complete window-layout-management (e.g. Gnus,
-BBDM, Xrefactory). But these packages can and should be handled very
+BBDB, Xrefactory). But these packages can and should be handled very
 well with the window-manager-support of ECB (@pxref{Window-managers
 and ECB}).
 
 @subsubsection Package BBDB
 
 @cindex BBDB
-With ECB-version < 1.96 it is not recommended to use BBDB and ECB
-simultaneously 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!
-
-But beginning with ECB 1.96 you can use one of the window-managers
-escreen.el or winring.el (@pxref{Window-managers and ECB}). With such
-a window-manager ECB and BBDB should work very well together - even in
-the same frame!
+As of ECB 2.21 there should be no conflicts between BBDB and ECB, so
+BBDB can be used even when the ECB-windows are visible.
+
+But if you encounter problems then it is recommened to use one of the
+window-managers escreen.el or winring.el (@pxref{Window-managers and
+ECB}). With such a window-manager ECB and BBDB should work together
+very well under all circumstances!
 
 @subsubsection Package calculator.el
 
 @end group
 @end example
 
+@subsubsection Package edebug (Lisp Debugger)
+
+@cindex edebug
+It is strongly recommended to run edebug only when the ECB-windows are
+hidden. With visible ECB-windows there will probably serious conflicts
+between the ECB-layout and the edebug-window-manager.
 
 @subsubsection Package ediff.el
 
 @subsubsection Package Gnus (Newsreader)
 
 @cindex Gnus
-With ECB-version < 1.96 it is not recommended to use Gnus and ECB
-simultaneously 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!
-
-But beginning with ECB 1.96 you can use one of the window-managers
-escreen.el or winring.el (@pxref{Window-managers and ECB}). With such
-a window-manager ECB and Gnus should work very well together - even in
-the same frame!
+As of ECB 2.21 there should be no conflicts between Gnus and ECB, so
+Gnus can be used even when the ECB-windows are visible.
+
+But if you encounter problems then it is recommened to use one of the
+window-managers escreen.el or winring.el (@pxref{Window-managers and
+ECB}). With such a window-manager ECB and Gnus should work together
+very well under all circumstances!
 
 @subsubsection Package JDEE (Java Development Environment)
 
 active ECB. This can be done with the hooks mentioned in @ref{Elisp
 programming}.
 
+@subsubsection Package VM (Emacs Mail-Client)
+
+@cindex VM package
+As of ECB 2.21 there should be no conflicts between VM and ECB, so
+VM can be used even when the ECB-windows are visible.
+
+But if you encounter problems then it is recommened to use one of the
+window-managers escreen.el or winring.el (@pxref{Window-managers and
+ECB}). With such a window-manager ECB and VM should work together very
+well under all circumstances!
+
+
 @subsubsection Package winner.el (winner-mode)
 
 @cindex winner-mode
 @ifnothtml
 @url{http://www.xref-tech.com}
 @end ifnothtml
-}, can be used during running ECB so long as
-not the Xrefactory-browser is used (e.g. via
-@code{xref-show-browser}). using the Xrefactory-broswer confuses the
-ECB-layout-engine as well as the Xrefactory window-layouter because
-the latter one does some wild window splitting and resizing of its
-own. The symbol completion window plays nice with ECB, but the source
-code browsers 3 window layout won't work with ECB enabled. It is so
-deeply confused by ECB that it drops a window. Normally hiding the ECB
-windows before starting the Xref-brwoser should help because with
-hidden ECB-windows there are no restrictions on the part of ECB
-concering window-layout. But to get sure ECB can also be deactivated
-;-)
-
-This can be achieved with the following advice which should be put in
-the @file{.emacs}:
-
-@example
-@group
-(defadvice xref-create-browser-windows 
-     (before hide-or-deactivate-ecb-for-xref first nil compile)
-   "deactivate ecb when invoking the xrefactory browser"
-   (when ecb-minor-mode
-     (ecb-toggle-ecb-windows -1)
-     ;; or if you want completely deactivating ECB uncomment this
-     ;; (ecb-deactivate)
-     )
-@end group
-@end example
-
-But the most recommended way is to use a window-manager as
-escreen.el or winring.el (and then use different escreens or
-window-configurations for ECB and Xrefactory-browsing -
-@ref{Window-managers and ECB}).
+}, can be used during running ECB regardless if the ECB-windows are
+visible or not. There should be no conflicts as of ECB versions >=
+2.21.
+
+If there are conflicts with the Xref-browser then the most recommended
+way is to use one of the window-manager escreen.el or winring.el (and
+then use different escreens or window-configurations for ECB and
+Xrefactory-browsing - @ref{Window-managers and ECB}).
 
 @node Bugs, , Conflicts, Conflicts and bugs
 @section Known bugs