lisp/obsolete/levents.el

   1 ;;; levents.el --- emulate the Lucid event data type and associated functions
   2
   3 ;; Copyright (C) 1993, 2001-2013 Free Software Foundation, Inc.
   4
   5 ;; Maintainer: FSF
   6 ;; Keywords: emulations
   7 ;; Obsolete-since: 23.2
   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 ;; Things we cannot emulate in Lisp:
  27 ;; It is not possible to emulate current-mouse-event as a variable,
  28 ;; though it is not hard to obtain the data from (this-command-keys).
  29
  30 ;; We do not have a variable unread-command-event;
  31 ;; instead, we have the more general unread-command-events.
  32
  33 ;; Our read-key-sequence and read-char are not precisely
  34 ;; compatible with those in Lucid Emacs, but they should work ok.
  35
  36 ;;; Code:
  37
  38 (defun next-command-event (event)
  39   (error "You must rewrite to use `read-command-event' instead of `next-command-event'"))
  40
  41 (defun next-event (event)
  42   (error "You must rewrite to use `read-event' instead of `next-event'"))
  43
  44 (defun dispatch-event (event)
  45   (error "`dispatch-event' not supported"))
  46
  47 ;; Make events of type eval, menu and timeout
  48 ;; execute properly.
  49
  50 (define-key global-map [menu] 'execute-eval-event)
  51 (define-key global-map [timeout] 'execute-eval-event)
  52 (define-key global-map [eval] 'execute-eval-event)
  53
  54 (defun execute-eval-event (event)
  55   (interactive "e")
  56   (funcall (nth 1 event) (nth 2 event)))
  57
  58 (put 'eval 'event-symbol-elements '(eval))
  59 (put 'menu 'event-symbol-elements '(eval))
  60 (put 'timeout 'event-symbol-elements '(eval))
  61
  62 (defun allocate-event ()
  63   "Return an empty event structure.
  64 In this emulation, it returns nil."
  65   nil)
  66
  67 (defun button-press-event-p (obj)
  68   "True if the argument is a mouse-button-press event object."
  69   (and (consp obj) (symbolp (car obj))
  70        (memq 'down (get (car obj) 'event-symbol-elements))))
  71
  72 (defun button-release-event-p (obj)
  73   "True if the argument is a mouse-button-release event object."
  74   (and (consp obj) (symbolp (car obj))
  75        (or (memq 'click (get (car obj) 'event-symbol-elements))
  76            (memq 'drag (get (car obj) 'event-symbol-elements)))))
  77
  78 (defun button-event-p (obj)
  79   "True if the argument is a mouse-button press or release event object."
  80   (and (consp obj) (symbolp (car obj))
  81        (or (memq 'click (get (car obj) 'event-symbol-elements))
  82            (memq 'down (get (car obj) 'event-symbol-elements))
  83            (memq 'drag (get (car obj) 'event-symbol-elements)))))
  84
  85 (defun mouse-event-p (obj)
  86   "True if the argument is a mouse-button press or release event object."
  87   (and (consp obj) (symbolp (car obj))
  88        (or (eq (car obj) 'mouse-movement)
  89            (memq 'click (get (car obj) 'event-symbol-elements))
  90            (memq 'down (get (car obj) 'event-symbol-elements))
  91            (memq 'drag (get (car obj) 'event-symbol-elements)))))
  92
  93 (defun character-to-event (ch &optional event)
  94   "Converts a numeric ASCII value to an event structure, replete with
  95 bucky bits.  The character is the first argument, and the event to fill
  96 in is the second.  This function contains knowledge about what the codes
  97 mean -- for example, the number 9 is converted to the character Tab,
  98 not the distinct character Control-I.
  99
 100 Beware that character-to-event and event-to-character are not strictly
 101 inverse functions, since events contain much more information than the
 102 ASCII character set can encode."
 103   ch)
 104
 105 (defun copy-event (event1 &optional event2)
 106   "Make a copy of the given event object.
 107 In this emulation, `copy-event' just returns its argument."
 108   event1)
 109
 110 (defun deallocate-event (event)
 111   "Allow the given event structure to be reused.
 112 In actual Lucid Emacs, you MUST NOT use this event object after
 113 calling this function with it.  You will lose.  It is not necessary to
 114 call this function, as event objects are garbage- collected like all
 115 other objects; however, it may be more efficient to explicitly
 116 deallocate events when you are sure that that is safe.
 117
 118 This emulation does not actually deallocate or reuse events
 119 except via garbage collection and `cons'."
 120   nil)
 121
 122 (defun enqueue-eval-event: (function object)
 123   "Add an eval event to the back of the queue.
 124 It will be the next event read after all pending events."
 125   (setq unread-command-events
 126         (nconc unread-command-events
 127                (list (list 'eval function object)))))
 128
 129 (defun eval-event-p (obj)
 130   "True if the argument is an eval or menu event object."
 131   (eq (car-safe obj) 'eval))
 132
 133 (defun event-button (event)
 134   "Return the button-number of the given mouse-button-press event."
 135   (let ((sym (car (get (car event) 'event-symbol-elements))))
 136     (cdr (assq sym '((mouse-1 . 1) (mouse-2 . 2) (mouse-3 . 3)
 137                      (mouse-4 . 4) (mouse-5 . 5))))))
 138
 139 (defun event-function (event)
 140   "Return the callback function of the given timeout, menu, or eval event."
 141   (nth 1 event))
 142
 143 (defun event-key (event)
 144   "Return the KeySym of the given key-press event.
 145 The value is an ASCII printing character (not upper case) or a symbol."
 146   (if (symbolp event)
 147       (car (get event 'event-symbol-elements))
 148     (let ((base (logand event (1- (lsh 1 18)))))
 149       (downcase (if (< base 32) (logior base 64) base)))))
 150
 151 (defun event-object (event)
 152   "Return the function argument of the given timeout, menu, or eval event."
 153   (nth 2 event))
 154
 155 (defun event-point (event)
 156   "Return the character position of the given mouse-related event.
 157 If the event did not occur over a window, or did
 158 not occur over text, then this returns nil.  Otherwise, it returns an index
 159 into the buffer visible in the event's window."
 160   (posn-point (event-end event)))
 161
 162 ;; Return position of start of line LINE in WINDOW.
 163 ;; If LINE is nil, return the last position
 164 ;; visible in WINDOW.
 165 (defun event-closest-point-1 (window &optional line)
 166   (let* ((total (- (window-height window)
 167                    (if (window-minibuffer-p window)
 168                        0 1)))
 169          (distance (or line total)))
 170     (save-excursion
 171       (goto-char (window-start window))
 172       (if (= (vertical-motion distance) distance)
 173           (if (not line)
 174               (forward-char -1)))
 175       (point))))
 176
 177 (defun event-closest-point (event &optional start-window)
 178   "Return the nearest position to where EVENT ended its motion.
 179 This is computed for the window where EVENT's motion started,
 180 or for window WINDOW if that is specified."
 181   (or start-window (setq start-window (posn-window (event-start event))))
 182   (if (eq start-window (posn-window (event-end event)))
 183       (if (eq (event-point event) 'vertical-line)
 184           (event-closest-point-1 start-window
 185                                  (cdr (posn-col-row (event-end event))))
 186         (if (eq (event-point event) 'mode-line)
 187             (event-closest-point-1 start-window)
 188           (event-point event)))
 189     ;; EVENT ended in some other window.
 190     (let* ((end-w (posn-window (event-end event)))
 191            (end-w-top)
 192            (w-top (nth 1 (window-edges start-window))))
 193       (setq end-w-top
 194             (if (windowp end-w)
 195                 (nth 1 (window-edges end-w))
 196               (/ (cdr (posn-x-y (event-end event)))
 197                  (frame-char-height end-w))))
 198       (if (>= end-w-top w-top)
 199           (event-closest-point-1 start-window)
 200         (window-start start-window)))))
 201
 202 (defun event-process (event)
 203   "Return the process of the given process-output event."
 204   (nth 1 event))
 205
 206 (defun event-timestamp (event)
 207   "Return the timestamp of the given event object.
 208 In Lucid Emacs, this works for any kind of event.
 209 In this emulation, it returns nil for non-mouse-related events."
 210   (and (listp event)
 211        (posn-timestamp (event-end event))))
 212
 213 (defun event-to-character (event &optional lenient)
 214   "Return the closest ASCII approximation to the given event object.
 215 If the event isn't a keypress, this returns nil.
 216 If the second argument is non-nil, then this is lenient in its
 217 translation; it will ignore modifier keys other than control and meta,
 218 and will ignore the shift modifier on those characters which have no
 219 shifted ASCII equivalent (Control-Shift-A for example, will be mapped to
 220 the same ASCII code as Control-A.)  If the second arg is nil, then nil
 221 will be returned for events which have no direct ASCII equivalent."
 222   (if (symbolp event)
 223       (and lenient
 224            (cdr (assq event '((backspace . 8) (delete . 127) (tab . 9)
 225                               (return . 10) (enter . 10)))))
 226     ;; Our interpretation is, ASCII means anything a number can represent.
 227     (if (integerp event)
 228         event nil)))
 229
 230 (defun event-window (event)
 231   "Return the window of the given mouse-related event object."
 232   (posn-window (event-end event)))
 233
 234 (defun event-x (event)
 235   "Return the X position in characters of the given mouse-related event."
 236   (/ (car (posn-col-row (event-end event)))
 237      (frame-char-width (window-frame (event-window event)))))
 238
 239 (defun event-x-pixel (event)
 240   "Return the X position in pixels of the given mouse-related event."
 241   (car (posn-col-row (event-end event))))
 242
 243 (defun event-y (event)
 244   "Return the Y position in characters of the given mouse-related event."
 245   (/ (cdr (posn-col-row (event-end event)))
 246      (frame-char-height (window-frame (event-window event)))))
 247
 248 (defun event-y-pixel (event)
 249   "Return the Y position in pixels of the given mouse-related event."
 250   (cdr (posn-col-row (event-end event))))
 251
 252 (defun key-press-event-p (obj)
 253   "True if the argument is a keyboard event object."
 254   (or (integerp obj)
 255       (and (symbolp obj)
 256            (get obj 'event-symbol-elements))))
 257
 258 (defun menu-event-p (obj)
 259   "True if the argument is a menu event object."
 260   (eq (car-safe obj) 'menu))
 261
 262 (defun motion-event-p (obj)
 263   "True if the argument is a mouse-motion event object."
 264   (eq (car-safe obj) 'mouse-movement))
 265
 266 (defun read-command-event ()
 267   "Return the next keyboard or mouse event; execute other events.
 268 This is similar to the function `next-command-event' of Lucid Emacs,
 269 but different in that it returns the event rather than filling in
 270 an existing event object."
 271   (let (event)
 272     (while (progn
 273              (setq event (read-event))
 274              (not (or (key-press-event-p event)
 275                       (button-press-event-p event)
 276                       (button-release-event-p event)
 277                       (menu-event-p event))))
 278       (let ((type (car-safe event)))
 279         (cond ((eq type 'eval)
 280                (funcall (nth 1 event) (nth 2 event)))
 281               ((eq type 'switch-frame)
 282                (select-frame (nth 1 event))))))
 283     event))
 284
 285 (defun process-event-p (obj)
 286   "True if the argument is a process-output event object.
 287 GNU Emacs 19 does not currently generate process-output events."
 288   (eq (car-safe obj) 'process))
 289
 290 (provide 'levents)
 291
 292 ;;; levents.el ends here