Current File : //proc/self/root/kunden/usr/share/emacs/27.2/lisp/emacs-lisp/easymenu.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


#@460 Determine when equivalent key bindings are computed for easy-menu menus.
It can take some time to calculate the equivalent key bindings that are shown
in a menu.  If the variable is on, then this calculation gives a (maybe
noticeable) delay when a mode is first entered.  If the variable is off, then
this delay will come when a menu is displayed the first time.  If you never use
menus, turn this variable off, otherwise it is probably better to keep it on.
(defvar easy-menu-precalculate-equivalent-keybindings nil (#$ . 409))
(make-obsolete-variable 'easy-menu-precalculate-equivalent-keybindings nil "23.1")
#@10 

(fn S)
(defalias 'easy-menu-intern #[257 "\211;\203	\300
!\207\207" [intern] 3 (#$ . 1027)])
(put 'easy-menu-intern 'byte-optimizer 'byte-compile-inline-expand)
#@3810 Define a pop-up menu and/or menu bar menu specified by MENU.
If SYMBOL is non-nil, define SYMBOL as a function to pop up the
submenu defined by MENU, with DOC as its doc string.

MAPS, if non-nil, should be a keymap or a list of keymaps; add
the submenu defined by MENU to the keymap or each of the keymaps,
as a top-level menu bar item.

The first element of MENU must be a string.  It is the menu bar
item name.  It may be followed by the following keyword argument
pairs:

 :filter FUNCTION
    FUNCTION must be a function which, if called with one
    argument---the list of the other menu items---returns the
    items to actually display.

 :visible INCLUDE
    INCLUDE is an expression.  The menu is visible if the
    expression evaluates to a non-nil value.  `:included' is an
    alias for `:visible'.

 :active ENABLE
    ENABLE is an expression.  The menu is enabled for selection
    if the expression evaluates to a non-nil value.  `:enable' is
    an alias for `:active'.

 :label FORM
    FORM is an expression that is dynamically evaluated and whose
    value serves as the menu's label (the default is the first
    element of MENU).

 :help HELP
    HELP is a string, the help to display for the menu.
    In a GUI this is a "tooltip" on the menu button.  (Though
    in Lucid :help is not shown for the top-level menu bar, only
    for sub-menus.)

The rest of the elements in MENU are menu items.
A menu item can be a vector of three elements:

  [NAME CALLBACK ENABLE]

NAME is a string--the menu item name.

CALLBACK is a command to run when the item is chosen, or an
expression to evaluate when the item is chosen.

ENABLE is an expression; the item is enabled for selection if the
expression evaluates to a non-nil value.

Alternatively, a menu item may have the form:

   [ NAME CALLBACK [ KEYWORD ARG ]... ]

where NAME and CALLBACK have the same meanings as above, and each
optional KEYWORD and ARG pair should be one of the following:

 :keys KEYS
    KEYS is a string; a keyboard equivalent to the menu item.
    This is normally not needed because keyboard equivalents are
    usually computed automatically.  KEYS is expanded with
    `substitute-command-keys' before it is used.

 :key-sequence KEYS
    KEYS is a hint for speeding up Emacs's first display of the
    menu.  It should be nil if you know that the menu item has no
    keyboard equivalent; otherwise it should be a string or
    vector specifying a keyboard equivalent for the menu item.

 :active ENABLE
    ENABLE is an expression; the item is enabled for selection
    whenever this expression's value is non-nil.  `:enable' is an
    alias for `:active'.

 :visible INCLUDE
    INCLUDE is an expression; this item is only visible if this
    expression has a non-nil value.  `:included' is an alias for
    `:visible'.

 :label FORM
    FORM is an expression that is dynamically evaluated and whose
    value serves as the menu item's label (the default is NAME).

 :suffix FORM
    FORM is an expression that is dynamically evaluated and whose
    value is concatenated with the menu entry's label.

 :style STYLE
    STYLE is a symbol describing the type of menu item; it should
    be `toggle' (a checkbox), or `radio' (a radio button), or any
    other value (meaning an ordinary menu item).

 :selected SELECTED
    SELECTED is an expression; the checkbox or radio button is
    selected whenever the expression's value is non-nil.

 :help HELP
    HELP is a string, the help to display for the menu item.

Alternatively, a menu item can be a string.  Then that string
appears in the menu as unselectable text.  A string consisting
solely of dashes is displayed as a menu separator.

Alternatively, a menu item can be a list with the same format as
MENU.  This is a submenu.

(fn SYMBOL MAPS DOC MENU)
(defalias 'easy-menu-define '(macro . #[1028 "\300\205\n\301\302F\303\304D\257E\207" [progn defvar nil easy-menu-do-define quote] 11 (#$ . 1199)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put easy-menu-define lisp-indent-function defun put edebug-form-spec (symbolp body)] 5)
#@130 Return a binding suitable to pass to `define-key'.
This is expected to be bound to a mouse event.

(fn MENU &optional ITEM-NAME)
(defalias 'easy-menu-binding #[513 "
9\205\f
\300NK\262\301
@\302=\203
A@AA\262\2020\2060\303!\203/\304!\2060\305BBB\207" [menu-prop menu-item :label keymapp keymap-prompt ""] 7 (#$ . 5326)])
#@29 

(fn SYMBOL MAPS DOC MENU)
(defalias 'easy-menu-do-define #[1028 "\300
@A\"\203\"
L\210\301\302\303\304\305\306!\307\"\310	\311&\"\210\312!\203-C\202.\211\205V\211@\313
\306\314@\211;\203E\315
!\262
\"\316@\"#\210
A\266\202\202.\262
\207" [easy-menu-create-menu defalias make-byte-code 257 "\301
\3009\203\302\300\303N\304\"\206\305\300K!\206\300\"\207" vconcat vector [x-popup-menu plist-get menu-prop :filter identity] 6 "@e" keymapp define-key menu-bar intern easy-menu-binding] 14 (#$ . 5669)])
#@446 Convert MENU to the right thing to return from a menu filter.
MENU is a menu as computed by `easy-menu-define' or `easy-menu-create-menu' or
a symbol whose value is such a menu.
In Emacs a menu filter must return a menu (a keymap), in XEmacs a filter must
return a menu items list (without menu name and keywords).
This function returns the right thing in the two cases.
If NAME is provided, it is used for the keymap.

(fn MENU &optional NAME)
(defalias 'easy-menu-filter-return #[513 "\300!\204
:\203\301
\206\302\"\262\202$\303!\203$\304!A\262
\207" [keymapp easy-menu-create-menu "" vectorp easy-menu-convert-item] 5 (#$ . 6205)])
#@210 Dynamically scoped var to register already used keys in a menu.
If it holds a list, this is expected to be a list of keys already seen in the
menu we're processing.  Else it means we're not processing a menu.
(defvar easy-menu-avoid-duplicate-keys t (#$ . 6861))
#@242 Create a menu called MENU-NAME with items described in MENU-ITEMS.
MENU-NAME is a string, the name of the menu.  MENU-ITEMS is a list of items
possibly preceded by keyword pairs as described in `easy-menu-define'.

(fn MENU-NAME MENU-ITEMS)
(defalias 'easy-menu-create-menu #[514 "\301!\302\211\211\211\211\211\211\211	\203j	A\203j\303\n@\211\262!\203j	A@\nAA\262\304\267\202f\305\306\307\310\311\"\312\"\313\314%\262\202f\211\206N\315\262\202f\211\262\202f\211\262\202f\211\206d\316\262\210\202
\317\232?\205\343
\203\203\320!\204\203\321BB\262\203\225\320!\204\225\322BB\262\203\241\323BB\262\211\203\255\324
BB\262\203\271\325BB\262\203\302	\202\313\326	\327\330
\"\"\262	\203\341\331	\332\"\262	\333	\334	#\210)\207" [easy-menu-avoid-duplicate-keys make-sparse-keymap nil keywordp #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:filter 53 :active 73 :enable 73 :label 83 :help 89 :visible 95 :included 95)) make-byte-code 257 "\302\301!\300\"\207" vconcat vector [easy-menu-filter-return] 4 "\n\n(fn MENU)" 'nil 'nil 'nil easy-menu-always-true-p :visible :enable :filter :help :label append mapcar easy-menu-convert-item easy-menu-make-symbol noexp put menu-prop] 19 (#$ . 7131)])
(defvar easy-menu-button-prefix '((radio . :radio) (toggle . :toggle)))
(defvar easy-menu-converted-items-table (make-hash-table :test 'equal))
#@375 Memoize the value returned by `easy-menu-convert-item-1' called on ITEM.
This makes key-shortcut-caching work a *lot* better when this
conversion is done from within a filter.
This also helps when the NAME of the entry is recreated each time:
since the menu is built and traversed separately, the lookup
would always fail because the key is `equal' but not `eq'.

(fn ITEM)
(defalias 'easy-menu-convert-item #[257 "\302
\"\211\206\303!\211\242	<\2036\2119\2036\211	>\2032\304\305\306\307!	G#!\262
\211AB\262\202\211	B\204@\310#\210
\207" [easy-menu-converted-items-table easy-menu-avoid-duplicate-keys gethash easy-menu-convert-item-1 intern format "%s-%d" symbol-name puthash] 9 (#$ . 8587)])
#@126 Parse an item description and convert it to a menu keymap element.
ITEM defines an item as in `easy-menu-define'.

(fn ITEM)
(defalias 'easy-menu-convert-item-1 #[257 "\301\211\211\211\211;\203\262\202H:\203\\@\211\262\262A\262\302!\204,\303\"\262\2046\304\262
\202H9\203H\305N\211\262\203H
@\306=\203U
A@\262
AA\262K\262\202H\307!\203DG\211\310V\203v\310H\206w\311\202w\304\312H\211\2629?\301\211\n\313H\211\262\262\203\225\314	!\262	\315!\203\310\301\211\211\211\211\211\211\211\262\f\fV\203
H\262TH\262\310\\\262\316\267\202\246\206\317\317\262\202\246\262\n\304\262	\202\246\262
\301\262\202\246\262\202\246\206\361\320\262\f\202\246\321BB\262\202\246\262\202\246\262\202\246\206
\322\262\202\246\202\246\203X
;\203>
;\2033
\323Q\202V
\324\323PE\202V
;\203O
\324\323PE\202V
\324\323F\262\325=\203y
;\203l
\326\327Q\202t
\324\326\330BBB\262\202\221

\203\221
\236\211\262\203\221
\331ABBB\262\211;\203\356
\332\333\"\203\337
\313\224\312\224W\205\253
\334
\313\312\224#\312\225\313\225W\205\270
\334\312\225\"\335\336\310\"!\204\306

\205\311
B\262\204\327

=?\205\332
\211B\266\204\202\342
\301\262	\211\203\356
\337
BB\262\203\f\340!\204\f\341\232\203\304\262\202\f\342BB\262\266\203 \340!\204 \343BB\262\204(\211\203?
\2037
;\2047\307!\203?\344BB\262\266\202H\345\346!\210\211;\203S\335
!\262
\211?\205g\347\205eBBBB\262
\207" [easy-menu-button-prefix nil keymapp easy-menu-create-menu t menu-prop :label vectorp 2 'nil 1 0 easy-menu-make-symbol keywordp #s(hash-table size 11 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:visible 202 :included 202 :key-sequence 212 :keys 221 :label 230 :enable 236 :active 236 :help 246 :suffix 258 :style 264 :selected 270)) 'nil 'nil :help 'nil " " concat button "[" "]" ("]") :button string-match "^[^\\]*\\(\\\\\\[\\([^]]+\\)]\\)[^\\]*$" substring intern match-string :keys easy-menu-always-true-p 'nil :visible :enable :key-sequence error "Invalid menu item in easymenu" menu-item] 25 (#$ . 9306)])
#@621 Add binding in MENU for KEY => ITEM.  Similar to `define-key-after'.
If KEY is not nil then delete any duplications.
If ITEM is nil, then delete the definition of KEY.

Optional argument BEFORE is nil or a key in MENU.  If BEFORE is not nil,
put binding before the item in MENU named BEFORE; otherwise,
if a binding for KEY is already present in MENU, just change it;
otherwise put the new binding last in MENU.
BEFORE can be either a string (menu item name) or a symbol
(the fake function key for the menu item).
KEY does not have to be a symbol, and comparison is done with equal.

(fn MENU KEY ITEM &optional BEFORE)
(defalias 'easy-menu-define-key #[1027 "9\203\n\300!\262
?\301\211\211?\205\256A?\206\302A!\211\262\2043\203[\303A@\"\203[\204:\304\262
\204SBAB\241\210\304\262A\262A\262\202\203\246A@\242\232\203\246\204\212\203\224AA\211\262\203\224\302!\204\224\303@\"\204\224\211AA\241\210\202A@\241\210\304\262A\262\202A\262\202\207" [indirect-function nil keymapp easy-menu-name-match t] 10 (#$ . 11483)])
#@170 Return t if NAME is the name of menu item ITEM.
NAME can be either a string, or a symbol.
ITEM should be a keymap binding of the form (KEY . MENU-ITEM).

(fn NAME ITEM)
(defalias 'easy-menu-name-match #[514 "\211:\205-
9\203\211\242=\207
;\205-\3001 \301\"0\202$\210\202'\206-\211\242\302!=\207" [(error) member-ignore-case intern] 5 (#$ . 12583)])
#@55 Return true if form X never evaluates to nil.

(fn X)
(defalias 'easy-menu-always-true-p #[257 "\211:\203\211@\300=\205\211A@\207\211\301=\206\2119?\207" [quote t] 3 (#$ . 12950)])
(defvar easy-menu-item-count 0)
#@207 Return a unique symbol with CALLBACK as function value.
When non-nil, NOEXP indicates that CALLBACK cannot be an expression
(i.e. does not need to be turned into a function).

(fn CALLBACK &optional NOEXP)
(defalias 'easy-menu-make-symbol #[513 "\301\302\303\"!T\211\304!\204 \305!\204 \306!\204 \203$\202-\307\310\311\312F\313\"M\210\211\207" [easy-menu-item-count make-symbol format "menu-function-%d" keymapp commandp functionp eval lambda nil (interactive) t] 9 (#$ . 13176)])
#@840 Change menu found at PATH as item NAME to contain ITEMS.
PATH is a list of strings for locating the menu that
should contain a submenu named NAME.
ITEMS is a list of menu items, as in `easy-menu-define'.
These items entirely replace the previous items in that submenu.

If MAP is specified, it should normally be a keymap; nil stands for the local
menu-bar keymap.  It can also be a symbol, which has earlier been used as the
first argument in a call to `easy-menu-define', or the value of such a symbol.

If the menu located by PATH has no submenu named NAME, add one.
If the optional argument BEFORE is present, add it just before
the submenu named BEFORE, otherwise add it at the end of the menu.

To implement dynamic menus, either call this from
`menu-bar-update-hook' or use a menu filter.

(fn PATH NAME ITEMS &optional BEFORE MAP)
(defalias 'easy-menu-change #[1283 "\300
\301\"$\207" [easy-menu-add-item easy-menu-create-menu] 11 (#$ . 13679)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\207" [defalias easy-menu-remove ignore "Remove MENU from the current menu bar.\nContrary to XEmacs, this is a nop on Emacs since menus are automatically\n(de)activated when the corresponding keymap is (de)activated.\n\n(fn MENU)" easy-menu-add "Add the menu to the menubar.\nOn Emacs this is a nop, because menus are already automatically\nactivated when the corresponding keymap is activated.  On XEmacs\nthis is needed to actually add the menu to the current menubar.\n\nYou should call this once the menu and keybindings are set up\ncompletely and menu filter functions can be expected to work.\n\n(fn MENU &optional MAP)"] 4)
#@264 Add submenu SUBMENU in the menu at MENU-PATH.
If BEFORE is non-nil, add before the item named BEFORE.
If IN-MENU is non-nil, follow MENU-PATH in IN-MENU.
This is a compatibility function; use `easy-menu-add-item'.

(fn MENU-PATH SUBMENU &optional BEFORE IN-MENU)
(defalias 'add-submenu #[1026 "\300
\206\301 \302B$\207" [easy-menu-add-item current-global-map "menu-bar"] 9 (#$ . 15328)])
#@1113 To the submenu of MAP with path PATH, add ITEM.

If an item with the same name is already present in this submenu,
then ITEM replaces it.  Otherwise, ITEM is added to this submenu.
In the latter case, ITEM is normally added at the end of the submenu.
However, if BEFORE is a string and there is an item in the submenu
with that name, then ITEM is added before that item.

MAP should normally be a keymap; nil stands for the local menu-bar keymap.
It can also be a symbol, which has earlier been used as the first
argument in a call to `easy-menu-define', or the value of such a symbol.

PATH is a list of strings for locating the submenu where ITEM is to be
added.  If PATH is nil, MAP itself is used.  Otherwise, the first
element should be the name of a submenu directly under MAP.  This
submenu is then traversed recursively with the remaining elements of PATH.

ITEM is either defined as in `easy-menu-define' or a non-nil value returned
by `easy-menu-item-present-p' or `easy-menu-remove-item' or a menu defined
earlier by `easy-menu-define' or `easy-menu-create-menu'.

(fn MAP PATH ITEM &optional BEFORE)
(defalias 'easy-menu-add-item #[1027 "\300?\205?\205\242;\205@#\262
:\203?
A:\203?
A@\301=\203?\302@\211;\203:\303
!\262
A$\207\304!\204Y
9\203`\304J!\203`
J\211\262\203`\305!B\262\306!\262\302@\211;\203s\303
!\262
A$\207" [easy-menu-get-map menu-item easy-menu-define-key intern keymapp keymap-prompt easy-menu-convert-item] 9 (#$ . 15730)])
#@215 In submenu of MAP with path PATH, return non-nil if item NAME is present.
MAP and PATH are defined as in `easy-menu-add-item'.
NAME should be a string, the name of the element to be looked for.

(fn MAP PATH NAME)
(defalias 'easy-menu-item-present-p #[771 "\300\301\"\"\207" [easy-menu-return-item easy-menu-get-map] 7 (#$ . 17231)])
#@191 From submenu of MAP with path PATH remove item NAME.
MAP and PATH are defined as in `easy-menu-add-item'.
NAME should be a string, the name of the element to be removed.

(fn MAP PATH NAME)
(defalias 'easy-menu-remove-item #[771 "\300\"\262\301\"\211\203\302\211;\203\303
!\262
\304#\210\211\207" [easy-menu-get-map easy-menu-return-item easy-menu-define-key intern nil] 9 (#$ . 17575)])
#@203 In menu MENU try to look for menu item with name NAME.
If a menu item is found, return (NAME . item), otherwise return nil.
If item is an old format item, a new format item is returned.

(fn MENU NAME)
(defalias 'easy-menu-return-item #[514 "\211\236A\206\300\301\211;\203\302
!\262
!\"\303\211\211\211\242;\203\205@\262
A\211\262@;\2039\304@D\262A\262:\203Y@:\203Y@@\203Q@@\247\203Y@\262A\2629\203n\305N\211\262\203n\306BB\262
\203w
B\262\305BBBB\202\214\205\214B\207" [lookup-key vector intern nil :help menu-enable :enable] 12 (#$ . 17981)])
#@191 Lookup menu item NAME in keymap MAP.
Like `lookup-key' except that NAME is not an array but just a single key
and that NAME can be a string representing the menu item's name.

(fn MAP NAME)
(defalias 'easy-menu-lookup-name #[514 "\300\301\211;\203\302
!\262
!\"\206/\211;\205/\3032/\304\305\306\307\310\301\"\311\"\312\313%\"0\207" [lookup-key vector intern found map-keymap make-byte-code 514 "\3021\301
\2350\202\210\303\207\205\304\305\306\300\307!\"\"\207" vconcat [(error) nil throw found lookup-key vector] 8 "\n\n(fn KEY ITEM)"] 10 (#$ . 18584)])
#@320 Return a sparse keymap in which to add or remove an item.
MAP and PATH are as defined in `easy-menu-add-item'.

TO-MODIFY, if non-nil, is the name of the item the caller
wants to modify in the map that we return.
In some cases we use that to select between the local and global maps.

(fn MAP PATH &optional TO-MODIFY)
(defalias 'easy-menu-get-map #[770 "\3002\263\2039\203\301!\204J\262\203*\301!\203&C\202,\202,\302 \2045\303B\262\211\203Y\211@\304\305\306\307\310\311\312\313!\314\"\315\316%\"\"\262
A\266\202\2026\210
\203y\211\211\203x\211@\317
\"\203q\320\300\"\210
A\266\202\202_\210\211\203\203\320\300@\"\210\205\216\321\322\323!@\"\324
!\325\206\231\326 \327\313\306\330\n\"\"\203\253B\202\254#\210\262
\262
0\262\301!\204\300\331\332\"\210\207" [found keymapp current-active-maps menu-bar delq nil mapcar make-byte-code 257 "\301
\300\"\262
\302
!\205
\211\207" vconcat vector [easy-menu-lookup-name keymapp] 4 "\n\n(fn MAP)" easy-menu-lookup-name throw format "%s" reverse make-sparse-keymap define-key current-local-map apply easy-menu-intern error "Malformed menu in easy-menu: (%s)"] 15 (#$ . 19165)])
(provide 'easymenu)