lisp/emacs-lisp/easymenu.el

   1 ;;; easymenu.el --- support the easymenu interface for defining a menu
   2
   3 ;; Copyright (C) 1994, 1996, 1998, 1999, 2000, 2001, 2002, 2003,
   4 ;;   2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
   5
   6 ;; Keywords: emulations
   7 ;; Author: Richard Stallman <rms@gnu.org>
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software: you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation, either version 3 of the License, or
  14 ;; (at your option) any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;; Commentary:
  25
  26 ;; This is compatible with easymenu.el by Per Abrahamsen
  27 ;; but it is much simpler as it doesn't try to support other Emacs versions.
  28 ;; The code was mostly derived from lmenu.el.
  29
  30 ;;; Code:
  31
  32 (defcustom easy-menu-precalculate-equivalent-keybindings t
  33   "Determine when equivalent key bindings are computed for easy-menu menus.
  34 It can take some time to calculate the equivalent key bindings that are shown
  35 in a menu.  If the variable is on, then this calculation gives a (maybe
  36 noticeable) delay when a mode is first entered.  If the variable is off, then
  37 this delay will come when a menu is displayed the first time.  If you never use
  38 menus, turn this variable off, otherwise it is probably better to keep it on."
  39   :type 'boolean
  40   :group 'menu
  41   :version "20.3")
  42
  43 (defsubst easy-menu-intern (s)
  44   (if (stringp s) (intern s) s))
  45
  46 ;;;###autoload
  47 (put 'easy-menu-define 'lisp-indent-function 'defun)
  48 ;;;###autoload
  49 (defmacro easy-menu-define (symbol maps doc menu)
  50   "Define a menu bar submenu in maps MAPS, according to MENU.
  51
  52 If SYMBOL is non-nil, store the menu keymap in the value of SYMBOL,
  53 and define SYMBOL as a function to pop up the menu, with DOC as its doc string.
  54 If SYMBOL is nil, just store the menu keymap into MAPS.
  55
  56 The first element of MENU must be a string.  It is the menu bar item name.
  57 It may be followed by the following keyword argument pairs
  58
  59    :filter FUNCTION
  60
  61 FUNCTION is a function with one argument, the rest of menu items.
  62 It returns the remaining items of the displayed menu.
  63
  64    :visible INCLUDE
  65
  66 INCLUDE is an expression; this menu is only visible if this
  67 expression has a non-nil value.  `:included' is an alias for `:visible'.
  68
  69    :active ENABLE
  70
  71 ENABLE is an expression; the menu is enabled for selection
  72 whenever this expression's value is non-nil.
  73
  74 The rest of the elements in MENU, are menu items.
  75
  76 A menu item is usually a vector of three elements:  [NAME CALLBACK ENABLE]
  77
  78 NAME is a string--the menu item name.
  79
  80 CALLBACK is a command to run when the item is chosen,
  81 or a list to evaluate when the item is chosen.
  82
  83 ENABLE is an expression; the item is enabled for selection
  84 whenever this expression's value is non-nil.
  85
  86 Alternatively, a menu item may have the form:
  87
  88    [ NAME CALLBACK [ KEYWORD ARG ] ... ]
  89
  90 Where KEYWORD is one of the symbols defined below.
  91
  92    :keys KEYS
  93
  94 KEYS is a string; a complex keyboard equivalent to this menu item.
  95 This is normally not needed because keyboard equivalents are usually
  96 computed automatically.
  97 KEYS is expanded with `substitute-command-keys' before it is used.
  98
  99    :key-sequence KEYS
 100
 101 KEYS is nil, a string or a vector; nil or a keyboard equivalent to this
 102 menu item.
 103 This is a hint that will considerably speed up Emacs' first display of
 104 a menu.  Use `:key-sequence nil' when you know that this menu item has no
 105 keyboard equivalent.
 106
 107    :active ENABLE
 108
 109 ENABLE is an expression; the item is enabled for selection
 110 whenever this expression's value is non-nil.
 111
 112    :visible INCLUDE
 113
 114 INCLUDE is an expression; this item is only visible if this
 115 expression has a non-nil value.  `:included' is an alias for `:visible'.
 116
 117    :label FORM
 118
 119 FORM is an expression that will be dynamically evaluated and whose
 120 value will be used for the menu entry's text label (the default is NAME).
 121
 122    :suffix FORM
 123
 124 FORM is an expression that will be dynamically evaluated and whose
 125 value will be concatenated to the menu entry's label.
 126
 127    :style STYLE
 128
 129 STYLE is a symbol describing the type of menu item.  The following are
 130 defined:
 131
 132 toggle: A checkbox.
 133         Prepend the name with `(*) ' or `( ) ' depending on if selected or not.
 134 radio: A radio button.
 135        Prepend the name with `[X] ' or `[ ] ' depending on if selected or not.
 136 button: Surround the name with `[' and `]'.  Use this for an item in the
 137         menu bar itself.
 138 anything else means an ordinary menu item.
 139
 140    :selected SELECTED
 141
 142 SELECTED is an expression; the checkbox or radio button is selected
 143 whenever this expression's value is non-nil.
 144
 145    :help HELP
 146
 147 HELP is a string, the help to display for the menu item.
 148
 149 A menu item can be a string.  Then that string appears in the menu as
 150 unselectable text.  A string consisting solely of hyphens is displayed
 151 as a solid horizontal line.
 152
 153 A menu item can be a list with the same format as MENU.  This is a submenu."
 154   `(progn
 155      ,(if symbol `(defvar ,symbol nil ,doc))
 156      (easy-menu-do-define (quote ,symbol) ,maps ,doc ,menu)))
 157
 158 (defun easy-menu-binding (menu &optional item-name)
 159   "Return a binding suitable to pass to `define-key'.
 160 This is expected to be bound to a mouse event."
 161   ;; Under Emacs this is almost trivial, whereas under XEmacs this may
 162   ;; involve defining a function that calls popup-menu.
 163   (let ((props (if (symbolp menu)
 164                    (prog1 (get menu 'menu-prop)
 165                      (setq menu (symbol-function menu))))))
 166     (cons 'menu-item
 167           (cons (or item-name
 168                     (if (keymapp menu)
 169                         (keymap-prompt menu))
 170                     "")
 171                 (cons menu props)))))
 172
 173 ;;;###autoload
 174 (defun easy-menu-do-define (symbol maps doc menu)
 175   ;; We can't do anything that might differ between Emacs dialects in
 176   ;; `easy-menu-define' in order to make byte compiled files
 177   ;; compatible.  Therefore everything interesting is done in this
 178   ;; function.
 179   (let ((keymap (easy-menu-create-menu (car menu) (cdr menu))))
 180     (when symbol
 181       (set symbol keymap)
 182       (defalias symbol
 183         `(lambda (event) ,doc (interactive "@e")
 184            ;; FIXME: XEmacs uses popup-menu which calls the binding
 185            ;; while x-popup-menu only returns the selection.
 186            (x-popup-menu event
 187                          (or (and (symbolp ,symbol)
 188                                   (funcall
 189                                    (or (plist-get (get ,symbol 'menu-prop)
 190                                                   :filter)
 191                                        'identity)
 192                                    (symbol-function ,symbol)))
 193                              ,symbol)))))
 194     (dolist (map (if (keymapp maps) (list maps) maps))
 195       (define-key map
 196         (vector 'menu-bar (easy-menu-intern (car menu)))
 197         (easy-menu-binding keymap (car menu))))))
 198
 199 (defun easy-menu-filter-return (menu &optional name)
 200  "Convert MENU to the right thing to return from a menu filter.
 201 MENU is a menu as computed by `easy-menu-define' or `easy-menu-create-menu' or
 202 a symbol whose value is such a menu.
 203 In Emacs a menu filter must return a menu (a keymap), in XEmacs a filter must
 204 return a menu items list (without menu name and keywords).
 205 This function returns the right thing in the two cases.
 206 If NAME is provided, it is used for the keymap."
 207  (cond
 208   ((and (not (keymapp menu)) (consp menu))
 209    ;; If it's a cons but not a keymap, then it can't be right
 210    ;; unless it's an XEmacs menu.
 211    (setq menu (easy-menu-create-menu (or name "") menu)))
 212   ((vectorp menu)
 213    ;; It's just a menu entry.
 214    (setq menu (cdr (easy-menu-convert-item menu)))))
 215  menu)
 216
 217 (defvar easy-menu-avoid-duplicate-keys t
 218   "Dynamically scoped var to register already used keys in a menu.
 219 If it holds a list, this is expected to be a list of keys already seen in the
 220 menu we're processing.  Else it means we're not processing a menu.")
 221
 222 ;;;###autoload
 223 (defun easy-menu-create-menu (menu-name menu-items)
 224   "Create a menu called MENU-NAME with items described in MENU-ITEMS.
 225 MENU-NAME is a string, the name of the menu.  MENU-ITEMS is a list of items
 226 possibly preceded by keyword pairs as described in `easy-menu-define'."
 227   (let ((menu (make-sparse-keymap menu-name))
 228         (easy-menu-avoid-duplicate-keys nil)
 229         prop keyword arg label enable filter visible help)
 230     ;; Look for keywords.
 231     (while (and menu-items
 232                 (cdr menu-items)
 233                 (keywordp (setq keyword (car menu-items))))
 234       (setq arg (cadr menu-items))
 235       (setq menu-items (cddr menu-items))
 236       (cond
 237        ((eq keyword :filter)
 238         (setq filter `(lambda (menu)
 239                         (easy-menu-filter-return (,arg menu) ,menu-name))))
 240        ((eq keyword :active) (setq enable (or arg ''nil)))
 241        ((eq keyword :label) (setq label arg))
 242        ((eq keyword :help) (setq help arg))
 243        ((or (eq keyword :included) (eq keyword :visible))
 244         (setq visible (or arg ''nil)))))
 245     (if (equal visible ''nil)
 246         nil                             ; Invisible menu entry, return nil.
 247       (if (and visible (not (easy-menu-always-true-p visible)))
 248           (setq prop (cons :visible (cons visible prop))))
 249       (if (and enable (not (easy-menu-always-true-p enable)))
 250           (setq prop (cons :enable (cons enable prop))))
 251       (if filter (setq prop (cons :filter (cons filter prop))))
 252       (if help (setq prop (cons :help (cons help prop))))
 253       (if label (setq prop (cons nil (cons label prop))))
 254       (if filter
 255           ;; The filter expects the menu in its XEmacs form and the pre-filter
 256           ;; form will only be passed to the filter anyway, so we'd better
 257           ;; not convert it at all (it will be converted on the fly by
 258           ;; easy-menu-filter-return).
 259           (setq menu menu-items)
 260         (setq menu (append menu (mapcar 'easy-menu-convert-item menu-items))))
 261       (when prop
 262         (setq menu (easy-menu-make-symbol menu 'noexp))
 263         (put menu 'menu-prop prop))
 264       menu)))
 265
 266
 267 ;; Known button types.
 268 (defvar easy-menu-button-prefix
 269   '((radio . :radio) (toggle . :toggle)))
 270
 271 (defvar easy-menu-converted-items-table (make-hash-table :test 'equal))
 272
 273 (defun easy-menu-convert-item (item)
 274   "Memoize the value returned by `easy-menu-convert-item-1' called on ITEM.
 275 This makes key-shortcut-caching work a *lot* better when this
 276 conversion is done from within a filter.
 277 This also helps when the NAME of the entry is recreated each time:
 278 since the menu is built and traversed separately, the lookup
 279 would always fail because the key is `equal' but not `eq'."
 280   (or (gethash item easy-menu-converted-items-table)
 281       (puthash item (easy-menu-convert-item-1 item)
 282                easy-menu-converted-items-table)))
 283
 284 (defun easy-menu-convert-item-1 (item)
 285   "Parse an item description and convert it to a menu keymap element.
 286 ITEM defines an item as in `easy-menu-define'."
 287   (let (name command label prop remove)
 288     (cond
 289      ((stringp item)                    ; An item or separator.
 290       (setq label item))
 291      ((consp item)                      ; A sub-menu
 292       (setq label (setq name (car item)))
 293       (setq command (cdr item))
 294       (if (not (keymapp command))
 295           (setq command (easy-menu-create-menu name command)))
 296       (if (null command)
 297           ;; Invisible menu item. Don't insert into keymap.
 298           (setq remove t)
 299         (when (and (symbolp command) (setq prop (get command 'menu-prop)))
 300           (when (null (car prop))
 301             (setq label (cadr prop))
 302             (setq prop (cddr prop)))
 303           (setq command (symbol-function command)))))
 304      ((vectorp item)                    ; An item.
 305       (let* ((ilen (length item))
 306              (active (if (> ilen 2) (or (aref item 2) ''nil) t))
 307              (no-name (not (symbolp (setq command (aref item 1)))))
 308              cache cache-specified)
 309         (setq label (setq name (aref item 0)))
 310         (if no-name (setq command (easy-menu-make-symbol command)))
 311         (if (keywordp active)
 312             (let ((count 2)
 313                   keyword arg suffix visible style selected keys)
 314               (setq active nil)
 315               (while (> ilen count)
 316                 (setq keyword (aref item count))
 317                 (setq arg (aref item (1+ count)))
 318                 (setq count (+ 2 count))
 319                 (cond
 320                  ((or (eq keyword :included) (eq keyword :visible))
 321                   (setq visible (or arg ''nil)))
 322                  ((eq keyword :key-sequence)
 323                   (setq cache arg cache-specified t))
 324                  ((eq keyword :keys) (setq keys arg no-name nil))
 325                  ((eq keyword :label) (setq label arg))
 326                  ((eq keyword :active) (setq active (or arg ''nil)))
 327                  ((eq keyword :help) (setq prop (cons :help (cons arg prop))))
 328                  ((eq keyword :suffix) (setq suffix arg))
 329                  ((eq keyword :style) (setq style arg))
 330                  ((eq keyword :selected) (setq selected (or arg ''nil)))))
 331               (if suffix
 332                   (setq label
 333                         (if (stringp suffix)
 334                             (if (stringp label) (concat label " " suffix)
 335                               (list 'concat label (concat " " suffix)))
 336                           (if (stringp label)
 337                               (list 'concat (concat label " ") suffix)
 338                             (list 'concat label " " suffix)))))
 339               (cond
 340                ((eq style 'button)
 341                 (setq label (if (stringp label) (concat "[" label "]")
 342                               (list 'concat "[" label "]"))))
 343                ((and selected
 344                      (setq style (assq style easy-menu-button-prefix)))
 345                 (setq prop (cons :button
 346                                  (cons (cons (cdr style) selected) prop)))))
 347               (when (stringp keys)
 348                 (if (string-match "^[^\\]*\\(\\\\\\[\\([^]]+\\)]\\)[^\\]*$"
 349                                   keys)
 350                     (let ((prefix
 351                            (if (< (match-beginning 0) (match-beginning 1))
 352                                (substring keys 0 (match-beginning 1))))
 353                           (postfix
 354                            (if (< (match-end 1) (match-end 0))
 355                                (substring keys (match-end 1))))
 356                           (cmd (intern (match-string 2 keys))))
 357                       (setq keys (and (or prefix postfix)
 358                                       (cons prefix postfix)))
 359                       (setq keys
 360                             (and (or keys (not (eq command cmd)))
 361                                  (cons cmd keys))))
 362                   (setq cache-specified nil))
 363                 (if keys (setq prop (cons :keys (cons keys prop)))))
 364               (if (and visible (not (easy-menu-always-true-p visible)))
 365                   (if (equal visible ''nil)
 366                       ;; Invisible menu item. Don't insert into keymap.
 367                       (setq remove t)
 368                     (setq prop (cons :visible (cons visible prop)))))))
 369         (if (and active (not (easy-menu-always-true-p active)))
 370             (setq prop (cons :enable (cons active prop))))
 371         (if (and (or no-name cache-specified)
 372                  (or (null cache) (stringp cache) (vectorp cache)))
 373             (setq prop (cons :key-sequence (cons cache prop))))))
 374      (t (error "Invalid menu item in easymenu")))
 375     ;; `intern' the name so as to merge multiple entries with the same name.
 376     ;; It also makes it easier/possible to lookup/change menu bindings
 377     ;; via keymap functions.
 378     (let ((key (easy-menu-intern name)))
 379       (when (listp easy-menu-avoid-duplicate-keys)
 380         ;; Merging multiple entries with the same name is sometimes what we
 381         ;; want, but not when the entries are actually different (e.g. same
 382         ;; name but different :suffix as seen in cal-menu.el) and appear in
 383         ;; the same menu.  So we try to detect and resolve conflicts.
 384         (while (and (stringp name)
 385                     (memq key easy-menu-avoid-duplicate-keys))
 386           ;; We need to use some distinct object, ideally a symbol, ideally
 387           ;; related to the `name'.  Uninterned symbols do not work (they
 388           ;; are apparently turned into strings and re-interned later on).
 389           (setq key (intern (format "%s (%d)" (symbol-name key)
 390                                     (length easy-menu-avoid-duplicate-keys)))))
 391         (push key easy-menu-avoid-duplicate-keys))
 392
 393       (cons key
 394             (and (not remove)
 395                  (cons 'menu-item
 396                        (cons label
 397                              (and name
 398                                   (cons command prop)))))))))
 399
 400 (defun easy-menu-define-key (menu key item &optional before)
 401   "Add binding in MENU for KEY => ITEM.  Similar to `define-key-after'.
 402 If KEY is not nil then delete any duplications.
 403 If ITEM is nil, then delete the definition of KEY.
 404
 405 Optional argument BEFORE is nil or a key in MENU.  If BEFORE is not nil,
 406 put binding before the item in MENU named BEFORE; otherwise,
 407 if a binding for KEY is already present in MENU, just change it;
 408 otherwise put the new binding last in MENU.
 409 BEFORE can be either a string (menu item name) or a symbol
 410 \(the fake function key for the menu item).
 411 KEY does not have to be a symbol, and comparison is done with equal."
 412   (if (symbolp menu) (setq menu (indirect-function menu)))
 413   (let ((inserted (null item))          ; Fake already inserted.
 414         tail done)
 415     (while (not done)
 416       (cond
 417        ((or (setq done (or (null (cdr menu)) (keymapp (cdr menu))))
 418             (and before (easy-menu-name-match before (cadr menu))))
 419         ;; If key is nil, stop here, otherwise keep going past the
 420         ;; inserted element so we can delete any duplications that come
 421         ;; later.
 422         (if (null key) (setq done t))
 423         (unless inserted                ; Don't insert more than once.
 424           (setcdr menu (cons (cons key item) (cdr menu)))
 425           (setq inserted t)
 426           (setq menu (cdr menu)))
 427         (setq menu (cdr menu)))
 428        ((and key (equal (car-safe (cadr menu)) key))
 429         (if (or inserted                ; Already inserted or
 430                 (and before             ;  wanted elsewhere and
 431                      (setq tail (cddr menu)) ; not last item and not
 432                      (not (keymapp tail))
 433                      (not (easy-menu-name-match
 434                            before (car tail))))) ; in position
 435             (setcdr menu (cddr menu))   ; Remove item.
 436           (setcdr (cadr menu) item)     ; Change item.
 437           (setq inserted t)
 438           (setq menu (cdr menu))))
 439        (t (setq menu (cdr menu)))))))
 440
 441 (defun easy-menu-name-match (name item)
 442   "Return t if NAME is the name of menu item ITEM.
 443 NAME can be either a string, or a symbol.
 444 ITEM should be a keymap binding of the form (KEY . MENU-ITEM)."
 445   (if (consp item)
 446       (if (symbolp name)
 447           (eq (car-safe item) name)
 448         (if (stringp name)
 449             ;; Match against the text that is displayed to the user.
 450             (or (condition-case nil (member-ignore-case name item)
 451                   (error nil))          ;`item' might not be a proper list.
 452                 ;; Also check the string version of the symbol name,
 453                 ;; for backwards compatibility.
 454                 (eq (car-safe item) (intern name)))))))
 455
 456 (defun easy-menu-always-true-p (x)
 457   "Return true if form X never evaluates to nil."
 458   (if (consp x) (and (eq (car x) 'quote) (cadr x))
 459     (or (eq x t) (not (symbolp x)))))
 460
 461 (defvar easy-menu-item-count 0)
 462
 463 (defun easy-menu-make-symbol (callback &optional noexp)
 464   "Return a unique symbol with CALLBACK as function value.
 465 When non-nil, NOEXP indicates that CALLBACK cannot be an expression
 466 \(i.e. does not need to be turned into a function)."
 467   (let ((command
 468          (make-symbol (format "menu-function-%d" easy-menu-item-count))))
 469     (setq easy-menu-item-count (1+ easy-menu-item-count))
 470     (fset command
 471           (if (or (keymapp callback) (commandp callback)
 472                   ;; `functionp' is probably not needed.
 473                   (functionp callback) noexp)
 474               callback
 475             `(lambda () (interactive) ,callback)))
 476     command))
 477
 478 ;;;###autoload
 479 (defun easy-menu-change (path name items &optional before map)
 480   "Change menu found at PATH as item NAME to contain ITEMS.
 481 PATH is a list of strings for locating the menu that
 482 should contain a submenu named NAME.
 483 ITEMS is a list of menu items, as in `easy-menu-define'.
 484 These items entirely replace the previous items in that submenu.
 485
 486 If MAP is specified, it should normally be a keymap; nil stands for the local
 487 menu-bar keymap.  It can also be a symbol, which has earlier been used as the
 488 first argument in a call to `easy-menu-define', or the value of such a symbol.
 489
 490 If the menu located by PATH has no submenu named NAME, add one.
 491 If the optional argument BEFORE is present, add it just before
 492 the submenu named BEFORE, otherwise add it at the end of the menu.
 493
 494 To implement dynamic menus, either call this from
 495 `menu-bar-update-hook' or use a menu filter."
 496   (easy-menu-add-item map path (easy-menu-create-menu name items) before))
 497
 498 ;; XEmacs needs the following two functions to add and remove menus.
 499 ;; In Emacs this is done automatically when switching keymaps, so
 500 ;; here easy-menu-remove is a noop and easy-menu-add only precalculates
 501 ;; equivalent keybindings (if easy-menu-precalculate-equivalent-keybindings
 502 ;; is on).
 503 (defalias 'easy-menu-remove 'ignore
 504   "Remove MENU from the current menu bar.
 505 Contrary to XEmacs, this is a nop on Emacs since menus are automatically
 506 \(de)activated when the corresponding keymap is (de)activated.
 507
 508 \(fn MENU)")
 509
 510 (defun easy-menu-add (menu &optional map)
 511   "Add the menu to the menubar.
 512 On Emacs, menus are already automatically activated when the
 513 corresponding keymap is activated.  On XEmacs this is needed to
 514 actually add the menu to the current menubar.
 515
 516 This also precalculates equivalent key bindings when
 517 `easy-menu-precalculate-equivalent-keybindings' is on.
 518
 519 You should call this once the menu and keybindings are set up
 520 completely and menu filter functions can be expected to work."
 521   (when easy-menu-precalculate-equivalent-keybindings
 522     (if (and (symbolp menu) (not (keymapp menu)) (boundp menu))
 523         (setq menu (symbol-value menu)))
 524     (and (keymapp menu) (fboundp 'x-popup-menu)
 525          (x-popup-menu nil menu))
 526     ))
 527
 528 (defun add-submenu (menu-path submenu &optional before in-menu)
 529   "Add submenu SUBMENU in the menu at MENU-PATH.
 530 If BEFORE is non-nil, add before the item named BEFORE.
 531 If IN-MENU is non-nil, follow MENU-PATH in IN-MENU.
 532 This is a compatibility function; use `easy-menu-add-item'."
 533   (easy-menu-add-item (or in-menu (current-global-map))
 534                       (cons "menu-bar" menu-path)
 535                       submenu before))
 536
 537 (defun easy-menu-add-item (map path item &optional before)
 538   "To the submenu of MAP with path PATH, add ITEM.
 539
 540 If an item with the same name is already present in this submenu,
 541 then ITEM replaces it.  Otherwise, ITEM is added to this submenu.
 542 In the latter case, ITEM is normally added at the end of the submenu.
 543 However, if BEFORE is a string and there is an item in the submenu
 544 with that name, then ITEM is added before that item.
 545
 546 MAP should normally be a keymap; nil stands for the local menu-bar keymap.
 547 It can also be a symbol, which has earlier been used as the first
 548 argument in a call to `easy-menu-define', or the value of such a symbol.
 549
 550 PATH is a list of strings for locating the submenu where ITEM is to be
 551 added.  If PATH is nil, MAP itself is used.  Otherwise, the first
 552 element should be the name of a submenu directly under MAP.  This
 553 submenu is then traversed recursively with the remaining elements of PATH.
 554
 555 ITEM is either defined as in `easy-menu-define' or a non-nil value returned
 556 by `easy-menu-item-present-p' or `easy-menu-remove-item' or a menu defined
 557 earlier by `easy-menu-define' or `easy-menu-create-menu'."
 558   (setq map (easy-menu-get-map map path
 559                                (and (null map) (null path)
 560                                     (stringp (car-safe item))
 561                                     (car item))))
 562   (if (and (consp item) (consp (cdr item)) (eq (cadr item) 'menu-item))
 563       ;; This is a value returned by `easy-menu-item-present-p' or
 564       ;; `easy-menu-remove-item'.
 565       (easy-menu-define-key map (easy-menu-intern (car item))
 566                             (cdr item) before)
 567     (if (or (keymapp item)
 568             (and (symbolp item) (keymapp (symbol-value item))
 569                  (setq item (symbol-value item))))
 570         ;; Item is a keymap, find the prompt string and use as item name.
 571         (setq item (cons (keymap-prompt item) item)))
 572     (setq item (easy-menu-convert-item item))
 573     (easy-menu-define-key map (easy-menu-intern (car item)) (cdr item) before)))
 574
 575 (defun easy-menu-item-present-p (map path name)
 576   "In submenu of MAP with path PATH, return non-nil if item NAME is present.
 577 MAP and PATH are defined as in `easy-menu-add-item'.
 578 NAME should be a string, the name of the element to be looked for."
 579   (easy-menu-return-item (easy-menu-get-map map path) name))
 580
 581 (defun easy-menu-remove-item (map path name)
 582   "From submenu of MAP with path PATH remove item NAME.
 583 MAP and PATH are defined as in `easy-menu-add-item'.
 584 NAME should be a string, the name of the element to be removed."
 585   (setq map (easy-menu-get-map map path))
 586   (let ((ret (easy-menu-return-item map name)))
 587     (if ret (easy-menu-define-key map (easy-menu-intern name) nil))
 588     ret))
 589
 590 (defun easy-menu-return-item (menu name)
 591   "In menu MENU try to look for menu item with name NAME.
 592 If a menu item is found, return (NAME . item), otherwise return nil.
 593 If item is an old format item, a new format item is returned."
 594   ;; The call to `lookup-key' also calls the C function `get_keyelt' which
 595   ;; looks inside a menu-item to only return the actual command.  This is
 596   ;; not what we want here.  We should either add an arg to lookup-key to be
 597   ;; able to turn off this "feature", or else we could use map-keymap here.
 598   ;; In the mean time, I just use `assq' which is an OK approximation since
 599   ;; menus are rarely built from vectors or char-tables.
 600   (let ((item (or (cdr (assq name menu))
 601                   (lookup-key menu (vector (easy-menu-intern name)))))
 602         ret enable cache label)
 603     (cond
 604      ((stringp (car-safe item))
 605       ;; This is the old menu format. Convert it to new format.
 606       (setq label (car item))
 607       (when (stringp (car (setq item (cdr item)))) ; Got help string
 608         (setq ret (list :help (car item)))
 609         (setq item (cdr item)))
 610       (when (and (consp item) (consp (car item))
 611                  (or (null (caar item)) (numberp (caar item))))
 612         (setq cache (car item))         ; Got cache
 613         (setq item (cdr item)))
 614       (and (symbolp item) (setq enable (get item 'menu-enable)) ; Got enable
 615            (setq ret (cons :enable (cons enable ret))))
 616       (if cache (setq ret (cons cache ret)))
 617       (cons name (cons 'menu-enable (cons label (cons item ret)))))
 618      (item ; (or (symbolp item) (keymapp item) (eq (car-safe item) 'menu-item))
 619       (cons name item))                 ; Keymap or new menu format
 620      )))
 621
 622 (defun easy-menu-lookup-name (map name)
 623   "Lookup menu item NAME in keymap MAP.
 624 Like `lookup-key' except that NAME is not an array but just a single key
 625 and that NAME can be a string representing the menu item's name."
 626   (or (lookup-key map (vector (easy-menu-intern name)))
 627       (when (stringp name)
 628         ;; `lookup-key' failed and we have a menu item name: look at the
 629         ;; actual menu entries's names.
 630         (catch 'found
 631           (map-keymap (lambda (key item)
 632                         (if (condition-case nil (member name item)
 633                               (error nil))
 634                             ;; Found it!!  Look for it again with
 635                             ;; `lookup-key' so as to handle inheritance and
 636                             ;; to extract the actual command/keymap bound to
 637                             ;; `name' from the item (via get_keyelt).
 638                             (throw 'found (lookup-key map (vector key)))))
 639                       map)))))
 640
 641 (defun easy-menu-get-map (map path &optional to-modify)
 642   "Return a sparse keymap in which to add or remove an item.
 643 MAP and PATH are as defined in `easy-menu-add-item'.
 644
 645 TO-MODIFY, if non-nil, is the name of the item the caller
 646 wants to modify in the map that we return.
 647 In some cases we use that to select between the local and global maps."
 648   (setq map
 649         (catch 'found
 650           (if (and map (symbolp map) (not (keymapp map)))
 651               (setq map (symbol-value map)))
 652           (let ((maps (if map (if (keymapp map) (list map) map)
 653                         (current-active-maps))))
 654             ;; Look for PATH in each map.
 655             (unless map (push 'menu-bar path))
 656             (dolist (name path)
 657               (setq maps
 658                     (delq nil (mapcar (lambda (map)
 659                                         (setq map (easy-menu-lookup-name
 660                                                    map name))
 661                                         (and (keymapp map) map))
 662                                       maps))))
 663
 664             ;; Prefer a map that already contains the to-be-modified entry.
 665             (when to-modify
 666               (dolist (map maps)
 667                 (when (easy-menu-lookup-name map to-modify)
 668                   (throw 'found map))))
 669             ;; Use the first valid map.
 670             (when maps (throw 'found (car maps)))
 671
 672             ;; Otherwise, make one up.
 673             ;; Hardcoding current-local-map is lame, but it's difficult
 674             ;; to know what the caller intended for us to do ;-(
 675             (let* ((name (if path (format "%s" (car (reverse path)))))
 676                    (newmap (make-sparse-keymap name)))
 677               (define-key (or map (current-local-map))
 678                 (apply 'vector (mapcar 'easy-menu-intern path))
 679                 (if name (cons name newmap) newmap))
 680               newmap))))
 681   (or (keymapp map) (error "Malformed menu in easy-menu: (%s)" map))
 682   map)
 683
 684 (provide 'easymenu)
 685
 686 ;; arch-tag: 2a04020d-90d2-476d-a7c6-71e072007a4a
 687 ;;; easymenu.el ends here