mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-11-24 07:20:37 +00:00
68cc4cb6b1
* lisp/image.el (create-image): Remove supererogatory instances of pcase. Recognize new `lambda' values and refrain from specifying a default transform-smoothing when it is returned. (image--default-smoothing): Return lambda if scaling is default. * lisp/tool-bar.el (tool-bar--image-expression): Revert this portion of last change.
599 lines
26 KiB
EmacsLisp
599 lines
26 KiB
EmacsLisp
;;; tool-bar.el --- setting up the tool bar -*- lexical-binding: t -*-
|
||
|
||
;; Copyright (C) 2000-2024 Free Software Foundation, Inc.
|
||
|
||
;; Author: Dave Love <fx@gnu.org>
|
||
;; Keywords: mouse frames
|
||
;; Package: emacs
|
||
|
||
;; This file is part of GNU Emacs.
|
||
|
||
;; GNU Emacs 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 of the License, or
|
||
;; (at your option) any later version.
|
||
|
||
;; GNU Emacs 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 GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
|
||
|
||
;;; Commentary:
|
||
|
||
;; Provides `tool-bar-mode' to control display of the tool-bar and
|
||
;; bindings for the global tool bar with convenience functions
|
||
;; `tool-bar-add-item' and `tool-bar-add-item-from-menu'.
|
||
|
||
;; The normal global binding for [tool-bar] (below) uses the value of
|
||
;; `tool-bar-map' as the actual keymap to define the tool bar. Modes
|
||
;; may either bind items under the [tool-bar] prefix key of the local
|
||
;; map to add to the global bar or may set `tool-bar-map'
|
||
;; buffer-locally to override it. (Some items are removed from the
|
||
;; global bar in modes which have `special' as their `mode-class'
|
||
;; property.)
|
||
|
||
;; Todo: Somehow make tool bars easily customizable by the naive?
|
||
|
||
;;; Code:
|
||
|
||
;; The autoload cookie doesn't work when preloading.
|
||
;; Deleting it means invoking this command won't work
|
||
;; when you are on a tty. I hope that won't cause too much trouble -- rms.
|
||
(define-minor-mode tool-bar-mode
|
||
"Toggle the tool bar in all graphical frames (Tool Bar mode).
|
||
|
||
See `tool-bar-add-item' and `tool-bar-add-item-from-menu' for
|
||
conveniently adding tool bar items."
|
||
:init-value t
|
||
:global t
|
||
;; It's defined in C/cus-start, this stops the d-m-m macro defining it again.
|
||
:variable tool-bar-mode
|
||
(let ((val (if tool-bar-mode 1 0)))
|
||
(dolist (frame (frame-list))
|
||
(set-frame-parameter frame 'tool-bar-lines val))
|
||
;; If the user has given `default-frame-alist' a `tool-bar-lines'
|
||
;; parameter, replace it.
|
||
(if (assq 'tool-bar-lines default-frame-alist)
|
||
(setq default-frame-alist
|
||
(cons (cons 'tool-bar-lines val)
|
||
(assq-delete-all 'tool-bar-lines
|
||
default-frame-alist)))))
|
||
(and tool-bar-mode
|
||
(= 1 (length (default-value 'tool-bar-map))) ; not yet setup
|
||
(tool-bar-setup)))
|
||
|
||
;;;###autoload
|
||
;; Used in the Show/Hide menu, to have the toggle reflect the current frame.
|
||
(defun toggle-tool-bar-mode-from-frame (&optional arg)
|
||
"Toggle tool bar on or off, based on the status of the current frame.
|
||
See `tool-bar-mode' for more information."
|
||
(interactive (list (or current-prefix-arg 'toggle)))
|
||
(if (eq arg 'toggle)
|
||
(tool-bar-mode (if (> (frame-parameter nil 'tool-bar-lines) 0) 0 1))
|
||
(tool-bar-mode arg)))
|
||
|
||
(defvar-keymap tool-bar-map
|
||
:doc "Keymap for the tool bar.
|
||
|
||
To override the global tool bar, define this variable
|
||
buffer-locally and add the items you want to it with
|
||
`tool-bar-add-item', `tool-bar-add-item-from-menu' and related
|
||
functions.")
|
||
|
||
(defvar secondary-tool-bar-map nil
|
||
"Optional secondary keymap for the tool bar.
|
||
|
||
If non-nil, tool bar items defined within this map are displayed
|
||
in a line below the tool bar if the `tool-bar-position' frame
|
||
parameter is set to `top', and above the tool bar it is set to
|
||
`bottom'.")
|
||
|
||
(global-set-key [tool-bar]
|
||
`(menu-item ,(purecopy "tool bar") ignore
|
||
:filter tool-bar-make-keymap))
|
||
|
||
(declare-function image-mask-p "image.c" (spec &optional frame))
|
||
|
||
(defconst tool-bar-keymap-cache (make-hash-table :test #'equal))
|
||
|
||
(defsubst tool-bar--cache-key ()
|
||
(cons (frame-terminal)
|
||
(sxhash-eq (if tool-bar-always-show-default (default-value 'tool-bar-map)
|
||
tool-bar-map))))
|
||
|
||
(defsubst tool-bar--secondary-cache-key ()
|
||
(cons (frame-terminal) (sxhash-eq secondary-tool-bar-map)))
|
||
|
||
(defun tool-bar--flush-cache ()
|
||
"Remove all cached entries that refer to the current `tool-bar-map'."
|
||
(let ((id (sxhash-eq tool-bar-map))
|
||
(secondary-id (and secondary-tool-bar-map
|
||
(sxhash-eq secondary-tool-bar-map)))
|
||
(entries nil))
|
||
(maphash (lambda (k _)
|
||
(when (or (equal (cdr k) id)
|
||
(equal (cdr k) secondary-id))
|
||
(push k entries)))
|
||
tool-bar-keymap-cache)
|
||
(dolist (k entries)
|
||
(remhash k tool-bar-keymap-cache))))
|
||
|
||
(defun tool-bar-make-keymap (&optional _ignore)
|
||
"Generate an actual keymap from `tool-bar-map'.
|
||
If `secondary-tool-bar-map' is non-nil, take it into account as well.
|
||
Its main job is to figure out which images to use based on the display's
|
||
color capability and based on the available image libraries."
|
||
(let* ((key (tool-bar--cache-key))
|
||
(base-keymap
|
||
(or (gethash key tool-bar-keymap-cache)
|
||
(setf (gethash key tool-bar-keymap-cache)
|
||
(tool-bar-make-keymap-1))))
|
||
(secondary-keymap
|
||
(and secondary-tool-bar-map
|
||
(or (gethash (tool-bar--secondary-cache-key)
|
||
tool-bar-keymap-cache)
|
||
(setf (gethash (tool-bar--secondary-cache-key)
|
||
tool-bar-keymap-cache)
|
||
(tool-bar-make-keymap-1
|
||
secondary-tool-bar-map))))))
|
||
(if secondary-keymap
|
||
(or (ignore-errors
|
||
(progn
|
||
;; Determine the value of the `tool-bar-position' frame
|
||
;; parameter.
|
||
(let ((position (frame-parameter nil 'tool-bar-position)))
|
||
(cond ((eq position 'top)
|
||
;; Place `base-keymap' above `secondary-keymap'.
|
||
(append base-keymap (list (list (gensym)
|
||
'menu-item
|
||
"" 'ignore
|
||
:wrap t))
|
||
(cdr secondary-keymap)))
|
||
((eq position 'bottom)
|
||
;; Place `secondary-keymap' above `base-keymap'.
|
||
(append secondary-keymap (list (list (gensym)
|
||
'menu-item
|
||
"" 'ignore
|
||
:wrap t))
|
||
(cdr base-keymap)))
|
||
;; If the tool bar position isn't known, don't
|
||
;; display the secondary keymap at all.
|
||
(t base-keymap)))))
|
||
;; If combining both keymaps fails, return the base
|
||
;; keymap.
|
||
base-keymap)
|
||
base-keymap)))
|
||
|
||
;; This function should return binds even if images can not be
|
||
;; displayed so the tool bar can still be displayed on terminals.
|
||
(defun tool-bar-make-keymap-1 (&optional map)
|
||
"Generate an actual keymap from `tool-bar-map', without caching.
|
||
MAP is either a keymap to use as a source for menu items, or nil,
|
||
in which case the value of `tool-bar-map' is used instead."
|
||
(mapcar (lambda (bind)
|
||
(let (image-exp plist)
|
||
(when (and (eq (car-safe (cdr-safe bind)) 'menu-item)
|
||
;; For the format of menu-items, see node
|
||
;; `Extended Menu Items' in the Elisp manual.
|
||
(setq plist (nthcdr (if (consp (nth 4 bind)) 5 4)
|
||
bind))
|
||
(setq image-exp (plist-get plist :image))
|
||
(consp image-exp)
|
||
(not (eq (car image-exp) 'image))
|
||
(fboundp (car image-exp)))
|
||
(let ((image (and (display-images-p)
|
||
(eval image-exp))))
|
||
(unless (and image (image-mask-p image))
|
||
(setq image (append image '(:mask heuristic))))
|
||
(setq bind (copy-sequence bind)
|
||
plist (nthcdr (if (consp (nth 4 bind)) 5 4)
|
||
bind))
|
||
(plist-put plist :image image)))
|
||
bind))
|
||
(or map
|
||
(if tool-bar-always-show-default (default-value 'tool-bar-map)
|
||
tool-bar-map))))
|
||
|
||
;;;###autoload
|
||
(defun tool-bar-add-item (icon def key &rest props)
|
||
"Add an item to the tool bar.
|
||
ICON names the image, DEF is the key definition and KEY is a symbol
|
||
for the fake function key in the menu keymap. Remaining arguments
|
||
PROPS are additional items to add to the menu item specification. See
|
||
Info node `(elisp)Tool Bar'. Items are added from left to right.
|
||
|
||
ICON is the base name of a file containing the image to use. The
|
||
function will first try to use low-color/ICON.xpm if `display-color-cells'
|
||
is less or equal to 256, then ICON.xpm, then ICON.pbm, and finally
|
||
ICON.xbm, using `find-image'.
|
||
|
||
Use this function only to make bindings in the global value of `tool-bar-map'.
|
||
To define items in any other map, use `tool-bar-local-item'."
|
||
(apply #'tool-bar-local-item icon def key tool-bar-map props)
|
||
(tool-bar--flush-cache))
|
||
|
||
(defun tool-bar--image-expression (icon)
|
||
"Return an expression that evaluates to an image spec for ICON."
|
||
(let* ((fg (face-attribute 'tool-bar :foreground))
|
||
(bg (face-attribute 'tool-bar :background))
|
||
(colors (nconc (if (eq fg 'unspecified) nil (list :foreground fg))
|
||
(if (eq bg 'unspecified) nil (list :background bg))))
|
||
(xpm-spec (list :type 'xpm :file (concat icon ".xpm")))
|
||
(xpm-lo-spec (list :type 'xpm :file
|
||
(concat "low-color/" icon ".xpm")))
|
||
(pbm-spec (append (list :type 'pbm :file
|
||
(concat icon ".pbm")) colors))
|
||
(xbm-spec (append (list :type 'xbm :file
|
||
(concat icon ".xbm")) colors)))
|
||
`(find-image (cond ((not (display-color-p))
|
||
',(list pbm-spec xbm-spec xpm-lo-spec xpm-spec))
|
||
((< (display-color-cells) 256)
|
||
',(list xpm-lo-spec xpm-spec pbm-spec xbm-spec))
|
||
(t
|
||
',(list xpm-spec pbm-spec xbm-spec)))
|
||
t)))
|
||
|
||
;;;###autoload
|
||
(defun tool-bar-local-item (icon def key map &rest props)
|
||
"Add an item to the tool bar in map MAP.
|
||
ICON names the image, DEF is the key definition and KEY is a symbol
|
||
for the fake function key in the menu keymap. Remaining arguments
|
||
PROPS are additional items to add to the menu item specification. See
|
||
Info node `(elisp)Tool Bar'. Items are added from left to right.
|
||
|
||
ICON is the base name of a file containing the image to use. The
|
||
function will first try to use low-color/ICON.xpm if `display-color-cells'
|
||
is less or equal to 256, then ICON.xpm, then ICON.pbm, and finally
|
||
ICON.xbm, using `find-image'."
|
||
(let* ((image-exp (tool-bar--image-expression icon)))
|
||
(define-key-after map (vector key)
|
||
`(menu-item ,(symbol-name key) ,def :image ,image-exp ,@props))
|
||
(tool-bar--flush-cache)
|
||
(force-mode-line-update)))
|
||
|
||
;;;###autoload
|
||
(defun tool-bar-add-item-from-menu (command icon &optional map &rest props)
|
||
"Define tool bar binding for COMMAND in keymap MAP using the given ICON.
|
||
This makes a binding for COMMAND in `tool-bar-map', copying its
|
||
binding from the menu bar in MAP (which defaults to `global-map'), but
|
||
modifies the binding by adding an image specification for ICON. It
|
||
finds ICON just like `tool-bar-add-item'. PROPS are additional
|
||
properties to add to the binding.
|
||
|
||
MAP must contain appropriate binding for `[menu-bar]' which holds a keymap.
|
||
|
||
Use this function only to make bindings in the global value of `tool-bar-map'.
|
||
To define items in any other map, use `tool-bar-local-item-from-menu'."
|
||
(apply #'tool-bar-local-item-from-menu command icon
|
||
(default-value 'tool-bar-map) map props))
|
||
|
||
;;;###autoload
|
||
(defun tool-bar-local-item-from-menu (command icon in-map &optional from-map &rest props)
|
||
"Define local tool bar binding for COMMAND using the given ICON.
|
||
This makes a binding for COMMAND in IN-MAP, copying its binding from
|
||
the menu bar in FROM-MAP (which defaults to `global-map'), but
|
||
modifies the binding by adding an image specification for ICON. It
|
||
finds ICON just like `tool-bar-add-item'. PROPS are additional
|
||
properties to add to the binding.
|
||
|
||
FROM-MAP must contain appropriate binding for `[menu-bar]' which
|
||
holds a keymap."
|
||
(unless from-map
|
||
(setq from-map global-map))
|
||
(let* ((menu-bar-map (lookup-key from-map [menu-bar]))
|
||
(keys (where-is-internal command menu-bar-map))
|
||
(image-exp (tool-bar--image-expression icon))
|
||
submap key)
|
||
;; We'll pick up the last valid entry in the list of keys if
|
||
;; there's more than one.
|
||
;; FIXME: Aren't they *all* "valid"?? --Stef
|
||
(dolist (k keys)
|
||
;; We're looking for a binding of the command in a submap of
|
||
;; the menu bar map, so the key sequence must be two or more
|
||
;; long.
|
||
(if (and (vectorp k)
|
||
(> (length k) 1))
|
||
(let ((m (lookup-key menu-bar-map (substring k 0 -1)))
|
||
;; Last element in the bound key sequence:
|
||
(kk (aref k (1- (length k)))))
|
||
(if (and (keymapp m)
|
||
(symbolp kk))
|
||
(setq submap m
|
||
key kk)))))
|
||
(when (and (symbolp submap) (boundp submap))
|
||
(setq submap (eval submap)))
|
||
(let ((defn (assq key (cdr submap))))
|
||
(if (eq (cadr defn) 'menu-item)
|
||
(define-key-after in-map (vector key)
|
||
(append (cdr defn) (list :image image-exp) props))
|
||
(setq defn (cdr defn))
|
||
(define-key-after in-map (vector key)
|
||
(let ((rest (cdr defn)))
|
||
;; If the rest of the definition starts
|
||
;; with a list of menu cache info, get rid of that.
|
||
(if (and (consp rest) (consp (car rest)))
|
||
(setq rest (cdr rest)))
|
||
(append `(menu-item ,(car defn) ,rest)
|
||
(list :image image-exp) props))))
|
||
(tool-bar--flush-cache)
|
||
(force-mode-line-update))))
|
||
|
||
;;; Set up some global items. Additions/deletions up for grabs.
|
||
|
||
(defun tool-bar-setup ()
|
||
(setq tool-bar-separator-image-expression
|
||
(tool-bar--image-expression "separator"))
|
||
(tool-bar-add-item-from-menu 'find-file "new" nil :label "New File"
|
||
:vert-only t)
|
||
(tool-bar-add-item-from-menu 'menu-find-file-existing "open" nil
|
||
:label "Open" :vert-only t)
|
||
(tool-bar-add-item-from-menu 'dired "diropen" nil :vert-only t)
|
||
(tool-bar-add-item-from-menu 'kill-this-buffer "close" nil :vert-only t)
|
||
(tool-bar-add-item-from-menu 'save-buffer "save" nil
|
||
:label "Save")
|
||
(define-key-after (default-value 'tool-bar-map) [separator-1] menu-bar-separator)
|
||
(tool-bar-add-item-from-menu 'undo "undo" nil)
|
||
(define-key-after (default-value 'tool-bar-map) [separator-2] menu-bar-separator)
|
||
(tool-bar-add-item-from-menu (lookup-key menu-bar-edit-menu [cut])
|
||
"cut" nil :vert-only t)
|
||
(tool-bar-add-item-from-menu (lookup-key menu-bar-edit-menu [copy])
|
||
"copy" nil :vert-only t)
|
||
(tool-bar-add-item-from-menu (lookup-key menu-bar-edit-menu [paste])
|
||
"paste" nil :vert-only t)
|
||
(define-key-after (default-value 'tool-bar-map) [separator-3] menu-bar-separator)
|
||
(tool-bar-add-item-from-menu 'isearch-forward "search"
|
||
nil :label "Search" :vert-only t)
|
||
;;(tool-bar-add-item-from-menu 'ispell-buffer "spell")
|
||
|
||
;; There's no icon appropriate for News and we need a command rather
|
||
;; than a lambda for Read Mail.
|
||
;;(tool-bar-add-item-from-menu 'compose-mail "mail/compose")
|
||
|
||
;; Help button on a tool bar is rather non-standard...
|
||
;; (let ((tool-bar-map (default-value 'tool-bar-map)))
|
||
;; (tool-bar-add-item "help" (lambda ()
|
||
;; (interactive)
|
||
;; (popup-menu menu-bar-help-menu))
|
||
;; 'help
|
||
;; :help "Pop up the Help menu"))
|
||
)
|
||
|
||
(if (featurep 'move-toolbar)
|
||
(defcustom tool-bar-position 'top
|
||
"Specify on which side the tool bar shall be.
|
||
Possible values are `top' (tool bar on top), `bottom' (tool bar at
|
||
bottom), `left' (tool bar on left) and `right' (tool bar on right).
|
||
This option takes effect only on graphical frames, the values `left' and
|
||
`right' only if Emacs was built with GTK, and `bottom' only on systems
|
||
besides Nextstep. Customize `tool-bar-mode' if you want to show or hide
|
||
the tool bar."
|
||
:version "24.1"
|
||
:type '(choice (const top)
|
||
(const bottom)
|
||
(const left)
|
||
(const right))
|
||
:group 'frames
|
||
:initialize 'custom-initialize-default
|
||
:set (lambda (sym val)
|
||
(set-default sym val)
|
||
(modify-all-frames-parameters
|
||
(list (cons 'tool-bar-position val))))))
|
||
|
||
(defcustom tool-bar-always-show-default nil
|
||
"If non-nil, `tool-bar-mode' only shows the default tool bar.
|
||
This works well when also using `global-window-tool-bar-mode' to
|
||
display buffer-specific tool bars."
|
||
:type 'boolean
|
||
:group 'frames
|
||
:group 'mouse
|
||
:version "30.1")
|
||
|
||
|
||
|
||
;; Modifier bar mode.
|
||
;; This displays a small tool bar containing modifier keys
|
||
;; above or below the main tool bar itself.
|
||
|
||
(defvar modifier-bar-modifier-list nil
|
||
"List of modifiers that are currently applied.
|
||
Each symbol in this list represents a modifier button that has
|
||
been pressed as part of decoding this key sequence.")
|
||
|
||
(declare-function set-text-conversion-style "textconv.c")
|
||
|
||
;; These functions are very similar to their counterparts in
|
||
;; simple.el, but allow combining multiple modifier buttons together.
|
||
|
||
(defun tool-bar-apply-modifiers (event modifiers)
|
||
"Apply the specified list of MODIFIERS to EVENT.
|
||
MODIFIERS must be a list containing only the symbols `alt',
|
||
`super', `hyper', `shift', `control' and `meta'.
|
||
Return EVENT with the specified modifiers applied."
|
||
(dolist (modifier modifiers)
|
||
(cond
|
||
((eq modifier 'alt)
|
||
(setq event (event-apply-modifier event 'alt 22 "A-")))
|
||
((eq modifier 'super)
|
||
(setq event (event-apply-modifier event 'super 23 "s-")))
|
||
((eq modifier 'hyper)
|
||
(setq event (event-apply-modifier event 'hyper 24 "H-")))
|
||
((eq modifier 'shift)
|
||
(setq event (event-apply-modifier event 'shift 25 "S-")))
|
||
((eq modifier 'control)
|
||
(setq event (event-apply-modifier event 'control 26 "C-")))
|
||
((eq modifier 'meta)
|
||
(setq event (event-apply-modifier event 'meta 27 "M-")))))
|
||
event)
|
||
|
||
(defvar overriding-text-conversion-style)
|
||
|
||
(defun modifier-bar-button (init-modifier-list)
|
||
"Decode the key sequence associated with a modifier bar button.
|
||
INIT-MODIFIER-LIST is a list of one symbol describing the button
|
||
being pressed.
|
||
|
||
Bind `modifier-bar-modifier-list' to INIT-MODIFIER-LIST. Read
|
||
events, adding each subsequent modifier bar event's associated
|
||
modifier to that list while updating the tool bar to disable
|
||
buttons that were pressed. Return any other event read with all
|
||
modifier keys read applied.
|
||
|
||
Temporarily disable text conversion and display the on screen
|
||
keyboard while doing so."
|
||
;; Save the previously used text conversion style.
|
||
(let ((old-text-conversion-style text-conversion-style)
|
||
;; Clear the list of modifiers currently pressed.
|
||
(modifier-bar-modifier-list init-modifier-list))
|
||
;; Disable text conversion.
|
||
(when (fboundp 'set-text-conversion-style)
|
||
(set-text-conversion-style nil))
|
||
(unwind-protect
|
||
(progn
|
||
;; Display the on screen keyboard.
|
||
(frame-toggle-on-screen-keyboard nil nil)
|
||
;; Update the tool bar to disable this modifier key.
|
||
(force-mode-line-update)
|
||
(let* ((modifiers init-modifier-list) event1
|
||
(overriding-text-conversion-style nil)
|
||
(event (read-event)))
|
||
;; Combine any more modifier key presses.
|
||
(while (eq event 'tool-bar)
|
||
(setq event1 (event-basic-type (read-event)))
|
||
;; Reject unknown tool bar events.
|
||
(unless (memq event1 '(alt super hyper shift control meta))
|
||
(user-error "Unknown tool-bar event %s" event1))
|
||
;; If `event' is the name of a modifier key, apply that
|
||
;; modifier key as well.
|
||
(unless (memq event1 modifiers)
|
||
(push event1 modifiers)
|
||
;; This list is used to check which tool bar buttons
|
||
;; need to be enabled.
|
||
(push event1 modifier-bar-modifier-list))
|
||
;; Update the tool bar to disable the modifier button
|
||
;; that was read.
|
||
(force-mode-line-update)
|
||
(redisplay)
|
||
;; Read another event.
|
||
(setq event (read-event)))
|
||
;; EVENT is a keyboard event to which the specified list of
|
||
;; modifier keys should be applied.
|
||
(vector (tool-bar-apply-modifiers event modifiers))))
|
||
;; Re-enable text conversion if necessary.
|
||
(unless (or (not (fboundp 'set-text-conversion-style))
|
||
(eq old-text-conversion-style text-conversion-style))
|
||
(set-text-conversion-style old-text-conversion-style t))
|
||
;; Re-enable all modifier bar buttons which may have been
|
||
;; disabled.
|
||
(force-mode-line-update))))
|
||
|
||
(defun tool-bar-event-apply-alt-modifier (_ignore-prompt)
|
||
"Like `event-apply-alt-modifier'.
|
||
However, take additional modifier tool bar items into account;
|
||
apply any extra modifiers bound to subsequent `tool-bar' events."
|
||
(modifier-bar-button '(alt)))
|
||
|
||
(defun tool-bar-event-apply-super-modifier (_ignore-prompt)
|
||
"Like `event-apply-super-modifier'.
|
||
However, take additional modifier tool bar items into account;
|
||
apply any extra modifiers bound to subsequent `tool-bar' events."
|
||
(modifier-bar-button '(super)))
|
||
|
||
(defun tool-bar-event-apply-hyper-modifier (_ignore-prompt)
|
||
"Like `event-apply-hyper-modifier'.
|
||
However, take additional modifier tool bar items into account;
|
||
apply any extra modifiers bound to subsequent `tool-bar' events."
|
||
(modifier-bar-button '(hyper)))
|
||
|
||
(defun tool-bar-event-apply-shift-modifier (_ignore-prompt)
|
||
"Like `event-apply-shift-modifier'.
|
||
However, take additional modifier tool bar items into account;
|
||
apply any extra modifiers bound to subsequent `tool-bar' events."
|
||
(modifier-bar-button '(shift)))
|
||
|
||
(defun tool-bar-event-apply-control-modifier (_ignore-prompt)
|
||
"Like `event-apply-control-modifier'.
|
||
However, take additional modifier tool bar items into account;
|
||
apply any extra modifiers bound to subsequent `tool-bar' events."
|
||
(modifier-bar-button '(control)))
|
||
|
||
(defun tool-bar-event-apply-meta-modifier (_ignore-prompt)
|
||
"Like `event-apply-meta-modifier'.
|
||
However, take additional modifier tool bar items into account;
|
||
apply any extra modifiers bound to subsequent `tool-bar' events."
|
||
(modifier-bar-button '(meta)))
|
||
|
||
(defun modifier-bar-available-p (modifier)
|
||
"Return whether the modifier button for MODIFIER should be enabled.
|
||
Return t if MODIFIER has not yet been selected as part of
|
||
decoding the current key sequence, nil otherwise."
|
||
(not (memq modifier modifier-bar-modifier-list)))
|
||
|
||
(define-minor-mode modifier-bar-mode
|
||
"Toggle display of the modifier bar.
|
||
|
||
When enabled, a small tool bar will be displayed next to the tool
|
||
bar containing items bound to
|
||
`tool-bar-event-apply-control-modifier' and its related commands,
|
||
which see."
|
||
:init-value nil
|
||
:global t
|
||
:group 'tool-bar
|
||
(if modifier-bar-mode
|
||
(progn
|
||
(setq secondary-tool-bar-map
|
||
;; The commands specified in the menu items here are not
|
||
;; used. Instead, Emacs relies on each of the tool bar
|
||
;; events being specified in `input-decode-map'.
|
||
`(keymap (control menu-item "Control Key"
|
||
event-apply-control-modifier
|
||
:help "Add Control modifier to the following event"
|
||
:image ,(tool-bar--image-expression "ctrl")
|
||
:enable (modifier-bar-available-p 'control))
|
||
(shift menu-item "Shift Key"
|
||
event-apply-shift-modifier
|
||
:help "Add Shift modifier to the following event"
|
||
:image ,(tool-bar--image-expression "shift")
|
||
:enable (modifier-bar-available-p 'shift))
|
||
(meta menu-item "Meta Key"
|
||
event-apply-meta-modifier
|
||
:help "Add Meta modifier to the following event"
|
||
:image ,(tool-bar--image-expression "meta")
|
||
:enable (modifier-bar-available-p 'meta))
|
||
(alt menu-item "Alt Key"
|
||
event-apply-alt-modifier
|
||
:help "Add Alt modifier to the following event"
|
||
:image ,(tool-bar--image-expression "alt")
|
||
:enable (modifier-bar-available-p 'alt))
|
||
(super menu-item "Super Key"
|
||
event-apply-super-modifier
|
||
:help "Add Super modifier to the following event"
|
||
:image ,(tool-bar--image-expression "super")
|
||
:enable (modifier-bar-available-p 'super))
|
||
(hyper menu-item "Hyper Key"
|
||
event-apply-hyper-modifier
|
||
:help "Add Hyper modifier to the following event"
|
||
:image ,(tool-bar--image-expression "hyper")
|
||
:enable (modifier-bar-available-p 'hyper))))
|
||
(define-key input-decode-map [tool-bar control]
|
||
#'tool-bar-event-apply-control-modifier)
|
||
(define-key input-decode-map [tool-bar shift]
|
||
#'tool-bar-event-apply-shift-modifier)
|
||
(define-key input-decode-map [tool-bar meta]
|
||
#'tool-bar-event-apply-meta-modifier)
|
||
(define-key input-decode-map [tool-bar alt]
|
||
#'tool-bar-event-apply-alt-modifier)
|
||
(define-key input-decode-map [tool-bar super]
|
||
#'tool-bar-event-apply-super-modifier)
|
||
(define-key input-decode-map [tool-bar hyper]
|
||
#'tool-bar-event-apply-hyper-modifier))
|
||
(setq secondary-tool-bar-map nil))
|
||
;; Update the mode line now.
|
||
(force-mode-line-update t))
|
||
|
||
(provide 'tool-bar)
|
||
|
||
;;; tool-bar.el ends here
|