Update icicles
authorJoerg Jaspert <joerg@debian.org>
Sun, 16 Mar 2014 22:36:58 +0000 (23:36 +0100)
committerJoerg Jaspert <joerg@debian.org>
Sun, 16 Mar 2014 22:36:58 +0000 (23:36 +0100)
22 files changed:
.emacs.d/elisp/icicle/col-highlight.el
.emacs.d/elisp/icicle/crosshairs.el
.emacs.d/elisp/icicle/doremi.el
.emacs.d/elisp/icicle/hexrgb.el
.emacs.d/elisp/icicle/hl-line+.el
.emacs.d/elisp/icicle/icicles-chg.el
.emacs.d/elisp/icicle/icicles-cmd1.el
.emacs.d/elisp/icicle/icicles-cmd2.el
.emacs.d/elisp/icicle/icicles-doc1.el
.emacs.d/elisp/icicle/icicles-doc2.el
.emacs.d/elisp/icicle/icicles-face.el
.emacs.d/elisp/icicle/icicles-fn.el
.emacs.d/elisp/icicle/icicles-mac.el
.emacs.d/elisp/icicle/icicles-mcmd.el
.emacs.d/elisp/icicle/icicles-mode.el
.emacs.d/elisp/icicle/icicles-opt.el
.emacs.d/elisp/icicle/icicles-var.el
.emacs.d/elisp/icicle/icicles.el
.emacs.d/elisp/icicle/icomplete+.el
.emacs.d/elisp/icicle/lacarte.el
.emacs.d/elisp/icicle/ring+.el
.emacs.d/elisp/icicle/synonyms.el

index 68600a8..f5db6fb 100644 (file)
@@ -1,27 +1,29 @@
 ;;; col-highlight.el --- Highlight the current column.
-;; 
+;;
 ;; Filename: col-highlight.el
 ;; Description: Highlight the current column.
 ;; Author: Drew Adams
-;; Maintainer: Drew Adams
-;; Copyright (C) 2006-2012, Drew Adams, all rights reserved.
+;; Maintainer: Drew Adams (concat "drew.adams" "@" "oracle" ".com")
+;; Copyright (C) 2006-2014, Drew Adams, all rights reserved.
 ;; Created: Fri Sep 08 11:06:35 2006
-;; Version: 22.0
-;; Last-Updated: Fri May 18 07:32:07 2012 (-0700)
+;; Version: 0
+;; Package-Requires: ((vline "0"))
+;; Last-Updated: Thu Dec 26 08:51:27 2013 (-0800)
 ;;           By: dradams
-;;     Update #: 367
+;;     Update #: 420
 ;; URL: http://www.emacswiki.org/cgi-bin/wiki/col-highlight.el
+;; Doc URL: http://emacswiki.org/emacs/HighlightCurrentColumn
 ;; Keywords: faces, frames, emulation, highlight, cursor, accessibility
 ;; Compatibility: GNU Emacs: 22.x, 23.x
-;; 
+;;
 ;; Features that might be required by this library:
 ;;
 ;;   `vline'.
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 
+;;
 ;;; Commentary:
-;; 
+;;
 ;;  This library highlights the current column.  When you move the
 ;;  cursor, the highlighting follows (tracks the cursor), as long as
 ;;  the highlighting stays on.
 ;;  vline (i.e., column) highlighting appear on top of other overlay
 ;;  highlighting that might exist.
 ;;
+;;  You can use option `col-highlight-show-only' to restrict
+;;  current-column highlighting to a section of text of a particular
+;;  kind: paragaph, sentence, page, defun, etc.
+;;
 ;;
 ;;  To use this file, you must also have library `vline.el'.
 ;;  Put this in your Emacs init file (~/.emacs):
@@ -90,7 +96,7 @@
 ;;  User options defined here:
 ;;
 ;;    `col-highlight-period', `column-highlight-mode',
-;;    `col-highlight-overlay-priority',
+;;    `col-highlight-overlay-priority', `col-highlight-show-only',
 ;;    `col-highlight-vline-face-flag'.
 ;;
 ;;  Faces defined here:
 ;;    `col-highlight-idle-timer', `col-highlight-when-idle-p'.
 ;;
 ;;
-;;  ***** NOTE: The following non-interactive function defined in
-;;              `vline.el' has been ADVISED HERE (to respect option
-;;              `col-highlight-overlay-priority'):
+;;  ***** NOTE: The following function defined in `vline.el' has
+;;              been REDEFINED HERE:
 ;;
-;;    `vline-show'.
+;;    `vline-show' - Respect options `col-highlight-overlay-priority'
+;;                   and `col-highlight-show-only'.
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 
+;;
 ;;; Change Log:
 ;;
+;; 2013/08/08 dadams
+;;     Added: col-highlight-show-only, redefinition of vline-show.
+;;     Removed defadvice of vline-show (replaced by redefinition).
+;; 2012/12/25 dadams
+;;     Added Package-Requires.
 ;; 2012/05/18 dadams
 ;;     Added: col-highlight-overlay-priority, defadvice of vline-show.
 ;; 2011/01/03 dadams
 ;;     Removed semi-support for Emacs 20.
 ;; 2006/09/08 dadams
 ;;     Created.
-;; 
+;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 
+;;
 ;; This program is free software; you can redistribute it and/or
 ;; modify it under the terms of the GNU General Public License as
 ;; published by the Free Software Foundation; either version 3, or
 ;; (at your option) any later version.
-;; 
+;;
 ;; This program is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 ;; General Public License for more details.
-;; 
+;;
 ;; You should have received a copy of the GNU General Public License
 ;; along with this program; see the file COPYING.  If not, write to
 ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 ;; Floor, Boston, MA 02110-1301, USA.
-;; 
+;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 
+;;
 ;;; Code:
 
 (require 'vline)
@@ -184,6 +195,25 @@ Don't forget to mention your Emacs and library versions."))
   :link '(url-link :tag "Download"
           "http://www.emacswiki.org/cgi-bin/wiki/col-highlight.el"))
 
+;;;###autoload
+(defcustom col-highlight-show-only nil
+  "Non-nil means `column-highlight-mode' affects only a section of text.
+This affects `vline-mode' also.
+
+The non-nil value determines the type of text section: paragraph,
+sentence, defun, page...
+
+The actual non-nil value is a forward movement command for the given
+section type, e.g., `forward-paragraph', `end-of-defun'."
+  :type '(choice
+          (const    :tag "All text"  nil)
+          (const    :tag "Paragraph" forward-paragraph)
+          (const    :tag "Sentence"  forward-sentence)
+          (const    :tag "Page"      forward-page)
+          (const    :tag "Defun"     end-of-defun)
+          (function :tag "Forward-thing function" :value forward-paragraph))
+  :group 'column-highlight)
+
 ;;;###autoload
 (defcustom col-highlight-vline-face-flag t
   "*Non-nil means `column-highlight-mode' uses `col-highlight-face'.
@@ -236,12 +266,117 @@ Do NOT change this yourself; instead, use
 ;; You must use `toggle-highlight-column-when-idle' to turn it on.
 (cancel-timer col-highlight-idle-timer)
 
-(defadvice vline-show (after set-priority activate)
-  "Set the overlay priority to `col-highlight-overlay-priority'."
-  (when (boundp 'vline-overlay-table)
-    (mapc (lambda (ov) (when (overlayp ov)
-                    (overlay-put ov 'priority col-highlight-overlay-priority)))
-          vline-overlay-table)))
+
+
+;;  REPLACE ORIGINAL `vline-show' defined in `vline.el'.
+;;
+;;  Respect options `col-highlight-overlay-priority' and `col-highlight-show-only'.
+;;
+(defun vline-show (&optional point)
+  (vline-clear)
+  (save-window-excursion
+    (save-excursion
+      (if point
+          (goto-char point)
+        (setq point  (point)))
+      (let* ((column           (vline-current-column))
+             (lcolumn          (current-column))
+             (i                0)
+             (compose-p        (memq vline-style '(compose mixed)))
+             (face-p           (memq vline-style '(face mixed)))
+             (line-char        (if compose-p vline-line-char ?\   ))
+             (line-str         (make-string 1 line-char))
+             (visual-line-str  line-str)
+             (in-fringe-p      (vline-into-fringe-p))
+             (only-beg         (and col-highlight-show-only
+                                    (condition-case nil
+                                        (save-excursion
+                                          (funcall col-highlight-show-only -1)
+                                          (point))
+                                      (error nil))))
+             (only-end         (and col-highlight-show-only
+                                    (condition-case nil
+                                        (save-excursion
+                                          (funcall col-highlight-show-only 1)
+                                          (point))
+                                      (error nil)))))
+        (when face-p
+          (setq line-str (propertize line-str 'face (vline-face nil)))
+          (setq visual-line-str  (propertize visual-line-str 'face (vline-face t))))
+        (goto-char (window-end nil t))
+        (vline-forward 0)
+        (while (and (not (bobp))
+                    (not in-fringe-p)
+                    (< i (window-height))
+                    (< i (length vline-overlay-table)))
+          (let ((cur-column   (vline-move-to-column column t))
+                (cur-lcolumn  (current-column)))
+            (unless (or (= (point) point) ; Non-cursor line only (eol workaround).
+                        (and only-beg  only-end  (or (<= (point) only-beg)
+                                                     (>= (point) only-end))))
+              (when (> cur-column column)
+                (let ((lcol  (current-column)))
+                  (backward-char)
+                  (setq cur-column  (- cur-column (- lcol (current-column))))))
+              (let* ((ovr       (aref vline-overlay-table i))
+                     (visual-p  (or (< lcolumn (current-column))
+                                    (> lcolumn (+ (current-column)
+                                                  (- column cur-column)))))
+                     ;; Consider a newline, tab and wide char.
+                     (str       (concat (make-string (- column cur-column) ?\  )
+                                        (if visual-p visual-line-str line-str)))
+                     (char      (char-after)))
+                (unless ovr
+                  (setq ovr  (make-overlay 0 0))
+                  (overlay-put ovr 'rear-nonsticky t)
+                  (aset vline-overlay-table i ovr))
+                (overlay-put ovr 'face nil)
+                (overlay-put ovr 'before-string nil)
+                (overlay-put ovr 'after-string nil)
+                (overlay-put ovr 'invisible nil)
+                (overlay-put ovr 'window (and vline-current-window-only  (selected-window)))
+                (cond ((memq char vline-multiwidth-space-list) ; Multiwidth space
+                       (setq str  (concat str (make-string (- (save-excursion (forward-char)
+                                                                              (current-column))
+                                                              (current-column)
+                                                              (string-width str))
+                                                           ?\  )))
+                       (move-overlay ovr (point) (1+ (point)))
+                       (overlay-put ovr 'invisible t)
+                       (overlay-put ovr 'after-string str))
+                      ((eolp)
+                       (move-overlay ovr (point) (point))
+                       (overlay-put ovr 'after-string str)
+                       (when (and (not truncate-lines) ; Do not expand more than window width.
+                                  (>= (1+ column) (window-width))
+                                  (>= column (vline-current-column))
+                                  (not (vline-into-fringe-p)))
+                         (delete-overlay ovr)))
+                      (t
+                       (cond (compose-p
+                              (let (str)
+                                (when char
+                                  (setq str  (compose-chars char
+                                                            (cond ((= (char-width char) 1)
+                                                                   '(tc . tc))
+                                                                  ((= cur-column column)
+                                                                   '(tc . tr))
+                                                                  (t
+                                                                   '(tc . tl)))
+                                                            line-char))
+                                  (when face-p
+                                    (setq str  (propertize str 'face (vline-face visual-p))))
+                                  (move-overlay ovr (point) (1+ (point)))
+                                  (overlay-put ovr 'invisible t)
+                                  (overlay-put ovr 'after-string str))))
+                             (face-p
+                              (move-overlay ovr (point) (1+ (point)))
+                              (overlay-put ovr 'face (vline-face visual-p))))))))
+            (setq i  (1+ i))
+            (vline-forward -1))))))
+  (mapc (lambda (ov) (when (overlayp ov) ; Set overlay priority to `col-highlight-overlay-priority'.
+                  (overlay-put ov 'priority col-highlight-overlay-priority)))
+        vline-overlay-table))
 
 ;;;###autoload
 (define-minor-mode column-highlight-mode
@@ -324,7 +459,7 @@ With a prefix ARG, highlight for that many seconds."
   "Highlight current column.
 This has no effect in the minibuffer, unless optional arg
 MINIBUFFER-ALSO-P is non-nil."
-  (unless (and (minibufferp) (not minibuffer-also-p))
+  (unless (and (minibufferp)  (not minibuffer-also-p))
     (let ((vline-current-window-only  t))
       (if col-highlight-vline-face-flag
           (let ((vline-style  'face)
@@ -336,7 +471,7 @@ MINIBUFFER-ALSO-P is non-nil."
   "Turn off highlighting of current column.
 This has no effect in the minibuffer, unless optional arg
 MINIBUFFER-ALSO-P is non-nil."
-  (unless (and (minibufferp) (not minibuffer-also-p))
+  (unless (and (minibufferp)  (not minibuffer-also-p))
     (if col-highlight-vline-face-flag
         (let ((vline-style  'face)
               (vline-face   col-highlight-face))
index 4ec052b..8aca9bb 100644 (file)
@@ -1,27 +1,30 @@
 ;;; crosshairs.el --- Highlight the current line and column.
-;; 
+;;
 ;; Filename: crosshairs.el
 ;; Description: Highlight the current line and column.
 ;; Author: Drew Adams
-;; Maintainer: Drew Adams
-;; Copyright (C) 2006-2012, Drew Adams, all rights reserved.
+;; Maintainer: Drew Adams (concat "drew.adams" "@" "oracle" ".com")
+;; Copyright (C) 2006-2014, Drew Adams, all rights reserved.
 ;; Created: Fri Sep 08 13:09:19 2006
-;; Version: 22.0
-;; Last-Updated: Fri May 18 07:22:07 2012 (-0700)
+;; Version: 0
+;; Package-Requires: ((hl-line+ "0") (col-highlight "0") (vline "0"))
+;; Last-Updated: Thu Dec 26 08:51:16 2013 (-0800)
 ;;           By: dradams
-;;     Update #: 465
-;; URL: http://www.emacswiki.org/cgi-bin/wiki/crosshairs.el
+;;     Update #: 487
+;; URL: http://www.emacswiki.org/crosshairs.el
+;; Doc URL: http://www.emacswiki.org/CrosshairHighlighting
 ;; Keywords: faces, frames, emulation, highlight, cursor, accessibility
-;; Compatibility: GNU Emacs: 22.x, 23.x
-;; 
+;; Compatibility: GNU Emacs: 22.x, 23.x, 24.x
+;; Package-Requires: ((col-highlight "22.0") (hl-line+ "20120823") (vline "1.10"))
+;;
 ;; Features that might be required by this library:
 ;;
 ;;   `col-highlight', `hl-line', `hl-line+', `vline'.
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 
-;;; Commentary: 
-;; 
+;;
+;;; Commentary:
+;;
 ;;  This library highlights the current line and the current column.
 ;;  It combines the features of libraries `hl-line.el', `hl-line+.el',
 ;;  and `col-highlight.el', which let you highlight the line or column
 ;;  when Emacs is idle.  Command `toggle-crosshairs-when-idle' toggles
 ;;  this mode.
 ;;
+;;  You can use command `flash-crosshairs' to do what its name says
+;;  when you switch buffers or windows.  Here is how one user did it
+;;  (rejoin the split URL):
+;;  http://unix.stackexchange.com/questions/83167/emacs-finding-the-
+;;  cursor-in-multiple-windows
+;;
 ;;
 ;;  See also:
 ;;
 ;;   or (global-set-key [(control ?+)] 'crosshairs-flash)
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 
+;;
 ;;; Change Log:
 ;;
+;; 2012/12/25 dadams
+;;     Added Package-Requires.
 ;; 2012/05/18 dadams
 ;;     Removed: crosshairs-overlay-priority.  Instead, use vline-overlay-priority
 ;;              and col-highlight-overlay-priority.
 ;;       If both are already on or off, reflect that as the crosshair state.
 ;;     crosshairs-toggle-when-idle:
 ;;       crosshairs-highlight-when-idle-p, not col-highlight-when-idle-p.
-;;     crosshairs-flash: 
+;;     crosshairs-flash:
 ;;       Save/restore global-hl-line-mode.
 ;;       Clear and rehighlight column initially.  Maybe highlight twice (bug).
 ;;       Don't use highlight modes to unhighlight - just unhighlight.
 ;;     Removed semi-support for Emacs 20.
 ;; 2006/09/08 dadams
 ;;     Created.
-;; 
+;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 
+;;
 ;; This program is free software; you can redistribute it and/or
 ;; modify it under the terms of the GNU General Public License as
 ;; published by the Free Software Foundation; either version 3, or
 ;; (at your option) any later version.
-;; 
+;;
 ;; This program is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 ;; General Public License for more details.
-;; 
+;;
 ;; You should have received a copy of the GNU General Public License
 ;; along with this program; see the file COPYING.  If not, write to
 ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 ;; Floor, Boston, MA 02110-1301, USA.
-;; 
+;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;;; Code:
index a9028e3..7855081 100644 (file)
@@ -3,20 +3,22 @@
 ;; Filename: doremi.el
 ;; Description: Incremental change using arrow keys or mouse wheel.
 ;; Author: Drew Adams
-;; Maintainer: Drew Adams
-;; Copyright (C) 2004-2012, Drew Adams, all rights reserved.
+;; Maintainer: Drew Adams (concat "drew.adams" "@" "oracle" ".com")
+;; Copyright (C) 2004-2014, Drew Adams, all rights reserved.
 ;; Created: Thu Sep 02 08:21:37 2004
-;; Version: 21.1
-;; Last-Updated: Fri Mar  2 08:16:51 2012 (-0800)
+;; Version: 0
+;; Package-Requires: ()
+;; Last-Updated: Thu Dec 26 08:48:54 2013 (-0800)
 ;;           By: dradams
-;;     Update #: 1603
-;; URL: http://www.emacswiki.org/cgi-bin/wiki/doremi.el
+;;     Update #: 1617
+;; URL: http://www.emacswiki.org/doremi.el
+;; Doc URL: http://www.emacswiki.org/DoReMi
 ;; Keywords: keys, cycle, repeat, higher-order
-;; Compatibility: GNU Emacs: 20.x, 21.x, 22.x, 23.x
+;; Compatibility: GNU Emacs: 20.x, 21.x, 22.x, 23.x, 24.x
 ;;
 ;; Features that might be required by this library:
 ;;
-;;   `mwheel', `ring', `ring+'.
+;;   `mwheel', `ring'.
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; of using function `doremi', see files `doremi-frm.el' and
 ;; `doremi-cmd.el'.
 ;;
-;; This library uses library `ring+.el', which provides extensions to
-;; the standard library `ring.el' to let you manipulate circular
-;; structures.
+;; For Emacs prior to release 23, this library requires library
+;; `ring+.el', which provides extensions to the standard library
+;; `ring.el' to let you manipulate circular structures.  (Library
+;; `ring+.el' is part of GNU Emacs 23 and later.)
 ;;
 ;;
 ;;  Non-interactive functions defined here:
 ;;
 ;;; Change Log:
 ;;
+;; 2013/06/06 dadams
+;;     Do not require ring+.el unless prior to Emacs 23.
 ;; 2011/09/07 dadams
 ;;     doremi: Use mouse-wheel-(up|down)-event everywhere.  Thx to Michael Heerdegen.
 ;; 2011/01/04 dadams
 ;;
 ;;; Code:
 
-(require 'ring+) ;; ring-convert-sequence-to-ring, ring-insert+extend,
-                 ;; ring-member, ring-next, ring-previous
+(require 'ring)
+(unless (fboundp 'ring-member)          ; Emacs 23
+  (require 'ring+))
+  ;; ring-convert-sequence-to-ring, ring-insert+extend, ring-member, ring-next, ring-previous
 (require 'mwheel nil t) ; (no error if not found): mwheel-event-button
 
 ;; In Emacs 20, because `mwheel.el' is not loaded, byte-compiling
@@ -273,7 +280,7 @@ the same effect as using `doremi-boost-up-keys' or
 
 ;; Originally, the key-variable options were for a single key, not a list of keys.
 ;; Top-level warning when load the library.
-(when (or (boundp 'doremi-up-key)   (boundp 'doremi-boost-up-key) 
+(when (or (boundp 'doremi-up-key)   (boundp 'doremi-boost-up-key)
           (boundp 'doremi-down-key) (boundp 'doremi-boost-down-key))
   (message "WARNING: Single-key options `doremi-...-key' are OBSOLETE. Use `doremi-...-keys'."))
  
@@ -521,7 +528,6 @@ MAX must be greater than min."
     (while (> new max) (setq new  (- new del)))
     (while (< new min) (setq new  (+ new del)))
     new))
-  
  
 ;;; Example Commands.  Uncomment these and try them to get the idea.
 ;;
index 3d40c64..fe69483 100644 (file)
@@ -3,13 +3,14 @@
 ;; Filename: hexrgb.el
 ;; Description: Functions to manipulate colors, including RGB hex strings.
 ;; Author: Drew Adams
-;; Maintainer: Drew Adams
-;; Copyright (C) 2004-2013, Drew Adams, all rights reserved.
+;; Maintainer: Drew Adams (concat "drew.adams" "@" "oracle" ".com")
+;; Copyright (C) 2004-2014, Drew Adams, all rights reserved.
 ;; Created: Mon Sep 20 22:58:45 2004
-;; Version: 21.0
-;; Last-Updated: Fri Jan 18 09:01:51 2013 (-0800)
+;; Version: 0
+;; Package-Requires: ()
+;; Last-Updated: Thu Dec 26 09:06:37 2013 (-0800)
 ;;           By: dradams
-;;     Update #: 953
+;;     Update #: 957
 ;; URL: http://www.emacswiki.org/hexrgb.el
 ;; Doc URL: http://www.emacswiki.org/SetColor
 ;; Doc URL: http://emacswiki.org/ColorPalette
@@ -482,7 +483,7 @@ Returns a list of HSV components of value 0.0 to 1.0, inclusive."
                  (arith-error nil))
                ;; Must be a number, not a NaN.  The standard test for a NaN is (not (= N N)),
                ;; but an Emacs 20 bug makes (= N N) return t for a NaN also.
-               (or (< emacs-major-version 21) (= saturation saturation)))                
+               (or (< emacs-major-version 21) (= saturation saturation)))
           (if (hexrgb-approx-equal 0.0 saturation)
               (setq hue         0.0
                     saturation  0.0)    ; Again, no color; only value.
@@ -640,7 +641,7 @@ The output list is as for `x-color-values'."
           green  (hexrgb-hex-to-int (substring color ndigits (* 2 ndigits)))
           blue   (hexrgb-hex-to-int (substring color (* 2 ndigits) (* 3 ndigits))))
     (list red green blue)))
-    
+
 ;; Like `doremi-increment-color-component', but for hue only, and with 0-1 range and NB-DIGITS.
 (defun hexrgb-increment-hue (color increment &optional nb-digits)
   "Increase hue component of COLOR by INCREMENT.
index 6dd45c4..9004f52 100644 (file)
@@ -1,26 +1,29 @@
 ;;; hl-line+.el --- Extensions to hl-line.el.
-;; 
+;;
 ;; Filename: hl-line+.el
 ;; Description: Extensions to hl-line.el.
 ;; Author: Drew Adams
-;; Maintainer: Drew Adams
-;; Copyright (C) 2006-2012, Drew Adams, all rights reserved.
+;; Maintainer: Drew Adams (concat "drew.adams" "@" "oracle" ".com")
+;; Copyright (C) 2006-2014, Drew Adams, all rights reserved.
 ;; Created: Sat Aug 26 18:17:18 2006
-;; Version: 22.0
-;; Last-Updated: Fri May 18 07:04:49 2012 (-0700)
+;; Version: 0
+;; Package-Requires: ()
+;; Last-Updated: Thu Dec 26 09:26:18 2013 (-0800)
 ;;           By: dradams
-;;     Update #: 465
-;; URL: http://www.emacswiki.org/cgi-bin/wiki/hl-line+.el
+;;     Update #: 485
+;; URL: http://www.emacswiki.org/hl-line+.el
+;; Doc URL: http://www.emacswiki.org/HighlightCurrentLine
+;; Doc URL: http://www.emacswiki.org/CrosshairHighlighting
 ;; Keywords: highlight, cursor, accessibility
-;; Compatibility: GNU Emacs: 22.x, 23.x
-;; 
+;; Compatibility: GNU Emacs: 22.x, 23.x, 24.x
+;;
 ;; Features that might be required by this library:
 ;;
 ;;   `hl-line'.
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 
-;;; Commentary: 
+;;
+;;; Commentary:
 ;;
 ;;  This library extends standard library `hl-line.el' in these ways:
 ;;
@@ -34,7 +37,7 @@
 ;;     customize `global-hl-line-mode' to nil.
 ;;
 ;;  3. It provides a face, `hl-line', that you can customize, instead
-;;     of using option `hl-line-face'.  
+;;     of using option `hl-line-face'.
 ;;
 ;;     I suggested #3 to the Emacs developers, and it was added to
 ;;     Emacs 22, but with a different default value.  If you use
 ;;    `global-hl-line-highlight', `hl-line-highlight'.
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 
+;;
 ;;; Change Log:
 ;;
+;; 2013/06/08 dadams
+;;     hl-line-inhibit-highlighting-for-modes: Corrected :type.
+;;     global-hl-line-highlight defadvice: Respect in hl-line-inhibit-highlighting-for-modes.
+;; 2013/01/17 dadams
+;;     toggle-hl-line-when-idle: Added optional MSGP arg.
 ;; 2012/05/18 dadams
 ;;     Added: hl-line-overlay-priority, defadvice for (global-)hl-line-highlight.
 ;; 2011/01/04 dadams
 ;;            hl-line-when-idle(-off).
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 
+;;
 ;; This program is free software; you can redistribute it and/or
 ;; modify it under the terms of the GNU General Public License as
 ;; published by the Free Software Foundation; either version 3, or
 ;; (at your option) any later version.
-;; 
+;;
 ;; This program is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 ;; General Public License for more details.
-;; 
+;;
 ;; You should have received a copy of the GNU General Public License
 ;; along with this program; see the file COPYING.  If not, write to
 ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 ;; Floor, Boston, MA 02110-1301, USA.
-;; 
+;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 
+;;
 ;;; Code:
 
 (require 'hl-line)
 (defcustom hl-line-inhibit-highlighting-for-modes ()
   "*Modes where highlighting is inhibited for `hl-line-highlight-now'.
 A list of `major-mode' values (symbols)."
-  :type 'list :group 'hl-line)
+  :type '(repeat (symbol :tag "Major mode where `hl-line' highlighting is inhibited"))
+  :group 'hl-line)
 
 ;;;###autoload
 (defcustom hl-line-overlay-priority 300
@@ -223,26 +232,33 @@ Do NOT change this yourself; instead, use `\\[toggle-hl-line-when-idle]'.")
   "Set the overlay priority to `hl-line-overlay-priority'."
   (overlay-put hl-line-overlay 'priority hl-line-overlay-priority))
 
-(defadvice global-hl-line-highlight (after set-priority activate)
-  "Set the overlay priority to `hl-line-overlay-priority'."
-  (overlay-put global-hl-line-overlay 'priority hl-line-overlay-priority))
+(defadvice global-hl-line-highlight (around set-priority-+respect-mode-inhibit activate)
+  "Set hl-line overlay priority and inhibit for specific modes.
+Set the overlay to `hl-line-overlay-priority'.
+Respect option `hl-line-inhibit-highlighting-for-modes'."
+  (unless (member major-mode hl-line-inhibit-highlighting-for-modes)
+    ad-do-it
+    (overlay-put global-hl-line-overlay 'priority hl-line-overlay-priority)))
 
 ;;;###autoload
 (defalias 'toggle-hl-line-when-idle 'hl-line-toggle-when-idle)
 ;;;###autoload
-(defun hl-line-toggle-when-idle (&optional arg)
+(defun hl-line-toggle-when-idle (&optional arg msgp)
   "Turn on or off using `global-hl-line-mode' when Emacs is idle.
 When on, use `global-hl-line-mode' whenever Emacs is idle.
-With prefix argument, turn on if ARG > 0; else turn off."
-  (interactive "P")
+With prefix argument, turn on if ARG > 0; else turn off.
+
+In Lisp code, non-nil optional second arg MSGP means display a message
+showing the new value."
+  (interactive "P\np")
   (setq hl-line-when-idle-p
         (if arg (> (prefix-numeric-value arg) 0) (not hl-line-when-idle-p)))
   (cond (hl-line-when-idle-p
          (timer-activate-when-idle hl-line-idle-timer)
-         (message "Turned ON using `global-hl-line-mode' when Emacs is idle."))
+         (when msgp (message "Turned ON using `global-hl-line-mode' when Emacs is idle.")))
         (t
          (cancel-timer hl-line-idle-timer)
-         (message "Turned OFF using `global-hl-line-mode' when Emacs is idle."))))
+         (when msgp (message "Turned OFF using `global-hl-line-mode' when Emacs is idle.")))))
 
 ;;;###autoload
 (defun hl-line-when-idle-interval (secs)
@@ -262,7 +278,7 @@ use `\\[toggle-hl-line-when-idle]."
     (global-hl-line-mode 1)
     (global-hl-line-highlight)
     (add-hook 'pre-command-hook 'hl-line-unhighlight-now)))
-    
+
 (defun hl-line-unhighlight-now ()
   "Turn off `global-hl-line-mode' and unhighlight current line now."
   (global-hl-line-mode -1)
index 9d50259..e643b11 100644 (file)
@@ -3,13 +3,12 @@
 ;; Filename: icicles-chg.el
 ;; Description: Change logs for Icicles libraries.
 ;; Author: Drew Adams
-;; Maintainer: Drew Adams
-;; Copyright (C) 2007-2013, Drew Adams, all rights reserved.
+;; Maintainer: Drew Adams (concat "drew.adams" "@" "oracle" ".com")
+;; Copyright (C) 2007-2014, Drew Adams, all rights reserved.
 ;; Created: Tue Nov 27 07:47:53 2007
-;; Version: 22.0
-;; Last-Updated: Sat Apr  6 21:38:48 2013 (-0700)
+;; Last-Updated: Sun Mar  9 10:00:46 2014 (-0700)
 ;;           By: dradams
-;;     Update #: 9926
+;;     Update #: 10738
 ;; URL: http://www.emacswiki.org/icicles-chg.el
 ;; Doc URL: http://www.emacswiki.org/Icicles
 ;; Keywords: extensions, help, abbrev, local, minibuffer,
  
 ;;;(@* "CHANGE LOG FOR `icicles-cmd1.el'")
 ;;
+;; 2014/03/09 dadams
+;;     icicle-file(-other-window): Set this-command so user sees msgs appropriate to the command.
+;; 2014/03/08 dadams
+;;     Use (featurep 'icomplete), not (boundp 'icomplete-mode), everywhere.
+;;     icicle-execute-extended-command-1: Move run of pre-command-hook after binding of this-command.
+;;     icicle-apropos-value, icicle-describe-option-of-type, *-find-file*-in-tags-table*:
+;;       Put properties icicle-turn-off-(icomplete-mode|incremental-completion).
+;;     icicle-(recent-file|find-file-abs)*: Put property icicle-hide-common-match.
+;;     icicle-locate*: Put properties icicle-turn-off* and icicle-hide-common-match.
+;;     icicle-find-file*(-in-tags-table*): Put property icicle-Completions-window-max-height.
+;; 2014/02/22 dadams
+;;     icicle-lisp-complete-symbol: Fixed regression introduced by 2014-01-15 change:
+;;       Max, not min, of point and BEG.  If END is nil, use BEG for PATTERN.  Go to BEG before insert.
+;; 2014/02/08 dadams
+;;     icicle-find-file-(no-search|of-content)-action-1:
+;;       Pass icicle-find-file-(no-search|of-content)-1 as arg, not icicle-find-file-action-fn.
+;;     icicle-find-file-or-expand-dir: Use funcall, not call-interactively (not really a command).
+;;                                     Use file-directory-p, not icicle-looks-like-dir-name-p.
+;;                                     Use file-name-as-directory to get new default-directory.
+;; 2014/01/25 dadams
+;;     icicle-bbdb-complete-name: Do not define if bbdb-version is not a number.
+;; 2014/01/18 dadams
+;;     icicle-customize-face(-other-window): Handle proxy candidates in action function.  Updated doc.
+;; 2014/01/15 dadams
+;;     icicle-lisp-complete-symbol:
+;;       Prevent read-only error message for empty input in minibuffer.  Update a bit wrt vanilla.
+;;       Wrap END calculation in unwind-protect also.
+;; 2014/01/08 dadams
+;;     icicle-command-abbrev-action: Set CMD to the invoked command, using command-history.
+;; 2014/01/06 dadams
+;;     icicle-apropos-value, icicle-command-abbrev: Bind icicle--last-toggle-transforming-msg.
+;; 2014/01/04 dadams
+;;     icicle-locate-file-*-1: Typo: Mistakenly used recentf-list instead of default-directory.
+;;     icicle-recent-file-*-1: Ensure recentf-list is boundp.
+;; 2014/01/02 dadams
+;;     icicle-execute-extended-command(-1):
+;;       Restore SPC correctly.  If CMD turns off Icicle mode then not icicle-self-insert.
+;; 2013/12/09 dadams
+;;     Added:
+;;       icicle-find-file-of-content-in-tags-table, icicle-find-file-no-search-in-tags-table,
+;;       icicle-find-file-of-content-in-tags-table-other-window,
+;;       icicle-find-file-no-search-in-tags-table-other-window,
+;;       icicle-find-file-of-content-in-tags-table-1, icicle-find-file-no-search-in-tags-table-1
+;;     icicle-find-file-in-tags-table(-other-window): use defalias now - either of-content|no-search.
+;;     Applied renamings: icicle-buffer-skip-hook               to icicle-buffer-skip-functions,
+;;                        icicle-find-file-of-content-skip-hook to icicle-file-skip-functions.
+;; 2013/12/08 dadams
+;;     Added:
+;;       icicle-find-file-abs-action-fn, icicle-find-file-action-fn, icicle-new-bufs-to-keep,
+;;       icicle-new-bufs-to-kill, icicle-existing-bufs,
+;;       icicle-find-file-no-search-1 (from w/o *-1) using action fn (and same cleanup for undo),
+;;       icicle-find-file-of-content-1 (from w/o *-1) using action fn,
+;;       icicle-find-file-abs-no-search-1 (from w/o *-1) using action fn,
+;;       icicle-find-file-abs-of-content-1 (from w/o *-1) using action fn,
+;;       icicle-recent-file-no-search-1 (from w/o *-1) using action fn
+;;         (& icicle-pref-arg, not curr, & same cleanup for undo),
+;;       icicle-recent-file-of-content-1 (from w/o *-1) using action fn,
+;;       icicle-locate-file-no-search-1 (from icicle-locate-file-1) using action fn (& same cleanup),
+;;       icicle-locate-file-of-content-1,
+;;       icicle-find-file-abs-read-only, icicle-find-file-abs-read-only-other-window,
+;;       icicle-locate-file-no-search, icicle-locate-file-no-search-other-window,
+;;       icicle-locate-file-no-search-no-symlinks,
+;;       icicle-locate-file-no-search-no-symlinks-other-window,
+;;       icicle-locate-file-of-content, icicle-locate-file-of-content-other-window,
+;;       icicle-locate-file-of-content-no-symlinks,
+;;       icicle-locate-file-of-content-no-symlinks-other-window,
+;;       icicle-locate-no-search, icicle-locate-no-search-other-window, 
+;;       icicle-locate-of-content, icicle-locate-of-content-other-window,
+;;       icicle-find-file-abs-no-search-action-1, icicle-find-file-abs-of-content-action-1,
+;;       icicle-find-file-no-search-action-1, icicle-find-file-of-content-action-1,
+;;       icicle-find-file-no-search-action, icicle-find-file-no-search-other-window-action,
+;;       icicle-find-file-of-content-action, icicle-find-file-of-content-other-window-action,
+;;       icicle-find-file-of-content-ro-action, icicle-find-file-of-content-ro-ow-action,
+;;       icicle-find-file-abs-no-search-action, icicle-find-file-abs-no-search-other-window-action,
+;;       icicle-find-file-abs-no-search-ro-action, icicle-find-file-abs-no-search-ro-ow-action, 
+;;       icicle-find-file-abs-of-content-action, icicle-find-file-abs-of-content-other-window-action,
+;;       icicle-find-file-abs-of-content-ro-action, icicle-find-file-abs-of-content-ro-ow-action.
+;;     icicle-(find-file(-abs)|recent-file|read-only)-(of-content|no-search)(-other-window):
+;;         Redefined as a defun, using *-1 and *-action-fn.
+;;     icicle-locate(-file)(-no-symlinks)(-other-window): defalias now - either of-content|no-search.
+;;     Removed: icicle-locate-file-action-fn, icicle-locate-file(-other-window)-action,
+;;              icicle-find-file-abs-1, icicle-locate-file-1.
+;;     icicle-find-file(-abs)-read-only(-other-window): Define for *-abs-* and *-of-content-* also.
+;;     icicle-buffer-multi-complete: Use new icicle-* vars, so do not bother to test with boundp.
+;; 2013/12/03 dadams
+;;     Added: icicle-find-file-abs-1.
+;;     icicle-find-file-abs-of-content(-other-window), icicle-recent-file-of-content(-other-window):
+;;       Use icicle-find-file-abs-1.
+;;     icicle-completing-yank: Typo - paren too early.
+;; 2013/12/01 dadams
+;;     Added: icicle-recent-file-of-content, icicle-recent-file-of-content-other-window.
+;;     Renamed: *-recent-file(-other-window) to icicle-recent-file-no-search(-other-window).
+;;     Redefine icicle-recent-file(-other-window) as *-of-content* or *-no-search*, per Emacs version.
+;;     icicle-execute-extended-command-1: Restore SPC to self inserting, for recursive minibuffers.
+;;     icicle-find-file-abs-of-content: Pass nil as OTHER-WINDOW-P arg to *-find-file-or-expand-dir
+;;     icicle-find-file(-abs)-of-content*, :
+;;       1. Do the cleanup also for undo code, not just last code.
+;;       2. Just kill-buffer, instead of visiting and doing restore-buffer-modified-p first.
+;; 2013/11/29 dadams
+;;     icicle-find-file(-abs)(-no-search|of-content)*, icicle-find-file-in-tags-table*:
+;;       icicle-all-candidates-list-alt-action-fn needs to icicle-transform-multi-completion each file.
+;; 2013/11/26 dadams
+;;     icicle-execute-extended-command: Temporarily bind SPC to minibuffer-complete-word.
+;; 2013/11/23 dadams
+;;     Added: icicle-find-file-abs-of-content, icicle-find-file-abs-of-content-other-window.
+;;     Renamed: *-find-file-absolute(-other-window) to icicle-find-file-abs-no-search(-other-window).
+;;     Redefine icicle-find-file-absolute(-other-window) as *-no-search* or *-of-content*.
+;;     icicle-find-file-of-content(-other-window):
+;;       Just set FILE (no FIL2 binding).
+;;       First code: Reset current-prefix-arg to nil, so can use it anew in action function.
+;;                   Added msg: Gathering files...
+;;     icicle-file-of-content-apropos-complete-match:
+;;       Handle date for absolute file names (icicle-find-file-abs-of-content).
+;;     icicle-make-file+date-candidate: Removed final space after %T.
+;; 2013/11/19 dadams
+;;     icicle-yank-pop-commands, icicle-completing-yank: Bind enable-recursive-minibuffers to t.
+;; 2013/11/03 dadams
+;;     Added: icicle-visit-marked-file-of-content-recursive(-other-window),
+;;            icicle-visit-marked-file-of-content-1, icicle-vmfoc-other-win-p, icicle-vmfoc-recursive-p
+;;     icicle-visit-marked-file-of-content(-other-window): Use icicle-visit-marked-file-of-content-1.
+;;     icicle-locate-file-no-symlinks: Fixed typo: action function is not *-other-window.
+;; 2013/10/31 dadams
+;;     icicle-visit-marked-file-of-content*: Use diredp-get-files, so handle recursively marked files.
+;; 2013/10/29 dadams
+;;     icicle-bookmark-cmd: Use bmkp-bookmark-set-confirm-overwrite, not bookmark-set, if defined.
+;;     icicle-bookmark-set: Added code from Bookmark+ bookmark-set, for confirmation query if exists.
+;; 2013/10/27 dadams
+;;     Added: icicle-custom-theme (Emacs 24+).
+;; 2013/09/02 dadams
+;;     Added: icicle-dabbrev--last-completion-buffer, icicle-dabbrev--last-obarray.
+;;     icicle-dabbrev-completion: Use those Icicles vars - dabbrev.el versions removed in Emacs 24.
+;; 2013/08/19 dadams
+;;     icicle-kill-buffer: Bind icicle-use-candidates-only-once-flag to t.
+;;     icicle-kill-a-buffer-and-update-completions: Do not update minibuffer-completion-table.
+;; 2013/08/05 dadams
+;;     icicle-find-file-or-expand-dir: Reverted last change.  Expand only for RET, not C-RET.
+;; 2013/08/04 dadams
+;;     icicle-find-file-or-expand-dir: bind enable-recursive-minibuffers to t (for C-RET etc.).
+;; 2013/08/03 dadams
+;;     icicle-kmacro-action: Fixed numeric prefix arg for count.
+;;     Applied renamings: icicle-*-first-p.
+;; 2013/08/02 dadams
+;;     Added: icicle-find-file-or-expand-dir.
+;;     icicle-find-file(of-content|-no-search)(-other-window), : Use icicle-find-file-or-expand-dir.
+;; 2013/08/01 dadams
+;;     icicle-comint-dynamic-complete-as-filename: Bind enable-recursive-minibuffers to t.
+;; 2013/07/29 dadams
+;;     icicle-comint-dynamic-simple-complete: Bind enable-recursive-minibuffers to t.
+;; 2013/07/23 dadams
+;;     icicle-buffer-multi-complete, icicle-describe-opt-of-type-complete:
+;;       Use regexp-quote before concat ^ to front of string.
+;; 2013/07/04 dadams
+;;     Use icicle-read-regexp, not read-string, for reading all regexps.
+;; 2013/07/02 dadams
+;;     Added: icicle-bookmark-help (factored out), icicle-bookmark-act-on-prop.
+;;     icicle-bookmark(-list|(-jump)(-other-window)):
+;;       Bind icicle-candidate-alt-action-fn to icicle-bookmark-act-on-prop.
+;;     icicle-bookmark(-set|list|-other-window|jump(-other-window)):
+;;       Bind icicle-candidate-help-fn to icicle-bookmark-help.
+;; 2013/06/23 dadams
+;;     icicle-find-file-of-content(-other-window): Ensure handle mode, vars, hooks, & handlers OK.
+;;       In action fn: UN-visit any buffers that were created for content searching.
+;; 2013/04/24 dadams
+;;     icicle-dired-saved-file-candidates:
+;;       Removed error if no saved file names.  Forgot to remove, when added icicle-file-list choosing.
+;;       icicle-dired-saved-file-candidates(-other-window): Error if no files after icicle-file-list.
+;; 2013/04/17 dadams
+;;     icicle-buffer-name-prompt, icicle-default-buffer-names: C-u C-u C-u means invisible buffers.
+;;     icicle-kill-buffer: Add current buff to icicle-default-buffer-names.
+;;     icicle-visit-marked-file-of-content*: Pass no arg to icicle-default-buffer-names.
+;;     icicle-add-buffer-candidate: Single default if < Emacs 23.
 ;; 2013/04/06 dadams
 ;;     icicle-default-buffer-names: If ARG is nil, put other-buffer first.  Return up to six, not four.
 ;; 2013/04/02 dadams
  
 ;;;(@* "CHANGE LOG FOR `icicles-cmd2.el'")
 ;;
+;; 2014/03/08 dadams
+;;     Use (featurep 'icomplete), not (boundp 'icomplete-mode), everywhere.
+;; 2014/03/03 dadams
+;;     icicle-search-xml-element: Try to handle attributes and <ELTNAME/> too.
+;; 2014/03/24 dadams
+;;     icicle-complete-keys, icicle-complete-menu-bar:
+;;       Do not bind icicle-orig-buff or icicle-orig-window - they are the minibuffer buf & window.
+;; 2014/02/07 dadams
+;;     Added: icicle-same-vector-keyseq-p.
+;;     icicle-this-command-keys-prefix:
+;;       Respect new option icicle-complete-keys-ignored-prefix-keys.
+;;       Use this-command-keys-vector, not this-command-keys.
+;; 2014/01/14 dadams
+;;     icicle-compilation-search-in-context-fn:
+;;       Wrap body in condition-case, so can tolerate non-error lines as no-op in compilation buffer.
+;; 2014/01/11 dadams
+;;     icicle-this-command-keys-prefix:
+;;       Reverted change made 2013-12-01.  S-TAB following any prefix key should complete that key.
+;; 2014/01/06 dadams
+;;     icicle-vardoc, icicle-fundoc, icicle-plist, icicle-doc:
+;;       Bind icicle--last-toggle-transforming-msg.
+;; 2014/01/05 dadams
+;;     Added: icicle-next-font-lock-keywords, icicle-next-font-lock-keywords-repeat,
+;;            icicle-font-lock-keyword, icicle-update-f-l-keywords.
+;; 2013/12/26 dadams
+;;     icicle-hide/show-comments: Updated from hide/show-comments in hide-comnts.el.
+;; 2013/12/23 dadams
+;;     Added: icicle-load-library.
+;;     Moved icicle-named-colors defvar inside icicle-cmd2-after-load-hexrgb.
+;; 2013/12/10 dadams
+;;     Added: icicle-search-regexp.
+;;     icicle-search-define-candidates-1: Set icicle-search-regexp.
+;;     icicle-search-highlight-and-maybe-replace:
+;;       Search for main regexp, to set match data for replace-match (via icicle-search-replace-match).
+;; 2013/12/01 dadams
+;;     icicle-this-command-keys-prefix: Use [] as prefix key if this command is icicle-complete-keys.
+;; 2013/11/17 dadams
+;;     Added: icicle-occur-dired-marked, icicle-occur-dired-marked-recursive,
+;;            icicle-search-dired-marked, icicle-search-dired-marked-recursive-1.
+;;     icicle-search-generic: Added optional PREFIX-ARG argument.  Bind icicle-pref-arg to it.
+;;     icicle-search, icicle-search-where-arg:
+;;       Bind current-prefix-arg to icicle-pref-arg, so can get pref arg from icicle-search-generic.
+;;     icicle-search-dired-marked*: Use icicle-search-dired-marked-recursive-1.
+;; 2013/10/18 dadams
+;;     Added: icicle-imenu-help.
+;;     icicle-imenu: Bind icicle-candidate-help-fn to icicle-imenu-help.
+;;     icicle-search: Respect an existing value of icicle-candidate-help-fn.
+;; 2013/10/02 dadams
+;;     icicle-next-visible-thing-1: Put back <=, not <, for comparison.  See comment.
+;; 2013/09/29 dadams
+;;     icicle-search-char-prop-matches-p: Typo: isearchp-some -> icicle-some.
+;; 2013/09/21 dadams
+;;     icicle-search-char-prop-matches-p: Corrected for overlays: only overlays, not get-char-property.
+;; 2013/09/16 dadams
+;;     icicle-search-regexp-scan:
+;;       If icicle-search-complement-domain-p then PREDICATE should not succeed.
+;; 2013/09/11 dadams
+;;     icicle-Info-multi-read-node-name: Bind case-fold-search to t in filter function for NODES.
+;; 2013/09/06 dadams
+;;     Added: icicle-imenu-macro-full.
+;;     icicle-imenu-*-full: First arg to icicle-imenu-1 should just be non-nil.
+;;     icicle-imenu-non-interactive-function: Emacs Lisp only, not Lisp mode too.
+;;     icicle-imenu-macro-full: Typo: Macro -> Macros.
+;; 2013/08/13 dadams
+;;     icicle-where-is: Bind icicle-highlight-input-completion-failure to nil if no prefix arg.
+;; 2013/07/24 dadams
+;;     icicle-exchange-point-and-mark: Use region-(beginning|end), not mark function - simpler.
+;;     icicle-next-visible-thing(-and-bounds): Use buffer limit if region is empty.
+;; 2013/07/23 dadams
+;;     icicle-Info-multi-read-node-name: Use regexp-quote before concat ^ to front of string.
+;; 2013/07/09 dadams
+;;     Added: icicle-complete-menu-bar.
+;;     icicle-add-key+cmd: Corrected menu-item description: Always use MITEM if available.
+;;     icicle-complete-(keys|menu-bar): Made case-insensitive by default.
+;; 2013/07/07 dadams
+;;     icicle-add-key+cmd: Use face icicle-key-complete-menu(-local) for menu items.
+;; 2013/07/04 dadams
+;;     Use icicle-read-regexp, not read-string, for reading all regexps.
+;; 2013/06/19 dadams
+;;     Added: icicle-WYSIWYG-font.  Removed (commented out): icicle-font-w-orig-size.
+;;     icicle-font: Rewrote, to show WYSIWYG candidates.
 ;; 2013/03/26 dadams
 ;;     icicle-Info-multi-read-node-name: setq STRG only if it is nil.
 ;;     icicle-Info-goto-node-of-content: Do not bother to bind icicle-candidate-properties-alist.
 ;;     icicle-goto-marker-1: Pass a PREDICATE arg that ensures the marker points somewhere.
 ;; 2010/04/25 dadams
 ;;     icicle-complete-keys-action:
-;;       Bind icicle-*, esp. *-initially-flag, around call of this-command-keys.  Thx to M Heerdegen.
+;;       Bind icicle-*, esp. *-initially-flag, around call of this-command-keys.  Thx to M. Heerdegen.
 ;;     icicle-complete-keys: Save some icicle-* vars to reuse in icicle-complete-keys-action.
 ;; 2010/04/17 dadams
 ;;     icicle-search-bookmark, icicle-define-search-bookmark-command:
  
 ;;;(@* "CHANGE LOG FOR `icicles-face.el'")
 ;;
+;; 2013/07/07 dadams
+;;     Added: icicle-key-complete-menu, icicle-key-complete-menu-local.
 ;; 2013/02/04 dadams
 ;;     Removed all autoload cookies.
 ;; 2013/01/18 dadams
  
 ;;;(@* "CHANGE LOG FOR `icicles-fn.el'")
 ;;
+;; 2014/03/06 dadams
+;;     icicle-insert-candidates:
+;;       Respect new options icicle-icomplete-mode-max-candidates and icicle-sorting-max-candidates.
+;; 2014/03/04 dadams
+;;     icicle-display-candidates-in-Completions:
+;;       Use icicle-display-completion-list, not display-completion-list.
+;;       Removed icicle-condition-case-no-debug around that call.
+;;       Pass NB-CANDS to icicle-display-completion-list.
+;;     icicle-display-completion-list: Added optional arg NB-CANDS.  Pass it to *-insert-candidates.
+;;     icicle-insert-candidates: Added optional arg NUMBER-OF-CANDIDATES.  Use it if available.
+;; 2014/02/21 dadams
+;;     Added: icicle-read-file-name-default.
+;;     icicle-read-file-name, icicle-read-file-name-1, icicle-dired-read-shell-command,
+;;       icicle-dired-guess-shell-command:
+;;         Added optional HISTORY arg.
+;;     icicle-read-file-name-1: If icicle-orig-read-file-name-fn = read-file-name-default then
+;;                              use icicle-read-file-name-default, which accepts a HISTORY arg.
+;;     icicle-dired-read-shell-command, icicle-dired-guess-shell-command:
+;;       Use shell-command-history by default.
+;;     icicle-read-shell-command-completing: Pass HIST to icicle-read-file-name.
+;; 2014/02/19 dadams
+;;     icicle-read-file-name: 
+;; 2014/02/08 dadams
+;;     Renamed: icicle-file-directory-p to icicle-looks-like-dir-name-p.
+;;     icicle-looks-like-dir-name-p: Better doc string.
+;; 2014/02/07 dadams
+;;     Added: icicle-unlist.  Use it in icicle-read-from-minibuffer, icicle-read-string-completing,
+;;                            icicle-read-string, icicle-insert-candidates, icicle-read-regexp.
+;; 2014/01/18 dadams
+;;     icicle-read-face-name: Rewrote for Emacs 24.  Doc string updated per Emacs bug #16483.
+;; 2014/01/11 dadams
+;;     icicle-completion-setup-function (Emacs 20-21): Wrap in condition case - Emacs bug.
+;; 2014/01/05 dadams
+;;     Added: icicle-list-position, icicle-repeat-command.
+;;     icicle-completing-read: Bind icicle-orig-*, so can use icicle-recomplete-from-original-domain.
+;; 2013/12/30 dadams
+;;     icicle-make-char-candidate: 3-part multi-completion now - added hex code point.
+;;     icicle-read-char-by-name:
+;;       3-part multi-completion now - can complete against hex code point too.
+;;       Ensure ignore case for comparison outside completion.  Report invalid INPUT, not CHR.
+;; 2013/12/29 dadams
+;;     Added: icicle-make-char-candidate.  Add hex and octal for code point in help echo.
+;;     icicle-read-char-by-name: Redefined to use multi-completion.  Can now use with narrowing.
+;; 2013/12/26 dadams
+;;     icicle-read-char-by-name: put NAME, not SYMB as icicle-orig-cand text property.
+;; 2013/11/28 dadams
+;;     icicle-read-face-name: Better fix for brain-dead vanilla Emacs PROMPT.
+;; 2013/11/24 dadams
+;;     icicle-read-face-name: Updated for Emacs 24.
+;; 2013/11/19 dadams
+;;     Removed: icicle-ORIG-read-file-name-default and icicle-read-file-name-default.
+;; 2013/10/30 dadams
+;;     icicle-fuzzy-candidates, icicle(-unsorted(-file-name))-(prefix|apropos)-candidates:
+;;       Always set icicle-common-match-string - to nil or to icicle-expanded-common-match.
+;;       For prefix completion, icicle-expanded-common-match if icicle-must-pass-after-match-predicate.
+;; 2013/08/03 dadams
+;;     Added: icicle-dirs-and-latest-use-first-p, icicle-latest-use-first-p.
+;;     Renamed: icicle-last-(accessed|modified)-first-p to icicle-latest-(access|modification)-first-p,
+;;              icicle-most-recent-first-p to icicle-latest-input-first-p.
+;;     icicle-show-help-in-mode-line, icicle-help-line-(buffer|file):
+;;       Propertize only the values, not their headings too.
+;;     icicle-help-line-file: Add access time.
+;;     icicle-historical-alphabetic-p, icicle-latest-input-first-p: Apply abbreviate-file-name.
+;; 2013/08/01 dadams
+;;     icicle-choose-completion-string: Do not display obnoxious vanilla Emacs obsolescence warning.
+;; 2013/07/04 dadams
+;;     Added: icicle-find-tag-default-as-regexp, icicle-read-regexp.
+;; 2013/06/21 dadams
+;;     icicle-display-candidates-in-Completions: Removed vestigial code for highlighting special cand.
+;; 2013/05/11 dadams
+;;     icicle-handle-default-for-prompt: Do not add nil DEFAULT to prompt.
+;; 2013/04/30 dadams
+;;     Renamed: icicle-add-default-to-prompt to icicle-handle-default-for-prompt.
+;;     icicle-handle-default-for-prompt: Always remove existing default expression from prompt.
+;;                                       Added INCLUDE.  If nil, do not add DEFAULT (just remove it).
+;;     icicle-completing-read:
+;;       Invoke icicle-handle-default-for-prompt unconditionally, passing (eq icicle-default-value t).
+;;     icicle-read-string: Use icicle-handle-default-for-prompt, not icicle-add-default-to-prompt.
+;; 2013/04/22 dadams
+;;     icicle-read-buffer: Pass all args to read-buffer-function funcall.  Thx to Nick Alcock.
+;; 2013/04/08 dadams
+;;     icicle-choose-completion-string: Added versions for Emacs 23.1 and 23.2+.
 ;; 2013/04/06 dadams
 ;;     icicle-completing-p:
 ;;       Bug fix for Emacs > 24.3.  Test minibuffer-completing-file-name, not filename keymaps.
 ;;       macros needs to be byte-compiled anew after loading the updated macros.
 ;; ****************************************************************************************************
 ;;
+;; 2013/03/08 dadams
+;;     icicle(-file)-define-command:
+;;       Use generated let-var CHOICE for (CMD|FILE)-CHOICE.
+;;       Handle hiding common match, incremental completion and icomplete mode per command properties.
+;; 2013/12/01 dadams
+;;     icicle-define-command, icicle-define-file-command:
+;;       Wrap FIRST-SEXP, minibuf read (with UNDO-SEXP), and LAST-SEXP in a catch, to ensure LAST-SEXP.
+;;       This is important for progressive completion, to, e.g., remove temporarily created buffers.
+;; 2013/04/17 dadams
+;;     icicle-buffer-bindings: For icicle-bufflist: use icicle-buffer-prefix-arg-filtering.
+;; 2013/04/15 dadams
+;;     icicle-buffer-bindings: (New) C-u C-u C-u means invisible buffers only.
 ;; 2013/03/31 dadams
 ;;     icicle-buffer-bindings: (New) C-u C-u means visible buffers only.
 ;; 2013/03/07 dadams
 ;;       Added optional arg not-interactive-p.
 ;;     Quiet the byte compiler for Emacs versions before 22.
 ;; 2007/10/14 dadams
-;;     icicle-define(-file)-command:
-;;       Updated generated doc to reflect icicle-act-before-cycle-flag.
+;;     icicle-define(-file)-command: Updated generated doc to reflect icicle-act-before-cycle-flag.
 ;; 2007/05/01 dadams
 ;;     icicle-define(-file)-command: Reset icicle-candidate-action-fn after reading input.
 ;; 2007/04/15 dadams
 ;;     icicle-define(-file)-command:
 ;;       Simplified action fn: Removed unwind-protect and outer condition-case,
-;;       so don't return error msg now, and only set minibuf focus if succeed.
+;;         so don't return error msg now, and only set minibuf focus if succeed.
 ;;     icicle-define(-file)-command, icicle-try-switch-buffer: Removed "%s" from handlers.
 ;; 2007/02/06 dadams
 ;;     icicle-define(-file)-command: Mention mouse bindings in command doc strings.
  
 ;;;(@* "CHANGE LOG FOR `icicles-mcmd.el'")
 ;;
+;; 2014/03/08 dadams
+;;     Added: icicle-toggle-icomplete-mode.
+;; 2014/03/06 dadams
+;;     icicle-change-sort-order: Set icicle-last-sort-comparer to current comparer, before changing.
+;; 2014/02/09 dadams
+;;     icicle-make-directory: Restore completion candidates after reading new dir name.
+;; 2014/02/08 dadams
+;;     icicle-(prefix|apropos)-complete-1:
+;;       Applied renaming of icicle-file-directory-p to icicle-looks-like-dir-name-p.
+;; 2014/02/07 dadams
+;;     icicle-history: Use icicle-unlist (new).
+;; 2014/01/18 dadams
+;;     icicle-(prefix|apropos)-complete-1: Respect new icicle-keep-Completions-for-sole-dir behavior.
+;; 2014/01/05 dadams
+;;     Added: icicle-recomplete-from-original-domain.
+;; 2014/01/04 dadams
+;;     icicle-help-string-completion: Added C-M-~: icicle-toggle-search-complementing-domain.
+;; 2014/01/02 dadams
+;;     icicle-unbind-buffer-candidate-keys: Unbind (bind to nil), not bind!
+;; 2014/01/01 dadams
+;;     icicle-(prefix|apropos)-complete-1: Sole completion case, for file name: Respect NO-DISPLAY-P.
+;; 2013/12/31 dadams
+;;     icicle-universal-argument--mode: Use set-transient-map, if defined.
+;; 2013/12/26 dadams
+;;     icicle-narrow-candidates: Get back original candidates, via text property icicle-orig-cand.
+;; 2013/12/01 dadams
+;;     icicle-top-level: Throw to the catch icicle-top-level, which is now defined for multi-commands.
+;; 2013/09/21 dadams
+;;     Added: icicle-universal-argument--mode.
+;;     icicle-(digit|negative|universal)-argument, : Updated for Emacs 24.4 (snapshot of 9/20).
+;;     Define only for Emacs < 24.4: icicle-universal-argument-other-key, universal-argument--mode.
+;; 2013/08/15 dadams
+;;     icicle-change-sort-order: Provide current as default and add to prompt when asking for new one.
+;; 2013/08/03 dadams
+;;     Added: icicle-sort-by-last-use, icicle-sort-by-last-use\,-dirs-first.
+;;     Applied renamings: icicle-*-first-p.
+;; 2013/08/02 dadams
+;;     Added: icicle-complete-current-candidate-as-input, icicle-dispatch-C-M-/,
+;;            icicle-toggle-expand-directory.
+;;     icicle-change-sort-order: Bind icicle-show-Completions-initially-flag to t.
+;;     icicle-help-string-completion: Added entry for icicle-toggle-expand-directory.
+;; 2013/08/01 dadams
+;;     icicle-choose-completion: Use icicle-choose-completion-string, not choose-completion-string.
+;; 2013/07/24 dadams
+;;     icicle-resolve-file-name, icicle-mouse-candidate-set-save(-more|-selected-1),
+;;       icicle-regexp-quote-input:
+;;         Use better nonempty region test.
+;; 2013/07/06 dadams
+;;     icicle-switch-to/from-minibuffer:
+;;       Added minibuffer messages.
+;;       Message, not error, if minibuffer not active.
+;; 2013/07/04 dadams
+;;     Use icicle-read-regexp, not read-string, for reading all regexps.
+;; 2013/06/22 dadams
+;;     icicle-(prefix|apropos)-complete-1: Apply renaming to icicle-keep-Completions-for-sole-dir-flag.
+;;                                         Does not affect absolute file names (no drill-down).
+;; 2013/06/20 dadams
+;;     icicle-(prefix|apropos)-complete-1: Revert change of 2012/05/11:
+;;         Do not set icicle-next-prefix-complete-cycles-p unless input did not change, because
+;;           if first (S-)TAB completes to dir that is sole candidate then second should not cycle.
+;;       Sole dir cand: If not icicle-remove-Completions-when-sole-dir-flag, then update *Completions*
+;;         instead of removing it.
+;;     icicle-apropos-complete-1: Corrected: Do not remove *Completions* if *-edit-update-p etc.
+;; 2013/06/18 dadams
+;;     icicle-abort-recursive-edit: If region is active in delete-selection-mode, just deactivate it.
+;;     icicle-minibuffer-help: Added icicle-toggle-WYSIWYG-Completions.
+;;                             Fixed intro line layout when icicle-completing-p.
+;;     toggle-icicle-WYSIWYG-Completions: Mention C-S-pause binding (new) in doc string.
+;; 2013/06/15 dadams
+;;     icicle-doremi-zoom-Completions+: No-op if no Completions window.
+;; 2013/05/13 dadams
+;;     icicle-change-sort-order: Handle integer value for icicle-change-sort-order-completion.
+;; 2013/04/24 dadams
+;;     icicle-minibuffer-help: Better intro for completion cases.
+;; 2013/04/18 dadams
+;;     icicle-(un)bind-buffer-candidate-keys:
+;;       Rewrote to use (new) option icicle-buffer-candidate-key-bindings.
+;; 2013/04/08 dadams
+;;     icicle-choose-completion: Added version for Emacs 23.2+.  Return completion number now.
+;;     icicle-mouse-choose-completion: Do not define for Emacs 23.2+ (uses icicle-choose-completion).
 ;; 2013/04/01 dadams
 ;;     Added: icicle-top-level.
 ;; 2013/03/31 dadams
 ;;     icicle-narrow-candidates:
 ;;       Use minibuffer-history-variable, not regexp-history.  Thx to Jost for bug report.
 ;; 2007/01/20 dadams
-;;     icicle-mouse-(choose-completion|candidate-action):
-;;       Use icicle-transform-multi-completion.
+;;     icicle-mouse-(choose-completion|candidate-action): Use icicle-transform-multi-completion.
 ;; 2007/01/15 dadams
 ;;     Added: icicle-change(-alternative)-sort-order, icicle-reverse-sort-order,
 ;;            icicle-current-sort-order, icicle-sort-*.
  
 ;;;(@* "CHANGE LOG FOR `icicles-mode.el'")
 ;;
+;; 2014/03/08 dadams
+;;     icicle-top-level-prep:
+;;       Test minibuffer-depth, not recursion-depth.  Do not set icicle-last-top-level-command for
+;;       commands: (icicle)-minibuffer-complete-and-exit, (icicle-)exit-minibuffer.
+;;     icicle-define-icicle-maps: Added icicle-toggle-icomplete-mode.
+;;     icicle-minibuffer-setup: Reinitialize icicle-last-icomplete-mode-value.
+;;     Added defadvice for interactive icomplete-mode, to reset icicle-last-icomplete-mode-value.
+;; 2014/02/24 dadams
+;;     icicle-define-icicle-maps, icicle-define-minibuffer-maps, icicle-bind-completion-keys:
+;;       Added menu item Show Available Keys (icicle-complete-keys).
+;; 2014/01/23 dadams
+;;     For BBDB: Determine older version not just by presence of old name but also by absence of new.
+;; 2014/01/05 dadams
+;;     Put icicle-recomplete-from-original-domain on icicle-menu-map and on Minibuf menu.
+;;     icicle-(bind|restore)-other-keymap-keys:
+;;       Bind icicle-next-font-lock-keywords-repeat, icicle-font-lock-keyword in facemenu-keymap.
+;; 2013/11/19 dadams
+;;     icicle-(redefine|restore)-std-completion-fns:
+;;       Remove use of icicle-read-file-name-default and icicle-ORIG-read-file-name-default.
+;; 2013/11/17 dadams
+;;     icicle-define-icicle-maps:
+;;       Add icicle-(search|occur)-dired-marked to menus.
+;;       Bind icicle-visit-marked-file-of-content-other-window to C-M-F, not C-S-o.
+;;       Bind icicle-occur-dired-marked to C-S-o and icicle-search-dired-marked to C-S-s.
+;;       Bind icicle-search-dired-marked-recursive to M-+ C-S-s.
+;;       Bind icicle-occur-dired-marked-recursive to M-+ C-S-o and to M-s M-s M.
+;;       Bind icicle-visit-marked-file-of-content-recursive-other-window to M-+ C-M-S-f, not C-S-o.
+;; 2013/11/03 dadams
+;;     Added icicle-visit-marked-file-of-content-recursive(-other-window) to
+;;       icicle-dired-recursive-marked-menu-map.
+;;     Bound icicle-visit-marked-file-of-content-recursive(-other-window) to M-+ C-F, M-+ C-O.
+;; 2013/06/18 dadams
+;;     icicle-define-icicle-maps: Moved icicle-toggle-WYSIWYG-Completions.  Added :keys.
+;; 2013/04/24 dadams
+;;     Fixed define-key-after sexps for older Emacs versions that do not allow multi-event KEY.
+;; 2013/04/23 dadams
+;;     Added: icicle-minibuf-(act-on-all|candidate-set|edit|history|save-retrieve)-menu-map,
+;;     Minibuf menu: Factored with submenus:
+;;       Act on All Candidates, Candidate Set, Edit, History, Save/Retrieve Candidates.
+;;     icicle-define-icicle-maps: Put buffer stuff on Buffers > Icicles, not File > Icicles > Buffers. 
+;; 2013/04/08 dadams
+;;     icicle-(redefine|restore)-std-completion-fns:
+;;       icicle-mouse-choose-completion is only for Emacs < 23.2.
 ;; 2013/04/05 dadams
 ;;     icicle-mode: Call ad-activate for all enabled advice.
 ;; 2013/04/04 dadams
  
 ;;;(@* "CHANGE LOG FOR `icicles-opt.el'")
 ;;
+;; 2014/03/08 dadams
+;;     icicle-Completions-toggle-submenu: Added icicle-toggle-icomplete-mode.
+;;     icicle-completion-key-bindings: Bind icicle-toggle-icomplete-mode to C-M-#.
+;; 2014/03/06 dadams
+;;     Added: icicle-icomplete-mode-max-candidates, icicle-sorting-max-candidates.
+;; 2014/02/24 dadams
+;;     icicle-complete-keys-ignored-prefix-keys: Init value is now ([menu-bar icicles]).
+;; 2014/02/07 dadams
+;;     Added: icicle-complete-keys-ignored-prefix-keys.
+;; 2014/02/05 dadams
+;;     icicle-S-TAB-completion-methods-per-command: Corrected :group - capitalized.
+;; 2014/02/02 dadams
+;;     icicle-buffer-prefix-arg-filtering: Corrected example in doc string.
+;; 2014/01/25 dadams
+;;     icicle-functions-to-redefine: Commented out bbdb-complete-name (obsolete in BBDB).
+;; 2014/01/18 dadams
+;;     Renamed: icicle-keep-Completions-for-sole-dir-flag to icicle-keep-Completions-for-sole-dir.
+;;     icicle-keep-Completions-for-sole-dir: Added pop-up value.  Default behavior now: do not pop up. 
+;; 2014/01/05 dadams
+;;     icicle-completion-key-bindings: Added icicle-recomplete-from-original-domain == C-x C-0.
+;; 2013/12/24 dadams
+;;     icicle-top-level-key-bindings: Added icicle-load-library (but not bound to a key, by default).
+;; 2013/12/09 dadams
+;;     Renamed: icicle-buffer-skip-hook               to icicle-buffer-skip-functions,
+;;              icicle-find-file-of-content-skip-hook to icicle-file-skip-functions.
+;; 2013/12/01 dadams
+;;     Added: icicle-image-file-p.
+;;     icicle-find-file-of-content-skip-hook: Use icicle-image-file-p, not nil, as default.
+;; 2013/10/29 dadams
+;;     icicle-top-level-key-bindings: Remap  bmkp-bookmark-set-confirm-overwrite to icicle-bookmark-cmd
+;; 2013/10/27 dadams
+;;     Added: icicle-custom-themes, icicle-custom-themes-accumulate-flag,
+;;            icicle-custom-themes-update-flag.  (All for Emacs 24+ only.)
+;; 2013/09/02 dadams
+;;     icicle-top-level-key-bindings:
+;;       Reverted change of 2013/03/18: icicle-dabbrev-completion is for Emacs 24 too now.
+;; 2013/08/03 dadams
+;;     icicle-file-sort: Updated doc string per renamings.
+;; 2013/08/02 dadams
+;;     Added: icicle-find-file-expand-directory-flag.
+;;     icicle-Completions-toggle-submenu, icicle-completion-key-bindings:
+;;       Added binding for icicle-toggle-expand-directory.
+;;     icicle-top-level-key-bindings: Bind C-M-/ to icicle-dispatch-C-M-/.
+;;     icicle-completion-key-bindings: Do not bind C-M-/ (overridden by icicle-mode binding anyway).
+;; 2013/07/09 dadams
+;;     icicle-top-level-key-bindings: Bind S-f10 to icicle-complete-menu-bar (new).
+;; 2013/07/04 dadams
+;;     icicle-buffer-prefix-arg-filtering: Typo: Removed ' from const value.
+;;     icicle-search-highlight-threshold, icicle(-alternative)-sort-comparer,
+;;       icicle(-no)-buffer-match-regexp, icicle-buffer-predicate, icicle-buffer-prefix-arg-filtering,
+;;       icicle-buffer-sort, icicle-comint-dynamic-complete-replacements, icicle-file-no-match-regexp,
+;;       icicle-file-predicate, icicle-file-sort, icicle-max-candidates, icicle-buffer-configs,
+;;       icicle-pp-eval-expression-print-(length|level), icicle-recenter,
+;;       icicle-thing-at-point-functions, icicle-zap-to-char-candidates:
+;;         Added :value.
+;;     icicle-alternative-sort-comparer: Corrected - needs same :type as icicle-sort-comparer.
+;; 2013/06/22 dadams
+;;     Renamed and reversed: *-remove-Completions-when-* to icicle-keep-Completions-for-sole-dir-flag.
+;; 2013/06/20 dadams
+;;     Added: icicle-remove-Completions-when-sole-dir-flag.
+;; 2013/06/19 dadams
+;;     icicle-WYSIWYG-Completions-flag: Updated doc string - fonts too now.
+;; 2013/06/18 dadams
+;;     icicle-completion-key-bindings: Added C-S-pause binding for icicle-toggle-WYSIWYG-Completions.
+;;     icicle-Completions-toggle-submenu: Moved icicle-toggle-WYSIWYG-Completions.
+;; 2013/05/13 dadams
+;;     Renamed icicle-change-sort-order-completion-flag to icicle-change-sort-order-completion.
+;;     icicle-change-sort-order-completion: Can now be an integer.
+;;     icicle-Completions-sorting-submenu: Updated to reflect new icicle-change-sort-order-completion.
+;; 2013/04/22 dadams
+;;     Reverted the change of 2012/02/28.  Emacs does not DTRT for push if require only when compile.
+;;       Must use eval-and-compile to require cl.el, not eval-when-compile, for Emacs 20.
+;; 2013/04/18 dadams
+;;     Added: icicle-buffer-candidate-key-bindings, icicle-buffer-prefix-arg-filtering.
+;;     *-completion-key-bindings, *-completion-list-key-bindings, *-minibuffer-key-bindings:
+;;       Removed C-? binding - use only M-?.
 ;; 2013/04/03 dadams
 ;;     icicle-comint-dynamic-complete-replacements: Removed entries for ess-complete-*.
 ;; 2013/04/01 dadams
  
 ;;;(@* "CHANGE LOG FOR `icicles-var.el'")
 ;;
+;; 2014/03/08 dadams
+;;     icicle-last-icomplete-mode-value: Use (featurep 'icomplete), not (boundp 'icomplete-mode).
+;; 2014/03/06 dadams
+;;     Added: icicle-last-icomplete-mode-value.
+;; 2014/01/05 dadams
+;;     Added: icicle-orig-font-lock-keywords, icicle-orig-minibuffer-completion-pred,
+;;            icicle-orig-minibuffer-completion-table, icicle-orig-must-match-regexp,
+;;            icicle-orig-must-not-match-regexp, icicle-orig-must-pass-predicate,
+;;            icicle-current-font-lock-part.
+;; 2013/12/03 dadams
+;;     icicle-read-expression-map: Swap TAB and M-TAB, so TAB completes Lisp symbols.
+;; 2013/11/19 dadams
+;;     Removed: icicle-read-file-name-internal-fn.
+;; 2013/09/21 dadams
+;;     icicle-universal-argument-map: Updated for Emacs 24.4 (snapshot from 9/20).
+;; 2013/05/13 dadams
+;;     icicle-general-help-string: Reflect renaming to icicle-change-sort-order-completion.
 ;; 2013/04/04 dadams
 ;;     Added: icicle-ess-use-ido.
 ;; 2013/03/23 dadams
index 60290b5..86749bc 100644 (file)
@@ -3,13 +3,12 @@
 ;; Filename: icicles-cmd1.el
 ;; Description: Top-level commands for Icicles
 ;; Author: Drew Adams
-;; Maintainer: Drew Adams
-;; Copyright (C) 1996-2013, Drew Adams, all rights reserved.
+;; Maintainer: Drew Adams (concat "drew.adams" "@" "oracle" ".com")
+;; Copyright (C) 1996-2014, Drew Adams, all rights reserved.
 ;; Created: Mon Feb 27 09:25:04 2006
-;; Version: 22.0
-;; Last-Updated: Sat Apr  6 21:42:22 2013 (-0700)
+;; Last-Updated: Sun Mar  9 09:59:48 2014 (-0700)
 ;;           By: dradams
-;;     Update #: 25681
+;;     Update #: 26878
 ;; URL: http://www.emacswiki.org/icicles-cmd1.el
 ;; Doc URL: http://www.emacswiki.org/Icicles
 ;; Keywords: extensions, help, abbrev, local, minibuffer,
 ;; Features that might be required by this library:
 ;;
 ;;   `apropos', `apropos-fn+var', `avoid', `cl', `cus-edit',
-;;   `cus-face', `cus-load', `cus-start', `doremi', `easymenu',
-;;   `el-swank-fuzzy', `ffap', `ffap-', `frame-cmds', `frame-fns',
-;;   `fuzzy', `fuzzy-match', `hexrgb', `icicles-fn', `icicles-mcmd',
-;;   `icicles-opt', `icicles-var', `image-dired', `kmacro',
-;;   `levenshtein', `misc-fns', `mouse3', `mwheel', `naked',
-;;   `regexp-opt', `ring', `ring+', `second-sel', `strings',
+;;   `cus-face', `cus-load', `cus-start', `cus-theme', `doremi',
+;;   `easymenu', `el-swank-fuzzy', `ffap', `ffap-', `frame-cmds',
+;;   `frame-fns', `fuzzy', `fuzzy-match', `hexrgb', `icicles-fn',
+;;   `icicles-mcmd', `icicles-opt', `icicles-var', `image-dired',
+;;   `kmacro', `levenshtein', `misc-fns', `mouse3', `mwheel',
+;;   `naked', `regexp-opt', `ring', `second-sel', `strings',
 ;;   `thingatpt', `thingatpt+', `wid-edit', `wid-edit+', `widget'.
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;  using Emacs 23.  Otherwise, Icicles key completion (and perhaps
 ;;  other things?) will not work correctly.
 ;;
+;;  Macros defined here:
+;;
+;;    `icicle-find-file-abs-no-search-action-1',
+;;    `icicle-find-file-abs-of-content-action-1',
+;;    `icicle-find-file-no-search-action-1',
+;;    `icicle-find-file-of-content-action-1'.
+;;
 ;;  Widgets defined here:
 ;;
 ;;    `icicle-file', `icicle-ORIG-file'.
 ;;    (+)`icicle-customize-apropos-opts-w-val-satisfying',
 ;;    (+)`icicle-customize-face',
 ;;    (+)`icicle-customize-face-other-window',
-;;    `icicle-customize-icicles-group', `icicle-dabbrev-completion',
-;;    (+)`icicle-delete-file', (+)`icicle-delete-window',
-;;    (+)`icicle-describe-option-of-type', `icicle-describe-process',
+;;    `icicle-customize-icicles-group', (+)`icicle-custom-theme',
+;;    `icicle-dabbrev-completion', (+)`icicle-delete-file',
+;;    (+)`icicle-delete-window', (+)`icicle-describe-option-of-type',
+;;    `icicle-describe-process',
 ;;    (+)`icicle-describe-var-w-val-satisfying',
 ;;    (+)`icicle-delete-windows', (+)`icicle-directory-list',
 ;;    (+)`icicle-dired', `icicle-dired-chosen-files',
 ;;    (+)`icicle-execute-named-keyboard-macro', (+)`icicle-face-list',
 ;;    (+)`icicle-file', (+)`icicle-file-list',
 ;;    (+)`icicle-file-other-window', (+)`icicle-find-file',
+;;    (+)`icicle-find-file-abs-no-search',
+;;    (+)`icicle-find-file-abs-no-search-other-window',
+;;    (+)`icicle-find-file-abs-of-content',
+;;    (+)`icicle-find-file-abs-of-content-other-window',
 ;;    (+)`icicle-find-file-absolute',
 ;;    (+)`icicle-find-file-absolute-other-window',
+;;    (+)`icicle-find-file-abs-read-only',
+;;    (+)`icicle-find-file-abs-read-only-other-window',
 ;;    (+)`icicle-find-file-in-tags-table',
 ;;    (+)`icicle-find-file-in-tags-table-other-window',
 ;;    (+)`icicle-find-file-of-content',
+;;    (+)`icicle-find-file-of-content-in-tags-table',
+;;    (+)`icicle-find-file-of-content-in-tags-table-other-window',
 ;;    (+)`icicle-find-file-of-content-other-window',
 ;;    (+)`icicle-find-file-other-window',
 ;;    (+)`icicle-find-file-no-search',
+;;    (+)`icicle-find-file-no-search-in-tags-table',
+;;    (+)`icicle-find-file-no-search-in-tags-table-other-window',
 ;;    (+)`icicle-find-file-no-search-other-window',
 ;;    (+)`icicle-find-file-read-only',
 ;;    (+)`icicle-find-file-read-only-other-window',
 ;;    (+)`icicle-keyword-list', (+)`icicle-kill-buffer',
 ;;    (+)`icicle-kmacro', `icicle-lisp-complete-symbol',
 ;;    (+)`icicle-locate', (+)`icicle-locate-file',
+;;    (+)`icicle-locate-file-no-search',
+;;    (+)`icicle-locate-file-no-search-no-symlinks',
+;;    (+)`icicle-locate-file-no-search-no-symlinks-other-window',
+;;    (+)`icicle-locate-file-no-search-other-window',
 ;;    (+)`icicle-locate-file-no-symlinks',
 ;;    (+)`icicle-locate-file-no-symlinks-other-window',
+;;    (+)`icicle-locate-file-of-content',
+;;    (+)`icicle-locate-file-of-content-no-symlinks',
+;;    (+)`icicle-locate-file-of-content-no-symlinks-other-window',
+;;    (+)`icicle-locate-file-of-content-other-window',
 ;;    (+)`icicle-locate-file-other-window',
-;;    (+)`icicle-locate-other-window', `icicle-ORIG-customize-face',
+;;    (+)`icicle-locate-other-window', (+)`icicle-locate-no-search',
+;;    (+)`icicle-locate-no-search-other-window',
+;;    (+)`icicle-locate-of-content',
+;;    (+)`icicle-locate-of-content-other-window',
+;;    `icicle-ORIG-customize-face',
 ;;    `icicle-ORIG-customize-face-other-window',
 ;;    `icicle-ORIG-dabbrev-completion',
 ;;    `icicle-ORIG-lisp-complete-symbol',
 ;;    `icicle-ORIG-repeat-complex-command',
 ;;    (+)`icicle-other-window-or-frame', `icicle-pop-tag-mark',
 ;;    `icicle-pp-eval-expression', (+)`icicle-recent-file',
+;;    (+)`icicle-recent-file-no-search',
+;;    (+)`icicle-recent-file-no-search-other-window',
+;;    (+)`icicle-recent-file-of-content',
+;;    (+)`icicle-recent-file-of-content-other-window',
 ;;    (+)`icicle-recent-file-other-window',
 ;;    `icicle-recompute-shell-command-candidates',
 ;;    (+)`icicle-regexp-list', (+)`icicle-remove-buffer-candidate',
 ;;    (+)`icicle-string-list', (+)`icicle-toggle-option',
 ;;    (+)`icicle-visit-marked-file-of-content',
 ;;    (+)`icicle-visit-marked-file-of-content-other-window',
+;;    (+)`icicle-visit-marked-file-of-content-recursive',
+;;    (+)`icicle-visit-marked-file-of-content-recursive-other-window',
 ;;    `icicle-widget-file-complete',
 ;;    (+)`icicle-yank-maybe-completing',
 ;;    (+)`icicle-yank-pop-commands', `icicle-zap-to-char',
 ;;  Non-interactive functions defined here:
 ;;
 ;;    `custom-variable-p', `icicle-apropos-opt-action',
-;;    `icicle-binary-option-p',
+;;    `icicle-binary-option-p', `icicle-bookmark-act-on-prop',
 ;;    `icicle-bookmark-bind-narrow-commands',
 ;;    `icicle-bookmark-cleanup', `icicle-bookmark-cleanup-on-quit',
-;;    `icicle-bookmark-delete-action', `icicle-bookmark-help-string',
-;;    `icicle-bookmark-jump-1',
+;;    `icicle-bookmark-delete-action', `icicle-bookmark-help',
+;;    `icicle-bookmark-help-string', `icicle-bookmark-jump-1',
 ;;    `icicle-buffer-apropos-complete-match',
 ;;    `icicle-buffer-cand-help', `icicle-buffer-multi-complete',
 ;;    `icicle-buffer-name-prompt',
 ;;    `icicle-describe-opt-of-type-complete',
 ;;    `icicle-execute-extended-command-1', `icicle-explore',
 ;;    `icicle-file-of-content-apropos-complete-match',
+;;    (+)`icicle-find-file-abs-no-search-1',
+;;    `icicle-find-file-abs-no-search-action',
+;;    `icicle-find-file-abs-no-search-other-window-action',
+;;    `icicle-find-file-abs-no-search-ro-action',
+;;    `icicle-find-file-abs-no-search-ro-ow-action',
+;;    (+)`icicle-find-file-abs-of-content-1',
+;;    `icicle-find-file-abs-of-content-action',
+;;    `icicle-find-file-abs-of-content-other-window-action',
+;;    `icicle-find-file-abs-of-content-ro-action',
+;;    `icicle-find-file-abs-of-content-ro-ow-action',
+;;    `icicle-find-file-no-search-action',
+;;    `icicle-find-file-no-search-other-window-action',
+;;    (+)`icicle-find-file-no-search-in-tags-table-1',
+;;    (+)`icicle-find-file-of-content-in-tags-table-1',
+;;    `icicle-find-file-of-content-ro-action',
+;;    `icicle-find-file-of-content-ro-ow-action',
+;;    `icicle-find-file-or-expand-dir',
 ;;    `icicle-find-first-tag-action',
 ;;    `icicle-find-first-tag-other-window-action',
 ;;    `icicle-find-tag-action', `icicle-find-tag-define-candidates',
 ;;    `icicle-find-tag-quit-or-error', `icicle-insert-for-yank',
 ;;    `icicle-kill-a-buffer-and-update-completions',
 ;;    `icicle-kmacro-action', `icicle-lisp-completion-at-point',
-;;    (+)`icicle-locate-file-1', `icicle-locate-file-action',
-;;    `icicle-locate-file-other-window-action',
+;;    (+)`icicle-locate-file-no-search-1',
+;;    (+)`icicle-locate-file-of-content-1',
 ;;    `icicle-make-bookmark-candidate',
 ;;    `icicle-make-file+date-candidate', `icicle-make-frame-alist',
 ;;    `icicle-make-window-alist',
 ;;    `icicle-bookmark-propertize-candidate',
 ;;    `icicle-pp-display-expression',
 ;;    `icicle-read-args-w-val-satisfying',
+;;    (+)`icicle-recent-file-of-content-1',
 ;;    `icicle-recent-files-without-buffers.',
 ;;    `icicle-remove-buffer-candidate-action',
 ;;    `icicle-remove-buffer-config-action',
 ;;    `icicle-remove-saved-set-action',
 ;;    `icicle-shell-command-on-file',
 ;;    `icicle-shell-dynamic-complete-as-command',
-;;    `icicle-shell-dynamic-complete-as-environment-variable'.
+;;    `icicle-shell-dynamic-complete-as-environment-variable',
+;;    (+)`icicle-visit-marked-file-of-content-1'.
 ;;
 ;;  Internal variables defined here:
 ;;
-;;    `icicle-locate-file-action-fn',
+;;    `icicle-dabbrev--last-completion-buffer',
+;;    `icicle-dabbrev--last-obarray', `icicle-existing-bufs',
+;;    `icicle-find-file-abs-action-fn', `icicle-find-file-action-fn',
 ;;    `icicle-locate-file-no-symlinks-p',
-;;    `icicle-locate-file-use-locate-p'.
+;;    `icicle-locate-file-use-locate-p', `icicle-new-bufs-to-keep',
+;;    `icicle-new-bufs-to-kill', `icicle-vmfoc-other-win-p',
+;;    `icicle-vmfoc-recursive-p'.
 ;;
 ;;
 ;;  ***** NOTE: The following functions defined in `dabbrev.el' have
 ;;              been REDEFINED HERE:
 ;;              (BBDB is available here: http://bbdb.sourceforge.net/.)
 ;;
-;;  `bbdb-complete-name' - Use Icicles minibuffer completion when there
+;;  `icicle-bbdb-complete-mail', `bbdb-complete-name' -
+;;                         Use Icicles minibuffer completion when there
 ;;                         are multiple candidates.
 ;;
 ;;
 ;;  headings throughout this file.  You can get `linkd.el' here:
 ;;  http://dto.freeshell.org/notebook/Linkd.html.
 ;;
+;;  (@> "Internal Variables (alphabetical)")
+;;  (@> "Macros")
 ;;  (@> "Icicles Top-Level Commands, Part 1")
  
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (eval-when-compile
  (when (< emacs-major-version 24)       ; $$$$$$$$ TODO: Update it for Emacs 24+
    (require 'dabbrev)))
-  ;; dabbrev-case-fold-search, dabbrev-upcase-means-case-search, dabbrev--last-obarray,
-  ;; dabbrev--last-completion-buffer, dabbrev--last-abbreviation, dabbrev--check-other-buffers,
-  ;; dabbrev-case-replace, dabbrev--reset-global-variables, dabbrev--minibuffer-origin,
+  ;; dabbrev-case-fold-search, dabbrev-upcase-means-case-search, dabbrev--last-abbreviation,
+  ;; dabbrev--check-other-buffers, dabbrev-case-replace, dabbrev--reset-global-variables,
   ;; dabbrev--find-all-expansions, dabbrev--substitute-expansion
 (eval-when-compile (require 'bookmark))
   ;; bookmark-all-names, bookmark-buffer-name, bookmark-current-bookmark
   ;; icicle-candidates-alist, icicle-color-theme-history, icicle-command-abbrev-history,
   ;; icicle-commands-for-abbrev, icicle-comp-base-is-default-dir-p, icicle-completion-candidates,
   ;; icicle-completion-set-history, icicle-current-input, icicle-delete-candidate-object,
-  ;; icicle-explore-final-choice, icicle-explore-final-choice-full, icicle-extra-candidates,
-  ;; icicle-face-name-history, icicle-frame-alist, icicle-frame-name-history, icicle-full-cand-fn,
-  ;; icicle-function-name-history, icicle-get-alist-candidate-function, icicle-hist-var,
+  ;; icicle-explore-final-choice, icicle-explore-final-choice-full,
+  ;; icicle-extra-candidates, icicle-face-name-history, icicle-frame-alist, icicle-frame-name-history,
+  ;; icicle-full-cand-fn, icicle-function-name-history, icicle-get-alist-candidate-function, icicle-hist-var,
   ;; icicle-incremental-completion-p, icicle-inhibit-sort-p, icicle-inhibit-try-switch-buffer,
   ;; icicle-kill-history, icicle-kmacro-alist, icicle-kmacro-history,icicle-list-use-nth-parts,
   ;; icicle-must-match-regexp, icicle-must-not-match-regexp, icicle-must-pass-after-match-predicate,
-  ;; icicle-new-last-cmd, icicle-orig-buff, icicle-orig-must-pass-after-match-pred,
-  ;; icicle-orig-pt-explore, icicle-orig-window, icicle-orig-win-explore, icicle-pref-arg,
-  ;; icicle-previous-raw-file-name-inputs, icicle-previous-raw-non-file-name-inputs, icicle-prompt,
-  ;; icicle-proxy-candidates, icicle-read-expression-map, icicle-remove-icicles-props-p,
-  ;; icicle-re-no-dot, icicle-saved-completion-candidates, icicle-search-history,
-  ;; icicle-transform-before-sort-p, icicle-use-candidates-only-once-alt-p,
-  ;; icicle-whole-candidate-as-text-prop-p, icicle-variable-name-history
+  ;; icicle-new-last-cmd, icicle-orig-buff, icicle-orig-must-pass-after-match-pred, icicle-orig-pt-explore,
+  ;; icicle-orig-window, icicle-orig-win-explore, icicle-pref-arg, icicle-previous-raw-file-name-inputs,
+  ;; icicle-previous-raw-non-file-name-inputs, icicle-prompt, icicle-proxy-candidates,
+  ;; icicle-read-expression-map, icicle-remove-icicles-props-p, icicle-re-no-dot,
+  ;; icicle-saved-completion-candidates, icicle-search-history, icicle-transform-before-sort-p,
+  ;; icicle-use-candidates-only-once-alt-p, icicle-whole-candidate-as-text-prop-p,
+  ;; icicle-variable-name-history
 (require 'icicles-fn)                   ; (This is required anyway by `icicles-mcmd.el'.)
   ;; icicle-delete-dups, icicle-highlight-lighter, icicle-multi-comp-apropos-complete-match,
-  ;; icicle-read-from-minibuf-nil-default, icicle-string-match-p
+  ;; icicle-read-from-minibuf-nil-default, icicle-read-regexp, icicle-string-match-p
 
 
 ;; Byte-compiling this file, you will likely get some byte-compiler warning messages.
   (defvar icicle-kmacro-alist)          ; In `icicles-var.el'
   (defvar kmacro-ring)                  ; In `kmacro.el'
   (defvar read-file-name-completion-ignore-case) ;  In `minibuffer.el'
-  (defvar recentf-list)                 ; In `recentf.el'
   (defvar tags-case-fold-search)        ; In `etags.el'
   (defvar tooltip-mode))                ; In `tooltip.el'
 
 
 (defvar apropos-do-all)                 ; In `apropos.el'
 (defvar bbdb-complete-mail-allow-cycling) ; In `bbdb-com.el'
-(defvar bbdb-complete-name-allow-cycling) ; In `bbdb-com.el'
+(defvar bbdb-complete-name-allow-cycling) ; In `bbdb-com.el', older BBDB versions
 (defvar bbdb-completion-list)           ; In `bbdb-come.el'
 (defvar bbdb-extract-address-components-func) ; In `bbdb-com.el'
 (defvar bbdb-expand-mail-aliases)       ; In `bbdb-com.el'
-(defvar bbdb-complete-name-hooks)       ; In `bbdb-com.el'
+(defvar bbdb-complete-name-hooks)       ; In `bbdb-com.el', older BBDB versions
 (defvar bbdb-completion-display-record) ; In `bbdb.el'
 (defvar bbdb-completion-type)           ; In `bbdb.el'
 (defvar bbdb-hashtable)                 ; In `bbdb.el'
 (defvar bmkp-non-file-filename)         ; In `bookmark+-1.el'
 (defvar bmkp-prompt-for-tags-flag)      ; In `bookmark+-1.el'
 (defvar bmkp-sorted-alist)              ; In `bookmark+-1.el'
-(defvar bookmark-current-point)         ; In `bookmark.el' for Emacs <
+(defvar bookmark-current-point)         ; In `bookmark.el' (Emacs < 23)
 (defvar color-theme)                    ; In `color-theme.el'
 (defvar color-themes)                   ; In `color-theme.el'
 (defvar color-theme-initialized)        ; In `color-theme.el'
 (defvar cookie-cache)
-(defvar dabbrev--last-obarray)          ; In `dabbrev.el' for Emacs < 24
-(defvar dabbrev--last-completion-buffer) ; In `dabbrev.el' for Emacs < 24
+(defvar custom-enabled-themes)          ; In `custom.el' (Emacs 24+)
+(defvar dabbrev-case-fold-search)       ; In `dabbrev.el'
+(defvar dabbrev-case-replace)           ; In `dabbrev.el'
+(defvar dabbrev-abbrev-char-regexp)     ; In `dabbrev.el'
+(defvar dabbrev--check-other-buffers)   ; In `dabbrev.el'
+(defvar dabbrev--last-abbreviation)     ; In `dabbrev.el'
+(defvar dabbrev--last-abbrev-location)  ; In `dabbrev.el'
+(defvar dabbrev-upcase-means-case-search) ; In `dabbrev.el'
 (defvar ess-current-process-name)       ; In `ess-inf.el'
 (defvar ess-mode-syntax-table)          ; In `ess-cust.el'
 (defvar ess-use-R-completion)           ; In `ess-cust.el'
-(defvar existing-bufs)                  ; `icicle-visit-marked-file-of-content', `icicle-find-file-of-content'
 (defvar file-cache-alist)               ; In `filecache.el'
 (defvar filesets-data)                  ; In `filesets.el'
 (defvar find-tag-default-function)      ; In `etags.el'
 (defvar goto-tag-location-function)     ; In `etags.el'
 (defvar icicle-buffer-easy-files)       ; Here
 (defvar icicle-clear-history-hist)      ; In `icicle-clear-history-1',`icicle-clear-current-history'
+(defvar icicle-custom-themes)           ; In `icicles-opt.el' (Emacs 24+)
+(defvar icicle-custom-themes-accumulate-flag) ; In `icicles-opt.el' (Emacs 24+)
+(defvar icicle-custom-themes-update-flag) ; In `icicles-opt.el' (Emacs 24+)
 (defvar icicle--last-toggle-transforming-msg) ; Here
 (defvar icicle-window-alist)            ; In `icicle-select-window'
 (defvar locate-make-command-line)       ; In `locate.el'
 (defvar proced-signal-list)             ; In `proced.el' (Emacs 23+)
+(defvar recentf-list)                   ; In `recentf.el'
 (defvar shell-completion-execonly)      ; In `shell.el'
 (defvar snarf-tag-function)             ; In `etags.el'
 (defvar translation-table-for-input)    ; Built-in, Emacs 21+
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
+;;(@* "Internal Variables (alphabetical)")
+
+;;; Internal variables (alphabetical) --------------------------------
+
+(defvar icicle-existing-bufs ()
+  "List of existing buffers before a content-searching command.")
+
+(defvar icicle-find-file-abs-action-fn nil
+  "Action function used in commands that find an absolute file name.")
+
+(defvar icicle-find-file-action-fn nil
+  "Action function used in commands that use `read-file-name'.")
+
+(defvar icicle-locate-file-no-symlinks-p nil
+  "Flag bound in `icicle-locate-file*' for use by `icicle-files-within'.")
+
+(defvar icicle-locate-file-use-locate-p nil
+  "Flag bound to non-nil in `icicle-locate(-other-window)'.
+Non-nil means `icicle-locate-file*' uses external command `locate'.")
+
+(defvar icicle-new-bufs-to-keep ()
+  "List of temporary buffers for content-searching commands.")
+
+(defvar icicle-new-bufs-to-kill ()
+  "List of temporary buffers for content-searching commands.")
+;;(@* "Macros")
+
+;;; Macros -----------------------------------------------------------
+
+(defmacro icicle-find-file-abs-no-search-action-1 (other-window-p read-only-p)
+  "Action function for commands reading absolute file names without searching.
+Non-nil OTHER-WINDOW-P means use other window.
+Non-nil READ-ONLY-P means visit file in read-only mode."
+  `(lambda (file)
+    (let ((r-o  (or ,read-only-p
+                    (and (memq this-command '(icicle-candidate-action icicle-mouse-candidate-action
+                                              icicle-all-candidates-action))
+                         current-prefix-arg)))
+          (fil  (icicle-transform-multi-completion file)))
+      (if r-o
+          (if ,other-window-p
+              (find-file-read-only-other-window fil 'WILDCARDS)
+            (find-file-read-only fil 'WILDCARDS))
+        (if ,other-window-p
+            (find-file-other-window fil 'WILDCARDS)
+          (find-file fil 'WILDCARDS))))))
+
+(defmacro icicle-find-file-no-search-action-1 (other-window-p)
+  "Action function for commands using `read-file-name' without searching.
+Non-nil OTHER-WINDOW-P means use other window."
+  ;; FREE VARS here: CURRENT-PREFIX-ARG, THIS-COMMAND, `icicle-pref-arg'.
+  `(lambda (file)
+    (let ((r-o  (if (memq this-command '(icicle-candidate-action icicle-mouse-candidate-action
+                                         icicle-all-candidates-action))
+                    (or (and ,icicle-pref-arg        (not current-prefix-arg))
+                        (and (not ,icicle-pref-arg)  current-prefix-arg))
+                  ,icicle-pref-arg)))
+      (icicle-find-file-or-expand-dir file #'icicle-find-file-no-search-1 r-o ,other-window-p))))
+
+(defmacro icicle-find-file-abs-of-content-action-1 (other-window-p read-only-p)
+  "File-visiting action function for commands reading absolute file names.
+Non-nil OTHER-WINDOW-P means use other window.
+Non-nil READ-ONLY-P means visit file in read-only mode."
+  `(lambda (file)
+    (setq file  (icicle-transform-multi-completion file)
+     file  (if (string= "" (file-name-nondirectory file)) (directory-file-name file) file))
+    (let* ((r-o        (or ,read-only-p
+                           (and (memq this-command '(icicle-candidate-action icicle-mouse-candidate-action
+                                                     icicle-all-candidates-action))
+                                current-prefix-arg))) ; Use this, not `icicle-pref-arg': for this candidate.
+           ;; If FILE uses wildcards there are multiple files to visit.
+           (wildfiles  (file-expand-wildcards file)))
+
+      ;; For each matching file name, kill any buffers created for content-searching it, so that
+      ;; `find-file*' DTRT wrt file-local variable declarations, file handlers, find-file hooks etc.
+      (dolist (fil  wildfiles)
+        (let ((created-buf  (car (memq (find-buffer-visiting fil) icicle-new-bufs-to-kill))))
+          (when (and (buffer-live-p created-buf)  (not (memq created-buf icicle-new-bufs-to-keep)))
+;;;               $$$$$$ Why were we calling `restore-buffer-modified-p' before killing?
+;;;               (with-current-buffer created-buf
+;;;                 (restore-buffer-modified-p nil) ; Just visiting can sometimes modify the buffer
+;;;                 (setq icicle-new-bufs-to-kill  (delete created-buf icicle-new-bufs-to-kill))
+;;;                 (kill-buffer created-buf)))))
+            (setq icicle-new-bufs-to-kill  (delete created-buf icicle-new-bufs-to-kill))
+            (kill-buffer created-buf))))
+
+      ;; Visit properly (mode, vars, handlers, hooks).
+      (let ((fn  (if r-o
+                     (if ,other-window-p #'find-file-read-only-other-window #'find-file-read-only)
+                   (if ,other-window-p #'find-file-other-window #'find-file))))
+        (funcall fn file 'WILDCARDS))
+
+      ;; Add the visited buffers to those we will keep (not kill).
+      ;; For a directory, get the Dired buffer instead of using `get-file-buffer'.
+      (dolist (fil  wildfiles)
+        (when (setq fil  (if (file-directory-p fil)
+                             (get-buffer (file-name-nondirectory fil))
+                           (get-file-buffer fil)))
+          (push fil icicle-new-bufs-to-keep))))))
+
+(defmacro icicle-find-file-of-content-action-1 (other-window-p read-only-p)
+  "Action function for commands using `read-file-name' with content searching.
+Non-nil OTHER-WINDOW-P means use other window.
+Non-nil READ-ONLY-P means visit file in read-only mode."
+  ;; FREE VARS here: CURRENT-PREFIX-ARG, THIS-COMMAND, `icicle-new-bufs-to-kill', `icicle-new-bufs-to-keep'.
+  `(lambda (file)                       ; Action function
+    (setq file  (icicle-transform-multi-completion file))
+    (setq file  (if (string= "" (file-name-nondirectory file)) (directory-file-name file) file))
+    (let* ((r-o        (or ,read-only-p
+                           (and (memq this-command '(icicle-candidate-action icicle-mouse-candidate-action
+                                                     icicle-all-candidates-action))
+                                current-prefix-arg))) ; Use this, not `icicle-pref-arg': for this candidate.
+           ;; If FILE uses wildcards then there are multiple files to visit.
+           (wildfiles  (file-expand-wildcards file)))
+
+      ;; For each matching file name, kill any buffers created for content-searching it, so that
+      ;; `find-file*' DTRT wrt file-local variable declarations, file handlers, find-file hooks etc.
+      (dolist (fil  wildfiles)
+        (let ((created-buf  (car (memq (find-buffer-visiting fil) icicle-new-bufs-to-kill))))
+          (when (and (buffer-live-p created-buf)  (not (memq created-buf icicle-new-bufs-to-keep)))
+;;;               $$$$$$ Why were we calling `restore-buffer-modified-p' before killing?
+;;;               (with-current-buffer created-buf
+;;;                 (restore-buffer-modified-p nil) ; Just visiting can sometimes modify the buffer
+;;;                 (setq icicle-new-bufs-to-kill  (delete created-buf icicle-new-bufs-to-kill))
+;;;                 (kill-buffer created-buf)))))
+            (setq icicle-new-bufs-to-kill  (delete created-buf icicle-new-bufs-to-kill))
+            (kill-buffer created-buf))))
+
+      ;; Visit properly (mode, vars, handlers, hooks).
+      (icicle-find-file-or-expand-dir file #'icicle-find-file-of-content-1 r-o ,other-window-p)
+
+      ;; Add the visited buffers to those we will keep (not kill).
+      ;; For a directory, get the Dired buffer instead of using `get-file-buffer'.
+      (dolist (fil  wildfiles)
+        (when (setq fil  (if (file-directory-p fil)
+                             (get-buffer (file-name-nondirectory fil))
+                           (get-file-buffer fil)))
+          (push fil icicle-new-bufs-to-keep))))))
 ;;(@* "Icicles Top-Level Commands, Part 1")
-;;; Icicles Top-Level Commands, Part 1 .   .   .   .   .   .   .   .   .
+
+;;; Icicles Top-Level Commands, Part 1 -------------------------------
 
 
 ;; REPLACE ORIGINAL `pp-eval-expression' defined in `pp.el',
@@ -608,13 +817,11 @@ customize option `icicle-top-level-key-bindings'."
       (setq values  (cons (eval expression) values))
     (let ((old-value  (make-symbol "t"))
           new-value)
-      ;; Bind debug-on-error to something unique so that we can
-      ;; detect when evaled code changes it.
+      ;; Bind `debug-on-error' to something unique so that we can detect when evaled code changes it.
       (let ((debug-on-error  old-value))
         (setq values     (cons (eval expression) values)
               new-value  debug-on-error))
-      ;; If evaled code has changed the value of debug-on-error,
-      ;; propagate that change to the global binding.
+      ;; If evaled code has changed the value of `debug-on-error', propagate that change to the global binding.
       (unless (eq old-value new-value)
         (setq debug-on-error  new-value))))
   (let ((print-length     icicle-pp-eval-expression-print-length)
@@ -811,6 +1018,7 @@ See `icicle-comint-dynamic-complete-filename'."
                (let* ((icicle-show-Completions-initially-flag      t)
                       (icicle-incremental-completion-p             'display)
                       (icicle-top-level-when-sole-completion-flag  t)
+                      (enable-recursive-minibuffers                t)
                       (choice
                        (save-excursion
                          (save-window-excursion (read-file-name "Complete: " directory nil t)))))
@@ -826,7 +1034,7 @@ See `icicle-comint-dynamic-complete-filename'."
              ;; Insert completion.  The completion string might have a different case from
              ;; what's in the prompt, if `read-file-name-completion-ignore-case' is non-nil.
              (delete-region filename-beg filename-end)
-             (if filedir (insert (comint-quote-filename filedir)))
+             (when filedir (insert (comint-quote-filename filedir)))
              (insert (comint-quote-filename (directory-file-name completion)))
              (cond ((symbolp (file-name-completion completion directory))
                     ;; We inserted a unique completion.  Add suffix.
@@ -845,6 +1053,7 @@ See `icicle-comint-dynamic-complete-filename'."
                         (let* ((icicle-show-Completions-initially-flag      t)
                                (icicle-incremental-completion-p             'display)
                                (icicle-top-level-when-sole-completion-flag  t)
+                               (enable-recursive-minibuffers                t)
                                (choice
                                 (save-excursion
                                   (save-window-excursion
@@ -872,17 +1081,17 @@ Completion is dependent on the value of `shell-completion-execonly',
 plus those that effect file completion.
 See `icicle-shell-dynamic-complete-as-command'.
 
-Returns t if successful.
+Return t if successful.
 
 Uses Icicles completion."
   (interactive)
   (let ((filename  (comint-match-partial-filename)))
-    (if (and filename
-             (save-match-data (not (string-match "[~/]" filename)))
-             (eq (match-beginning 0) (save-excursion (shell-backward-command 1) (point))))
-        (prog2 (unless (window-minibuffer-p (selected-window))
-                 (message "Completing command name..."))
-            (icicle-shell-dynamic-complete-as-command)))))
+    (when (and filename
+               (save-match-data (not (string-match "[~/]" filename)))
+               (eq (match-beginning 0) (save-excursion (shell-backward-command 1) (point))))
+      (prog2 (unless (window-minibuffer-p (selected-window))
+               (message "Completing command name..."))
+          (icicle-shell-dynamic-complete-as-command)))))
 
 (defun icicle-shell-dynamic-complete-as-command ()
   "Dynamically complete text at point as a command.
@@ -945,11 +1154,11 @@ Inserts completion characters at point by completing STUB from the
 strings in CANDIDATES.  Uses Icicles completion if completion is
 ambiguous.
 
-Returns nil if no completion was inserted.
-Returns `sole' if completed with the only completion match.
-Returns `shortest' if completed with the shortest of the completion matches.
-Returns `partial' if completed as far as possible with the completion matches.
-Returns `listed' if a completion listing was shown.
+Return nil if no completion was inserted.
+Return `sole' if completed with the only completion match.
+Return `shortest' if completed with the shortest match.
+Return `partial' if completed as far as possible.
+Return `listed' if a completion listing was shown.
 
 See also `icicle-comint-dynamic-complete-filename'."
   (let* ((completion-ignore-case  (memq system-type '(ms-dos windows-nt cygwin)))
@@ -973,13 +1182,14 @@ See also `icicle-comint-dynamic-complete-filename'."
              (insert suffix)
              'sole))
           (t                            ; There's no unique completion.
-           (let ((completion  (try-completion stub candidates)))
+           (let ((completion                    (try-completion stub candidates))
+                 (enable-recursive-minibuffers  t))
              ;; Insert the longest substring.
              (insert (substring completion (length stub)))
              (cond ((and comint-completion-recexact  comint-completion-addsuffix
                          (string-equal stub completion)
                          (member completion completions))
-                    (insert suffix)     ; User wants shortest match.
+                    (insert suffix)     ; Not unique but user wants shortest match.
                     (unless minibuffer-p (message "Completed shortest"))
                     'shortest)
                    ((or comint-completion-autolist  (string-equal stub completion))
@@ -1016,10 +1226,10 @@ argument."
   (interactive)
   (require 'shell)
   (let ((variable  (shell-match-partial-variable)))
-    (if (and variable  (string-match "^\\$" variable))
-        (prog2 (unless (window-minibuffer-p (selected-window))
-                 (message "Completing variable name..."))
-            (icicle-shell-dynamic-complete-as-environment-variable)))))
+    (when (and variable  (string-match "^\\$" variable))
+      (prog2 (unless (window-minibuffer-p (selected-window))
+               (message "Completing variable name..."))
+          (icicle-shell-dynamic-complete-as-environment-variable)))))
 
 (defun icicle-shell-dynamic-complete-as-environment-variable ()
   "`shell-dynamic-complete-as-environment-variable' but uses Icicles completion."
@@ -1031,16 +1241,16 @@ argument."
          (addsuffix                    comint-completion-addsuffix)
          (comint-completion-addsuffix  nil)
          (success                      (icicle-comint-dynamic-simple-complete variable variables)))
-    (if (memq success '(sole shortest))
-        (let* ((var           (shell-match-partial-variable))
-               (variable      (substring var (string-match "[^$({]" var)))
-               (protection    (cond ((string-match "{" var)                                    "}")
-                                    ((string-match "(" var)                                    ")")
-                                    (t                                                         "")))
-               (suffix        (cond ((null addsuffix)                                          "")
-                                    ((file-directory-p (comint-directory (getenv variable)))   "/")
-                                    (t                                                         " "))))
-          (insert protection  suffix)))
+    (when (memq success '(sole shortest))
+      (let* ((var         (shell-match-partial-variable))
+             (variable    (substring var (string-match "[^$({]" var)))
+             (protection  (cond ((string-match "{" var)                                    "}")
+                                ((string-match "(" var)                                    ")")
+                                (t                                                         "")))
+             (suffix      (cond ((null addsuffix)                                          "")
+                                ((file-directory-p (comint-directory (getenv variable)))   "/")
+                                (t                                                         " "))))
+        (insert protection  suffix)))
     success))
 
 
@@ -1133,19 +1343,24 @@ Perform completion on the GDB command preceding point."
     (icicle-comint-dynamic-simple-complete command-word complete-list)))
 
 
+(defvar icicle-dabbrev--last-obarray nil
+  "Last obarray of completions used by `icicle-dabbrev-completion'.")
+
+(defvar icicle-dabbrev--last-completion-buffer nil
+  "Buffer last completed in by `icicle-dabbrev-completion'.")
+
+
 ;; REPLACE ORIGINAL `dabbrev-completion' defined in `dabbrev.el',
 ;; saving it for restoration when you toggle `icicle-mode'.
 ;;
 ;; You can complete from an empty abbrev also.
 ;; Uses Icicles completion when there are multiple candidates.
 ;;
-(when (< emacs-major-version 24)        ; $$$$$$$$ TODO: Update this for Emacs 24+.
+(when (and (fboundp 'dabbrev-completion)  (not (fboundp 'icicle-ORIG-dabbrev-completion)))
+  (defalias 'icicle-ORIG-dabbrev-completion (symbol-function 'dabbrev-completion)))
 
-  (when (and (fboundp 'dabbrev-completion)  (not (fboundp 'icicle-ORIG-dabbrev-completion)))
-    (defalias 'icicle-ORIG-dabbrev-completion (symbol-function 'dabbrev-completion)))
-
-  (defun icicle-dabbrev-completion (&optional arg) ; Bound to `C-M-/' globally.
-    "Completion on current word.
+(defun icicle-dabbrev-completion (&optional arg) ; Bound to `C-M-/' globally.
+  "Complete current word in buffer.
 Like \\[dabbrev-expand], but finds all expansions in the current buffer
 and presents suggestions for completion.
 
@@ -1157,88 +1372,89 @@ searches *ALL* buffers.
 
 With no prefix argument, it reuses an old completion list
 if there is a suitable one already."
-    (interactive "*P")
-    (unless (featurep 'dabbrev)
-      (unless (require 'dabbrev nil t) (error "Library `dabbrev' not found"))
-      (icicle-mode 1))                  ; Redefine `dabbrev-completion' to Icicles version.
-    (dabbrev--reset-global-variables)
-    (let* ((dabbrev-check-other-buffers  (and arg  t)) ; Must be t
-           (dabbrev-check-all-buffers    (and arg  (= (prefix-numeric-value arg) 16)))
-           (abbrev                       (icicle-dabbrev--abbrev-at-point))
-           (ignore-case-p                (and (if (eq dabbrev-case-fold-search 'case-fold-search)
-                                                  case-fold-search
-                                                dabbrev-case-fold-search)
-                                              (or (not dabbrev-upcase-means-case-search)
-                                                  (string= abbrev (downcase abbrev)))))
-           (my-obarray                   dabbrev--last-obarray)
-           init)
-      ;; If new abbreviation to expand, then expand it.
-      (save-excursion
-        (unless (and (null arg)
-                     my-obarray
-                     (or (eq dabbrev--last-completion-buffer (current-buffer))
-                         (and (window-minibuffer-p (selected-window))
-                              (eq dabbrev--last-completion-buffer (dabbrev--minibuffer-origin))))
-                     dabbrev--last-abbreviation
-                     (>= (length abbrev) (length dabbrev--last-abbreviation))
-                     (string= dabbrev--last-abbreviation
-                              (substring abbrev 0 (length dabbrev--last-abbreviation)))
-                     (setq init  (try-completion abbrev my-obarray)))
-          (setq dabbrev--last-abbreviation  abbrev)
-          (let ((completion-list         (dabbrev--find-all-expansions abbrev ignore-case-p))
-                (completion-ignore-case  ignore-case-p))
-            ;; Make an obarray with all expansions
-            (setq my-obarray  (make-vector (length completion-list) 0))
-            (unless (> (length my-obarray) 0)
-              (icicle-user-error "No dynamic expansion for \"%s\" found%s" abbrev
-                                 (if dabbrev--check-other-buffers "" " in this-buffer")))
-            (dolist (string  completion-list)
-              (cond ((or (not ignore-case-p)  (not dabbrev-case-replace))
-                     (intern string my-obarray))
-                    ((string= abbrev (icicle-upcase abbrev))
-                     (intern (icicle-upcase string) my-obarray))
-                    ((string= (substring abbrev 0 1) (icicle-upcase (substring abbrev 0 1)))
-                     (intern (capitalize string) my-obarray))
-                    (t (intern (downcase string) my-obarray))))
-            (setq dabbrev--last-obarray            my-obarray
-                  dabbrev--last-completion-buffer  (current-buffer)
-                  ;; Find the expanded common string.
-                  init                             (try-completion abbrev my-obarray)))))
-      ;; Let the user choose between the expansions
-      (unless (stringp init) (setq init  abbrev))
-      (cond
-        ((and (not (string-equal init ""))
-              (not (string-equal (downcase init) (downcase abbrev)))
-              (<= (length (all-completions init my-obarray)) 1))
-         (message "Completed (no other completions)")
-         (if (< emacs-major-version 21)
-             (dabbrev--substitute-expansion nil abbrev init)
-           (dabbrev--substitute-expansion nil abbrev init nil))
-         (when (window-minibuffer-p (selected-window)) (message nil)))
-        ;;$$       ;; Complete text only up through the common root. NOT USED.
-        ;;       ((and icicle-dabbrev-stop-at-common-root-p
-        ;;             (not (string-equal init ""))
-        ;;             (not (string-equal (downcase init) (downcase abbrev))))
-        ;;        (message "Use `%s' again to complete further"
-        ;;                 (icicle-key-description (this-command-keys) nil icicle-key-descriptions-use-<>-flag))
-        ;;        (if (< emacs-major-version 21)
-        ;;            (dabbrev--substitute-expansion nil abbrev init)
-        ;;          (dabbrev--substitute-expansion nil abbrev init nil))
-        ;;        (when (window-minibuffer-p (selected-window)) (message nil))) ; $$ NEEDED?
-        (t
-         ;; String is a common root already.  Use Icicles completion.
-         (icicle-highlight-lighter)
-         (message "Making completion list...")
-         (search-backward abbrev)
-         (replace-match "")
-         (condition-case nil
-             (let* ((icicle-show-Completions-initially-flag  t)
-                    (icicle-incremental-completion-p         'display)
-                    (minibuffer-completion-table             my-obarray)
-                    (choice
-                     (completing-read "Complete: " my-obarray nil nil init nil init)))
-               (when choice (insert choice)))
-           (quit (insert abbrev)))))))
+  (interactive "*P")
+  (unless (featurep 'dabbrev)
+    (unless (require 'dabbrev nil t) (error "Library `dabbrev' not found"))
+    (icicle-mode 1))                    ; Redefine `dabbrev-completion' to Icicles version.
+  (dabbrev--reset-global-variables)
+  (let* ((dabbrev-check-other-buffers  (and arg  t)) ; Must be t
+         (dabbrev-check-all-buffers    (and arg  (= (prefix-numeric-value arg) 16)))
+         (abbrev                       (icicle-dabbrev--abbrev-at-point))
+         (ignore-case-p                (and (if (eq dabbrev-case-fold-search 'case-fold-search)
+                                                case-fold-search
+                                              dabbrev-case-fold-search)
+                                            (or (not dabbrev-upcase-means-case-search)
+                                                (string= abbrev (downcase abbrev)))))
+         (my-obarray                   icicle-dabbrev--last-obarray)
+         init)
+    (save-excursion                     ; If new abbreviation to expand then expand it.
+      (unless (and (null arg)           ; Reuse existing completions, if appropriate.
+                   my-obarray
+                   (or (eq icicle-dabbrev--last-completion-buffer (current-buffer))
+                       (and (window-minibuffer-p (selected-window))
+                            (eq icicle-dabbrev--last-completion-buffer
+                                (window-buffer (minibuffer-selected-window)))))
+                   dabbrev--last-abbreviation
+                   (>= (length abbrev) (length dabbrev--last-abbreviation))
+                   (string= dabbrev--last-abbreviation
+                            (substring abbrev 0 (length dabbrev--last-abbreviation)))
+                   (setq init  (try-completion abbrev my-obarray)))
+        (setq dabbrev--last-abbreviation  abbrev)
+        (let ((completion-list         (dabbrev--find-all-expansions abbrev ignore-case-p))
+              (completion-ignore-case  ignore-case-p))
+          ;; Make an obarray with all expansions
+          (setq my-obarray  (make-vector (length completion-list) 0))
+          (unless (> (length my-obarray) 0)
+            (icicle-user-error "No dynamic expansion for \"%s\" found%s" abbrev
+                               (if dabbrev--check-other-buffers "" " in this-buffer")))
+          (dolist (string  completion-list)
+            (cond ((or (not ignore-case-p)  (not dabbrev-case-replace))
+                   (intern string my-obarray))
+                  ((string= abbrev (icicle-upcase abbrev))
+                   (intern (icicle-upcase string) my-obarray))
+                  ((string= (substring abbrev 0 1) (icicle-upcase (substring abbrev 0 1)))
+                   (intern (capitalize string) my-obarray))
+                  (t (intern (downcase string) my-obarray))))
+          (setq icicle-dabbrev--last-obarray            my-obarray
+                icicle-dabbrev--last-completion-buffer  (current-buffer)
+                ;; Find the expanded common string.
+                init                             (try-completion abbrev my-obarray)))))
+    ;; Let the user choose between the expansions
+    (unless (stringp init) (setq init  abbrev))
+    (cond
+      ((and (not (string-equal init ""))
+            (not (string-equal (downcase init) (downcase abbrev)))
+            (<= (length (all-completions init my-obarray)) 1))
+       (message "Completed (no other completions)")
+       (if (< emacs-major-version 21)
+           (dabbrev--substitute-expansion nil abbrev init)
+         (dabbrev--substitute-expansion nil abbrev init nil))
+       (when (window-minibuffer-p (selected-window)) (message nil)))
+      ;;$$       ;; Complete text only up through the common root. NOT USED.
+      ;;       ((and icicle-dabbrev-stop-at-common-root-p
+      ;;             (not (string-equal init ""))
+      ;;             (not (string-equal (downcase init) (downcase abbrev))))
+      ;;        (message "Use `%s' again to complete further"
+      ;;                 (icicle-key-description (this-command-keys) nil
+      ;;                                         icicle-key-descriptions-use-<>-flag))
+      ;;        (if (< emacs-major-version 21)
+      ;;            (dabbrev--substitute-expansion nil abbrev init)
+      ;;          (dabbrev--substitute-expansion nil abbrev init nil))
+      ;;        (when (window-minibuffer-p (selected-window)) (message nil))) ; $$ NEEDED?
+      (t
+       ;; String is a common root already.  Use Icicles completion.
+       (icicle-highlight-lighter)
+       (message "Making completion list...")
+       (search-backward abbrev)
+       (replace-match "")
+       (condition-case nil
+           (let* ((icicle-show-Completions-initially-flag  t)
+                  (icicle-incremental-completion-p         'display)
+                  (minibuffer-completion-table             my-obarray)
+                  (choice
+                   (completing-read "Complete: " my-obarray nil nil init nil init)))
+             (when choice (insert choice)))
+         (quit (insert abbrev)))))))
 
   (defun icicle-dabbrev--abbrev-at-point ()
     "Like `dabbrev--abbrev-at-point', but returns \"\" if there is no match.
@@ -1258,7 +1474,7 @@ Vanilla `dabbrev--abbrev-at-point' raises an error if no match."
               (forward-char 1)))
           (dabbrev--goto-start-of-abbrev) ; Now find the beginning of that one.
           (setq abv  (buffer-substring-no-properties dabbrev--last-abbrev-location (point)))))
-      abv)))
+      abv))
 
 
 ;; REPLACE ORIGINAL `bbdb-complete-mail' defined in `bbdb-com.el', version 3.02
@@ -1273,7 +1489,7 @@ Vanilla `dabbrev--abbrev-at-point' raises an error if no match."
   "In a mail buffer, complete the user name or mail address before point.
 Completes up to the preceding newline, colon or comma, or the value of
 START-POS.
-Returns non-nil if there is a valid completion, else return nil.
+Return non-nil if there is a valid completion, else return nil.
 You can control completion behaviour using `bbdb-completion-list'
 \(`bbdb-completion-type' in older BBDB versions).
 
@@ -1330,15 +1546,15 @@ See your version of BBDB for more information."
              (unless mails (error "Matching record has no `mail' field"))
              ;; (1) If PATTERN matches name, AKA, or organization of ONE-RECORD,
              ;;     then ADDRESS is the first mail address of ONE-RECORD.
-             (if (try-completion pattern (append (and (memq 'fl-name completion-list)
-                                                      (list (or (bbdb-record-name one-record)  "")))
-                                                 (and (memq 'lf-name completion-list)
-                                                      (list (or (bbdb-record-name-lf one-record)  "")))
-                                                 (and (memq 'aka completion-list)
-                                                      (bbdb-record-field one-record 'aka-all))
-                                                 (and (memq 'organization completion-list)
-                                                      (bbdb-record-organization one-record))))
-                 (setq mail  (car mails)))
+             (when (try-completion pattern (append (and (memq 'fl-name completion-list)
+                                                        (list (or (bbdb-record-name one-record)  "")))
+                                                   (and (memq 'lf-name completion-list)
+                                                        (list (or (bbdb-record-name-lf one-record)  "")))
+                                                   (and (memq 'aka completion-list)
+                                                        (bbdb-record-field one-record 'aka-all))
+                                                   (and (memq 'organization completion-list)
+                                                        (bbdb-record-organization one-record))))
+               (setq mail  (car mails)))
              ;; (2) If PATTERN matches one or multiple mail addresses of ONE-RECORD,
              ;;     then we take the first one matching PATTERN.
              (unless mail (while (setq elt  (pop mails))
@@ -1461,7 +1677,8 @@ See your version of BBDB for more information."
 ;;
 ;; Avoid a byte-compile error if user has already loaded BBDB version 3+.
 ;; The error has to do with `bbdb-records' being a defsubst that takes no args.
-(unless (eval-when-compile (and (featurep 'bbdb)  (not (string-lessp bbdb-version "3"))))
+(unless (eval-when-compile (and (featurep 'bbdb)  (or (not (zerop (string-to-number bbdb-version)))
+                                                      (not (string-lessp bbdb-version "3")))))
   (defun icicle-bbdb-complete-name (&optional start-pos)
     "Complete the user full-name or net-address before point.
 Completes only up to the preceding newline, colon, or comma, or the
@@ -1512,9 +1729,8 @@ control completion behaviour using `bbdb-completion-type'."
                                                              (equal (symbol-value x) (symbol-value sym)))
                                                            all-the-completions))))
                                (setq only-one-p  nil))
-                             (if (memq sym all-the-completions)
-                                 nil
-                               (setq all-the-completions  (cons sym all-the-completions)))))))
+                             (and (not (memq sym all-the-completions))
+                                  (setq all-the-completions  (cons sym all-the-completions)))))))
                    (completion           (progn (all-completions pattern ht pred)
                                                 (try-completion pattern ht)))
                    (exact-match          (eq completion t)))
@@ -1574,10 +1790,10 @@ control completion behaviour using `bbdb-completion-type'."
              (when (bbdb-record-net (car recs))
                ;; Did we match on name?
                (let ((b-r-name  (or (bbdb-record-name (car recs))  "")))
-                 (if (string= pattern (substring (downcase b-r-name) 0
-                                                 (min (length b-r-name) (length pattern))))
-                     (setq match-recs  (cons (car recs) match-recs)
-                           matched     t)))
+                 (when (string= pattern (substring (downcase b-r-name) 0
+                                                   (min (length b-r-name) (length pattern))))
+                   (setq match-recs  (cons (car recs) match-recs)
+                         matched     t)))
                ;; Did we match on aka?
                (unless matched
                  (setq lst  (bbdb-record-aka (car recs)))
@@ -1594,14 +1810,14 @@ control completion behaviour using `bbdb-completion-type'."
                  (setq lst      (bbdb-record-net (car recs))
                        primary  t)      ; primary wins over secondary...
                  (while lst
-                   (if (string= pattern (substring (downcase (car lst)) 0
-                                                   (min (length (downcase (car lst)))
-                                                        (length pattern))))
-                       (setq the-net     (car lst)
-                             lst         ()
-                             match-recs  (if primary
-                                             (cons (car recs) match-recs)
-                                           (append match-recs (list (car recs))))))
+                   (when (string= pattern (substring (downcase (car lst)) 0
+                                                     (min (length (downcase (car lst)))
+                                                          (length pattern))))
+                     (setq the-net     (car lst)
+                           lst         ()
+                           match-recs  (if primary
+                                           (cons (car recs) match-recs)
+                                         (append match-recs (list (car recs))))))
                    (setq lst      (cdr lst)
                          primary  nil))))
              (setq recs     (cdr recs)  ; Next rec for loop.
@@ -1730,19 +1946,38 @@ symbols with function definitions are considered.  Otherwise, all
 symbols with function definitions, values or properties are
 considered."
   (interactive)
-  (let* ((end            (point))
+  (let* ((pos            (point))
          (buffer-syntax  (syntax-table))
+         ;; $$$$$$ FIXME: In minibuffer with no input, `backward-sexp' moves into the prompt, which is
+         ;;        read-only.  What we do currently is just let that happen and let the pattern be "".
+         ;;        Better would be to stop movement into the prompt etc.  See also Emacs bug #16453.
          (beg            (unwind-protect
-                              (save-excursion
+                              (progn
                                 (set-syntax-table emacs-lisp-mode-syntax-table)
-                                (backward-sexp 1)
-                                (while (= (char-syntax (following-char)) ?\') (forward-char 1))
-                                (point))
+                                (condition-case nil
+                                    (save-excursion
+                                      (backward-sexp 1)
+                                      (skip-syntax-forward "'")
+                                      (point))
+                                  (scan-error pos)))
                            (set-syntax-table buffer-syntax)))
-         (pattern       (buffer-substring beg end))
+         (end           (unless (or (eq beg (point-max))
+                                    (member (char-syntax (char-after beg)) '(?\" ?\( ?\))))
+                          (unwind-protect
+                               (progn
+                                 (set-syntax-table emacs-lisp-mode-syntax-table)
+                                 (condition-case nil
+                                     (save-excursion
+                                       (goto-char beg)
+                                       (forward-sexp 1)
+                                       (max (point) beg))
+                                   (scan-error pos)))
+                            (set-syntax-table buffer-syntax))))
+         (pattern       (buffer-substring beg (or end  beg)))
          (new           (try-completion pattern obarray)))
     (unless (stringp new) (setq new  pattern))
-    (delete-region beg end)
+    (condition-case nil (delete-region beg end) (error nil)) ; E.g. read-only text of a prompt.
+    (goto-char beg)
     (insert new)
     (setq end  (+ beg (length new)))
     (if (and (not (string= new ""))  (not (string= (downcase new) (downcase pattern)))
@@ -1756,15 +1991,16 @@ considered."
              (icicle-show-Completions-initially-flag      t)
              (icicle-candidate-alt-action-fn
               (or icicle-candidate-alt-action-fn  (setq alt-fn  (icicle-alt-act-fn-for-type "symbol"))))
-             (icicle-all-candidates-list-alt-action-fn ; M-|'
-              (or icicle-all-candidates-list-alt-action-fn alt-fn
+             (icicle-all-candidates-list-alt-action-fn ; `M-|'
+              (or icicle-all-candidates-list-alt-action-fn
+                  alt-fn
                   (icicle-alt-act-fn-for-type "symbol")))
              (predicate
               (or predicate
                   (save-excursion
                     (goto-char beg)
                     (if (not (eq (char-before) ?\( ))
-                        (lambda (sym) ;why not just nil ?   -sm
+                        (lambda (sym)   ;why not just nil ?   -sm
                           (or (boundp sym)  (fboundp sym)  (symbol-plist sym)))
                       ;; If first element of parent list is not an open paren, assume that this is a
                       ;; funcall position: use `fboundp'.  If not, then maybe this is a variable in
@@ -1777,7 +2013,7 @@ considered."
         ;;       candidate and pass nil as PRED to `completing-read'.  Don't bother for now.
         (setq new  (save-excursion (completing-read "Complete Lisp symbol: "
                                                     obarray predicate t new)))))
-    (delete-region beg end)
+    (condition-case nil (delete-region beg end) (error nil)) ; E.g. read-only text of a prompt.
     (insert new)))
 
 
@@ -1824,8 +2060,13 @@ Same as `icicle-customize-face' except it uses a different window."
    (list (let* ((icicle-multi-completing-p             t)
                 (icicle-list-use-nth-parts             '(1))
                 (icicle-candidate-action-fn
-                 (lambda (x)
-                   (icicle-ORIG-customize-face-other-window (intern (icicle-transform-multi-completion x)))
+                 (lambda (fc)
+                   (let ((proxy  (car (member fc icicle-proxy-candidates))))
+                     (setq fc  (icicle-transform-multi-completion fc)
+                           fc  (if proxy
+                                   (symbol-value (intern (substring proxy 1 (1- (length proxy)))))
+                                 (intern fc)))
+                     (icicle-ORIG-customize-face fc))
                    (select-window (minibuffer-window))
                    (select-frame-set-input-focus (selected-frame))))
                 (icicle-all-candidates-list-action-fn  'icicle-customize-faces)
@@ -1834,7 +2075,7 @@ Same as `icicle-customize-face' except it uses a different window."
                 (icicle-candidate-alt-action-fn
                  (or icicle-candidate-alt-action-fn
                      (setq alt-fn  (icicle-alt-act-fn-for-type "face"))))
-                (icicle-all-candidates-list-alt-action-fn ; M-|'
+                (icicle-all-candidates-list-alt-action-fn ; `M-|'
                  (or icicle-all-candidates-list-alt-action-fn
                      alt-fn
                      (icicle-alt-act-fn-for-type "face"))))
@@ -1878,24 +2119,39 @@ With prefix `C-M-' instead of `C-', the same keys (`C-M-mouse-2',
 Use `mouse-2', `RET', or `S-RET' to finally choose a candidate,
 or `C-g' to quit.
 
-With a prefix argument, you can enter multiple faces at the same time
-with a single `RET' (in Emacs 22 or later).  This gives you more or
-less the `crm' completion behavior of `customize-face' in vanilla
-Emacs.  Most Icicles completion features are still available, but
-`TAB' performs `crm' completion, so it does not also cycle among
-completion candidates.  You can, as always, use `down' to do that.
+With no prefix argument:
 
-A advantage of using a prefix argument is that the default value is
-the list of all faces under the cursor.  A disadvantage is that face
-candidates are not WYSIWYG in buffer `*Completions*'.
+* Candidates are shown according to option
+  `icicle-WYSIWYG-Completions-flag'.
+
+* If `icicle-add-proxy-candidates-flag' is non-nil then proxy
+  candidates are included.  These are the names of face-name options,
+  that is, options with custom-type `face'.  The face that is option
+  value is used.
+
+With a prefix argument:
+
+* You get no WYSIWYG display and no proxy candidates.
+
+* You can enter multiple faces at the same time with a single
+  `RET' (in Emacs 22 or later).  This gives you more or less the `crm'
+  completion behavior of `customize-face' in vanilla Emacs.  Most
+  Icicles completion features are still available, but `TAB' performs
+  `crm' completion, so it does not also cycle among completion
+  candidates.  You can, as always, use `down' to do that.
 
 This is an Icicles command - see command `icicle-mode'."
   (interactive
    (list (let* ((icicle-multi-completing-p             t)
                 (icicle-list-use-nth-parts             '(1))
                 (icicle-candidate-action-fn
-                 (lambda (x)
-                   (icicle-ORIG-customize-face (intern (icicle-transform-multi-completion x)))
+                 (lambda (fc)
+                   (let ((proxy  (car (member fc icicle-proxy-candidates))))
+                     (setq fc  (icicle-transform-multi-completion fc)
+                           fc  (if proxy
+                                   (symbol-value (intern (substring proxy 1 (1- (length proxy)))))
+                                 (intern fc)))
+                     (icicle-ORIG-customize-face fc))
                    (select-window (minibuffer-window))
                    (select-frame-set-input-focus (selected-frame))))
                 (icicle-all-candidates-list-action-fn  'icicle-customize-faces)
@@ -1903,7 +2159,7 @@ This is an Icicles command - see command `icicle-mode'."
                 (alt-fn                                nil)
                 (icicle-candidate-alt-action-fn
                  (or icicle-candidate-alt-action-fn  (setq alt-fn  (icicle-alt-act-fn-for-type "face"))))
-                (icicle-all-candidates-list-alt-action-fn ; M-|'
+                (icicle-all-candidates-list-alt-action-fn ; `M-|'
                  (or icicle-all-candidates-list-alt-action-fn
                      alt-fn
                      (icicle-alt-act-fn-for-type "face"))))
@@ -1980,7 +2236,7 @@ separate the words (any strings, in fact, including regexps) using
                                                         (if (null ',pref-arg)
                                                             (user-variable-p s)
                                                           (get s 'variable-documentation)))))))
-          (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+          (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
           (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred)))
      (list (completing-read "Customize (pattern): " obarray (and icompletep  pred) nil nil 'regexp-history)
            pref-arg
@@ -1993,7 +2249,7 @@ separate the words (any strings, in fact, including regexps) using
     (when (fboundp 'apropos-parse-pattern) (apropos-parse-pattern pattern)) ; Emacs 22+
     (when msgp (message "Gathering apropos data for customize `%s'..." pattern))
     (mapatoms `(lambda (symbol)         ; FREE here: APROPOS-REGEXP.
-                (when (string-match ,(if (> emacs-major-version 21) apropos-regexp pattern)
+                (when (string-match ,(and (> emacs-major-version 21)  apropos-regexp pattern)
                                     (symbol-name symbol))
                   (when (and (not (memq ,type '(faces options))) ; groups or t
                              (get symbol 'custom-group))
@@ -2036,7 +2292,7 @@ See `icicle-customize-apropos'."
    (let* ((pred                                    (lambda (s)
                                                      (unless (symbolp s) (setq s  (intern s)))
                                                      (custom-facep s)))
-          (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+          (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
           (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred)))
      (list (completing-read "Customize faces (pattern): " obarray (and icompletep  pred)
                             nil nil 'regexp-history)
@@ -2055,7 +2311,7 @@ See `icicle-customize-apropos'."
    (let* ((pred                                    (lambda (s)
                                                      (unless (symbolp s) (setq s  (intern s)))
                                                      (get s 'custom-group)))
-          (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+          (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
           (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred)))
      (list (completing-read "Customize groups (pattern): " obarray (and icompletep  pred)
                             nil nil 'regexp-history)
@@ -2084,7 +2340,7 @@ the customize buffer."
                                                        (user-variable-p s)
                                                        (and ',pref-arg
                                                         (get s 'variable-documentation))))))
-          (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+          (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
           (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred)))
      (list (completing-read "Customize options (pattern): " obarray (and icompletep  pred)
                             nil nil 'regexp-history)
@@ -2169,11 +2425,9 @@ separate the words (any strings, in fact, including regexps) using
            (mapatoms (lambda (symb) (when (fboundp symb) (put symb 'icicle-special-candidate t))))
            (let ((icicle-fancy-candidates-p  t)
                  (icicle-candidate-alt-action-fn
-                  (or icicle-candidate-alt-action-fn
-                      (icicle-alt-act-fn-for-type "symbol")))
-                 (icicle-all-candidates-list-alt-action-fn
-                  (or icicle-all-candidates-list-alt-action-fn
-                      (icicle-alt-act-fn-for-type "symbol"))))
+                  (or icicle-candidate-alt-action-fn  (icicle-alt-act-fn-for-type "symbol")))
+                 (icicle-all-candidates-list-alt-action-fn ; `M-|'
+                  (or icicle-all-candidates-list-alt-action-fn  (icicle-alt-act-fn-for-type "symbol"))))
              (completing-read "Apropos symbol (regexp or words): " obarray
                               nil nil nil 'regexp-history)))
       (mapatoms (lambda (symb) (put symb 'icicle-special-candidate nil))))
@@ -2208,13 +2462,12 @@ See `icicle-apropos' for a description of PATTERN."
                                                                   (unless (symbolp s) (setq s  (intern s)))
                                                                   (and (boundp s)
                                                                        (get s 'variable-documentation))))
-                     (icompletep                                (and (boundp 'icomplete-mode)
-                                                                     icomplete-mode))
+                     (icompletep                                (and (featurep 'icomplete)  icomplete-mode))
                      (icicle-must-pass-after-match-predicate    (and (not icompletep)  pred))
                      (icicle-candidate-alt-action-fn            (or icicle-candidate-alt-action-fn
                                                                     (icicle-alt-act-fn-for-type "variable")))
-                     (icicle-all-candidates-list-alt-action-fn  (or icicle-all-candidates-list-alt-action-fn
-                                                                    (icicle-alt-act-fn-for-type "variable"))))
+                     (icicle-all-candidates-list-alt-action-fn ; `M-|'
+                      (or icicle-all-candidates-list-alt-action-fn  (icicle-alt-act-fn-for-type "variable"))))
                 (completing-read
                  (concat "Apropos variable (regexp" (and (>= emacs-major-version 22)  " or words")
                          "): ")
@@ -2237,7 +2490,7 @@ See `icicle-apropos' for a description of PATTERN."
       (let* ((pred                                    (lambda (s)
                                                         (unless (symbolp s) (setq s  (intern s)))
                                                         (user-variable-p s)))
-             (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+             (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
              (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred)))
         (list (completing-read
                (concat "Apropos user option (regexp" (and (>= emacs-major-version 22)  " or words")
@@ -2246,7 +2499,7 @@ See `icicle-apropos' for a description of PATTERN."
      (let ((apropos-do-all  nil)
            (icicle-candidate-alt-action-fn
             (or icicle-candidate-alt-action-fn  (icicle-alt-act-fn-for-type "option")))
-           (icicle-all-candidates-list-alt-action-fn
+           (icicle-all-candidates-list-alt-action-fn ; `M-|'
             (or icicle-all-candidates-list-alt-action-fn  (icicle-alt-act-fn-for-type "option"))))
        (when (and (> emacs-major-version 21)  (require 'apropos nil t)
                   (string= (regexp-quote pattern) pattern)
@@ -2271,11 +2524,11 @@ See `icicle-apropos' for a description of PATTERN."
                      (pred                                     (lambda (s)
                                                                  (unless (symbolp s) (setq s  (intern s)))
                                                                  (fboundp s)))
-                     (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+                     (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
                      (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred))
                      (icicle-candidate-alt-action-fn          (or icicle-candidate-alt-action-fn
                                                                   (icicle-alt-act-fn-for-type "function")))
-                     (icicle-all-candidates-list-alt-action-fn
+                     (icicle-all-candidates-list-alt-action-fn ; `M-|'
                       (or icicle-all-candidates-list-alt-action-fn
                           (icicle-alt-act-fn-for-type "function"))))
                 (completing-read
@@ -2299,11 +2552,11 @@ See `icicle-apropos' for a description of PATTERN."
       (let* ((pred                                      (lambda (s)
                                                           (unless (symbolp s) (setq s  (intern s)))
                                                           (commandp s)))
-             (icompletep                                (and (boundp 'icomplete-mode)  icomplete-mode))
+             (icompletep                                (and (featurep 'icomplete)  icomplete-mode))
              (icicle-must-pass-after-match-predicate    (and (not icompletep)  pred))
              (icicle-candidate-alt-action-fn            (or icicle-candidate-alt-action-fn
                                                             (icicle-alt-act-fn-for-type "command")))
-             (icicle-all-candidates-list-alt-action-fn  (or icicle-all-candidates-list-alt-action-fn
+             (icicle-all-candidates-list-alt-action-fn  (or icicle-all-candidates-list-alt-action-fn ; `M-|'
                                                             (icicle-alt-act-fn-for-type "command"))))
         (list (completing-read
                (concat "Apropos command (regexp" (and (>= emacs-major-version 22)  " or words")
@@ -2347,21 +2600,18 @@ using face `icicle-special-candidate'."
                                                                 (lambda (s)
                                                                   (unless (symbolp s) (setq s  (intern s)))
                                                                   (user-variable-p s))))
-                     (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+                     (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
                      (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred))
                      (icicle-candidate-alt-action-fn          (or icicle-candidate-alt-action-fn
                                                                   (icicle-alt-act-fn-for-type
                                                                    (if icicle-fancy-candidates-p
                                                                        "variable"
                                                                      "option"))))
-                     (icicle-all-candidates-list-alt-action-fn
+                     (icicle-all-candidates-list-alt-action-fn ; `M-|'
                       (or icicle-all-candidates-list-alt-action-fn
-                          (icicle-alt-act-fn-for-type (if icicle-fancy-candidates-p
-                                                          "variable"
-                                                        "option")))))
+                          (icicle-alt-act-fn-for-type (if icicle-fancy-candidates-p "variable" "option")))))
                 (completing-read
-                 (concat "Apropos " (if (or current-prefix-arg  apropos-do-all)
-                                        "variable" "user option")
+                 (concat "Apropos " (if (or current-prefix-arg  apropos-do-all) "variable" "user option")
                          " (regexp" (and (>= emacs-major-version 22)  " or words") "): ")
                  obarray (and icompletep  pred) nil nil 'regexp-history)))
          (when (or current-prefix-arg  apropos-do-all)
@@ -2408,21 +2658,20 @@ of strings is used as a word list."
                                                                 (lambda (s)
                                                                   (unless (symbolp s) (setq s  (intern s)))
                                                                   (commandp s))))
-                     (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+                     (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
                      (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred))
                      (icicle-candidate-alt-action-fn           (or icicle-candidate-alt-action-fn
                                                                    (icicle-alt-act-fn-for-type
                                                                     (if icicle-fancy-candidates-p
                                                                         "function"
                                                                       "command"))))
-                     (icicle-all-candidates-list-alt-action-fn
+                     (icicle-all-candidates-list-alt-action-fn ; `M-|'
                       (or icicle-all-candidates-list-alt-action-fn
-                          (icicle-alt-act-fn-for-type (if icicle-fancy-candidates-p
-                                                          "function"
-                                                        "command")))))
+                          (icicle-alt-act-fn-for-type (if icicle-fancy-candidates-p "function" "command")))))
                 (completing-read
                  (concat "Apropos " (if (or current-prefix-arg  apropos-do-all)
-                                        "command or function" "command")
+                                        "command or function"
+                                      "command")
                          " (regexp" (and (>= emacs-major-version 22)  " or words") "): ")
                  obarray (and icompletep  pred) nil nil 'regexp-history)))
          (when (or current-prefix-arg  apropos-do-all)
@@ -2495,6 +2744,9 @@ Return the list of matches."
           (and matches  (princ "\n\n")))))
     matches))                           ; Return matching Zippyisms.
 
+
+(put 'icicle-apropos-value 'icicle-turn-off-icomplete-mode t)
+(put 'icicle-apropos-value 'icicle-turn-off-incremental-completion t)
 (icicle-define-command icicle-apropos-value
   "Choose a variable, function, or other symbol description.
 This is similar to vanilla command `apropos-value', but you can match
@@ -2521,16 +2773,21 @@ none: only user options (+ values)
  > 0: only faces (+ plists)
  = 0: only options (+ values), commands (+ defs), faces (+ plists)
 
-Remember that you can use \\<minibuffer-local-completion-map>\
-`\\[icicle-cycle-incremental-completion]' to toggle incremental completion.
-
 See also:
 * `icicle-apropos-vars-w-val-satisfying',
   `icicle-describe-vars-w-val-satisfying' - values satisfy a predicate
 * `icicle-plist' - similar to this command with positive prefix arg
 * `icicle-vardoc', `icicle-fundoc', `icicle-doc' - match name & doc
 * `icicle-apropos-options-of-type', `icicle-describe-option-of-type' -
-  match name & defcustom type"
+  match name & defcustom type
+
+Because you will often use this command in contexts that result in
+many, many completion candidates, the following are turned off by
+default for this command:
+
+ * Icomplete mode.  You can toggle this using \\<minibuffer-local-completion-map>\
+`\\[icicle-toggle-icomplete-mode]'.
+ * Icicles incremental completion.  You can cycle this using `\\[icicle-cycle-incremental-completion]'."
   icicle-doc-action                     ; Action function
   prompt                                ; `completing-read' args
   (let ((cands  (and (consp pref-arg)  icicle-apropos-value-last-initial-cand-set))
@@ -2549,72 +2806,74 @@ See also:
       (setq icicle-apropos-value-last-initial-cand-set  cands))
     cands)
   nil nil nil nil nil nil
-  ((pref-arg                            current-prefix-arg)
-   (num-arg                             (prefix-numeric-value pref-arg))
-   (prompt                              (format "SYMBOL `C-M-j' %s: " (if pref-arg "INFO" "VALUE"))) ; Bindings
-   (icicle-toggle-transforming-message  (cond ((or (consp pref-arg)  (= num-arg 0))
-                                               "Filtering to OPTIONS, COMMANDS, & FACES is now %s")
-                                              ((and pref-arg  (> num-arg 0))
-                                               "Filtering to FACES (+ plists) is now %s")
-                                              ((< num-arg 0)
-                                               "Filtering to COMMANDS (+ defs) is now %s")
-                                              (t "Filtering to user OPTIONS (+ values) is now %s")))
-   (icicle-candidate-properties-alist   '((1 (face icicle-candidate-part))))
-   (icicle-multi-completing-p           t)
-   (icicle-list-use-nth-parts           '(1))
-   (icicle-transform-before-sort-p      t)
-   (icicle-transform-function           nil) ; No transformation: all symbols.
-   (icicle-last-transform-function      (lambda (cands) ; `C-$': only user options, commands, or faces.
-                                          (loop for cc in cands
-                                                with symb
-                                                do (setq symb  (intern (icicle-transform-multi-completion cc)))
-                                                if (cond ((or (consp `,pref-arg)  (= `,num-arg 0))
-                                                          (or (user-variable-p symb)
-                                                              (commandp symb)
-                                                              (facep symb)))
-                                                         ((and `,pref-arg  (> `,num-arg 0))
-                                                          (facep symb))
-                                                         ((< `,num-arg 0)
-                                                          (commandp symb))
-                                                         (t
-                                                          (user-variable-p symb)))
-                                                collect cc)))
-   (print-fn                            (lambda (obj)
-                                          (let ((print-circle  t))
+  ((pref-arg                              current-prefix-arg) ; Bindings
+   (num-arg                               (prefix-numeric-value pref-arg))
+   (prompt                                (format "SYMBOL `C-M-j' %s: " (if pref-arg "INFO" "VALUE")))
+   (icicle--last-toggle-transforming-msg  icicle-toggle-transforming-message)
+   (icicle-toggle-transforming-message    (cond ((or (consp pref-arg)  (= num-arg 0))
+                                                 "Filtering to OPTIONS, COMMANDS, & FACES is now %s")
+                                                ((and pref-arg  (> num-arg 0))
+                                                 "Filtering to FACES (+ plists) is now %s")
+                                                ((< num-arg 0)
+                                                 "Filtering to COMMANDS (+ defs) is now %s")
+                                                (t "Filtering to user OPTIONS (+ values) is now %s")))
+   (icicle-candidate-properties-alist     '((1 (face icicle-candidate-part))))
+   (icicle-multi-completing-p             t)
+   (icicle-list-use-nth-parts             '(1))
+   (icicle-transform-before-sort-p        t)
+   (icicle-transform-function             nil) ; No transformation: all symbols.
+   (icicle-last-transform-function        (lambda (cands) ; `C-$': only user options, commands, or faces.
+                                            (loop for cc in cands
+                                                  with symb
+                                                  do (setq symb  (intern
+                                                                  (icicle-transform-multi-completion cc)))
+                                                  if (cond ((or (consp `,pref-arg)  (= `,num-arg 0))
+                                                            (or (user-variable-p symb)
+                                                                (commandp symb)
+                                                                (facep symb)))
+                                                           ((and `,pref-arg  (> `,num-arg 0))
+                                                            (facep symb))
+                                                           ((< `,num-arg 0)
+                                                            (commandp symb))
+                                                           (t
+                                                            (user-variable-p symb)))
+                                                  collect cc)))
+   (print-fn                              (lambda (obj)
+                                            (let ((print-circle  t))
 ;;; $$$$$$                                  (condition-case nil
 ;;;                                             (prin1-to-string obj)
 ;;;                                           (error "`icicle-apropos-value' printing error")))))
-                                            (prin1-to-string obj))))
-   (make-cand                           (cond ((< num-arg 0) ; Function
-                                               (lambda (symb)
-                                                 (and (fboundp symb)
-                                                      `((,(symbol-name symb)
-                                                         ,(if (byte-code-function-p (symbol-function symb))
-                                                              ""
-                                                              (funcall print-fn (symbol-function symb))))))))
-                                              ((= num-arg 0) ; Do ALL
-                                               (lambda (symb) ; Favor the var, then the fn, then the plist.
-                                                 (cond ((boundp symb)
-                                                        `((,(symbol-name symb)
-                                                           ,(funcall print-fn (symbol-value symb)))))
-                                                       ((fboundp symb)
+                                              (prin1-to-string obj))))
+   (make-cand                             (cond ((< num-arg 0) ; Function
+                                                 (lambda (symb)
+                                                   (and (fboundp symb)
                                                         `((,(symbol-name symb)
                                                            ,(if (byte-code-function-p (symbol-function symb))
                                                                 ""
-                                                                (funcall print-fn (symbol-function symb))))))
-                                                       ((symbol-plist symb)
+                                                                (funcall print-fn (symbol-function symb))))))))
+                                                ((= num-arg 0) ; Do ALL
+                                                 (lambda (symb) ; Favor the var, then the fn, then the plist.
+                                                   (cond ((boundp symb)
+                                                          `((,(symbol-name symb)
+                                                             ,(funcall print-fn (symbol-value symb)))))
+                                                         ((fboundp symb)
+                                                          `((,(symbol-name symb)
+                                                             ,(if (byte-code-function-p (symbol-function symb))
+                                                                  ""
+                                                                  (funcall print-fn (symbol-function symb))))))
+                                                         ((symbol-plist symb)
+                                                          `((,(symbol-name symb)
+                                                             ,(funcall print-fn (symbol-plist symb))))))))
+                                                ((and pref-arg  (> num-arg 0)) ; Plist
+                                                 (lambda (symb)
+                                                   (and (symbol-plist symb)
                                                         `((,(symbol-name symb)
-                                                           ,(funcall print-fn (symbol-plist symb))))))))
-                                              ((and pref-arg  (> num-arg 0)) ; Plist
-                                               (lambda (symb)
-                                                 (and (symbol-plist symb)
-                                                      `((,(symbol-name symb)
-                                                         ,(funcall print-fn (symbol-plist symb)))))))
-                                              (t ; Variable
-                                               (lambda (symb)
-                                                 (and (boundp symb)
-                                                      `((,(symbol-name symb)
-                                                         ,(funcall print-fn (symbol-value symb))))))))))
+                                                           ,(funcall print-fn (symbol-plist symb)))))))
+                                                (t ; Variable
+                                                 (lambda (symb)
+                                                   (and (boundp symb)
+                                                        `((,(symbol-name symb)
+                                                           ,(funcall print-fn (symbol-value symb))))))))))
   (progn (put-text-property 0 1 'icicle-fancy-candidates t prompt) ; First code.
          (icicle-highlight-lighter)
          (message "Gathering %s%s..." (cond ((consp pref-arg)              'SYMBOLS)
@@ -2628,6 +2887,9 @@ See also:
                         ((and pref-arg  (> num-arg 0)) " and their plists")
                         (t " and their values")))))
 
+
+(put 'icicle-describe-option-of-type 'icicle-turn-off-icomplete-mode t)
+(put 'icicle-describe-option-of-type 'icicle-turn-off-incremental-completion t)
 (icicle-define-command icicle-describe-option-of-type ; Bound to `C-h C-o'.  Command name
   "Describe a user option that was defined with a given `defcustom' type.
 Enter patterns for the OPTION name and TYPE definition in the
@@ -2726,12 +2988,17 @@ If you instead want all Icicles options whose type definition contains
 
  icicle C-M-j string
 
-Remember that you can use `\\<minibuffer-local-completion-map>\
-\\[icicle-cycle-incremental-completion] to toggle incremental completion.
-
 See also:
-* `icicle-apropos-options-of-type', to show options of a given type
-* `icicle-apropos-value', using `C-$' to filter to options only" ; Doc string
+ * `icicle-apropos-options-of-type', to show options of a given type
+ * `icicle-apropos-value', using `C-$' to filter to options only
+
+Because you will often use this command in contexts that result in
+many, many completion candidates, the following are turned off by
+default for this command:
+
+ * Icomplete mode.  You can toggle this using \\<minibuffer-local-completion-map>\
+`\\[icicle-toggle-icomplete-mode]'.
+ * Icicles incremental completion.  You can cycle this using `\\[icicle-cycle-incremental-completion]'."
   icicle-describe-opt-action            ; Action function
   prompt                                ; `completing-read' args
   'icicle-describe-opt-of-type-complete nil nil nil nil nil nil
@@ -2791,7 +3058,7 @@ This is used as the value of `minibuffer-completion-table'."
     (setq result
           (lexical-let ((ops-re  (if (memq icicle-current-completion-mode '(nil apropos))
                                      ops
-                                   (concat "^" ops))))
+                                   (concat "^" (regexp-quote ops)))))
             (icicle-remove-if-not
              (lambda (opt+typ)          ; FREE here: OPS-RE, MODE, TP.
                (and (string-match ops-re (symbol-name (car opt+typ)))
@@ -2905,7 +3172,7 @@ return the symbol with that name."
                                                     (and
                                                      (funcall #',symbpred sy)
                                                      (funcall #',valpred (symbol-value sy)))))
-         (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+         (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
          (icicle-must-pass-after-match-predicate  (and (not icompletep)  varpred))
          (varpat                                  (completing-read
                                                    prompt obarray (and icompletep  varpred) nil nil nil
@@ -2965,8 +3232,8 @@ and `\\[repeat-matching-complex-command]' to match regexp input, but Icicles inp
                                 (prin1-to-string elt))))
                     ;; If command was added to command-history as a string, get rid of that.
                     ;; We want only evaluable expressions there.
-                    (if (stringp (car command-history))
-                        (setq command-history  (cdr command-history))))))
+                    (and (stringp (car command-history))
+                         (setq command-history  (cdr command-history))))))
           ;; If command to be redone does not match front of history, add it to the history.
           (or (equal newcmd (car command-history))
               (setq command-history  (cons newcmd command-history)))
@@ -3435,13 +3702,10 @@ Existence of files with relative names is checked in the Dired
 directory (default directory)."
   (interactive "P")
   ;; $$$$$$$ Maybe filter sets to get only file-name candidate sets?
-  (unless icicle-saved-completion-candidates
-    (icicle-user-error "%s" (substitute-command-keys "No saved completion candidates.  \
-Use \\<minibuffer-local-completion-map>`\\[icicle-candidate-set-save]' to save candidates")))
   (let* ((default-directory           (if prompt-for-dir-p
                                           (read-file-name "Directory: " nil default-directory nil)
                                         default-directory))
-         (icicle-multi-completing-p   t)
+         (icicle-multi-completing-p   t) ; Could have multi-completion saved candidates, from `C-- C-x C-f'.
          (icicle-list-use-nth-parts   '(1))
          (file-names                  (icicle-remove-if
                                        (lambda (fil)
@@ -3452,8 +3716,10 @@ Use \\<minibuffer-local-completion-map>`\\[icicle-candidate-set-save]' to save c
                                                 (mapcar #'icicle-transform-multi-completion
                                                         icicle-saved-completion-candidates))
                                            (icicle-file-list)))))
+    (unless file-names (error "No files or directories chosen"))
     (dired (cons (generate-new-buffer-name "Icy File Set") (nreverse file-names)))))
 
+
 (put 'icicle-dired-saved-file-candidates-other-window 'icicle-Completions-window-max-height 200)
 (defalias 'icicle-dired-chosen-files-other-window 'icicle-dired-saved-file-candidates-other-window)
 (defun icicle-dired-saved-file-candidates-other-window (prompt-for-dir-p) ; Bound `C-M-<' in Dired.
@@ -3471,7 +3737,7 @@ directory (default directory)."
   (let* ((default-directory           (if prompt-for-dir-p
                                           (read-file-name "Directory: " nil default-directory nil)
                                         default-directory))
-         (icicle-multi-completing-p   t)
+         (icicle-multi-completing-p   t) ; Could have multi-completion saved candidates, from `C-- C-x C-f'.
          (icicle-list-use-nth-parts   '(1))
          (file-names                  (icicle-remove-if
                                        (lambda (fil)
@@ -3482,8 +3748,10 @@ directory (default directory)."
                                                 (mapcar #'icicle-transform-multi-completion
                                                         icicle-saved-completion-candidates))
                                            (icicle-file-list)))))
+    (unless file-names (error "No files or directories chosen"))
     (dired-other-window (cons (generate-new-buffer-name "Icy File Set") (nreverse file-names)))))
 
+
 (put 'icicle-dired-project 'icicle-Completions-window-max-height 200)
 (defun icicle-dired-project (prompt-for-dir-p)
   "Open Dired on a saved project.
@@ -3527,6 +3795,7 @@ you use library `Bookmark+'."
                                           file-names))))))
     (define-key minibuffer-local-completion-map (icicle-kbd "C-x m") nil)))
 
+
 (put 'icicle-dired-project-other-window 'icicle-Completions-window-max-height 200)
 (defun icicle-dired-project-other-window (prompt-for-dir-p) ; Bound to `C-{' in Dired.
   "Open Dired on a saved project in another window.
@@ -3623,7 +3892,7 @@ If there is only one candidate, then FINAL-ACTION-FN is called
 immediately.  The candidate is not available to act on (e.g. using
 \\<minibuffer-local-completion-map>`\\[icicle-candidate-alt-action]').
 
-Returns:
+Return:
  The result of executing FINAL-ACTION-FN, if that arg is non-nil.
  Otherwise, `icicle-explore-final-choice-full'.
 
@@ -3636,7 +3905,7 @@ commands, it need not be.  It can be useful anytime you need to use
 \(`C-g'), completion errors, and final actions."
   (let ((icicle-incremental-completion          'always)
         (icicle-whole-candidate-as-text-prop-p  t)
-        (icicle-transform-function              (if (interactive-p) nil icicle-transform-function))
+        (icicle-transform-function              (and (not (interactive-p))  icicle-transform-function))
         (icicle-act-before-cycle-flag           icicle-act-before-cycle-flag)
         (icicle-orig-pt-explore                 (point-marker))
         (icicle-orig-win-explore                (selected-window))
@@ -3700,11 +3969,11 @@ then customize option `icicle-top-level-key-bindings'." ; Doc string
    (pred                                    (lambda (c)
                                               (unless (symbolp c) (setq c  (intern-soft c)))
                                               (commandp c)))
-   (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+   (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
    (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred))
    (icicle-candidate-alt-action-fn          (or icicle-candidate-alt-action-fn
                                                 (setq alt-fn  (icicle-alt-act-fn-for-type "command"))))
-   (icicle-all-candidates-list-alt-action-fn ; M-|'
+   (icicle-all-candidates-list-alt-action-fn ; `M-|'
     (or icicle-all-candidates-list-alt-action-fn  alt-fn  (icicle-alt-act-fn-for-type "command")))
    (icicle--last-toggle-transforming-msg    icicle-toggle-transforming-message)
    (icicle-toggle-transforming-message      "Filtering to commands bound to keys is now %s")
@@ -3723,8 +3992,12 @@ then customize option `icicle-top-level-key-bindings'." ; Doc string
                                                        (and key
                                                             (format "  %s" (icicle-key-description key))))))))
    icicle-new-last-cmd)                 ; Set in `icicle-execute-extended-command-1'.
-  nil  nil                              ; First code, undo code
-  (setq this-command  icicle-new-last-cmd)) ; Last code: this will update `last-command'
+  (define-key minibuffer-local-must-match-map " " 'minibuffer-complete-word) ; First code
+  nil                                   ; Undo code
+  (progn                                ; Last code.  Restore `SPC'.  CMD might turn off Icicle mode...
+    (define-key minibuffer-local-must-match-map
+        " " (if icicle-mode 'icicle-self-insert 'minibuffer-complete-word))
+    (setq this-command  icicle-new-last-cmd))) ; This will update `last-command'.
 
 ;; Free vars here: `icicle-orig-buff' and `icicle-orig-window' are bound by `icicle-define-command'.
 ;;                 `icicle-new-last-cmd' and `icicle-orig-must-pass-after-match-pred' are bound in
@@ -3742,7 +4015,7 @@ then customize option `icicle-top-level-key-bindings'." ; Doc string
          (icicle-toggle-transforming-message        icicle--last-toggle-transforming-msg) ; Restore - FREE HERE
          ;; Rebind alternative action functions to nil, so we don't override the command we call.
          (icicle-candidate-alt-action-fn            nil)
-         (icicle-all-candidates-list-alt-action-fn  nil)
+         (icicle-all-candidates-list-alt-action-fn  nil) ; `M-|'
          ;; Rebind `icicle-candidate-action-fn' to a function that calls the candidate command on a single
          ;; argument that it reads.  This is used only if the command itself reads an input argument with
          ;; completion.  When that is the case, you can use completion on that input, and if you do that,
@@ -3765,7 +4038,6 @@ then customize option `icicle-top-level-key-bindings'." ; Doc string
            (when (> count 1) (message "(%d times)" count)))
           ((commandp cmd)
            (run-hooks 'post-command-hook)
-           (run-hooks 'pre-command-hook)
            (let ((enable-recursive-minibuffers            t)
                  ;; Restore this before we invoke command, since it might use completion.
                  (icicle-must-pass-after-match-predicate  icicle-orig-must-pass-after-match-pred)
@@ -3773,6 +4045,9 @@ then customize option `icicle-top-level-key-bindings'." ; Doc string
                  ;; to be `cmd' during the `C-RET' part, but `last-command' must not be `cmd'
                  ;; during the `next' part.
                  (this-command                            cmd))
+             (run-hooks 'pre-command-hook)
+             (define-key minibuffer-local-must-match-map ; Restore `SPC'.  CMD might turn off Icicle mode...
+                 " " (if icicle-mode 'icicle-self-insert 'minibuffer-complete-word))
              (call-interactively cmd 'record-it)))
           ;; Should not happen, since `icicle-e*-e*-command' calls `completing-read' with non-nil REQUIRE arg.
           (t (error "Not a command: `%s'" cmd-name)))
@@ -3792,7 +4067,7 @@ then customize option `icicle-top-level-key-bindings'." ; Doc string
         (when (and binding  (not (and (vectorp binding)  (eq (aref binding 0) 'mouse-movement))))
           (let ((message-log-max  nil)  ; Do not log this message.
                 ;; If CMD showed a msg in echo area, wait a bit, before showing the key-reminder msg.
-                (waited           (sit-for (if (current-message)  wait-time  0))))
+                (waited           (sit-for (if (current-message) wait-time 0))))
             (when (and waited  (atom unread-command-events))
               (unwind-protect
                    (progn (message "You can invoke command `%s' using `%s'"
@@ -3876,12 +4151,13 @@ You can use `\\[icicle-toggle-annotation]' to toggle showing key bindings as ann
    (pred                                    (lambda (c)
                                               (unless (symbolp c) (setq c  (intern-soft c)))
                                               (commandp c)))
-   (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+   (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
    (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred))
    (icicle-candidate-alt-action-fn          (or icicle-candidate-alt-action-fn
                                                 (setq alt-fn  (icicle-alt-act-fn-for-type "command"))))
-   (icicle-all-candidates-list-alt-action-fn ; M-|'
+   (icicle-all-candidates-list-alt-action-fn ; `M-|'
     (or icicle-all-candidates-list-alt-action-fn  alt-fn  (icicle-alt-act-fn-for-type "command")))
+   (icicle--last-toggle-transforming-msg    icicle-toggle-transforming-message)
    (icicle-toggle-transforming-message      "Filtering to commands bound to keys is now %s")
    (icicle-last-transform-function          (lambda (cands) ; Because we bind `icicle-transform-function'.
                                               (with-current-buffer icicle-pre-minibuffer-buffer
@@ -3916,7 +4192,7 @@ If ABBREV-OR-CMD is not an abbreviation or a command, raise an error."
          (icicle-must-pass-after-match-predicate    icicle-orig-must-pass-after-match-pred)
          ;; Rebind alternative action functions to nil, so we don't override command we call.
          (icicle-candidate-alt-action-fn            nil)
-         (icicle-all-candidates-list-alt-action-fn  nil)
+         (icicle-all-candidates-list-alt-action-fn  nil) ; `M-|'
          (not-cmdp                                  (not (commandp abbrev-or-cmd)))
          (regexp                                    (and (or not-cmdp  icicle-command-abbrev-priority-flag)
                                                          (icicle-command-abbrev-regexp abbrev-or-cmd)))
@@ -3938,7 +4214,8 @@ If ABBREV-OR-CMD is not an abbreviation or a command, raise an error."
                          (let ((enable-recursive-minibuffers  t)
                                (icicle-current-input          abbrev-or-cmd))
                            (icicle-remove-Completions-window)
-                           (icicle-command-abbrev-command)))))
+                           (icicle-command-abbrev-command)
+                           (caar command-history))))) ; CMD read and invoked, to be recorded.
              (icicle-command-abbrev-record abbrev-or-cmd cmd)))
           ((not not-cmdp) (call-interactively abbrev-or-cmd)))))
 
@@ -3977,14 +4254,14 @@ If ABBREV-OR-CMD is not an abbreviation or a command, raise an error."
    (alt-fn                            nil)
    (icicle-candidate-alt-action-fn    (or icicle-candidate-alt-action-fn
                                           (setq alt-fn  (icicle-alt-act-fn-for-type "command"))))
-   (icicle-all-candidates-list-alt-action-fn ; M-|'
+   (icicle-all-candidates-list-alt-action-fn ; `M-|'
     (or icicle-all-candidates-list-alt-action-fn  alt-fn  (icicle-alt-act-fn-for-type "command")))
    (icicle-add-proxy-candidates-flag  nil) ; No abbrevs - just commands here.
    (last-command                      last-command) ; Save and restore the last command.
    icicle-new-last-cmd)                 ; Set in `icicle-execute-extended-command-1'.
   nil nil                               ; First code, undo code
   (setq this-command  icicle-new-last-cmd) ; Last code: this will update `last-command'.
-  'NON-INTERACTIVE)                     ; This is not a real command.
+  'NOT-INTERACTIVE-P)                   ; Not a real command - just a helper function.
 
 (defun icicle-command-abbrev-record (abbrev command)
   "Record ABBREV and COMMAND in `icicle-command-abbrev-alist'."
@@ -4003,17 +4280,17 @@ If ABBREV-OR-CMD is not an abbreviation or a command, raise an error."
               (format " (prefix %d)" (prefix-numeric-value current-prefix-arg))
             ""))
   obarray (and icompletep  pred) t nil 'icicle-kmacro-history nil nil
-  ((last-command                            last-command) ; Save and restore the last command.
+  ((last-command                            last-command) ; Save and restore the last command. (Bindings.)
    (alt-fn                                  nil)
    (icicle-orig-must-pass-after-match-pred  icicle-must-pass-after-match-predicate)
    (pred                                    (lambda (fn)
                                               (unless (symbolp fn) (setq fn  (intern fn)))
                                               (and (commandp fn)  (arrayp (symbol-function fn)))))
-   (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+   (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
    (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred))
    (icicle-candidate-alt-action-fn          (or icicle-candidate-alt-action-fn
                                                 (setq alt-fn  (icicle-alt-act-fn-for-type "command"))))
-   (icicle-all-candidates-list-alt-action-fn ; M-|'
+   (icicle-all-candidates-list-alt-action-fn ; `M-|'
     (or icicle-all-candidates-list-alt-action-fn  alt-fn  (icicle-alt-act-fn-for-type "command")))))
 
 (when (locate-library "kmacro")
@@ -4043,6 +4320,7 @@ an action uses the base prefix arg you used for `icicle-kmacro'."
     (lexical-let ((count  0))
       (setq icicle-kmacro-alist
             (mapcar (lambda (x) (cons (format "%d" (setq count  (1+ count))) x)) ; FREE here: COUNT.
+                    ;; @@@@@@@ Why the (if nil...) here?
                     (reverse (if nil kmacro-ring (cons (kmacro-ring-head) kmacro-ring))))))
     nil 'NO-EXIT-WO-MATCH nil 'icicle-kmacro-history
     (and (kmacro-ring-head)  (null kmacro-ring)  "1") nil
@@ -4058,7 +4336,7 @@ an action uses the base prefix arg you used for `icicle-kmacro'."
     "Action function for `icicle-kmacro'."
     (when (get-buffer icicle-orig-buff) (set-buffer icicle-orig-buff))
     (when (window-live-p icicle-orig-window) (select-window icicle-orig-window))
-    (let* ((count  (if current-prefix-arg (prefix-numeric-value current-prefix-arg) icicle-pref-arg))
+    (let* ((count  (prefix-numeric-value (or current-prefix-arg  icicle-pref-arg)))
            (macro  (cadr (assoc cand icicle-kmacro-alist))))
       (unless macro (error "No such macro: `%s'" cand))
       (execute-kbd-macro macro count #'kmacro-loop-setup-function)
@@ -4095,11 +4373,11 @@ candidates, as follows:
            (lambda (x)
              (unless (symbolp x) (setq x  (intern x)))
              (and (boundp x)  (icicle-binary-option-p x)  (eq nil (symbol-value x)))))))
-   (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+   (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
    (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred))
    (icicle-candidate-alt-action-fn
     (or icicle-candidate-alt-action-fn  (setq alt-fn  (icicle-alt-act-fn-for-type "option"))))
-   (icicle-all-candidates-list-alt-action-fn ; M-|'
+   (icicle-all-candidates-list-alt-action-fn ; `M-|'
     (or icicle-all-candidates-list-alt-action-fn  alt-fn  (icicle-alt-act-fn-for-type "option")))))
 
 (icicle-define-command icicle-clear-history
@@ -4214,11 +4492,11 @@ With a prefix arg, all variables are candidates." ; Doc string
                                               (lambda (x)
                                                 (unless (symbolp x) (setq x  (intern x)))
                                                 (and (boundp x)  (user-variable-p x)  (symbol-value x)))))
-   (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+   (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
    (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred))
    (icicle-candidate-alt-action-fn
     (or icicle-candidate-alt-action-fn  (setq alt-fn  (icicle-alt-act-fn-for-type "option"))))
-   (icicle-all-candidates-list-alt-action-fn ; M-|'
+   (icicle-all-candidates-list-alt-action-fn ; `M-|'
     (or icicle-all-candidates-list-alt-action-fn  alt-fn  (icicle-alt-act-fn-for-type "option")))))
 
 (when (and icicle-define-alias-commands-flag  (not (fboundp 'toggle)))
@@ -4249,11 +4527,11 @@ candidates, as follows:
           (current-prefix-arg (lambda (c) (unless (symbolp c) (setq c  (intern c))) (boundp c)))
           (t                  (lambda (c)
                                 (unless (symbolp c) (setq c  (intern c))) (icicle-binary-option-p c)))))
-   (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+   (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
    (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred))
    (icicle-candidate-alt-action-fn
     (or icicle-candidate-alt-action-fn  (setq alt-fn  (icicle-alt-act-fn-for-type "option"))))
-   (icicle-all-candidates-list-alt-action-fn ; M-|'
+   (icicle-all-candidates-list-alt-action-fn ; `M-|'
     (or icicle-all-candidates-list-alt-action-fn  alt-fn  (icicle-alt-act-fn-for-type "option")))))
 
 (defun icicle-binary-option-p (symbol)
@@ -4279,11 +4557,11 @@ This command needs library `doremi.el'." ; Doc string
    (pred                                    (lambda (symb)
                                               (unless (symbolp symb) (setq symb  (intern-soft symb)))
                                               (memq (get symb 'custom-type) '(number integer float))))
-   (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+   (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
    (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred))
    (icicle-candidate-alt-action-fn
     (or icicle-candidate-alt-action-fn  (setq alt-fn  (icicle-alt-act-fn-for-type "option"))))
-   (icicle-all-candidates-list-alt-action-fn ; M-|'
+   (icicle-all-candidates-list-alt-action-fn ; `M-|'
     (or icicle-all-candidates-list-alt-action-fn  alt-fn  (icicle-alt-act-fn-for-type "option"))))
   (unless (require 'doremi nil t)       ; First code
     (icicle-user-error "You need library `doremi.el' for this command")))
@@ -4313,12 +4591,12 @@ This command needs library `doremi.el'." ; Doc string
                                               (lambda (symb)
                                                 (unless (symbolp symb) (setq symb  (intern symb)))
                                                 (boundp symb))))
-   (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+   (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
    (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred))
    (icicle-candidate-alt-action-fn
     (or icicle-candidate-alt-action-fn
         (setq alt-fn  (icicle-alt-act-fn-for-type (if prefix-arg "option" "variable")))))
-   (icicle-all-candidates-list-alt-action-fn ; M-|'
+   (icicle-all-candidates-list-alt-action-fn ; `M-|'
     (or icicle-all-candidates-list-alt-action-fn alt-fn
         (icicle-alt-act-fn-for-type (if prefix-arg "option" "variable")))))
   (unless (require 'doremi nil t)       ; First code
@@ -4346,7 +4624,7 @@ Raises an error if VARIABLE's value is not a number."
                                                      (lambda (s)
                                                        (unless (symbolp s) (setq s  (intern s)))
                                                        (boundp s))))
-          (icompletep                              (and (boundp 'icomplete-mode)  icomplete-mode))
+          (icompletep                              (and (featurep 'icomplete)  icomplete-mode))
           (icicle-must-pass-after-match-predicate  (and (not icompletep)  pred)))
      (list (intern (completing-read "Increment variable: " obarray (and icompletep  pred) t nil nil
                                     (and symb  (symbol-name symb)) t))
@@ -4364,7 +4642,8 @@ Raises an error if VARIABLE's value is not a number."
           (symbol-value variable)
           increment))
 
-(defun icicle-bookmark-cmd (&optional parg) ; Bound to what `bookmark-set' is bound to (`C-x r m').
+(defun icicle-bookmark-cmd (&optional parg) ; Bound to what `bookmark-set' and
+                                        ; `bmkp-bookmark-set-confirm-overwrite' are bound to (`C-x r m').
   "Set bookmark or visit bookmark(s).
 With a negative prefix arg, visit bookmark(s), using
   `icicle-bookmark-other-window' (see that command for more info).
@@ -4409,10 +4688,11 @@ Otherwise, set a bookmark, as follows:
     that has the same name.
 
 By default, Icicle mode remaps all key sequences that are normally
-bound to `bookmark-set' to `icicle-bookmark-cmd'.  If you do not want
-this remapping, then customize option `icicle-top-level-key-bindings'.
-In particular, you might prefer to remap `bookmark-set' to
-`icicle-bookmark-set' (see Note, above)."
+bound to `bookmark-set' (and `bmkp-bookmark-set-confirm-overwrite', if
+defined) to `icicle-bookmark-cmd'.  If you do not want this remapping,
+then customize option `icicle-top-level-key-bindings'.  In particular,
+you might prefer to remap `bookmark-set' to `icicle-bookmark-set' (see
+Note, above)."
   (interactive "P")
   (if (and parg  (< (prefix-numeric-value parg) 0))
       (icicle-bookmark-other-window)
@@ -4427,12 +4707,16 @@ In particular, you might prefer to remap `bookmark-set' to
                           "\n" " " (substring def-name 0 (min icicle-bookmark-name-length-max
                                                               (length def-name))))))
         (message "Setting bookmark `%s'" trim-name) (sit-for 2)
-        (bookmark-set trim-name (and parg  (or (consp parg)  (zerop (prefix-numeric-value parg)))))))))
+        (funcall (if (fboundp 'bmkp-bookmark-set-confirm-overwrite) ; Defined in `bookmark+-1.el'.
+                     #'bmkp-bookmark-set-confirm-overwrite
+                   #'bookmark-set)
+                 (and parg  (or (consp parg)  (zerop (prefix-numeric-value parg)))))))))
 
 (defun icicle-bookmark-set (&optional name parg interactivep) ; `C-x r m'
-  "With `Bookmark+', this is `bookmark-set' with Icicles multi-completions.
-In particular, you can use (lax) completion for the bookmark name.
-Without `Bookmark+', this is the same as vanilla Emacs `bookmark-set'.
+  "Without `Bookmark+', this is the same as vanilla Emacs `bookmark-set'.
+With `Bookmark+', this is `bmkp-bookmark-set-confirm-overwrite' with
+Icicles multi-completions.  In particular, you can use (lax)
+completion for the bookmark name.
 
 With `Bookmark+':
 
@@ -4464,15 +4748,16 @@ instead of those for the current buffer."
                (prompt                                 "Bookmark: ")
                (icicle-multi-completing-p              icicle-show-multi-completion-flag)
                (icicle-list-use-nth-parts              '(1))
-               (icicle-candidate-properties-alist      (if (not icicle-show-multi-completion-flag)
+               (icicle-candidate-properties-alist      (if (not icicle-multi-completing-p)
                                                            ()
                                                          (if (facep 'file-name-shadow)
                                                              '((2 (face file-name-shadow))
                                                                (3 (face bookmark-menu-heading)))
                                                            '((3 (face bookmark-menu-heading))))))
-               (icicle-transform-function              (if (interactive-p) nil icicle-transform-function))
+               (icicle-transform-function              (and (not (interactive-p))  icicle-transform-function))
                (icicle-whole-candidate-as-text-prop-p  t)
                (icicle-transform-before-sort-p         t)
+               (icicle-candidate-help-fn               'icicle-bookmark-help)
                (icicle-candidates-alist
                 (if (not (featurep 'bookmark+))
                     (mapcar (lambda (cand)
@@ -4516,19 +4801,7 @@ instead of those for the current buffer."
                                  bmkp-local-file-type-cp bmkp-handler-cp)
                                 icicle-alpha-p)))
                         '(("by previous use alphabetically" . icicle-historical-alphabetic-p)
-                          ("case insensitive" . icicle-case-insensitive-string-less-p))))
-               (icicle-candidate-help-fn
-                ;; FREE here: CURRENT-PREFIX-ARG, ICICLE-GET-ALIST-CANDIDATE-FUNCTION,
-                ;;            ICICLE-SHOW-MULTI-COMPLETION-FLAG.
-                (lambda (cand)
-                  (when (and (featurep 'bookmark+)  icicle-show-multi-completion-flag)
-                    (setq cand  (funcall icicle-get-alist-candidate-function cand))
-                    (setq cand  (cons (caar cand) (cdr cand))))
-                  (if (featurep 'bookmark+)
-                      (if current-prefix-arg
-                          (bmkp-describe-bookmark-internals cand)
-                        (bmkp-describe-bookmark cand))
-                    (icicle-msg-maybe-in-minibuffer (icicle-bookmark-help-string cand))))))
+                          ("case insensitive" . icicle-case-insensitive-string-less-p)))))
            (require 'bookmark)
            (when (featurep 'bookmark+)
              ;; Bind keys to narrow bookmark candidates by type.  Lax is for multi-completion case.
@@ -4557,6 +4830,11 @@ instead of those for the current buffer."
                                                                          'bookmark-history
                                                                        'icicle-bookmark-history))))))
              (when (string-equal bname "") (setq bname  defname))
+             (when (and interactivep  (boundp 'bmkp-bookmark-set-confirms-overwrite-p)
+                        bmkp-bookmark-set-confirms-overwrite-p  (atom parg)
+                        (bmkp-get-bookmark-in-alist bname 'NOERROR)
+                        (not (y-or-n-p (format "Overwirte bookmark `%s'? " bname))))
+               (error "OK, canceled"))
              (bookmark-store bname (cdr record) (consp parg))
              (when (and interactivep  bmkp-prompt-for-tags-flag)
                (bmkp-add-tags bname (bmkp-read-tags-completing))) ; Don't bother to refresh tags. (?)
@@ -4616,9 +4894,7 @@ If the option value is nil then DISPLAY is just the bookmark name."
                  (guts      (bookmark-get-bookmark-record bookmark))
                  (file      (bookmark-get-filename bookmark))
                  (buf       (bmkp-get-buffer-name bookmark))
-                 (file/buf  (if (and buf  (equal file bmkp-non-file-filename))
-                                buf
-                              file))
+                 (file/buf  (if (and buf  (equal file bmkp-non-file-filename)) buf file))
                  (tags      (bmkp-get-tags bookmark)))
             (cons `(,(icicle-candidate-short-help
                       (icicle-bookmark-help-string bname)
@@ -4634,6 +4910,96 @@ If the option value is nil then DISPLAY is just the bookmark name."
                 guts)))
     (error nil)))
 
+(defun icicle-bookmark-help-string (bookmark-name)
+  "Return a help string for BOOKMARK-NAME." ; `bmkp-*' functions are defined in `Bookmark+'.
+  ;; Use BOOKMARK-NAME, not full bookmark BMK, as arg to vanilla bookmark functions, for Emacs < 23.
+  (let* ((bmk            (bookmark-get-bookmark bookmark-name))
+         (buf            (and (fboundp 'bmkp-get-buffer-name)  (bmkp-get-buffer-name bmk)))
+         (file           (bookmark-get-filename bookmark-name))
+         (start          (bookmark-get-position bookmark-name))
+         (no-position-p  (not start))
+         (end            (and (fboundp 'bmkp-get-end-position)  (bmkp-get-end-position bmk)))
+         (annot          (bookmark-get-annotation bookmark-name))
+         (sequence-p     (and (fboundp 'bmkp-sequence-bookmark-p)
+                              (bmkp-sequence-bookmark-p bmk)))
+         (function-p     (and (fboundp 'bmkp-function-bookmark-p)
+                              (bmkp-function-bookmark-p bmk)))
+         (blist-p        (and (fboundp 'bmkp-bookmark-list-bookmark-p)
+                              (bmkp-bookmark-list-bookmark-p bmk)))
+         (desktop-p      (and (fboundp 'bmkp-desktop-bookmark-p)
+                              (bmkp-desktop-bookmark-p bmk)))
+         (dired-p        (and (fboundp 'bmkp-dired-bookmark-p)  (bmkp-dired-bookmark-p bmk)))
+         (gnus-p         (and (fboundp 'bmkp-gnus-bookmark-p)  (bmkp-gnus-bookmark-p bmk)))
+         (info-p         (and (fboundp 'bmkp-info-bookmark-p)  (bmkp-info-bookmark-p bmk)))
+         (man-p          (and (fboundp 'bmkp-man-bookmark-p)  (bmkp-man-bookmark-p bmk)))
+         (url-p          (and (fboundp 'bmkp-url-bookmark-p)  (bmkp-url-bookmark-p bmk)))
+         type-info-p)
+    (when (or sequence-p  function-p) (setq no-position-p  t))
+    (concat (setq type-info-p
+                  (cond (sequence-p (format "Sequence: %S" (bookmark-prop-get bmk 'sequence)))
+                        (function-p (let ((fn  (bookmark-prop-get bmk 'function)))
+                                      (if (symbolp fn) (format "Function: `%s'" fn) "Function")))
+                        (desktop-p  "Desktop, ")
+                        (dired-p    (format "Dired %s, " file))
+                        (gnus-p     "Gnus, ")
+                        (info-p     "Info, ")
+                        (man-p      (let ((man-args  (bookmark-prop-get bmk 'man-args)))
+                                      (if man-args
+                                          (format "`man %s', " man-args)
+                                        ;; WoMan has no variable for the cmd name.
+                                        (format "%s, " (bookmark-prop-get bmk 'buffer-name)))))
+                        (url-p      "URL, ")
+                        (t nil)))
+            (and (not dired-p)
+                 (or (and file  (or (not (boundp 'bmkp-non-file-filename))
+                                    (not (equal file bmkp-non-file-filename)))
+                          (format (if type-info-p "file `%s', " "File `%s', ") file))
+                     (and buf  (format (if type-info-p "buffer `%s', " "Buffer `%s', ") buf))))
+            (and (not no-position-p)
+                 (if (and end  (> (- end start) 0))
+                     (format "from %d to %d (%d chars)" start end (- end start))
+                   (format "position %d" start)))
+            (and annot  (format ", %s" annot)))))
+
+(defun icicle-bookmark-help (cand)
+  "Icicles help function for a bookmark candidate."
+  ;; FREE here: CURRENT-PREFIX-ARG, ICICLE-GET-ALIST-CANDIDATE-FUNCTION, ICICLE-MULTI-COMPLETING-P.
+  (when (and (featurep 'bookmark+)  icicle-multi-completing-p)
+    (setq cand  (funcall icicle-get-alist-candidate-function cand))
+    (setq cand  (cons (caar cand) (cdr cand))))
+  (if (featurep 'bookmark+)
+      (if current-prefix-arg
+          (bmkp-describe-bookmark-internals cand)
+        (bmkp-describe-bookmark cand))
+    (icicle-msg-maybe-in-minibuffer (icicle-bookmark-help-string cand))))
+
+(defun icicle-bookmark-act-on-prop (cand)
+  "Apply a function to a bookmark property.  You choose both.
+The argument is a bookmark name or a multi-completion with 3 parts:
+
+    a. the bookmark name
+    b. the bookmark file or buffer name
+    c. any tags"
+  (when (and (featurep 'bookmark+)  icicle-multi-completing-p)
+    (setq cand  (funcall icicle-get-alist-candidate-function cand))
+    (setq cand  (cons (caar cand) (cdr cand))))
+  (let* ((enable-recursive-minibuffers  t)
+         (full-bmk                      (bookmark-get-bookmark cand))
+         (props                         `("bookmark-name"
+                                          ,@(mapcar (lambda (data) (symbol-name (car data)))
+                                                    (bmkp-bookmark-data-from-record full-bmk))))
+         (property                      (intern (completing-read "Bookmark property to act on: "
+                                                                 (mapcar #'list props) nil t)))
+         (result                        (condition-case err
+                                            (funcall (read (completing-read "Function to apply to property: "
+                                                                            obarray 'functionp))
+                                                     (if (eq 'bookmark-name property)
+                                                         (bmkp-bookmark-name-from-record full-bmk)
+                                                       (bookmark-prop-get full-bmk property)))
+                                          (error (concat "ERROR: " (message (error-message-string err)))))))
+    (pp-eval-expression `',result)
+    result))
+
 (icicle-define-command icicle-bookmark  ; Bound to `C-x j j', `C-x p b', `C-x r b'.
   "Jump to a bookmark.
 With a plain prefix argument (`C-u'), reverse the effect of option
@@ -4720,6 +5086,12 @@ If you also use library `Bookmark+', then:
    See also the individual multi-commands for different bookmark
    types: `icicle-bookmark-info-other-window' etc.
 
+ * `C-S-RET', the alternative candidate action, prompts you for a
+   property of the candidate bookmark and a function, then applies the
+   function to the property.  Completion is available for the
+   properties (and symbol functions).  You can also use a lambda sexp
+   as the function.
+
 If you also use library `crosshairs.el', then the visited bookmark
 position is highlighted."               ; Doc string
   (lambda (cand) (icicle-bookmark-jump (icicle-transform-multi-completion cand))) ; Action
@@ -4731,15 +5103,17 @@ position is highlighted."               ; Doc string
    (prompt                                 "Bookmark: ")
    (icicle-multi-completing-p              icicle-show-multi-completion-flag)
    (icicle-list-use-nth-parts              '(1))
-   (icicle-candidate-properties-alist      (if (not icicle-show-multi-completion-flag)
+   (icicle-candidate-properties-alist      (if (not icicle-multi-completing-p)
                                                ()
                                              (if (facep 'file-name-shadow)
                                                  '((2 (face file-name-shadow))
                                                    (3 (face bookmark-menu-heading)))
                                                '((3 (face bookmark-menu-heading))))))
-   (icicle-transform-function              (if (interactive-p) nil icicle-transform-function))
+   (icicle-transform-function              (and (not (interactive-p))  icicle-transform-function))
    (icicle-whole-candidate-as-text-prop-p  t)
    (icicle-transform-before-sort-p         t)
+   (icicle-candidate-help-fn               'icicle-bookmark-help)
+   (icicle-candidate-alt-action-fn         (or icicle-candidate-alt-action-fn  'icicle-bookmark-act-on-prop))
    (icicle-delete-candidate-object         'icicle-bookmark-delete-action)
    (icicle-sort-orders-alist
     (append '(("in *Bookmark List* order") ; Renamed from "turned OFF'.
@@ -4767,16 +5141,6 @@ position is highlighted."               ; Doc string
                     icicle-alpha-p)))
             '(("by previous use alphabetically" . icicle-historical-alphabetic-p)
               ("case insensitive" . icicle-case-insensitive-string-less-p))))
-   (icicle-candidate-help-fn
-    ;; FREE here: CURRENT-PREFIX-ARG, ICICLE-GET-ALIST-CANDIDATE-FUNCTION,
-    ;;            ICICLE-SHOW-MULTI-COMPLETION-FLAG.
-    (lambda (cand)
-      (when (and (featurep 'bookmark+)  icicle-show-multi-completion-flag)
-        (setq cand  (funcall icicle-get-alist-candidate-function cand)
-              cand  (cons (caar cand) (cdr cand))))
-      (if (featurep 'bookmark+)
-          (if current-prefix-arg (bmkp-describe-bookmark-internals cand) (bmkp-describe-bookmark cand))
-        (icicle-msg-maybe-in-minibuffer (icicle-bookmark-help-string cand)))))
    (icicle-candidates-alist
     (if (not (featurep 'bookmark+))
         (mapcar (lambda (cand)
@@ -4812,15 +5176,17 @@ Same as `icicle-bookmark', but uses another window." ; Doc string
    (prompt                                 "Bookmark: ")
    (icicle-multi-completing-p              icicle-show-multi-completion-flag)
    (icicle-list-use-nth-parts              '(1))
-   (icicle-candidate-properties-alist      (if (not icicle-show-multi-completion-flag)
+   (icicle-candidate-properties-alist      (if (not icicle-multi-completing-p)
                                                ()
                                              (if (facep 'file-name-shadow)
                                                  '((2 (face file-name-shadow))
                                                    (3 (face bookmark-menu-heading)))
                                                '((3 (face bookmark-menu-heading))))))
-   (icicle-transform-function              (if (interactive-p) nil icicle-transform-function))
+   (icicle-transform-function              (and (not (interactive-p))  icicle-transform-function))
    (icicle-whole-candidate-as-text-prop-p  t)
    (icicle-transform-before-sort-p         t)
+   (icicle-candidate-help-fn               'icicle-bookmark-help)
+   (icicle-candidate-alt-action-fn         (or icicle-candidate-alt-action-fn  'icicle-bookmark-act-on-prop))
    (icicle-delete-candidate-object         'icicle-bookmark-delete-action)
    (icicle-sort-orders-alist
     (append '(("in *Bookmark List* order") ; Renamed from "turned OFF'.
@@ -4848,18 +5214,6 @@ Same as `icicle-bookmark', but uses another window." ; Doc string
                     icicle-alpha-p)))
             '(("by previous use alphabetically" . icicle-historical-alphabetic-p)
               ("case insensitive" . icicle-case-insensitive-string-less-p))))
-   (icicle-candidate-help-fn
-    ;; FREE here: CURRENT-PREFIX-ARG, ICICLE-GET-ALIST-CANDIDATE-FUNCTION,
-    ;;            ICICLE-SHOW-MULTI-COMPLETION-FLAG.
-    (lambda (cand)
-      (when (and (featurep 'bookmark+)  icicle-show-multi-completion-flag)
-        (setq cand  (funcall icicle-get-alist-candidate-function cand))
-        (setq cand  (cons (caar cand) (cdr cand))))
-      (if (featurep 'bookmark+)
-          (if current-prefix-arg
-              (bmkp-describe-bookmark-internals cand)
-            (bmkp-describe-bookmark cand))
-        (icicle-msg-maybe-in-minibuffer (icicle-bookmark-help-string cand)))))
    (icicle-candidates-alist
     (if (not (featurep 'bookmark+))
         (mapcar (lambda (cand)
@@ -4974,17 +5328,37 @@ Same as `icicle-bookmark', but uses another window." ; Doc string
 (defun icicle-bookmark-jump (bookmark)
   "Jump to BOOKMARK.
 If `crosshairs.el' is loaded, then highlight the target position.
-You probably don't want to use this.  Use `icicle-bookmark' instead."
-  (interactive (list (bookmark-completing-read "Jump to bookmark" bookmark-current-bookmark)))
+You probably do not want to use this.  Use `icicle-bookmark' instead.
+
+If you also use library `Bookmark+', then:
+
+ * `C-M-return' shows detailed info about the current bookmark candidate.
+   `C-u C-M-return' shows the complete, internal info for the bookmark.
+   Likewise, for the other candidate help keys: `C-M-down' etc.
+   (And the mode line always shows summary info about the bookmark.)
+
+ * `C-S-RET', the alternative candidate action, prompts you for a
+   property of the candidate bookmark and a function, then applies the
+   function to the property.  Completion is available for the
+   properties (and symbol functions).  You can also use a lambda sexp
+   as the function."
+  (interactive
+   (list (let ((icicle-candidate-help-fn        'icicle-bookmark-help)
+               (icicle-candidate-alt-action-fn  (or icicle-candidate-alt-action-fn
+                                                    'icicle-bookmark-act-on-prop)))
+           (bookmark-completing-read "Jump to bookmark" bookmark-current-bookmark))))
   (icicle-bookmark-jump-1 bookmark))
 
 (defun icicle-bookmark-jump-other-window (bookmark)
   "Jump to BOOKMARK in another window.
-If `crosshairs.el' is loaded, then highlight the target position.
-You probably don't want to use this.  Use
+Same as `icicle-bookmark-jump', but uses another window.
+You probably do not want to use this.  Use
 `icicle-bookmark-other-window' instead."
-  (interactive (list (bookmark-completing-read "Jump to bookmark (other window)"
-                                               bookmark-current-bookmark)))
+  (interactive
+   (list (let ((icicle-candidate-help-fn        'icicle-bookmark-help)
+               (icicle-candidate-alt-action-fn  (or icicle-candidate-alt-action-fn
+                                                    'icicle-bookmark-act-on-prop)))
+           (bookmark-completing-read "Jump to bookmark (other window)" bookmark-current-bookmark))))
   (icicle-bookmark-jump-1 bookmark 'other-window))
 
 (defun icicle-bookmark-jump-1 (bookmark &optional other-window-p)
@@ -5013,57 +5387,6 @@ You probably don't want to use this.  Use
 ;; $$$$$$   (select-window (minibuffer-window))
 ;; $$$$$$   (select-frame-set-input-focus (selected-frame)))
 
-(defun icicle-bookmark-help-string (bookmark-name)
-  "Return a help string for BOOKMARK-NAME." ; `bmkp-*' functions are defined in `Bookmark+'.
-  ;; Use BOOKMARK-NAME, not full bookmark BMK, as arg to vanilla bookmark functions, for Emacs < 23.
-  (let* ((bmk            (bookmark-get-bookmark bookmark-name))
-         (buf            (and (fboundp 'bmkp-get-buffer-name)  (bmkp-get-buffer-name bmk)))
-         (file           (bookmark-get-filename bookmark-name))
-         (start          (bookmark-get-position bookmark-name))
-         (no-position-p  (not start))
-         (end            (and (fboundp 'bmkp-get-end-position)  (bmkp-get-end-position bmk)))
-         (annot          (bookmark-get-annotation bookmark-name))
-         (sequence-p     (and (fboundp 'bmkp-sequence-bookmark-p)
-                              (bmkp-sequence-bookmark-p bmk)))
-         (function-p     (and (fboundp 'bmkp-function-bookmark-p)
-                              (bmkp-function-bookmark-p bmk)))
-         (blist-p        (and (fboundp 'bmkp-bookmark-list-bookmark-p)
-                              (bmkp-bookmark-list-bookmark-p bmk)))
-         (desktop-p      (and (fboundp 'bmkp-desktop-bookmark-p)
-                              (bmkp-desktop-bookmark-p bmk)))
-         (dired-p        (and (fboundp 'bmkp-dired-bookmark-p)  (bmkp-dired-bookmark-p bmk)))
-         (gnus-p         (and (fboundp 'bmkp-gnus-bookmark-p)  (bmkp-gnus-bookmark-p bmk)))
-         (info-p         (and (fboundp 'bmkp-info-bookmark-p)  (bmkp-info-bookmark-p bmk)))
-         (man-p          (and (fboundp 'bmkp-man-bookmark-p)  (bmkp-man-bookmark-p bmk)))
-         (url-p          (and (fboundp 'bmkp-url-bookmark-p)  (bmkp-url-bookmark-p bmk)))
-         type-info-p)
-    (when (or sequence-p  function-p) (setq no-position-p  t))
-    (concat (setq type-info-p
-                  (cond (sequence-p (format "Sequence: %S" (bookmark-prop-get bmk 'sequence)))
-                        (function-p (let ((fn  (bookmark-prop-get bmk 'function)))
-                                      (if (symbolp fn) (format "Function: `%s'" fn) "Function")))
-                        (desktop-p  "Desktop, ")
-                        (dired-p    (format "Dired %s, " file))
-                        (gnus-p     "Gnus, ")
-                        (info-p     "Info, ")
-                        (man-p      (let ((man-args  (bookmark-prop-get bmk 'man-args)))
-                                      (if man-args
-                                          (format "`man %s', " man-args)
-                                        ;; WoMan has no variable for the cmd name.
-                                        (format "%s, " (bookmark-prop-get bmk 'buffer-name)))))
-                        (url-p      "URL, ")
-                        (t nil)))
-            (and (not dired-p)
-                 (or (and file  (or (not (boundp 'bmkp-non-file-filename))
-                                    (not (equal file bmkp-non-file-filename)))
-                          (format (if type-info-p "file `%s', " "File `%s', ") file))
-                     (and buf  (format (if type-info-p "buffer `%s', " "Buffer `%s', ") buf))))
-            (and (not no-position-p)
-                 (if (and end  (> (- end start) 0))
-                     (format "from %d to %d (%d chars)" start end (- end start))
-                   (format "position %d" start)))
-            (and annot  (format ", %s" annot)))))
-
 ;;; MUST keep this synchronized with any general Icicle-mode `C-M-' bindings in `icicles-mode.el'.
 ;;  That includes things like `icicle-read+insert-file-name-keys'.
 (defun icicle-bookmark-cleanup ()
@@ -5387,13 +5710,13 @@ You are prompted for the FILES."
 (icicle-define-bookmark-other-window-command "some-tags" nil                              ; `C-x 4 j t +'
                                              (bmkp-read-tags-completing nil nil current-prefix-arg))
 (icicle-define-bookmark-command              "all-tags-regexp" nil                        ; `C-x j t % *'
-                                             (read-string "Regexp for tags: "))
+                                             (icicle-read-regexp "Regexp for tags: "))
 (icicle-define-bookmark-other-window-command "all-tags-regexp" nil                        ; `C-x 4 j t % *'
-                                             (read-string "Regexp for tags: "))
+                                             (icicle-read-regexp "Regexp for tags: "))
 (icicle-define-bookmark-command              "some-tags-regexp" nil                       ; `C-x j t % +'
-                                             (read-string "Regexp for tags: "))
+                                             (icicle-read-regexp "Regexp for tags: "))
 (icicle-define-bookmark-other-window-command "some-tags-regexp" nil                       ; `C-x 4 j t % +'
-                                             (read-string "Regexp for tags: "))
+                                             (icicle-read-regexp "Regexp for tags: "))
 (icicle-define-bookmark-command              "file-all-tags" nil                          ; `C-x j t f *'
                                              (bmkp-read-tags-completing nil nil current-prefix-arg))
 (icicle-define-bookmark-other-window-command "file-all-tags" nil                          ; `C-x 4 j t f *'
@@ -5403,13 +5726,13 @@ You are prompted for the FILES."
 (icicle-define-bookmark-other-window-command "file-some-tags" nil                         ; `C-x 4 j t f +'
                                              (bmkp-read-tags-completing nil nil current-prefix-arg))
 (icicle-define-bookmark-command              "file-all-tags-regexp" nil                   ; `C-x j t f % *'
-                                             (read-string "Regexp for tags: "))
+                                             (icicle-read-regexp "Regexp for tags: "))
 (icicle-define-bookmark-other-window-command "file-all-tags-regexp" nil                   ; `C-x 4 j t f % *'
-                                             (read-string "Regexp for tags: "))
+                                             (icicle-read-regexp "Regexp for tags: "))
 (icicle-define-bookmark-command              "file-some-tags-regexp" nil                  ; `C-x j t f % +'
-                                             (read-string "Regexp for tags: "))
+                                             (icicle-read-regexp "Regexp for tags: "))
 (icicle-define-bookmark-other-window-command "file-some-tags-regexp" nil                  ; `C-x 4 j t f % +'
-                                             (read-string "Regexp for tags: "))
+                                             (icicle-read-regexp "Regexp for tags: "))
 (icicle-define-bookmark-command              "file-this-dir-all-tags" nil                 ; `C-x j t . f *'
                                              (bmkp-read-tags-completing nil nil current-prefix-arg))
 (icicle-define-bookmark-other-window-command "file-this-dir-all-tags" nil                 ; `C-x 4 j t . f *'
@@ -5419,13 +5742,13 @@ You are prompted for the FILES."
 (icicle-define-bookmark-other-window-command "file-this-dir-some-tags" nil                ; `C-x 4 j t . f +'
                                              (bmkp-read-tags-completing nil nil current-prefix-arg))
 (icicle-define-bookmark-command              "file-this-dir-all-tags-regexp" nil          ; `C-x j t . f % *'
-                                             (read-string "Regexp for tags: "))
+                                             (icicle-read-regexp "Regexp for tags: "))
 (icicle-define-bookmark-other-window-command "file-this-dir-all-tags-regexp" nil          ; `C-x 4 j t . f % *'
-                                             (read-string "Regexp for tags: "))
+                                             (icicle-read-regexp "Regexp for tags: "))
 (icicle-define-bookmark-command              "file-this-dir-some-tags-regexp" nil         ; `C-x j t . f % +'
-                                             (read-string "Regexp for tags: "))
+                                             (icicle-read-regexp "Regexp for tags: "))
 (icicle-define-bookmark-other-window-command "file-this-dir-some-tags-regexp" nil         ; `C-x 4 j t . f % +'
-                                             (read-string "Regexp for tags: "))
+                                             (icicle-read-regexp "Regexp for tags: "))
 (icicle-define-bookmark-command              "url")                                       ; `C-x j u'
 (icicle-define-bookmark-other-window-command "url")                                       ; `C-x 4 j u'
 (icicle-define-bookmark-command              "w3m")                                       ; `C-x j w'
@@ -5612,7 +5935,7 @@ See `icicle-explore', argument DEFINE-CANDIDATES-FN."
 
 (defun icicle-find-tag-define-candidates-1 (regexp show-file-p)
   "Helper function for `icicle-find-tag-define-candidates'.
-Returns completion alist of tag information for tags matching REGEXP.
+Return completion alist of tag information for tags matching REGEXP.
 Include file name (label) if SHOW-FILE-P is non-nil.
 
 If SHOW-FILE-P is nil, then alist items look like this:
@@ -5645,11 +5968,11 @@ Either LINE or POSITION can be nil.  POSITION is used if present."
              ;; TAG-INFO: If no specific tag, (t nil (point-min)). Else, (TEXT LINE . STARTPOS).
              ;; e.g. TEXT = "(defun foo ()" or just "foo" (if explicit),
              ;;      LINE = "148", STARTPOS = "1723"
-             (tag-info (save-excursion (funcall snarf-tag-function))) ; e.g. `etags-snarf-tag'.
-             (tag (if (eq t (car tag-info)) nil (car tag-info)))
+             (tag-info   (save-excursion (funcall snarf-tag-function))) ; e.g. `etags-snarf-tag'.
+             (tag        (and (not (eq t (car tag-info)))  (car tag-info)))
              ;; FILE-PATH is absolute. FILE-LABEL is relative to `default-directory'.
-             (file-path (save-excursion
-                          (if tag (file-of-tag) (save-excursion (next-line 1) (file-of-tag)))))
+             (file-path  (save-excursion
+                           (if tag (file-of-tag) (save-excursion (next-line 1) (file-of-tag)))))
              (file-label (expand-file-name file-path (file-truename default-directory))))
         (when (and tag  (not (string= "" tag))  (= (aref tag 0) ?\( ))
           (setq tag  (concat tag " ...)")))
@@ -5783,7 +6106,7 @@ the frames will be called `*Help*[2]' for use with this command." ; Doc string
    (alt-fn              nil)
    (icicle-candidate-alt-action-fn
     (or icicle-candidate-alt-action-fn  (setq alt-fn  (icicle-alt-act-fn-for-type "frame"))))
-   (icicle-all-candidates-list-alt-action-fn ; M-|'
+   (icicle-all-candidates-list-alt-action-fn ; `M-|'
     (or icicle-all-candidates-list-alt-action-fn  alt-fn  (icicle-alt-act-fn-for-type "frame")))))
 
 (defun icicle-select-frame-by-name (name &optional frame-alist)
@@ -5793,7 +6116,7 @@ Each element has the form (FNAME . FRAME), where FNAME names FRAME.
 See `icicle-make-frame-alist' for more about FNAME."
   (interactive (let* ((alist    (icicle-make-frame-alist))
                       (default  (car (rassoc (selected-frame) alist)))
-                      (input    (completing-read "Select Frame: " alist nil t nil
+                      (input    (completing-read "Select frame: " alist nil t nil
                                                  'frame-name-history default)))
                  (list (if (= (length input) 0) default input)
                        alist)))
@@ -5856,7 +6179,7 @@ WINDOW.  See `icicle-make-window-alist' for more about WNAME.
 If `crosshairs.el' is loaded, then the target position is highlighted."
   (interactive (let* ((alist    (icicle-make-window-alist current-prefix-arg))
                       (default  (car (rassoc (selected-window) alist)))
-                      (input    (completing-read "Select Window: " alist nil t nil nil default)))
+                      (input    (completing-read "Select window: " alist nil t nil nil default)))
                  (list (if (= (length input) 0) default input) alist)))
   (unless window-alist
     (setq window-alist  (or (and (boundp 'icicle-window-alist)  icicle-window-alist)
@@ -5907,7 +6230,7 @@ Otherwise, use only windows from the selected frame."
    (icicle-inhibit-try-switch-buffer      t)
    (icicle-candidate-alt-action-fn
     (or icicle-candidate-alt-action-fn  (icicle-alt-act-fn-for-type "buffer")))
-   (icicle-all-candidates-list-alt-action-fn ; M-|'
+   (icicle-all-candidates-list-alt-action-fn ; `M-|'
     (or icicle-all-candidates-list-alt-action-fn  (icicle-alt-act-fn-for-type "buffer")))))
 
 (defun icicle-delete-window (bufferp)   ; Bound to `C-x 0' in Icicle mode.
@@ -5959,12 +6282,15 @@ this remapping, then customize option
 `icicle-top-level-key-bindings'."       ; Doc string
   icicle-kill-a-buffer-and-update-completions ; Action function
   (icicle-buffer-name-prompt "Kill")    ; `completing-read' args
-  (mapcar (lambda (buf) (list (buffer-name buf))) icicle-bufflist) nil ; `icicle-bufflist' is free.
+  (mapcar (lambda (buf) (list (buffer-name buf))) icicle-bufflist) nil ; `icicle-bufflist' is free here.
   (and (fboundp 'confirm-nonexistent-file-or-buffer)  (confirm-nonexistent-file-or-buffer)) ; Emacs 23.
-  nil 'buffer-name-history (buffer-name (current-buffer)) nil
-  (icicle-buffer-bindings)              ; Bindings
-  ;; Actually, there is no reason to bind `C-x m' to `icicle-bookmark-non-file-other-window' here,
-  ;; but to keep things simple we do it anyway.
+  nil 'buffer-name-history (if (< emacs-major-version 23)
+                               (buffer-name (current-buffer))
+                             (cons (buffer-name (current-buffer))
+                                   (icicle-default-buffer-names current-prefix-arg)))
+  nil
+  (icicle-buffer-bindings               ; Bindings
+   ((icicle-use-candidates-only-once-flag  t)))
   (icicle-bind-buffer-candidate-keys)   ; First code
   nil                                   ; Undo code
   (icicle-unbind-buffer-candidate-keys)) ; Last code
@@ -5975,6 +6301,8 @@ ACTION is the command action, a string.  It starts the prompt.
 Non-nil OTHER-WINDOW-P appends \" in other window\" to the prompt."
   (concat  (cond ((null current-prefix-arg)
                   (format "%s buffer" action))
+                 ((and (consp current-prefix-arg)  (> (prefix-numeric-value current-prefix-arg) 16)) ; 3 `C-u'
+                  (format "%s invisible buffer" action))
                  ((and (consp current-prefix-arg)  (> (prefix-numeric-value current-prefix-arg) 4)) ; `C-u C-u'
                   (format "%s visible buffer" action))
                  ((and (consp current-prefix-arg)  (fboundp 'derived-mode-p)) ; `C-u'
@@ -5998,8 +6326,6 @@ Non-nil OTHER-WINDOW-P appends \" in other window\" to the prompt."
             (if (fboundp 'kill-buffer-and-its-windows)
                 (kill-buffer-and-its-windows buf) ; Defined in `misc-cmds.el'.
               (kill-buffer buf))
-            ;; Update the set of completions, then update `*Completions*'.
-            (setq minibuffer-completion-table  (mapcar (lambda (buf) (list (buffer-name buf))) (buffer-list)))
             (icicle-complete-again-update))
         (error nil))
     (message "No such live buffer: `%s'" buf)))
@@ -6058,6 +6384,10 @@ depending on the prefix arg:
 * Plain prefix arg (`C-u'): buffers with the same mode as current,
   or with a mode that the current mode is derived from
 * Double plain (`C-u C-u'): visible buffers (possibly iconified)
+* Triple plain (`C-u C-u C-u'): invisible buffers
+
+Those are the default prefix-argument behaviors, but you can change
+them using option `icicle-buffer-prefix-arg-filtering'.
 
 For Emacs 23 and later, the default values (via `M-n') are the
 \(buffer-name components of the) first four completion candidates
@@ -6079,6 +6409,9 @@ You can use these additional keys during completion:
 * `C-x v +'   Keep only buffers that are visible (maybe iconified).
 * `\\[icicle-delete-candidate-object]'  Kill the buffer named by a completion candidate.
 
+Those are default key bindings, but you can change them using option
+`icicle-buffer-candidate-key-bindings'.
+
 These options, when non-nil, control candidate matching and filtering:
 
  `icicle-buffer-extras'             - Extra buffers to display
@@ -6089,8 +6422,8 @@ These options, when non-nil, control candidate matching and filtering:
  `icicle-buffer-no-match-regexp'    - Regexp buffers must not match
  `icicle-buffer-predicate'          - Predicate buffer names satisfy
  `icicle-buffer-sort'               - Sort function for candidates
- `icicle-buffer-skip-hook'          - Exclude from content searching
- `icicle-find-file-of-content-skip-hook' - Same, cached/recent files
+ `icicle-buffer-skip-functions'     - Exclude from content searching
+ `icicle-file-skip-functions'       - Same, but cached/recent files
 
 For example, to change the default behavior to show only buffers that
 are associated with files, set `icicle-buffer-predicate' to this:
@@ -6147,15 +6480,20 @@ the behavior."                          ; Doc string
 For Emacs 23+, up to six names are returned.
 
 Optional ARG is used only for Emacs 23+.  Its meaning is the same as
-the prefix argument in Icicles buffer commands - it determines what
-kinds of buffers to include:
- * nil       :  all buffers
+the prefix argument in Icicles buffer commands, except that it
+determines which kinds of buffers to include as default values, not as
+completion candidates:
+
+ * nil       : all buffers, and the first default is `other-buffer'
  * Number > 0: buffers visiting files or directories (Dired)
  * Number < 0: buffers associated with the selected frame
  * Number = 0: buffers with the same mode as the current buffer
- * Cons      : buffers with the same mode as current, or with
+ * (4)       : buffers with the same mode as current, or with
                a mode that the current mode is derived from
-When ARG is nil, the first buffer is `other-buffer'."
+ * (16)      : visible buffers
+ * (64)      : invisible buffers
+
+In any case, the current buffer is always excluded."
   (if (< emacs-major-version 23)
       (let ((bname  (buffer-name (if (fboundp 'another-buffer) ; In `misc-fns.el'.
                                      (another-buffer nil t)
@@ -6164,7 +6502,7 @@ When ARG is nil, the first buffer is `other-buffer'."
             (car icicle-bufflist)
           bname))
     ;; Emacs 23 accepts a list of default values.  ; Just keep the first 4.  (This could be an option.)
-    (let* ((bfnames  (mapcar #'buffer-name (delete (current-buffer) (or icicle-bufflist  (buffer-list))))))
+    (let ((bfnames  (mapcar #'buffer-name (delete (current-buffer) (or icicle-bufflist  (buffer-list))))))
       (when icicle-buffer-ignore-space-prefix-flag
         (setq bfnames  (icicle-remove-if (lambda (bfname) (icicle-string-match-p "^ " bfname)) bfnames)))
       (let ((six  (icicle-first-N 6 bfnames)))
@@ -6221,7 +6559,7 @@ Used as the value of `icicle-buffer-complete-fn' and hence as
                                  (icicle-transform-multi-completion strg)))
                  (name-pat     (if (memq icicle-current-completion-mode '(nil apropos))
                                    name-pat
-                                 (concat "^" name-pat)))
+                                 (concat "^" (regexp-quote name-pat))))
                  (content-pat  (let ((icicle-list-use-nth-parts  '(2)))
                                  (icicle-transform-multi-completion strg)))
                  (bufs         (mapcar (lambda (buf) (buffer-name buf)) icicle-bufflist))
@@ -6231,15 +6569,13 @@ Used as the value of `icicle-buffer-complete-fn' and hence as
                  (bufs         (icicle-remove-if (lambda (buf)
                                                    (or (not (icicle-string-match-p name-pat buf))
                                                        (run-hook-with-args-until-success
-                                                        'icicle-buffer-skip-hook buf)))
+                                                        'icicle-buffer-skip-functions buf)))
                                                  bufs))
                  (bufs         (cond ((equal "" content-pat)
                                       (dolist (buf  bufs)
-                                        ;; Free vars here: EXISTING-BUFFERS, NEW-BUFS--TO-KILL.
-                                        ;; Bound in `icicle-visit-marked-file-of-content(-other-window)'.
-                                        (when (and (boundp 'existing-bufs)  (boundp 'new-bufs--to-kill)
-                                                   (not (memq (setq buf  (get-buffer buf)) existing-bufs)))
-                                          (add-to-list 'new-bufs--to-kill buf)))
+                                        ;; Bound in `icicle-visit-marked-file-of-content-1'.
+                                        (unless (memq (setq buf  (get-buffer buf)) icicle-existing-bufs)
+                                          (add-to-list 'icicle-new-bufs-to-kill buf)))
                                       bufs)
                                      (t
                                       (icicle-remove-if-not
@@ -6248,11 +6584,9 @@ Used as the value of `icicle-buffer-complete-fn' and hence as
                                                          (save-excursion
                                                            (goto-char (point-min))
                                                            (re-search-forward content-pat nil t)))))
-                                           ;; Free vars here: EXISTING-BUFFERS, NEW-BUFS--TO-KILL.
-                                           ;; Bound in `icicle-visit-marked-file-of-content(-other-window)'.
-                                           (when (and (boundp 'existing-bufs)  (boundp 'new-bufs--to-kill)
-                                                      (not (memq (setq buf  (get-buffer buf)) existing-bufs)))
-                                             (add-to-list 'new-bufs--to-kill buf))
+                                           ;; Bound in `icicle-visit-marked-file-of-content-1'.
+                                           (unless (memq (setq buf  (get-buffer buf)) icicle-existing-bufs)
+                                             (add-to-list 'icicle-new-bufs-to-kill buf))
                                            (when (and found ; Don't do it just because incrementally complete.
                                                       (or (icicle-get-safe this-command
                                                                            'icicle-apropos-completing-command)
@@ -6264,16 +6598,16 @@ Used as the value of `icicle-buffer-complete-fn' and hence as
                                              (isearch-update-ring content-pat 'REGEXP))
                                            found))
                                        bufs))))
-                 (filnames    (and (> icicle-buffer-include-recent-files-nflag 0)
-                                   (require 'recentf nil t)
-                                   (or recentf-list  (recentf-load-list))
-                                   (icicle-recent-files-without-buffers bufs)))
+                 (filnames     (and (> icicle-buffer-include-recent-files-nflag 0)
+                                    (require 'recentf nil t)
+                                    (or recentf-list  (recentf-load-list))
+                                    (icicle-recent-files-without-buffers bufs)))
                  (filnames     (append filnames (and (> icicle-buffer-include-cached-files-nflag 0)
                                                      (icicle-cached-files-without-buffers bufs))))
                  (filnames     (icicle-remove-if (lambda (fil)
                                                    (or (not (icicle-string-match-p name-pat fil))
                                                        (run-hook-with-args-until-success
-                                                        'icicle-find-file-of-content-skip-hook fil)))
+                                                        'icicle-file-skip-functions fil)))
                                                  filnames))
                  (filnames     (if (equal "" content-pat)
                                    filnames
@@ -6288,10 +6622,10 @@ Used as the value of `icicle-buffer-complete-fn' and hence as
                                                           (save-excursion
                                                             (goto-char (point-min))
                                                             (re-search-forward content-pat nil t)))))
-                                           ;; Free vars here: EXISTING-BUFFERS, NEW-BUFS--TO-KILL
-                                           (when (and (boundp 'existing-bufs)  (boundp 'new-bufs--to-kill)
-                                                      (not (memq buf existing-bufs)))
-                                             (add-to-list 'new-bufs--to-kill buf))
+                                           ;; Free vars here: EXISTING-BUFFERS, NEW-BUFS--TO-KILL.
+                                           ;; Bound in `icicle-visit-marked-file-of-content-1'.
+                                           (unless (memq buf icicle-existing-bufs)
+                                             (add-to-list 'icicle-new-bufs-to-kill buf))
                                            (when (and found ; Don't do it just because incrementally complete.
                                                       (or (icicle-get-safe this-command
                                                                            'icicle-apropos-completing-command)
@@ -6408,7 +6742,15 @@ Same as `icicle-buffer' except it uses a different window." ; Doc string
   nil                                   ; Undo code
   (icicle-unbind-buffer-candidate-keys)) ; Last code
 
-(icicle-define-command icicle-visit-marked-file-of-content ; Command name
+(defvar icicle-vmfoc-other-win-p nil
+  "Flag bound in `icicle-visit-marked-file-of-content*'.
+Non-nil means use other window.")
+
+(defvar icicle-vmfoc-recursive-p nil
+  "Flag bound in `icicle-visit-marked-file-of-content*'.
+Non-nil means act on files marked in subdirs, defined recursively.")
+
+(defun icicle-visit-marked-file-of-content () ; Bound to `C-S-f', aka `C-F', in Dired.
   "Visit a marked file whose content matches a regexp.
 The marked files are examined, and those whose file names and/or
 contents match your multi-completion input are available as candidate
@@ -6419,66 +6761,66 @@ information.  You must be in Dired mode to use this command.
 When this command is finished, any unused buffers that were created
 for content matching are killed, if option
 `icicle-kill-visited-buffers-flag' is non-nil.  But a prefix argument
-flips the behavior specified by that option." ; Doc string
-  (lambda (buf)                         ; Action function.  Free var here: NEW-BUFS--TO-KEEP.
-    (push (switch-to-buffer (icicle-transform-multi-completion buf))
-          new-bufs--to-keep))           ; Add the visited buffer to those we will keep (not kill).
-  prompt 'icicle-buffer-multi-complete nil ; `completing-read' args
-  (and (fboundp 'confirm-nonexistent-file-or-buffer)  (confirm-nonexistent-file-or-buffer)) ; Emacs 23.
-  nil 'buffer-name-history (icicle-default-buffer-names current-prefix-arg) nil
-  (icicle-buffer-bindings               ; Bindings
-   ((prompt                                 (icicle-buffer-name-prompt "Visit file"))
-    (icicle-show-multi-completion-flag      t) ; Override user setting.
-    (icicle-multi-completing-p              t)
-    (icicle-list-use-nth-parts              '(1))
-    (init-pref-arg                          current-prefix-arg)
-    (existing-bufs                          (buffer-list))
-    (new-bufs--to-kill                      ())
-    (new-bufs--to-keep                      ())
-    (icicle-candidate-help-fn               'icicle-buffer-cand-help))
-   ((icicle-buffer-complete-fn              'icicle-buffer-multi-complete)
-    ;; Bind `icicle-apropos-complete-match-fn' to nil to prevent automatic input matching in
-    ;; `icicle-unsorted-apropos-candidates' etc., because `icicle-buffer-multi-complete' does everything.
-    (icicle-apropos-complete-match-fn       nil)
-    (icicle-last-apropos-complete-match-fn  'icicle-buffer-apropos-complete-match)
-    (icicle-bufflist                        (save-excursion
-                                              (let* ((files  (dired-get-marked-files
-                                                              nil nil
-                                                              (lambda (file) (not (file-directory-p file)))))
-                                                     (bufs   ()))
-                                                (dolist (file  files) (push (find-file-noselect file) bufs))
-                                                bufs)))))
-  (progn (unless (eq major-mode 'dired-mode) (icicle-user-error "Use this command only in Dired mode"))
-         (icicle-bind-buffer-candidate-keys)
-         (put-text-property 0 1 'icicle-fancy-candidates t prompt) ; First code
-         (icicle-highlight-lighter)
-         (message "Matching file contents..."))
-  nil                                   ; Undo code
-  (progn (icicle-unbind-buffer-candidate-keys) ; Last code
-         (when (or (and init-pref-arg        (not icicle-kill-visited-buffers-flag))
-                   (and (not init-pref-arg)  icicle-kill-visited-buffers-flag))
-           (dolist (buf  new-bufs--to-kill)
-             (unless (memq buf new-bufs--to-keep) (kill-buffer buf))))))
+flips the behavior specified by that option."
+  (interactive)
+  (let ((icicle-vmfoc-other-win-p  nil)
+        (icicle-vmfoc-recursive-p  nil))
+    (icicle-visit-marked-file-of-content-1)))
 
-(icicle-define-command icicle-visit-marked-file-of-content-other-window ; Command name
+(defun icicle-visit-marked-file-of-content-other-window () ; Bound to `C-M-S-f', aka `C-M-F', in Dired.
   "Visit a marked file whose content matches a regexp, in another window.
 Same as `icicle-visit-marked-file-of-content' except it uses a
-different window.  You must be in Dired to use this command." ; Doc string
+different window.  You must be in Dired mode to use this command."
+  (interactive)
+  (let ((icicle-vmfoc-other-win-p  t)
+        (icicle-vmfoc-recursive-p  nil))
+    (icicle-visit-marked-file-of-content-1)))
+
+(defun icicle-visit-marked-file-of-content-recursive () ; Bound to `M-+ C-S-f', aka `M-+ C-F', in Dired.
+  "Visit a marked file whose content matches a regexp.
+Like `icicle-visit-marked-file-of-content', but include also the files
+marked in marked subdirs, recursively.
+
+You need library `dired+.el' for this command, and you must be in
+Dired mode to use it."
+  (interactive)
+  (let ((icicle-vmfoc-other-win-p  nil)
+        (icicle-vmfoc-recursive-p  t))
+    (icicle-visit-marked-file-of-content-1)))
+
+(defun icicle-visit-marked-file-of-content-recursive-other-window ()
+                                        ; Bound to `M-+ C-M-S-f', aka `M-+ C-M-F', in Dired.
+  "Visit a marked file whose content matches a regexp, in another window.
+Like `icicle-visit-marked-file-of-content-other-window', but include
+also the files marked in marked subdirs, recursively.
+
+You need library `dired+.el' for this command, and you must be in
+Dired mode to use it."
+  (interactive)
+  (let ((icicle-vmfoc-other-win-p  t)
+        (icicle-vmfoc-recursive-p  t))
+    (icicle-visit-marked-file-of-content-1)))
+
+(icicle-define-command icicle-visit-marked-file-of-content-1
+  "Helper for `icicle-visit-marked-file-of-content*'." ; Doc string
   (lambda (buf)                         ; Action function.  Free var here: NEW-BUFS--TO-KEEP.
-    (push (switch-to-buffer-other-window (icicle-transform-multi-completion buf))
-          new-bufs--to-keep))           ; Add the visited buffer to those we will keep (not kill).
+    (push (funcall act-fn (icicle-transform-multi-completion buf))
+          icicle-new-bufs-to-keep))           ; Add the visited buffer to those we will keep (not kill).
   prompt 'icicle-buffer-multi-complete nil ; `completing-read' args
   (and (fboundp 'confirm-nonexistent-file-or-buffer)  (confirm-nonexistent-file-or-buffer)) ; Emacs 23.
-  nil 'buffer-name-history (icicle-default-buffer-names current-prefix-arg) nil
+  nil 'buffer-name-history (icicle-default-buffer-names) nil
   (icicle-buffer-bindings               ; Bindings
    ((prompt                                 (icicle-buffer-name-prompt "Visit file" 'OTHER-WIN))
     (icicle-show-multi-completion-flag      t) ; Override user setting.
     (icicle-multi-completing-p              t)
     (icicle-list-use-nth-parts              '(1))
     (init-pref-arg                          current-prefix-arg)
-    (existing-bufs                          (buffer-list))
-    (new-bufs--to-kill                      ())
-    (new-bufs--to-keep                      ())
+    (icicle-existing-bufs                   (buffer-list))
+    (icicle-new-bufs-to-kill                ())
+    (icicle-new-bufs-to-keep                ())
+    (act-fn                                 (if icicle-vmfoc-other-win-p
+                                                'switch-to-buffer-other-window
+                                              'switch-to-buffer))
     (icicle-candidate-help-fn               'icicle-buffer-cand-help))
    ((icicle-buffer-complete-fn              'icicle-buffer-multi-complete)
     ;; Bind `icicle-apropos-complete-match-fn' to nil to prevent automatic input matching in
@@ -6486,13 +6828,19 @@ different window.  You must be in Dired to use this command." ; Doc string
     (icicle-apropos-complete-match-fn       nil)
     (icicle-last-apropos-complete-match-fn  'icicle-buffer-apropos-complete-match)
     (icicle-bufflist                        (save-excursion
-                                              (let* ((files  (dired-get-marked-files
-                                                              nil nil
-                                                              (lambda (file) (not (file-directory-p file)))))
+                                              (let* ((files  (if (and icicle-vmfoc-recursive-p
+                                                                      (fboundp 'diredp-get-files))
+                                                                 (diredp-get-files)
+                                                               (dired-get-marked-files
+                                                                nil nil
+                                                                (lambda (file)
+                                                                  (not (file-directory-p file))))))
                                                      (bufs   ()))
                                                 (dolist (file  files) (push (find-file-noselect file) bufs))
                                                 bufs)))))
-  (progn (unless (eq major-mode 'dired-mode) (icicle-user-error "Use this command only in Dired mode"))
+  (progn (when (and icicle-vmfoc-recursive-p  (not (fboundp 'diredp-get-files)))
+           (icicle-user-error "You need library `dired+.el' for this command"))
+         (unless (eq major-mode 'dired-mode) (icicle-user-error "Use this command only in Dired mode"))
          (icicle-bind-buffer-candidate-keys)
          (put-text-property 0 1 'icicle-fancy-candidates t prompt) ; First code
          (icicle-highlight-lighter)
@@ -6501,8 +6849,9 @@ different window.  You must be in Dired to use this command." ; Doc string
   (progn (icicle-unbind-buffer-candidate-keys) ; Last code
          (when (or (and init-pref-arg        (not icicle-kill-visited-buffers-flag))
                    (and (not init-pref-arg)  icicle-kill-visited-buffers-flag))
-           (dolist (buf  new-bufs--to-kill)
-             (unless (memq buf new-bufs--to-keep) (kill-buffer buf))))))
+           (dolist (buf  icicle-new-bufs-to-kill)
+             (unless (memq buf icicle-new-bufs-to-keep) (kill-buffer buf)))))
+  'NOT-INTERACTIVE-P)                   ; Not a real command - just a helper function.
 
 (icicle-define-command icicle-insert-buffer
   "Multi-command version of `insert-buffer'.
@@ -6534,7 +6883,11 @@ completion candidates, default values, and additional key bindings." ; Doc strin
   (icicle-buffer-name-prompt "Show always") ; `completing-read' args
   (mapcar (lambda (buf) (list (buffer-name buf))) icicle-bufflist) nil ; `icicle-bufflist' is free.
   (and (fboundp 'confirm-nonexistent-file-or-buffer)  (confirm-nonexistent-file-or-buffer)) ; Emacs 23.
-  nil 'buffer-name-history (icicle-default-buffer-names current-prefix-arg) nil
+  nil 'buffer-name-history (if (< emacs-major-version 23)
+                               (buffer-name (current-buffer))
+                             (cons (buffer-name (current-buffer))
+                                   (icicle-default-buffer-names current-prefix-arg)))
+  nil
   (icicle-buffer-bindings               ; Bindings
    ((icicle-delete-candidate-object        'icicle-remove-buffer-candidate-action) ; Override default (kill).
     (icicle-use-candidates-only-once-flag  t)))
@@ -6554,7 +6907,7 @@ Save the updated option."               ; Doc string
   ((icicle-use-candidates-only-once-flag  t) ; Bindings
    (icicle-candidate-alt-action-fn
     (or icicle-candidate-alt-action-fn  (icicle-alt-act-fn-for-type "buffer")))
-   (icicle-all-candidates-list-alt-action-fn ; M-|'
+   (icicle-all-candidates-list-alt-action-fn ; `M-|'
     (or icicle-all-candidates-list-alt-action-fn  (icicle-alt-act-fn-for-type "buffer"))))
   (unless icicle-buffer-extras (icicle-user-error "`icicle-extra-buffers' is empty"))) ; First code
 
@@ -6658,11 +7011,12 @@ state just before this command invocation, but to some previous
 snapshot.
 
 To use this command, you must have loaded library `color-theme.el',
-available from http://www.emacswiki.org/cgi-bin/wiki.pl?ColorTheme." ; Doc string
+available from http://www.nongnu.org/color-theme.  See also:
+http://www.emacswiki.org/ColorTheme."   ; Doc string
   (lambda (theme)
-    (when (string= "" theme) (icicle-user-error "No theme name entered (empty input)"))
+    (when (string= "" theme) (icicle-user-error "No color theme name entered (empty input)"))
     (funcall  (intern theme)))          ; Action function: just call the theme.
-  "Theme: " icicle-color-themes nil t nil ; `completing-read' args
+  "Color theme: " icicle-color-themes nil t nil ; `completing-read' args
   (if (boundp 'color-theme-history) 'color-theme-history 'icicle-color-theme-history)
   nil nil
   ((icicle-delete-candidate-object  'icicle-color-themes) ; Bindings
@@ -6703,6 +7057,76 @@ available from http://www.emacswiki.org/cgi-bin/wiki.pl?ColorTheme." ; Doc strin
   (color-theme-snapshot))               ; Undo code
 
 
+;; Emacs 22-23 `cus-themes.el' has no `provide', and only Emacs 24 version
+;; has `custom-available-themes'.
+(when (condition-case nil (require 'cus-theme nil t) (error nil)) ; Emacs 24+
+
+  (icicle-define-command icicle-custom-theme ; Command name
+    "Change custom theme.
+The themes used as candidates are those in option `icicle-custom-themes'.
+
+You can use \\<minibuffer-local-completion-map>\
+`\\[icicle-delete-candidate-object]' during completion to remove the current
+candidate from the list of Icicles custom themes.
+
+You can use `C-g' to quit and cancel changes by the command.  Note,
+however, that some things might not be restored.  `C-g' can only
+disable any themes that you applied.  It cannot restore other
+customizations that enabling a theme might have overruled.  This is a
+limitation of Emacs custom themes: you can disable them, but you
+cannot restore non-theme settings in effect before enabling a theme.
+Color themes (and command `icicle-color-theme') do not have this
+limitation.
+
+Note: Having a lot of frames present can slow down this command
+considerably.
+
+Option `icicle-custom-themes-accumulate-flag' determines whether
+cycling accumulates themes or disables all themes other than the
+current one.  Note: A non-nil value (accumulating) can considerably
+slow down cycling.
+
+Option `icicle-custom-themes-update-flag' determines whether the
+updated value of `icicle-custom-themes' is saved.  A prefix arg to
+this command flips the option value for the current invocation of the
+command."                               ; Doc string
+    (lambda (theme)                     ; Action function: enable theme.
+      (when (string= "" theme) (icicle-user-error "No theme name entered (empty input)"))
+      (setq theme  (intern theme))
+      (condition-case nil
+          (progn (unless icicle-custom-themes-accumulate-flag
+                   (mapc #'disable-theme (delete theme custom-enabled-themes)))
+                 (unless (memq theme custom-enabled-themes) ; Don't enable if already enabled.
+                   (if (custom-theme-p theme) (enable-theme theme) (load-theme theme t)))
+                 (run-hooks 'icicle-custom-theme-hook))
+        (error (condition-case nil (disable-theme theme) (error nil))))
+      theme)                            ; Return it (but not necessary).
+    "Custom theme: "                    ; `completing-read' args
+    (mapcar (lambda (thm) (list (symbol-name thm))) icicle-custom-themes) nil t nil
+    (if (boundp 'custom-theme-history) 'custom-theme-history 'icicle-custom-theme-history)
+    nil nil
+    ((flip         current-prefix-arg)  ; Bindings
+     (orig-themes  (delq nil (copy-sequence custom-enabled-themes)))
+     (icicle-delete-candidate-object
+      (lambda (thm) (setq icicle-custom-themes  (delq (intern thm) icicle-custom-themes)))))
+    (unless icicle-custom-themes        ; First code
+      (setq icicle-custom-themes  (custom-available-themes)))
+    (condition-case nil                 ; Undo code
+        (progn (mapc #'disable-theme custom-enabled-themes)
+               (mapc #'enable-theme orig-themes))
+      (error nil))
+    (when custom-enabled-themes         ; Last code
+      ;; `enable-theme' -> `custom-reevaluate-setting' adds `nil'.
+      (setq icicle-custom-themes  (delq nil icicle-custom-themes))
+      ;; Move chosen theme to the front.
+      (setq icicle-custom-themes  (delete (car custom-enabled-themes) icicle-custom-themes))
+      (setq icicle-custom-themes  (cons (car custom-enabled-themes) icicle-custom-themes))
+      (message "Theme: `%s'" (car icicle-custom-themes))
+      (when (or (and flip        (not icicle-custom-themes-update-flag))
+                (and (not flip)  icicle-custom-themes-update-flag))
+        (customize-save-variable 'icicle-custom-themes icicle-custom-themes)))))
+
+
 ;; Make delete-selection mode recognize yanking, so it replaces region text.
 (put 'icicle-yank-pop-commands 'delete-selection 'yank)
 
@@ -6734,16 +7158,17 @@ You need library `second-sel.el' for this command."
     (condition-case nil
         (ad-disable-advice 'yank-pop 'around 'kill-ring-browse-maybe)
       (error nil)))
-  (cond ((memq last-command secondary-selection-yank-secondary-commands)
-         (when buffer-read-only (icicle-user-error "Buffer is read-only: %S" (current-buffer)))
-         (yank-pop-secondary arg))
-        ((memq last-command secondary-selection-yank-commands)
-         (when buffer-read-only (icicle-user-error "Buffer is read-only: %S" (current-buffer)))
-         (yank-pop arg))
-        (t
-         (icicle-completing-yank)
-         ;; Need to do this because `icicle-completing-yank' sets it to `yank'.
-         (setq this-command  'icicle-yank-pop-commands))))
+  (let ((enable-recursive-minibuffers  t))
+    (cond ((memq last-command secondary-selection-yank-secondary-commands)
+           (when buffer-read-only (icicle-user-error "Buffer is read-only: %S" (current-buffer)))
+           (yank-pop-secondary arg))
+          ((memq last-command secondary-selection-yank-commands)
+           (when buffer-read-only (icicle-user-error "Buffer is read-only: %S" (current-buffer)))
+           (yank-pop arg))
+          (t
+           (icicle-completing-yank)
+           ;; Need to do this because `icicle-completing-yank' sets it to `yank'.
+           (setq this-command  'icicle-yank-pop-commands)))))
 
 
 ;; Make delete-selection mode recognize yanking, so it replaces region text.
@@ -6773,29 +7198,28 @@ candidates to yank in different ways (repeat)
   icicle-insert-for-yank                ; Action function
   "Insert: " (mapcar #'list kills-in-order) nil t nil 'icicle-kill-history ; `completing-read' args
   (car kills-in-order) nil
-  ((icicle-transform-function       'icicle-remove-duplicates) ; Bindings
+  ((enable-recursive-minibuffers    t)
+   (icicle-transform-function       'icicle-remove-duplicates) ; Bindings
    (icicle-sort-comparer            nil)
    (selection-ring                  (if (not current-prefix-arg)
                                         'kill-ring
                                       (if (boundp 'browse-kill-ring-alternative-ring)
                                           browse-kill-ring-alternative-ring
                                         (if (boundp 'secondary-selection-ring)
-                                            'secondary-selection-ring)
-                                        'kill-ring)))
+                                            'secondary-selection-ring
+                                          'kill-ring))))
    (icicle-candidate-alt-action-fn  `(lambda (seln) ; Add selection to the front of the other ring.
                                       ;; FREE here: BROWSE-KILL-RING-ALTERNATIVE-PUSH-FUNCTION,
                                       ;;            BROWSE-KILL-RING-ALTERNATIVE-RING.
                                       (let ((other-ring  (if (eq 'kill-ring ',selection-ring)
                                                              (if (fboundp 'browse-kill-ring)
                                                                  browse-kill-ring-alternative-ring
-                                                               (if (boundp 'secondary-selection-ring)
-                                                                   'secondary-selection-ring
-                                                                 nil))
+                                                               (and (boundp 'secondary-selection-ring)
+                                                                    'secondary-selection-ring))
                                                            'kill-ring)))
                                         (if (eq 'kill-ring ',selection-ring)
                                             (if (fboundp 'browse-kill-ring-alternative-push-function)
-                                                (funcall browse-kill-ring-alternative-push-function
-                                                         seln)
+                                                (funcall browse-kill-ring-alternative-push-function seln)
                                               (when (boundp 'secondary-selection-ring)
                                                 (add-secondary-to-ring seln)))
                                           (kill-new seln))
@@ -6973,7 +7397,7 @@ can use the following keys:
    ((switches               (and current-prefix-arg
                                  (read-string "Dired listing switches: " dired-listing-switches)))
     (icicle-file-sort       (or icicle-file-sort  'icicle-dirs-first-p))
-    (icicle-all-candidates-list-alt-action-fn ; M-|'
+    (icicle-all-candidates-list-alt-action-fn ; `M-|'
      (lambda (files) (let ((enable-recursive-minibuffers  t))
                        (dired-other-window (cons (read-string "Dired buffer name: ") files)))))))
   (icicle-bind-file-candidate-keys)     ; First code
@@ -6988,7 +7412,7 @@ can use the following keys:
    ((switches               (and current-prefix-arg
                                  (read-string "Dired listing switches: " dired-listing-switches)))
     (icicle-file-sort       (or icicle-file-sort  'icicle-dirs-first-p))
-    (icicle-all-candidates-list-alt-action-fn ; M-|'
+    (icicle-all-candidates-list-alt-action-fn ; `M-|'
      (lambda (files) (let ((enable-recursive-minibuffers  t))
                        (dired-other-window (cons (read-string "Dired buffer name: ") files)))))))
   (icicle-bind-file-candidate-keys)     ; First code
@@ -7006,6 +7430,11 @@ With a prefix argument, use absolute file names
  With a negative prefix arg, you can choose also by date:
   Completion candidates include the last modification date.
 
+all of these commands let you search file content, as well as file
+names (unless you use an Emacs version prior to 23).  See
+`icicle-find-file' and `icicle-find-file-absolute' for more
+information.
+
 Note that when you use a prefix arg, completion matches candidates as
 ordinary strings.  It knows nothing of file names per se.  In
 particular, you cannot use remote file-name syntax if you use a prefix
@@ -7018,10 +7447,6 @@ act on all candidates using \\<minibuffer-local-completion-map>\
 arg.  This does not apply to the final candidate chosen (using `RET'
 or `mouse-2') - a prefix arg has no effect for that.
 
-See `icicle-find-file' and `icicle-find-file-absolute' for more
-information.  Note that for Emacs 23 and later, `icicle-find-file'
-lets you search file content, as well as file names.
-
 During completion (`*' means this requires library `Bookmark+')\\<minibuffer-local-completion-map>, you
 can use the following keys:
    C-c +        - create a new directory
@@ -7041,7 +7466,9 @@ then customize option `icicle-top-level-key-bindings'."
   (interactive "P")
   (if arg
       (let ((current-prefix-arg  (not (wholenump (prefix-numeric-value arg)))))
+        (setq this-command  'icicle-find-file-absolute) ; So user sees msgs appropriate to the command.
         (icicle-find-file-absolute))
+    (setq this-command  'icicle-find-file) ; So user sees msgs appropriate to the command.
     (icicle-find-file)))
 
 
@@ -7051,12 +7478,31 @@ then customize option `icicle-top-level-key-bindings'."
   (interactive "P")
   (if arg
       (let ((current-prefix-arg  (not (wholenump (prefix-numeric-value arg)))))
+        (setq this-command  'icicle-find-file-absolute-other-window) ; So user sees appropriate msgs.
         (icicle-find-file-absolute-other-window))
+    (setq this-command  'icicle-find-file-other-window) ; So user sees msgs appropriate to the command.
     (icicle-find-file-other-window)))
 
+(defun icicle-find-file-abs-no-search-action (file)
+  "Action function for commands reading absolute file names without searching."
+  (funcall (icicle-find-file-abs-no-search-action-1 nil nil) file))
 
-(put 'icicle-find-file-absolute 'icicle-Completions-window-max-height 200)
-(icicle-define-command icicle-find-file-absolute ; Bound to `C-u C-x f' in Icicle mode.
+(defun icicle-find-file-abs-no-search-other-window-action (file)
+  "Action function for commands reading absolute file names without searching."
+  (funcall (icicle-find-file-abs-no-search-action-1 'OTHER-WINDOW-P nil) file))
+
+(defun icicle-find-file-abs-no-search-ro-action (file)
+  "Action function for commands reading absolute file names without searching."
+  (funcall (icicle-find-file-abs-no-search-action-1 nil 'READ-ONLY-P) file))
+
+(defun icicle-find-file-abs-no-search-ro-ow-action (file)
+  "Action function for commands reading absolute file names without searching."
+  (funcall (icicle-find-file-abs-no-search-action-1 'OTHER-WINDOW-P 'READ-ONLY-P) file))
+
+
+(put 'icicle-find-file-abs-no-search 'icicle-hide-common-match t)
+(put 'icicle-find-file-abs-no-search 'icicle-Completions-window-max-height 200)
+(defun icicle-find-file-abs-no-search () ; Bound to `C-u C-x f' in Icicle mode.
   "Visit a file or directory, given its absolute name.
 Unlike `icicle-find-file', the completion candidates are absolute, not
 relative, file names.
@@ -7079,10 +7525,6 @@ can for ordinary (non-absolute) file-name completion.  To change to a
 different directory, with its files as candidates, use \\<minibuffer-local-completion-map>`C-c C-d' from
 the minibuffer - it prompts you for the new directory.
 
-Remember that you can use `C-x .' to hide the common match portion of
-each candidate.  That can be particularly helpful for files that are
-in a common directory.
-
 With a prefix argument, you can choose also by date: Completion
 candidates include the last modification date.
 
@@ -7109,7 +7551,7 @@ can use the following keys:
 
 These options, when non-nil, control candidate matching and filtering:
 
- `icicle-file-extras'           - Extra file names to display
+ `icicle-file-extras'           - Extra absolute file names to display
  `icicle-file-match-regexp'     - Regexp that file names must match
  `icicle-file-no-match-regexp'  - Regexp file names must not match
  `icicle-file-predicate'        - Predicate file names must satisfy
@@ -7125,62 +7567,27 @@ Option `icicle-file-require-match-flag' can be used to override
 option `icicle-require-match-flag'.
 
 Option `icicle-files-ido-like' non-nil gives this command a more
-Ido-like behavior."                     ; Doc string
-  (lambda (file)                        ; FREE here: CURRENT-PREFIX-ARG, THIS-COMMAND.
-    (let ((r-o  (and (memq this-command '(icicle-candidate-action icicle-mouse-candidate-action
-                                          icicle-all-candidates-action))
-                     current-prefix-arg))
-          (fil  (icicle-transform-multi-completion file)))
-      (if r-o
-          (find-file-read-only fil 'WILDCARDS)
-        (find-file fil 'WILDCARDS))))
-  prompt icicle-abs-file-candidates nil ; `completing-read' args
-  (and (fboundp 'confirm-nonexistent-file-or-buffer)  (confirm-nonexistent-file-or-buffer)) ;Emacs 23.
-  nil 'file-name-history default-directory nil
-  (icicle-file-bindings                 ; Bindings
-   ((prompt                             "File or dir (absolute): ")
-    (icicle-full-cand-fn                `(lambda (file)
-                                          (setq file  (if (file-directory-p file)
-                                                          (file-name-as-directory file)
-                                                        file))
-                                          ,(if current-prefix-arg
-                                               '(icicle-make-file+date-candidate file)
-                                               '(list file))))
-    (icicle-abs-file-candidates         (mapcar icicle-full-cand-fn
-                                                (directory-files default-directory 'FULL nil 'NOSORT)))
-    (icicle-all-candidates-list-alt-action-fn ; M-|'
-     (lambda (files) (let ((enable-recursive-minibuffers  t))
-                       (dired-other-window (cons (read-string "Dired buffer name: ") files)))))
-    (icicle-special-candidate-regexp    (or icicle-special-candidate-regexp  ".+/$"))
-    (icicle-candidate-properties-alist  (and current-prefix-arg  '((1 (face icicle-candidate-part)))))
-    (icicle-multi-completing-p          current-prefix-arg)
-    (icicle-list-use-nth-parts          (and current-prefix-arg  '(1)))))
-  (progn                                ; First code
-    (when current-prefix-arg
-      (put-text-property 0 1 'icicle-fancy-candidates t prompt)
-      (setq current-prefix-arg  nil))   ; Reset so can use it in action function.
-    (icicle-highlight-lighter)
-    (message "Gathering files...")
-    (icicle-bind-file-candidate-keys)
-    (define-key minibuffer-local-completion-map "\C-c\C-d" 'icicle-cd-for-abs-files)
-    (define-key minibuffer-local-must-match-map "\C-c\C-d" 'icicle-cd-for-abs-files))
-  nil                                   ; Undo code
-  (progn (icicle-unbind-file-candidate-keys) ; Last code
-         (define-key minibuffer-local-completion-map "\C-c\C-d" nil)
-         (define-key minibuffer-local-must-match-map "\C-c\C-d" nil)))
+Ido-like behavior.
 
+Because absolute file names can be long, with common prefixes, the
+common match portion of each candidate is hidden by default.  You can
+toggle this hiding using `\\[icicle-dispatch-C-x.]'."
+  (interactive)
+  (let ((icicle-find-file-abs-action-fn  'icicle-find-file-abs-no-search-action))
+    (icicle-find-file-abs-no-search-1)))
 
-(put 'icicle-find-file-absolute-other-window 'icicle-Completions-window-max-height 200)
-(icicle-define-command icicle-find-file-absolute-other-window ; Bound to `C-u C-x 4 f'
-  "Same as `icicle-find-file-absolute' except uses another window." ; Doc string
-  (lambda (file)                        ; FREE here: CURRENT-PREFIX-ARG, THIS-COMMAND.
-    (let ((r-o  (and (memq this-command '(icicle-candidate-action icicle-mouse-candidate-action
-                                          icicle-all-candidates-action))
-                     current-prefix-arg))
-          (fil  (icicle-transform-multi-completion file)))
-      (if r-o
-          (find-file-read-only-other-window fil 'WILDCARDS)
-        (find-file-other-window fil 'WILDCARDS))))
+
+(put 'icicle-find-file-abs-no-search-other-window 'icicle-hide-common-match t)
+(put 'icicle-find-file-abs-no-search-other-window 'icicle-Completions-window-max-height 200)
+(defun icicle-find-file-abs-no-search-other-window () ; Bound to `C-u C-x 4 f'
+  "Same as `icicle-find-file-abs-no-search' except uses another window."
+  (interactive)
+  (let ((icicle-find-file-abs-action-fn  'icicle-find-file-abs-no-search-other-window-action))
+    (icicle-find-file-abs-no-search-1)))
+
+(icicle-define-command icicle-find-file-abs-no-search-1
+  "Helper for `icicle-find-file-abs-no-search(-other-window)'." ; Doc string
+  (lambda (fil) (funcall icicle-find-file-abs-action-fn fil)) ; FREE here: `icicle-find-file-abs-action-fn'.
   prompt icicle-abs-file-candidates nil ; `completing-read' args
   (and (fboundp 'confirm-nonexistent-file-or-buffer)  (confirm-nonexistent-file-or-buffer)) ;Emacs 23.
   nil 'file-name-history default-directory nil
@@ -7195,9 +7602,10 @@ Ido-like behavior."                     ; Doc string
                                                '(list file))))
     (icicle-abs-file-candidates         (mapcar icicle-full-cand-fn
                                                 (directory-files default-directory 'FULL nil 'NOSORT)))
-    (icicle-all-candidates-list-alt-action-fn ; M-|'
+    (icicle-all-candidates-list-alt-action-fn ; `M-|'
      (lambda (files) (let ((enable-recursive-minibuffers  t))
-                       (dired-other-window (cons (read-string "Dired buffer name: ") files)))))
+                       (dired-other-window (cons (read-string "Dired buffer name: ")
+                                                 (mapcar #'icicle-transform-multi-completion files))))))
     (icicle-special-candidate-regexp    (or icicle-special-candidate-regexp  ".+/$"))
     (icicle-candidate-properties-alist  (and current-prefix-arg  '((1 (face icicle-candidate-part)))))
     (icicle-multi-completing-p          current-prefix-arg)
@@ -7205,7 +7613,7 @@ Ido-like behavior."                     ; Doc string
   (progn                                ; First code
     (when current-prefix-arg
       (put-text-property 0 1 'icicle-fancy-candidates t prompt)
-      (setq current-prefix-arg  nil))   ; Reset so can use it in action function.
+      (setq current-prefix-arg  nil))   ; Reset, so can use it in action function.
     (icicle-highlight-lighter)
     (message "Gathering files...")
     (icicle-bind-file-candidate-keys)
@@ -7214,7 +7622,8 @@ Ido-like behavior."                     ; Doc string
   nil                                   ; Undo code
   (progn (icicle-unbind-file-candidate-keys) ; Last code
          (define-key minibuffer-local-completion-map "\C-c\C-d" nil)
-         (define-key minibuffer-local-must-match-map "\C-c\C-d" nil)))
+         (define-key minibuffer-local-must-match-map "\C-c\C-d" nil))
+  'NOT-INTERACTIVE-P)                 ; Not a real command - just a helper function.
 
 ;; This is a minibuffer command.  It is in this file because it is used only here.
 ;;
@@ -7239,9 +7648,43 @@ Ido-like behavior."                     ; Doc string
     (setq minibuffer-completion-table
           (car (icicle-mctize-all icicle-abs-file-candidates minibuffer-completion-predicate)))))
 
+(defun icicle-find-file-no-search-action (file)
+  "Action function for commands using `read-file-name' without searching."
+  (funcall (icicle-find-file-no-search-action-1 nil) file))
+
+(defun icicle-find-file-no-search-other-window-action (file)
+  "Action function for commands using `read-file-name' without searching."
+  (funcall (icicle-find-file-no-search-action-1 'OTHER-WINDOW-P) file))
+
+
+(icicle-define-file-command icicle-find-file-no-search-1
+  "Helper for `icicle-find-file-no-search(-other-window)'." ; Doc string
+  (lambda (fil) (funcall icicle-find-file-action-fn fil)) ; FREE here: `icicle-find-file-action-fn'.
+  prompt nil                            ; `read-file-name' args
+  (if (and (eq major-mode 'dired-mode)  (fboundp 'dired-get-file-for-visit)) ; Emacs 22+.
+      (condition-case nil               ; E.g. error because not on file line (ignore)
+          (abbreviate-file-name (dired-get-file-for-visit))
+        (error nil))
+    default-directory)
+  (and (fboundp 'confirm-nonexistent-file-or-buffer)  (confirm-nonexistent-file-or-buffer)) ;Emacs 23.
+  nil nil
+  (icicle-file-bindings                 ; Bindings
+   ((prompt                             (concat "File or directory" (and icicle-pref-arg
+                                                                         " (read-only)") ": "))
+    (icicle-pref-arg                    current-prefix-arg)
+    (icicle-all-candidates-list-alt-action-fn ; `M-|'
+     (lambda (files) (let ((enable-recursive-minibuffers  t))
+                       (dired-other-window (cons (read-string "Dired buffer name: ") files)))))))
+  (progn                                ; First code
+    (icicle-bind-file-candidate-keys)
+    (setq current-prefix-arg  nil))     ; Reset, so can use it in action function.
+  (icicle-unbind-file-candidate-keys)   ; Undo code
+  (icicle-unbind-file-candidate-keys)   ; Last code
+  'NOT-INTERACTIVE-P)                   ; Not a real command - just a helper function.
+
 
 (put 'icicle-find-file-no-search 'icicle-Completions-window-max-height 200)
-(icicle-define-file-command icicle-find-file-no-search
+(defun icicle-find-file-no-search ()
   "Visit a file or directory.
 \(Option `find-file-run-dired' determines whether you can actually
 visit a directory candidate that you choose.)
@@ -7297,100 +7740,165 @@ Option `icicle-file-require-match-flag' can be used to override
 option `icicle-require-match-flag'.
 
 Option `icicle-files-ido-like' non-nil gives this command a more
-Ido-like behavior."                     ; Doc string
-  (lambda (file)                        ; FREE here: CURRENT-PREFIX-ARG, INIT-PREF-ARG, THIS-COMMAND.
-    (let* ((r-o  (if (memq this-command '(icicle-candidate-action icicle-mouse-candidate-action
-                                          icicle-all-candidates-action))
-                     (or (and init-pref-arg        (not current-prefix-arg))
-                         (and (not init-pref-arg)  current-prefix-arg))
-                   init-pref-arg))
-           (fn   (if r-o 'find-file-read-only 'find-file)))
-      (funcall fn file 'WILDCARDS)))
-  (concat "File or directory" (and init-pref-arg  " (read-only)") ": ") ; `read-file-name' args
-  nil (if (and (eq major-mode 'dired-mode)  (fboundp 'dired-get-file-for-visit)) ; Emacs 22+.
-          (condition-case nil           ; E.g. error because not on file line (ignore)
-              (abbreviate-file-name (dired-get-file-for-visit))
-            (error nil))
-        default-directory)
-  (and (fboundp 'confirm-nonexistent-file-or-buffer)  (confirm-nonexistent-file-or-buffer)) ;Emacs 23.
-  nil nil
-  (icicle-file-bindings                 ; Bindings
-   ((init-pref-arg  current-prefix-arg)
-    (icicle-all-candidates-list-alt-action-fn ; `M-|'
-     (lambda (files) (let ((enable-recursive-minibuffers  t))
-                       (dired-other-window (cons (read-string "Dired buffer name: ") files)))))))
-  (icicle-bind-file-candidate-keys)     ; First code
-  nil                                   ; Undo code
-  (icicle-unbind-file-candidate-keys))  ; Last code
+Ido-like behavior."
+  (interactive)
+  (let ((icicle-find-file-action-fn  'icicle-find-file-no-search-action))
+    (icicle-find-file-no-search-1)))
 
 
 (put 'icicle-find-file-no-search-other-window 'icicle-Completions-window-max-height 200)
-(icicle-define-file-command icicle-find-file-no-search-other-window
-  "Same as `icicle-find-file-no-search', except uses another window." ; Doc string
-  (lambda (file)                        ; FREE here: CURRENT-PREFIX-ARG, INIT-PREF-ARG, THIS-COMMAND.
-    (let* ((r-o  (if (memq this-command '(icicle-candidate-action icicle-mouse-candidate-action
-                                          icicle-all-candidates-action))
-                     (or (and init-pref-arg        (not current-prefix-arg))
-                         (and (not init-pref-arg)  current-prefix-arg))
-                   init-pref-arg))
-           (fn   (if r-o 'find-file-read-only-other-window 'find-file-other-window)))
-      (funcall fn file 'WILDCARDS)))
-  (concat "File or directory" (and init-pref-arg  " (read-only)") ": ") ; `read-file-name' args
-  nil (if (and (eq major-mode 'dired-mode)  (fboundp 'dired-get-file-for-visit)) ; Emacs 22+.
-          (condition-case nil           ; E.g. error because not on file line (ignore)
-              (abbreviate-file-name (dired-get-file-for-visit))
-            (error nil))
-        default-directory)
-  (and (fboundp 'confirm-nonexistent-file-or-buffer)  (confirm-nonexistent-file-or-buffer)) ;Emacs 23.
-  nil nil
-  (icicle-file-bindings                 ; Bindings
-   ((init-pref-arg  current-prefix-arg)
-    (icicle-all-candidates-list-alt-action-fn ; `M-|'
-     (lambda (files) (let ((enable-recursive-minibuffers  t))
-                       (dired-other-window (cons (read-string "Dired buffer name: ") files)))))))
-  (icicle-bind-file-candidate-keys)     ; First code
-  nil                                   ; Undo code
-  (icicle-unbind-file-candidate-keys))  ; Last code
+(defun icicle-find-file-no-search-other-window ()
+  "Same as `icicle-find-file-no-search' except uses another window."
+  (interactive)
+  (let ((icicle-find-file-action-fn  'icicle-find-file-no-search-other-window-action))
+    (icicle-find-file-no-search-1)))
+
+(defun icicle-find-file-or-expand-dir (file-or-dir command read-only-p other-window-p)
+  "Helper for Icicles commands that find files using `read-file-name'.
+FILE-OR-DIR is the target file or directory name.
+COMMAND is the original Icicles file-finding command (a symbol).
+Non-nil READ-ONLY-P means visit the file in read-only mode.
+Non-nil OTHER-WINDOW-P means visit the file in another window.
+
+If `icicle-find-file-expand-directory-flag' is non-nil, FILE-OR-DIR is
+a directory name, and you have used a key such as `RET' that normally
+would make a final candidate choice and exit the minibuffer, then,
+instead of visiting the directory using Dired, COMMAND is restarted,
+but this time in directory FILENAME.  That is, you descend into
+directory FILE-OR-DIR.
+
+A non-exiting action such as `C-RET' does not have this special
+behavior.  Instead, it always visits the chosen directory."
+  (if (and icicle-find-file-expand-directory-flag
+           (file-directory-p file-or-dir) ; Not just `icicle-looks-like-dir-name-p'.
+           (zerop (minibuffer-depth))
+           (> emacs-major-version 20))  ; Emacs 20 BUG: `default-directory' gets changed.
+      (let ((default-directory                       (file-name-as-directory file-or-dir))
+            (icicle-show-Completions-initially-flag  t))
+        (funcall command))
+    (let ((fn  (if read-only-p
+                   (if other-window-p #'find-file-read-only-other-window #'find-file-read-only)
+                 (if other-window-p #'find-file-other-window #'find-file))))
+      (funcall fn file-or-dir 'WILDCARDS))))
 
 
 (put 'icicle-find-file-read-only 'icicle-Completions-window-max-height 200)
 (defun icicle-find-file-read-only ()    ; Bound to `C-x C-r' in Icicle mode.
   "Visit a file or directory in read-only mode.
-This is `icicle-find-file-no-search' with prefix-arg behavior flipped.
+Other than using read-only mode, this is like `icicle-find-file'."
+  (interactive)
+  (if (fboundp 'icicle-find-file-of-content)
+      (let ((icicle-find-file-action-fn  'icicle-find-file-of-content-ro-action))
+        (icicle-find-file-of-content-1))
+    (let ((current-prefix-arg  (not current-prefix-arg))) (icicle-find-file-no-search))))
 
-If you use a prefix arg when you act on a candidate file name then
-visit the file without read-only mode.
 
-If you use a prefix arg for the command itself, this reverses the
-effect of using a prefix arg on individual candidates.  That is, with
-a prefix arg for the command, files are not visited in read-only mode
-by default and a prefix arg for an individual file visits it in
-read-only mode.
+(put 'icicle-find-file-read-only-other-window 'icicle-Completions-window-max-height 200)
+(defun icicle-find-file-read-only-other-window () ; Bound to `C-x 4 r' in Icicle mode.
+  "Same as `icicle-find-file-read-only' except uses another window."
+  (interactive)
+  (if (fboundp 'icicle-find-file-of-content)
+      (let ((icicle-find-file-action-fn  'icicle-find-file-of-content-ro-ow-action))
+        (icicle-find-file-of-content-1))
+    (let ((current-prefix-arg  (not current-prefix-arg))) (icicle-find-file-no-search-other-window))))
 
-During completion (`*' means this requires library `Bookmark+')\\<minibuffer-local-completion-map>:
 
- *You can use `C-x a +' or `C-x a -' to add or remove tags from the
-   current-candidate file.  You are prompted for the tags.
- *You can use `C-x m' to access file bookmarks (not just autofiles).
-  You can use `C-c +' to create a new directory.
-  You can use `\\[icicle-all-candidates-list-alt-action]' to open Dired on currently matching file names.
-  You can use `\\[icicle-delete-candidate-object]' to delete a candidate file or (empty) dir."
+(put 'icicle-find-file-abs-read-only 'icicle-hide-common-match t)
+(put 'icicle-find-file-abs-read-only 'icicle-Completions-window-max-height 200)
+(defun icicle-find-file-abs-read-only ()
+  "Visit a file or directory in read-only mode, given its absolute file name.
+Same as `icicle-find-file-absolute', but visit the target read-only."
   (interactive)
-  (let ((current-prefix-arg  (not current-prefix-arg)))
-    (icicle-find-file-no-search)))
+  (if (fboundp 'icicle-find-file-of-content)
+      (let ((icicle-find-file-abs-action-fn  'icicle-find-file-abs-of-content-ro-action))
+        (icicle-find-file-abs-of-content-1))
+    (let ((icicle-find-file-abs-action-fn  'icicle-find-file-abs-no-search-ro-action))
+      (icicle-find-file-abs-no-search-1))))
 
 
-(put 'icicle-find-file-read-only-other-window 'icicle-Completions-window-max-height 200)
-(defun icicle-find-file-read-only-other-window () ; Bound to `C-x 4 r' in Icicle mode.
-  "Same as `icicle-find-file-read-only' except uses another window."
+(put 'icicle-find-file-abs-read-only-other-window 'icicle-hide-common-match t)
+(put 'icicle-find-file-abs-read-only-other-window 'icicle-Completions-window-max-height 200)
+(defun icicle-find-file-abs-read-only-other-window () ; Bound to `C-x 4 r' in Icicle mode.
+  "Same as `icicle-find-file-abs-read-only' except uses another window."
   (interactive)
-  (let ((current-prefix-arg  (not current-prefix-arg)))
-    (icicle-find-file-no-search-other-window)))
+  (if (fboundp 'icicle-find-file-of-content)
+      (let ((icicle-find-file-abs-action-fn  'icicle-find-file-abs-of-content-ro-ow-action))
+        (icicle-find-file-abs-of-content-1))
+    (let ((icicle-find-file-abs-action-fn  'icicle-find-file-abs-no-search-ro-ow-action))
+      (icicle-find-file-abs-no-search-1))))
+
 
 (when (> emacs-major-version 22)
 
+  (defun icicle-find-file-of-content-action (file)
+    "Action function for commands using `read-file-name' with content searching."
+    (funcall (icicle-find-file-of-content-action-1 nil nil) file))
+
+  (defun icicle-find-file-of-content-other-window-action (file)
+    "Action function for commands using `read-file-name' with content searching."
+    (funcall (icicle-find-file-of-content-action-1 'OTHER-WINDOW-P nil) file))
+
+  (defun icicle-find-file-of-content-ro-action (file)
+    "Read-only action for commands using `read-file-name' with content searching."
+    (funcall (icicle-find-file-of-content-action-1 nil 'READ-ONLY-P) file))
+
+  (defun icicle-find-file-of-content-ro-ow-action (file)
+    "Read-only action for commands using `read-file-name' with content searching."
+    (funcall (icicle-find-file-of-content-action-1 'OTHER-WINDOW-P 'READ-ONLY-P) file))
+
+  (icicle-define-file-command icicle-find-file-of-content-1
+    "Helper for `icicle-find-file-of-content(-other-window)'." ; Doc string
+    ;; Free vars here CURRENT-PREFIX-ARG, `icicle-pref-arg'.
+    ;; FREE here: `icicle-find-file-action-fn'.
+    (lambda (fil) (funcall icicle-find-file-action-fn fil))
+    prompt nil (if (eq major-mode 'dired-mode) ; `read-file-name' args
+                   (condition-case nil  ; E.g. error because not on file line (ignore)
+                       (abbreviate-file-name (dired-get-file-for-visit))
+                     (error nil))
+                 default-directory)
+    (confirm-nonexistent-file-or-buffer) nil nil
+    (icicle-file-bindings               ; Bindings
+     ((icicle-pref-arg                        current-prefix-arg)
+      (prompt                                 "File or directory: ")
+      (icicle-compute-narrowing-regexp-p      t) ; For progressive completion.
+      (icicle-apropos-complete-match-fn       'icicle-file-of-content-apropos-complete-match)
+      (icicle-last-apropos-complete-match-fn  'icicle-file-of-content-apropos-complete-match)
+      (icicle-show-multi-completion-flag      t) ; Override user setting.
+      (icicle-multi-completing-p              t)
+      (icicle-list-use-nth-parts              '(1))
+      (icicle-transform-before-sort-p         t)
+      (icicle-existing-bufs                   (buffer-list))
+      (icicle-new-bufs-to-kill                ())
+      (icicle-new-bufs-to-keep                ())
+      (cleanup-code                     ; Use for both undo code and last code.
+       (lambda ()
+         (icicle-unbind-file-candidate-keys)
+         (when (or (and icicle-pref-arg        (not icicle-kill-visited-buffers-flag))
+                   (and (not icicle-pref-arg)  icicle-kill-visited-buffers-flag))
+           (dolist (buf  icicle-new-bufs-to-kill)
+;;;              $$$$$$ Why were we calling `restore-buffer-modified-p' before killing?
+;;;              (unless (memq buf icicle-new-bufs-to-keep)
+;;;                (when (buffer-live-p buf) ; Might have been killed, since both undo code and last code.
+;;;                  (with-current-buffer buf
+;;;                    (restore-buffer-modified-p nil) ; Just visiting can sometimes modify the buffer
+;;;                    (kill-buffer buf))))))))
+             (when (and (buffer-live-p buf)  (not (memq buf icicle-new-bufs-to-keep))) (kill-buffer buf))))))
+      (icicle-all-candidates-list-alt-action-fn ; `M-|'
+       (lambda (files) (let ((enable-recursive-minibuffers  t))
+                         (dired-other-window (cons (read-string "Dired buffer name: ")
+                                                   (mapcar #'icicle-transform-multi-completion files))))))))
+    (progn (put-text-property 0 1 'icicle-fancy-candidates t prompt) ; First code
+           (setq current-prefix-arg  nil) ; Reset, so can use it in action function.
+           (icicle-highlight-lighter)
+           (message "Gathering files...")
+           (icicle-bind-file-candidate-keys))
+    (funcall cleanup-code)              ; Undo code
+    (funcall cleanup-code)
+    'NOT-INTERACTIVE-P)
+
+
   (put 'icicle-find-file-of-content 'icicle-Completions-window-max-height 200)
-  (icicle-define-file-command icicle-find-file-of-content ; Not bound by default.
+  (defun icicle-find-file-of-content ()
     "Visit a file or dir whose name and/or content matches.
 Candidate files and directories for completion are examined, and those
 whose names and/or contents match your multi-completion input are
@@ -7474,116 +7982,824 @@ can use the following keys:
  * C-x a +      - add tags to current candidate
  * C-x a -      - remove tags from current candidate
  * C-x m        - access file bookmarks (not just autofiles)" ; Doc string
-    (lambda (file)                      ; Action function
-      ;; Free vars here: CURRENT-PREFIX-ARG, INIT-PREF-ARG, THIS-COMMAND, NEW-BUFS--TO-KEEP.
-      (let* ((r-o  (and (memq this-command '(icicle-candidate-action icicle-mouse-candidate-action
-                                             icicle-all-candidates-action))
-                        current-prefix-arg))
-             (fn   (if r-o 'find-file-read-only 'find-file)))
-        (setq file  (icicle-transform-multi-completion file))
-        (funcall fn file 'WILDCARDS)
-        (when (and (file-readable-p file)  (buffer-file-name)) (normal-mode)) ; Else in fundamental mode.
-        ;; Add the visited buffer to those we will keep (not kill).
-        ;; If FILE uses wildcards then there will be multiple such buffers.
-        ;; For a directory, get the Dired buffer instead of using `get-file-buffer'.
-        (let ((fil2  (if (string= "" (file-name-nondirectory file))  (directory-file-name file)  file)))
-          (dolist (fil  (file-expand-wildcards fil2))
-            (when (setq fil  (if (file-directory-p fil)
-                                 (get-buffer (file-name-nondirectory fil))
-                               (get-file-buffer fil)))
-              (push fil new-bufs--to-keep))))))
-    prompt nil (if (eq major-mode 'dired-mode) ; `read-file-name' args
-                   (condition-case nil  ; E.g. error because not on file line (ignore)
-                       (abbreviate-file-name (dired-get-file-for-visit))
-                     (error nil))
-                 default-directory)
-    (confirm-nonexistent-file-or-buffer) nil nil
+    (interactive)
+    (let ((icicle-find-file-action-fn  'icicle-find-file-of-content-action))
+      (icicle-find-file-of-content-1)))
+
+
+  (put 'icicle-find-file-of-content-other-window 'icicle-Completions-window-max-height 200)
+  (defun icicle-find-file-of-content-other-window ()
+    "Same as `icicle-find-file-of-content' except uses another window."
+    (interactive)
+    (let ((icicle-find-file-action-fn  'icicle-find-file-of-content-other-window-action))
+      (icicle-find-file-of-content-1)))
+
+  (defun icicle-find-file-abs-of-content-action (file)
+    "File-visiting action function for commands reading absolute file names."
+    (funcall (icicle-find-file-abs-of-content-action-1 nil nil) file))
+
+  (defun icicle-find-file-abs-of-content-other-window-action (file)
+    "File-visiting action function for commands reading absolute file names."
+    (funcall (icicle-find-file-abs-of-content-action-1 'OTHER-WINDOW-P nil) file))
+
+  (defun icicle-find-file-abs-of-content-ro-action (file)
+    "Read-only action function for commands reading absolute file names."
+    (funcall (icicle-find-file-abs-of-content-action-1 nil 'READ-ONLY-P) file))
+
+  (defun icicle-find-file-abs-of-content-ro-ow-action (file)
+    "Read-only action function for commands reading absolute file names."
+    (funcall (icicle-find-file-abs-of-content-action-1 'OTHER-WINDOW-P 'READ-ONLY-P) file))
+
+
+  (put 'icicle-find-file-abs-of-content 'icicle-hide-common-match t)
+  (put 'icicle-find-file-abs-of-content 'icicle-Completions-window-max-height 200)
+  (defun icicle-find-file-abs-of-content () ; Bound (indirectly) to `C-u C-x C-f'.
+    "Visit a file or directory, given its absolute file name.
+That is, unlike `icicle-find-file', the completion candidates here are
+absolute, not relative, file names.
+
+By default, the completion candidates are files in the current
+directory, but you can substitute other candidates by retrieving a
+saved candidate set.
+
+Completion here matches candidates as ordinary strings.  It knows
+nothing of file names per se.  In particular, you cannot use remote
+file-name syntax.
+
+You cannot move up and down the file hierarchy the same way you can
+for ordinary (non-absolute) file-name completion.  To change to a
+different directory, with its files as candidates, use \\<minibuffer-local-completion-map>`C-c C-d' from
+the minibuffer - it prompts you for the new directory.
+
+When you use this command with a prefix arg, you can choose also by
+date: Completion candidates include the last modification date.
+
+  NOTE: Using a prefix arg with this command is different from using
+  it with `icicle-find-file', which uses `read-file-name' and thus
+  non-absolute file names.  For that command, a prefix arg flips the
+  behavior of option `icicle-kill-visited-buffers-flag'.
+
+Whether or not you use a prefix argument, completion candidates are
+multi-completions, with the first part being the file name and the
+last part being the file contents.  If you use a prefix arg then there
+is a middle part, which is the last modification date for the file.
+
+For example, if you do not use a prefix arg then you can match files
+whose names contain `quine' and whose contents contain `curry' using
+this input pattern, where `^G^J' stands for the value of
+`icicle-list-join-string':
+
+quine.*^G^J.*curry
+
+If you use a prefix arg then you can match the subset of those files
+whose dates match `2013 11 21', using this input pattern:
+
+quine.*^G^J2013 11 21^G^J.*curry
+
+And if you use a prefix arg, so you can see the dates in
+`*Completions*', but you do not care to match the date, then you can
+use this input pattern:
+
+quine.*^G^J.*^G^J.*curry
+
+A prefix argument has a different meaning when used when you act on an
+individual completion candidate.  It means that you visit that file or
+directory in read-only mode.  This includes when you act on all
+candidates using \\<minibuffer-local-completion-map>`\\[icicle-all-candidates-action]': \
+precede the `\\[icicle-all-candidates-action]' with a prefix arg.
+
+This does not apply to the final candidate chosen (using `RET' or
+`mouse-2') - a prefix arg has no effect for that.
+
+During completion, you can use the following keys (`*' means this
+requires library `Bookmark+')\\<minibuffer-local-completion-map>:
+
+   C-c C-d      - change the `default-directory' (a la `cd')
+   C-c +        - create a new directory
+   \\[icicle-all-candidates-list-alt-action]          - open Dired on the currently matching file names
+   \\[icicle-delete-candidate-object]     - delete candidate file or (empty) dir
+ * C-x C-t *    - narrow to files with all of the tags you specify
+ * C-x C-t +    - narrow to files with some of the tags you specify
+ * C-x C-t % *  - narrow to files with all tags matching a regexp
+ * C-x C-t % +  - narrow to files with some tags  matching a regexp
+ * C-x a +      - add tags to current candidate
+ * C-x a -      - remove tags from current candidate
+ * C-x m        - access file bookmarks (not just autofiles)
+
+These options, when non-nil, control candidate matching and filtering:
+
+ `icicle-file-extras'           - Extra absolute file names to display
+ `icicle-file-match-regexp'     - Regexp that file names must match
+ `icicle-file-no-match-regexp'  - Regexp file names must not match
+ `icicle-file-predicate'        - Predicate file names must satisfy
+ `icicle-file-sort'             - Sort function for candidates
+
+For example, to show only names of files larger than 5000 bytes, set
+`icicle-file-predicate' to:
+
+  (lambda (file) (and (numberp (nth 7 (file-attributes file)))
+                      (> (nth 7 (file-attributes file)) 5000)))
+
+Option `icicle-file-require-match-flag' can be used to override
+option `icicle-require-match-flag'.
+
+Option `icicle-files-ido-like' non-nil gives this command a more
+Ido-like behavior.
+
+Because absolute file names can be long, with common prefixes, the
+common match portion of each candidate is hidden by default.  You can
+toggle this hiding using `\\[icicle-dispatch-C-x.]'."
+    (interactive)
+    (let ((icicle-find-file-abs-action-fn  'icicle-find-file-abs-of-content-action))
+      (icicle-find-file-abs-of-content-1)))
+
+
+  (put 'icicle-find-file-abs-of-content-other-window 'icicle-hide-common-match t)
+  (put 'icicle-find-file-abs-of-content-other-window 'icicle-Completions-window-max-height 200)
+  (defun icicle-find-file-abs-of-content-other-window () ; Bound (indirectly) to `C-u C-x 4 f'.
+    "Same as `icicle-find-file-abs-of-content' except uses another window."
+    (interactive)
+    (let ((icicle-find-file-abs-action-fn  'icicle-find-file-abs-of-content-other-window-action))
+      (icicle-find-file-abs-of-content-1)))
+
+  (icicle-define-command icicle-find-file-abs-of-content-1
+    "Helper for `icicle-find-file-abs(-other-window)'." ; Doc string
+    (lambda (fil) (funcall icicle-find-file-abs-action-fn fil)) ; FREE here: `icicle-find-file-abs-action-fn'.
+    prompt icicle-abs-file-candidates nil (confirm-nonexistent-file-or-buffer) nil ; `completing-read' args
+    'file-name-history (if (eq major-mode 'dired-mode)
+                           (condition-case nil ; E.g. error because not on file line (ignore)
+                               (abbreviate-file-name (dired-get-file-for-visit))
+                             (error nil))
+                         default-directory)
+    nil
     (icicle-file-bindings               ; Bindings
-     ((init-pref-arg                          current-prefix-arg)
-      (prompt                             "File or directory: ")
+     ((prompt                             "File or dir (absolute): ")
+      (icicle-pref-arg                        current-prefix-arg)
       (icicle-compute-narrowing-regexp-p      t) ; For progressive completion.
       (icicle-apropos-complete-match-fn       'icicle-file-of-content-apropos-complete-match)
       (icicle-last-apropos-complete-match-fn  'icicle-file-of-content-apropos-complete-match)
+      (icicle-full-cand-fn                    `(lambda (file)
+                                                (setq file  (if (file-directory-p file)
+                                                                (file-name-as-directory file)
+                                                              file))
+                                                ,(if icicle-pref-arg
+                                                     '(icicle-make-file+date-candidate file)
+                                                     '(list file))))
+      (icicle-abs-file-candidates             (mapcar icicle-full-cand-fn
+                                                      (directory-files default-directory 'FULL nil 'NOSORT)))
       (icicle-show-multi-completion-flag      t) ; Override user setting.
       (icicle-multi-completing-p              t)
       (icicle-list-use-nth-parts              '(1))
       (icicle-transform-before-sort-p         t)
-      (existing-bufs                          (buffer-list))
-      (new-bufs--to-kill                      ())
-      (new-bufs--to-keep                      ())
+      (icicle-existing-bufs                   (buffer-list))
+      (icicle-new-bufs-to-kill                ())
+      (icicle-new-bufs-to-keep                ())
+      (cleanup-code                     ; Use for both undo code and last code.
+       (lambda ()
+         (icicle-unbind-file-candidate-keys)
+         (define-key minibuffer-local-completion-map "\C-c\C-d" nil)
+         (define-key minibuffer-local-must-match-map "\C-c\C-d" nil)
+         (when icicle-kill-visited-buffers-flag
+           (dolist (buf  icicle-new-bufs-to-kill)
+;;;              $$$$$$ Why were we calling `restore-buffer-modified-p' before killing?
+;;;              (unless (memq buf icicle-new-bufs-to-keep)
+;;;                (when (buffer-live-p buf) ; Might have been killed, since both undo code and last code.
+;;;                  (with-current-buffer buf
+;;;                    (restore-buffer-modified-p nil) ; Just visiting can sometimes modify the buffer
+;;;                    (kill-buffer buf))))))))
+             (when (and (buffer-live-p buf)  (not (memq buf icicle-new-bufs-to-keep))) (kill-buffer buf))))))
       (icicle-all-candidates-list-alt-action-fn ; `M-|'
        (lambda (files) (let ((enable-recursive-minibuffers  t))
-                         (dired-other-window (cons (read-string "Dired buffer name: ") files)))))))
-    (progn (icicle-bind-file-candidate-keys) ; First code
-           (put-text-property 0 1 'icicle-fancy-candidates t prompt)
-           (icicle-highlight-lighter))
-    nil                                 ; Undo code
-    (progn (icicle-unbind-file-candidate-keys) ; Last code
-           (when (or (and init-pref-arg        (not icicle-kill-visited-buffers-flag))
-                     (and (not init-pref-arg)  icicle-kill-visited-buffers-flag))
-             (dolist (buf  new-bufs--to-kill)
-               (unless (memq buf new-bufs--to-keep)
-                 (with-current-buffer buf
-                   (restore-buffer-modified-p nil) ; Just visiting can sometimes modify the buffer
-                   (kill-buffer buf)))))))
+                         (dired-other-window (cons (read-string "Dired buffer name: ")
+                                                   (mapcar #'icicle-transform-multi-completion files))))))
+      (icicle-special-candidate-regexp        (or icicle-special-candidate-regexp  ".+/$"))
+      (icicle-candidate-properties-alist      (and icicle-pref-arg  '((1 (face icicle-candidate-part)))))
+      ))
+    (progn                              ; First code
+      (put-text-property 0 1 'icicle-fancy-candidates t prompt)
+      (setq current-prefix-arg  nil)    ; Reset, so can use it in action function.
+      (icicle-highlight-lighter)
+      (message "Gathering files...")
+      (icicle-bind-file-candidate-keys)
+      (define-key minibuffer-local-completion-map "\C-c\C-d" 'icicle-cd-for-abs-files)
+      (define-key minibuffer-local-must-match-map "\C-c\C-d" 'icicle-cd-for-abs-files))
+    (funcall cleanup-code)              ; Undo code
+    (funcall cleanup-code)              ; Last code
+    'NOT-INTERACTIVE-P)                 ; Not a real command - just a helper function.
+
+
+    (put 'icicle-recent-file-of-content 'icicle-hide-common-match t)
+    (put 'icicle-recent-file-of-content 'icicle-Completions-window-max-height 200)
+  (defun icicle-recent-file-of-content ()
+    "Open a recently used file.
+Completion candidates here are absolute, not relative, file names.
+Completion here matches candidates as ordinary strings.  It knows
+nothing of file names per se.  In particular, you cannot use remote
+file-name syntax.
 
+When you use this command with a prefix arg, you can choose also by
+date: Completion candidates include the last modification date.
 
-  (put 'icicle-find-file-of-content-other-window 'icicle-Completions-window-max-height 200)
-  (icicle-define-file-command icicle-find-file-of-content-other-window ; Not bound by default.
-    "Visit a file or dir whose name and/or content matches, in another window.
-Same as `icicle-find-file-of-content' except it uses a different window." ; Doc string
-    (lambda (file)                      ; Action function
-      ;; Free vars here: CURRENT-PREFIX-ARG, INIT-PREF-ARG, THIS-COMMAND, NEW-BUFS--TO-KEEP.
-      (let* ((r-o  (and (memq this-command '(icicle-candidate-action icicle-mouse-candidate-action
-                                             icicle-all-candidates-action))
-                        current-prefix-arg))
-             (fn   (if r-o 'find-file-read-only-other-window 'find-file-other-window)))
-        (setq file  (icicle-transform-multi-completion file))
-        (funcall fn file 'WILDCARDS)
-        (when (and (file-readable-p file)  (buffer-file-name)) (normal-mode)) ; Else in fundamental mode.
-        ;; Add the visited buffer to those we will keep (not kill).
-        ;; If FILE uses wildcards then there will be multiple such buffers.
-        ;; For a directory, get the Dired buffer instead of using `get-file-buffer'.
-        (let ((fil2  (if (string= "" (file-name-nondirectory file))  (directory-file-name file)  file)))
-          (dolist (fil  (file-expand-wildcards fil2))
-            (when (setq fil  (if (file-directory-p fil)
-                                 (get-buffer (file-name-nondirectory fil))
-                               (get-file-buffer fil)))
-              (push fil new-bufs--to-keep))))))
-    prompt nil (if (eq major-mode 'dired-mode) ; `read-file-name' args
-                   (condition-case nil  ; E.g. error because not on file line (ignore)
-                       (abbreviate-file-name (dired-get-file-for-visit))
-                     (error nil))
-                 default-directory)
-    (confirm-nonexistent-file-or-buffer) nil nil
+Whether or not you use a prefix argument, completion candidates are
+multi-completions, with the first part being the file name and the
+last part being the file contents.  If you use a prefix arg then there
+is a middle part, which is the last modification date for the file.
+
+For example, if you do not use a prefix arg then you can match files
+whose names contain `quine' and whose contents contain `curry' using
+this input pattern, where `^G^J' stands for the value of
+`icicle-list-join-string':
+
+quine.*^G^J.*curry
+
+If you use a prefix arg then you can match the subset of those files
+whose dates match `2013 11 21', using this input pattern:
+
+quine.*^G^J2013 11 21^G^J.*curry
+
+And if you use a prefix arg, so you can see the dates in
+`*Completions*', but you do not care to match the date, then you can
+use this input pattern:
+
+quine.*^G^J.*^G^J.*curry
+
+A prefix argument has a different meaning when used when you act on an
+individual completion candidate.  It means that you visit that file or
+directory in read-only mode.  This includes when you act on all
+candidates using \\<minibuffer-local-completion-map>`\\[icicle-all-candidates-action]': \
+precede the `\\[icicle-all-candidates-action]' with a prefix arg.
+
+This does not apply to the final candidate chosen (using `RET' or
+`mouse-2') - a prefix arg has no effect for that.
+
+During completion, you can use the following keys (`*' means this
+requires library `Bookmark+')\\<minibuffer-local-completion-map>:
+
+   C-c +        - create a new directory
+   \\[icicle-all-candidates-list-alt-action]          - open Dired on the currently matching file names
+   \\[icicle-delete-candidate-object]     - delete candidate file or (empty) dir
+ * C-x C-t *    - narrow to files with all of the tags you specify
+ * C-x C-t +    - narrow to files with some of the tags you specify
+ * C-x C-t % *  - narrow to files with all tags matching a regexp
+ * C-x C-t % +  - narrow to files with some tags  matching a regexp
+ * C-x a +      - add tags to current candidate
+ * C-x a -      - remove tags from current candidate
+ * C-x m        - access file bookmarks (not just autofiles)
+
+You can use any of the alternative-action keys, such as `\\[icicle-candidate-alt-action]', to
+remove a candidate file from the recent files list, `recentf-list'.
+\(The file itself is not deleted.)
+
+These options, when non-nil, control candidate matching and filtering:
+
+ `icicle-file-extras'           - Extra absolute file names to display
+ `icicle-file-match-regexp'     - Regexp that file names must match
+ `icicle-file-no-match-regexp'  - Regexp file names must not match
+ `icicle-file-predicate'        - Predicate file names must satisfy
+ `icicle-file-sort'             - Sort function for candidates
+
+For example, to show only names of files larger than 5000 bytes, set
+`icicle-file-predicate' to:
+
+  (lambda (file) (and (numberp (nth 7 (file-attributes file)))
+                      (> (nth 7 (file-attributes file)) 5000)))
+
+Option `icicle-file-require-match-flag' can be used to override
+option `icicle-require-match-flag'.
+
+Option `icicle-files-ido-like' non-nil gives this command a more
+Ido-like behavior.
+
+Because absolute file names can be long, with common prefixes, the
+common match portion of each candidate is hidden by default.  You can
+toggle this hiding using `\\[icicle-dispatch-C-x.]'."
+    (interactive)
+    (let ((icicle-find-file-abs-action-fn  'icicle-find-file-abs-of-content-action))
+      (icicle-recent-file-of-content-1)))
+
+
+  (put 'icicle-recent-file-of-content-other-window 'icicle-hide-common-match t)
+  (put 'icicle-recent-file-of-content-other-window 'icicle-Completions-window-max-height 200)
+  (defun icicle-recent-file-of-content-other-window ()
+    "Same as `icicle-recent-file-of-content' except uses another window."
+    (interactive)
+    (let ((icicle-find-file-abs-action-fn  'icicle-find-file-abs-of-content-other-window-action))
+      (icicle-recent-file-of-content-1)))
+
+  (icicle-define-command icicle-recent-file-of-content-1 ; Command name
+    "Helper for `icicle-recent-file-of-content(-other-window)'." ; Doc string
+    (lambda (fil) (funcall icicle-find-file-abs-action-fn fil)) ; FREE here: `icicle-find-file-abs-action-fn'.
+    prompt icicle-abs-file-candidates nil (confirm-nonexistent-file-or-buffer) nil ; `completing-read' args
+    'file-name-history (if (eq major-mode 'dired-mode)
+                           (condition-case nil ; E.g. error because not on file line (ignore)
+                               (abbreviate-file-name (dired-get-file-for-visit))
+                             (error nil))
+                         (and (boundp 'recentf-list)  (car recentf-list)))
+    nil
+    (icicle-file-bindings               ; Bindings
+     ((prompt                                 "Recent file (absolute): ")
+      (icicle-pref-arg                        current-prefix-arg)
+      (icicle-compute-narrowing-regexp-p      t) ; For progressive completion.
+      (icicle-apropos-complete-match-fn       'icicle-file-of-content-apropos-complete-match)
+      (icicle-last-apropos-complete-match-fn  'icicle-file-of-content-apropos-complete-match)
+      (icicle-full-cand-fn                    `(lambda (file)
+                                                (setq file  (if (file-directory-p file)
+                                                                (file-name-as-directory file)
+                                                              file))
+                                                ,(if icicle-pref-arg
+                                                     '(icicle-make-file+date-candidate file)
+                                                     '(list file))))
+      (icicle-abs-file-candidates
+       (progn (require 'recentf nil t)
+              (when (fboundp 'recentf-mode) (recentf-mode 99))
+              (unless (and (boundp 'recentf-list)  (consp recentf-list))
+                (icicle-user-error "Recent-files list is empty"))
+              (mapcar icicle-full-cand-fn recentf-list)))
+      (icicle-show-multi-completion-flag      t) ; Override user setting.
+      (icicle-multi-completing-p              t)
+      (icicle-list-use-nth-parts              '(1))
+      (icicle-transform-before-sort-p         t)
+      (icicle-existing-bufs                   (buffer-list))
+      (icicle-new-bufs-to-kill                ())
+      (icicle-new-bufs-to-keep                ())
+      (cleanup-code                     ; Use for both undo code and last code.
+       (lambda ()
+         (icicle-unbind-file-candidate-keys)
+         (when icicle-kill-visited-buffers-flag
+           (dolist (buf  icicle-new-bufs-to-kill)
+;;;              $$$$$$ Why were we calling `restore-buffer-modified-p' before killing?
+;;;              (unless (memq buf icicle-new-bufs-to-keep)
+;;;                (when (buffer-live-p buf) ; Might have been killed, since both undo code and last code.
+;;;                  (with-current-buffer buf
+;;;                    (restore-buffer-modified-p nil) ; Just visiting can sometimes modify the buffer
+;;;                    (kill-buffer buf))))))))
+             (when (and (buffer-live-p buf)  (not (memq buf icicle-new-bufs-to-keep))) (kill-buffer buf))))))
+      (icicle-all-candidates-list-alt-action-fn ; `M-|'
+       (lambda (files) (let ((enable-recursive-minibuffers  t))
+                         (dired-other-window (cons (read-string "Dired buffer name: ")
+                                                   (mapcar #'icicle-transform-multi-completion files))))))
+
+      (icicle-special-candidate-regexp        (or icicle-special-candidate-regexp  ".+/$"))
+      (icicle-candidate-properties-alist      (and icicle-pref-arg  '((1 (face icicle-candidate-part)))))
+      (icicle-sort-comparer                   'icicle-latest-access-first-p)
+      (icicle-candidate-alt-action-fn         'icicle-remove-from-recentf-candidate-action)
+      (icicle-use-candidates-only-once-alt-p  t)
+      ))
+    (progn                              ; First code
+      (put-text-property 0 1 'icicle-fancy-candidates t prompt)
+      (setq current-prefix-arg  nil)    ; Reset, so can use it in action function.
+      (icicle-highlight-lighter)
+      (message "Gathering files...")
+      (icicle-bind-file-candidate-keys))
+    (funcall cleanup-code)              ; Undo code
+    (funcall cleanup-code)              ; Last code
+    'NOT-INTERACTIVE-P)                 ; Not a real command - just a helper function.
+
+
+  (put 'icicle-locate-file-of-content 'icicle-turn-off-icomplete-mode t)
+  (put 'icicle-locate-file-of-content 'icicle-turn-off-incremental-completion t)
+  (put 'icicle-locate-file-of-content 'icicle-hide-common-match t)
+  (put 'icicle-locate-file-of-content 'icicle-Completions-window-max-height 200)
+  (defun icicle-locate-file-of-content ()
+    "Visit a file within one or more directories or their subdirectories.
+A prefix argument determines the behavior, as follows:
+
+* None: The default (i.e., current) directory is used.
+
+* Plain (`C-u'): You are prompted for the directories, using
+  multi-command `icicle-directory-list'.
+
+* Non-negative (>= 0): You are prompted for the directory.
+
+* Non-positive (<= 0): You can choose files also by date: A completion
+  candidate includes the last modification date of the file.
+
+* Double plain (`C-u C-u'): You are prompted for the directories and
+  candidates include last-modification dates.
+
+The absolute names of all files within a directory and all of its
+subdirectories are targets for completion.  Regexp input is matched
+against all parts of the absolute name, not just the file-name part.
+
+You can use this command to find all files within your file system
+that match a regexp, but be aware that gathering and matching the file
+names will take some time.
+
+See also command `icicle-locate-file-of-content-no-symlinks', which
+does the same thing but without following symbolic links.
+
+If you use Emacs on a platform that has an external program `locate',
+then consider using `icicle-locate-of-content' instead of
+`icicle-locate-file-of-content'.
+
+Remember that you can save the set of files matching your input using
+\\<minibuffer-local-completion-map>\
+`\\[icicle-candidate-set-save]' or \
+`\\[icicle-candidate-set-save-persistently]'.  You can then retrieve quickly them later using
+`\\[icicle-candidate-set-retrieve]' or \
+`\\[icicle-candidate-set-retrieve-persistent]'.
+
+Note that completion here matches candidates as ordinary strings.  It
+knows nothing of file names per se.  In particular, you cannot use
+remote file-name syntax.
+
+You cannot move up and down the file hierarchy the same way you can
+for ordinary (non-absolute) file-name completion.  To change to a
+different directory, with its files as candidates, use \\<minibuffer-local-completion-map>`C-c C-d' from
+the minibuffer - it prompts you for the new directory.
+
+During completion (`*' means this requires library `Bookmark+')\\<minibuffer-local-completion-map>, you
+can use the following keys:
+   C-c C-d      - change the `default-directory' (a la `cd')
+   C-c +        - create a new directory
+   \\[icicle-all-candidates-list-alt-action]          - open Dired on the currently matching file names
+   \\[icicle-delete-candidate-object]     - delete candidate file or (empty) dir
+ * C-x C-t *    - narrow to files with all of the tags you specify
+ * C-x C-t +    - narrow to files with some of the tags you specify
+ * C-x C-t % *  - narrow to files with all tags matching a regexp
+ * C-x C-t % +  - narrow to files with some tags  matching a regexp
+ * C-x a +      - add tags to current candidate
+ * C-x a -      - remove tags from current candidate
+ * C-x m        - access file bookmarks (not just autofiles)
+
+Directories in `icicle-ignored-directories' are ignored (skipped).  In
+addition, these options control candidate matching and filtering:
+
+ `icicle-file-extras'           - Extra absolute file names to display
+ `icicle-file-match-regexp'     - Regexp that file names must match
+ `icicle-file-no-match-regexp'  - Regexp file names must not match
+ `icicle-file-predicate'        - Predicate file names must satisfy
+ `icicle-file-require-match-flag' - See `icicle-require-match-flag'
+ `icicle-file-sort'             - Sort function for candidates
+
+For example, to show only names of files larger than 5000 bytes, set
+`icicle-file-predicate' to:
+
+  (lambda (file) (and (numberp (nth 7 (file-attributes file)))
+                      (> (nth 7 (file-attributes file)) 5000)))
+
+Because you will often use this command in contexts that result in
+many, many completion candidates, the following are turned off by
+default for this command:
+
+ * Icomplete mode.  You can toggle this using \\<minibuffer-local-completion-map>\
+`\\[icicle-toggle-icomplete-mode]'.
+ * Icicles incremental completion.  You can cycle this using `\\[icicle-cycle-incremental-completion]'.
+
+Because absolute file names can be long, with common prefixes, the
+common match portion of each candidate is hidden by default.  You can
+toggle this hiding using `\\[icicle-dispatch-C-x.]'."
+    (interactive)
+    (let ((icicle-find-file-abs-action-fn    'icicle-find-file-abs-of-content-action)
+          (icicle-locate-file-no-symlinks-p  nil))
+      (icicle-locate-file-of-content-1)))
+
+
+  (put 'icicle-locate-file-of-content-other-window 'icicle-turn-off-icomplete-mode t)
+  (put 'icicle-locate-file-of-content-other-window 'icicle-turn-off-incremental-completion t)
+  (put 'icicle-locate-file-of-content-other-window 'icicle-hide-common-match t)
+  (put 'icicle-locate-file-of-content-other-window 'icicle-Completions-window-max-height 200)
+  (defun icicle-locate-file-of-content-other-window ()
+    "Same as `icicle-locate-file-of-content' except uses another window.
+See also command `icicle-locate-file-no-symlinks-other-window', which
+does not follow symbolic links."
+    (interactive)
+    (let ((icicle-find-file-abs-action-fn    'icicle-find-file-abs-of-content-other-window-action)
+          (icicle-locate-file-no-symlinks-p  nil))
+      (icicle-locate-file-of-content-1)))
+
+
+  (put 'icicle-locate-of-content 'icicle-turn-off-icomplete-mode t)
+  (put 'icicle-locate-of-content 'icicle-turn-off-incremental-completion t)
+  (put 'icicle-locate-of-content 'icicle-hide-common-match t)
+  (put 'icicle-locate-of-content 'icicle-Completions-window-max-height 200)
+  (defun icicle-locate-of-content ()
+    "Run the external program `locate', then visit files.
+Unlike `icicle-locate-file-of-content' this is a wrapper for the
+external program `locate', which searches an index of files in your
+file system, which is normally created by external program `updatedb'.
+Because of this indexing, this command can be much faster than
+`icicle-locate-file-of-content'.
+
+`icicle-locate-of-content' first prompts for a search pattern for
+program `locate', which it passes to that program.  The absolute file
+names that match this pattern are targets for Icicles completion.
+
+`icicle-locate-of-content' uses settings from library `locate.el'
+where appropriate.  In particular, you can customize
+`locate-make-command-line' to use either regexp matching or file-name
+globbing.  Here is an example of a setup to use regexp matching:
+
+\(setq locate-make-command-line
+      (lambda (ss) (list locate-command \"--regex\" ss)))
+
+Which particular options the external program `locate' accepts, and
+how matching is performed, depend on your operating system and its
+implementation of that program.
+
+A prefix argument has the same meaning as for vanilla Emacs command
+`locate': prompt for a shell command to run instead of program
+`locate'.  A prefix arg has the effect of flipping the value of user
+option `locate-prompt-for-command' for the duration of the command
+invocation.
+
+After you input the search pattern for program `locate', normal
+Icicles input pattern matching is available for completion.  This is
+absolute file-name completion, so your input can match any parts of
+the name, including directory components.
+
+Remember that you can save the set of files matching your input using
+\\<minibuffer-local-completion-map>\
+`\\[icicle-candidate-set-save]' or \
+`\\[icicle-candidate-set-save-persistently]'.  You can then retrieve quickly them later using
+`\\[icicle-candidate-set-retrieve]' or \
+`\\[icicle-candidate-set-retrieve-persistent]'.
+
+Note that completion here matches candidates as ordinary strings.  It
+knows nothing of file names per se.  In particular, you cannot use
+remote file-name syntax.
+
+During completion (`*' means this requires library `Bookmark+')\\<minibuffer-local-completion-map>, you
+can use the following keys:
+   C-c +        - create a new directory
+   \\[icicle-all-candidates-list-alt-action]          - open Dired on the currently matching file names
+   \\[icicle-delete-candidate-object]     - delete candidate file or (empty) dir
+ * C-x C-t *    - narrow to files with all of the tags you specify
+ * C-x C-t +    - narrow to files with some of the tags you specify
+ * C-x C-t % *  - narrow to files with all tags matching a regexp
+ * C-x C-t % +  - narrow to files with some tags  matching a regexp
+ * C-x a +      - add tags to current candidate
+ * C-x a -      - remove tags from current candidate
+ * C-x m        - access file bookmarks (not just autofiles)
+
+These Icicles options control candidate matching and filtering:
+
+ `icicle-file-extras'           - Extra absolute file names to display
+ `icicle-file-match-regexp'     - Regexp that file names must match
+ `icicle-file-no-match-regexp'  - Regexp file names must not match
+ `icicle-file-predicate'        - Predicate file names must satisfy
+ `icicle-file-require-match-flag' - See `icicle-require-match-flag'
+ `icicle-file-sort'             - Sort function for candidates
+
+For example, to show only names of files larger than 5000 bytes, you
+could temporarily set `icicle-file-predicate' to:
+
+  (lambda (file) (and (numberp (nth 7 (file-attributes file)))
+                      (> (nth 7 (file-attributes file)) 5000)))
+
+Because you will often use this command in contexts that result in
+many, many completion candidates, the following are turned off by
+default for this command:
+
+ * Icomplete mode
+ * Iciciles incremental completion.  You can cycle this using \\<minibuffer-local-completion-map>\
+`\\[icicle-cycle-incremental-completion]'.
+
+Because absolute file names can be long, with common prefixes, the
+common match portion of each candidate is hidden by default.  You can
+toggle this hiding using `\\[icicle-dispatch-C-x.]'."
+    (interactive)
+    (let ((icicle-find-file-abs-action-fn   'icicle-find-file-abs-of-content-action)
+          (icicle-locate-file-use-locate-p  t))
+      (icicle-locate-file-of-content-1)))
+
+
+  (put 'icicle-locate-of-content-other-window 'icicle-turn-off-icomplete-mode t)
+  (put 'icicle-locate-of-content-other-window 'icicle-turn-off-incremental-completion t)
+  (put 'icicle-locate-of-content-other-window 'icicle-hide-common-match t)
+  (put 'icicle-locate-of-content-other-window 'icicle-Completions-window-max-height 200)
+  (defun icicle-locate-of-content-other-window ()
+    "Same as `icicle-locate-of-content' except uses another window."
+    (interactive)
+    (let ((icicle-find-file-abs-action-fn   'icicle-find-file-abs-of-content-other-window-action)
+          (icicle-locate-file-use-locate-p  t))
+      (icicle-locate-file-of-content-1)))
+
+
+  (put 'icicle-locate-file-of-content-no-symlinks 'icicle-turn-off-icomplete-mode t)
+  (put 'icicle-locate-file-of-content-no-symlinks 'icicle-turn-off-incremental-completion t)
+  (put 'icicle-locate-file-of-content-no-symlinks 'icicle-hide-common-match t)
+  (put 'icicle-locate-file-of-content-no-symlinks 'icicle-Completions-window-max-height 200)
+  (defun icicle-locate-file-of-content-no-symlinks ()
+    "Same as `icicle-locate-file-of-content', except do not follow symlinks."
+    (interactive)
+    (let ((icicle-find-file-abs-action-fn    'icicle-find-file-abs-of-content-action)
+          (icicle-locate-file-no-symlinks-p  t))
+      (icicle-locate-file-of-content-1)))
+
+
+  (put 'icicle-locate-file-of-content-no-symlinks-other-window 'icicle-turn-off-icomplete-mode t)
+  (put 'icicle-locate-file-of-content-no-symlinks-other-window 'icicle-turn-off-incremental-completion t)
+  (put 'icicle-locate-file-of-content-no-symlinks-other-window 'icicle-hide-common-match t)
+  (put 'icicle-locate-file-of-content-no-symlinks-other-window 'icicle-Completions-window-max-height 200)
+  (defun icicle-locate-file-of-content-no-symlinks-other-window ()
+    "Same as `icicle-locate-file-of-content-no-symlinks', except uses another window."
+    (interactive)
+    (let ((icicle-find-file-abs-action-fn    'icicle-find-file-abs-of-content-other-window-action)
+          (icicle-locate-file-no-symlinks-p  t))
+      (icicle-locate-file-of-content-1)))
+
+  (icicle-define-command icicle-locate-file-of-content-1
+    "Helper for `icicle-locate(-file-of-content(-no-symlinks))(-other-window)'." ; Doc string
+    (lambda (fil) (funcall icicle-find-file-abs-action-fn fil)) ; FREE here: `icicle-find-file-abs-action-fn'.
+    prompt icicle-abs-file-candidates nil (confirm-nonexistent-file-or-buffer) nil ; `completing-read' args
+    'file-name-history (if (eq major-mode 'dired-mode)
+                           (condition-case nil ; E.g. error because not on file line (ignore)
+                               (abbreviate-file-name (dired-get-file-for-visit))
+                             (error nil))
+                         default-directory)
+    nil
+    (icicle-file-bindings               ; Bindings
+     ((prompt                                 "File (absolute): ")
+      (icicle-pref-arg                        current-prefix-arg)
+      (icicle-compute-narrowing-regexp-p      t) ; For progressive completion.
+      (icicle-apropos-complete-match-fn       'icicle-file-of-content-apropos-complete-match)
+      (icicle-last-apropos-complete-match-fn  'icicle-file-of-content-apropos-complete-match)
+      (dirs                                   (and (not icicle-locate-file-use-locate-p)
+                                                   (cond ((and icicle-pref-arg  (consp icicle-pref-arg))
+                                                          (icicle-directory-list))
+                                                         ((and icicle-pref-arg
+                                                               (wholenump (prefix-numeric-value
+                                                                           icicle-pref-arg)))
+                                                          (read-file-name "Locate under which directory: "
+                                                                          nil default-directory nil))
+                                                         (t  default-directory))))
+      (icicle-full-cand-fn                    `(lambda (file)
+                                                (setq file  (if (file-directory-p file)
+                                                                (file-name-as-directory file)
+                                                              file))
+                                                ,(if icicle-pref-arg
+                                                     '(icicle-make-file+date-candidate file)
+                                                     '(list file))))
+      (IGNORED--FOR-SIDE-EFFECT
+       (progn (icicle-highlight-lighter)
+              (if icicle-locate-file-use-locate-p
+                  (require 'locate)     ; Hard-require: error if not there.
+                (message "Gathering files %s (this could take a while)..."
+                         (if (or (symbolp dirs)  (consp dirs))
+                             (format "in `%s'" (icicle-propertize dirs 'face 'icicle-msg-emphasis))
+                           (format "within `%s'" (icicle-propertize dirs 'face 'icicle-msg-emphasis)))))))
+      (icicle-abs-file-candidates
+       (mapcar (if icicle-pref-arg #'icicle-make-file+date-candidate #'list)
+               (if icicle-locate-file-use-locate-p
+                   (let* ((locate-buffer-name  " *Icicles Locate*")
+                          (temp-locate-buffer  (get-buffer-create locate-buffer-name)))
+                     (unwind-protect
+                          (with-current-buffer temp-locate-buffer
+                            (let ((cands  ()))
+                              (call-interactively #'locate) ; Gets `current-prefix-arg'.
+                              (dired-repeat-over-lines
+                               (count-lines (point-min) (point-max))
+                               (lambda () (push (dired-get-filename nil t) cands))) ; FREE here: CANDS.
+                              (nreverse cands)))
+                       (kill-buffer temp-locate-buffer)))
+                 (if (not (or (symbolp dirs)  (consp dirs)))
+                     (icicle-files-within (directory-files dirs 'full icicle-re-no-dot)
+                                          nil icicle-locate-file-no-symlinks-p)
+                   (apply #'append
+                          (mapcar (if icicle-locate-file-no-symlinks-p
+                                      (lambda (dir)
+                                        (icicle-remove-if
+                                         #'file-symlink-p
+                                         (directory-files dir 'full icicle-re-no-dot 'NOSORT)))
+                                    (lambda (dir) (directory-files dir 'full icicle-re-no-dot 'NOSORT)))
+                                  dirs))))))
+      (use-dialog-box                         nil)
+      (icicle-show-multi-completion-flag      t) ; Override user setting.
+      (icicle-multi-completing-p              t)
+      (icicle-list-use-nth-parts              '(1))
+      (icicle-transform-before-sort-p         t)
+      (icicle-existing-bufs                   (buffer-list))
+      (icicle-new-bufs-to-kill                ())
+      (icicle-new-bufs-to-keep                ())
+      (icicle-all-candidates-list-alt-action-fn ; `M-|'
+       (lambda (files) (let ((enable-recursive-minibuffers  t))
+                         (dired-other-window (cons (read-string "Dired buffer name: ")
+                                                   (mapcar #'icicle-transform-multi-completion files))))))
+      (icicle-special-candidate-regexp        (or icicle-special-candidate-regexp  ".+/$"))
+      (icicle-candidate-properties-alist      (and icicle-pref-arg  '((1 (face icicle-candidate-part)))))
+      (cleanup-code                     ; Use for both undo code and last code.
+       (lambda ()
+         (icicle-unbind-file-candidate-keys)
+         (unless icicle-locate-file-use-locate-p
+           (define-key minibuffer-local-completion-map "\C-c\C-d" nil)
+           (define-key minibuffer-local-must-match-map "\C-c\C-d" nil))
+         (when icicle-kill-visited-buffers-flag
+           (dolist (buf  icicle-new-bufs-to-kill)
+;;;              $$$$$$ Why were we calling `restore-buffer-modified-p' before killing?
+;;;              (unless (memq buf icicle-new-bufs-to-keep)
+;;;                (when (buffer-live-p buf) ; Might have been killed, since both undo code and last code.
+;;;                  (with-current-buffer buf
+;;;                    (restore-buffer-modified-p nil) ; Just visiting can sometimes modify the buffer
+;;;                    (kill-buffer buf))))))))
+             (when (and (buffer-live-p buf)  (not (memq buf icicle-new-bufs-to-keep))) (kill-buffer buf))))))))
+    (progn                              ; First code
+      (put-text-property 0 1 'icicle-fancy-candidates t prompt)
+      (setq current-prefix-arg  nil)    ; Reset, so can use it in action function.
+      (icicle-bind-file-candidate-keys)
+      (unless icicle-locate-file-use-locate-p
+        (define-key minibuffer-local-completion-map "\C-c\C-d" 'icicle-cd-for-loc-files)
+        (define-key minibuffer-local-must-match-map "\C-c\C-d" 'icicle-cd-for-loc-files)))
+    (funcall cleanup-code)              ; Undo code
+    (funcall cleanup-code)              ; Last code
+    'NOT-INTERACTIVE-P)                 ; Not a real command - just a helper function.
+
+
+  (put 'icicle-find-file-of-content-in-tags-table 'icicle-turn-off-icomplete-mode t)
+  (put 'icicle-find-file-of-content-in-tags-table 'icicle-turn-off-incremental-completion t)
+  (put 'icicle-find-file-of-content-in-tags-table 'icicle-Completions-window-max-height 200)
+  (defun i