| 1 | /* Hooks by which low level terminal operations |
| 2 | can be made to call other routines. |
| 3 | Copyright (C) 1985, 1986, 1993, 1994 Free Software Foundation, Inc. |
| 4 | |
| 5 | This file is part of GNU Emacs. |
| 6 | |
| 7 | GNU Emacs is free software; you can redistribute it and/or modify |
| 8 | it under the terms of the GNU General Public License as published by |
| 9 | the Free Software Foundation; either version 2, or (at your option) |
| 10 | any later version. |
| 11 | |
| 12 | GNU Emacs is distributed in the hope that it will be useful, |
| 13 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 15 | GNU General Public License for more details. |
| 16 | |
| 17 | You should have received a copy of the GNU General Public License |
| 18 | along with GNU Emacs; see the file COPYING. If not, write to |
| 19 | the Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| 20 | Boston, MA 02111-1307, USA. */ |
| 21 | |
| 22 | \f |
| 23 | /* Miscellanea. */ |
| 24 | |
| 25 | struct glyph; |
| 26 | struct frame; |
| 27 | |
| 28 | /* If nonzero, send all terminal output characters to this stream also. */ |
| 29 | extern FILE *termscript; |
| 30 | |
| 31 | /* Only use prototypes when lisp.h has been included. */ |
| 32 | #ifndef P_ |
| 33 | #define P_(X) () |
| 34 | #endif |
| 35 | \f |
| 36 | /* Text display hooks. */ |
| 37 | |
| 38 | extern void (*cursor_to_hook) P_ ((int vpos, int hpos)); |
| 39 | extern void (*raw_cursor_to_hook) P_ ((int, int)); |
| 40 | |
| 41 | extern void (*clear_to_end_hook) P_ ((void)); |
| 42 | extern void (*clear_frame_hook) P_ ((void)); |
| 43 | extern void (*clear_end_of_line_hook) P_ ((int)); |
| 44 | |
| 45 | extern void (*ins_del_lines_hook) P_ ((int, int)); |
| 46 | |
| 47 | extern void (*insert_glyphs_hook) P_ ((struct glyph *s, int n)); |
| 48 | extern void (*write_glyphs_hook) P_ ((struct glyph *s, int n)); |
| 49 | extern void (*delete_glyphs_hook) P_ ((int)); |
| 50 | |
| 51 | extern void (*ring_bell_hook) P_ ((void)); |
| 52 | |
| 53 | extern void (*reset_terminal_modes_hook) P_ ((void)); |
| 54 | extern void (*set_terminal_modes_hook) P_ ((void)); |
| 55 | extern void (*update_begin_hook) P_ ((struct frame *)); |
| 56 | extern void (*update_end_hook) P_ ((struct frame *)); |
| 57 | extern void (*set_terminal_window_hook) P_ ((int)); |
| 58 | |
| 59 | |
| 60 | \f |
| 61 | /* Multi-frame and mouse support hooks. */ |
| 62 | |
| 63 | enum scroll_bar_part { |
| 64 | scroll_bar_above_handle, |
| 65 | scroll_bar_handle, |
| 66 | scroll_bar_below_handle, |
| 67 | scroll_bar_up_arrow, |
| 68 | scroll_bar_down_arrow, |
| 69 | scroll_bar_to_top, |
| 70 | scroll_bar_to_bottom, |
| 71 | scroll_bar_end_scroll, |
| 72 | scroll_bar_move_ratio |
| 73 | }; |
| 74 | |
| 75 | /* Return the current position of the mouse. |
| 76 | |
| 77 | Set *f to the frame the mouse is in, or zero if the mouse is in no |
| 78 | Emacs frame. If it is set to zero, all the other arguments are |
| 79 | garbage. |
| 80 | |
| 81 | If the motion started in a scroll bar, set *bar_window to the |
| 82 | scroll bar's window, *part to the part the mouse is currently over, |
| 83 | *x to the position of the mouse along the scroll bar, and *y to the |
| 84 | overall length of the scroll bar. |
| 85 | |
| 86 | Otherwise, set *bar_window to Qnil, and *x and *y to the column and |
| 87 | row of the character cell the mouse is over. |
| 88 | |
| 89 | Set *time to the time the mouse was at the returned position. |
| 90 | |
| 91 | This should clear mouse_moved until the next motion |
| 92 | event arrives. */ |
| 93 | extern void (*mouse_position_hook) P_ ((struct frame **f, int, |
| 94 | Lisp_Object *bar_window, |
| 95 | enum scroll_bar_part *part, |
| 96 | Lisp_Object *x, |
| 97 | Lisp_Object *y, |
| 98 | unsigned long *time)); |
| 99 | |
| 100 | /* The window system handling code should set this if the mouse has |
| 101 | moved since the last call to the mouse_position_hook. Calling that |
| 102 | hook should clear this. */ |
| 103 | extern int mouse_moved; |
| 104 | |
| 105 | /* When a frame's focus redirection is changed, this hook tells the |
| 106 | window system code to re-decide where to put the highlight. Under |
| 107 | X, this means that Emacs lies about where the focus is. */ |
| 108 | extern void (*frame_rehighlight_hook) P_ ((struct frame *)); |
| 109 | |
| 110 | /* If we're displaying frames using a window system that can stack |
| 111 | frames on top of each other, this hook allows you to bring a frame |
| 112 | to the front, or bury it behind all the other windows. If this |
| 113 | hook is zero, that means the device we're displaying on doesn't |
| 114 | support overlapping frames, so there's no need to raise or lower |
| 115 | anything. |
| 116 | |
| 117 | If RAISE is non-zero, F is brought to the front, before all other |
| 118 | windows. If RAISE is zero, F is sent to the back, behind all other |
| 119 | windows. */ |
| 120 | extern void (*frame_raise_lower_hook) P_ ((struct frame *f, int raise)); |
| 121 | |
| 122 | \f |
| 123 | /* Scroll bar hooks. */ |
| 124 | |
| 125 | /* The representation of scroll bars is determined by the code which |
| 126 | implements them, except for one thing: they must be represented by |
| 127 | lisp objects. This allows us to place references to them in |
| 128 | Lisp_Windows without worrying about those references becoming |
| 129 | dangling references when the scroll bar is destroyed. |
| 130 | |
| 131 | The window-system-independent portion of Emacs just refers to |
| 132 | scroll bars via their windows, and never looks inside the scroll bar |
| 133 | representation; it always uses hook functions to do all the |
| 134 | scroll bar manipulation it needs. |
| 135 | |
| 136 | The `vertical_scroll_bar' field of a Lisp_Window refers to that |
| 137 | window's scroll bar, or is nil if the window doesn't have a |
| 138 | scroll bar. |
| 139 | |
| 140 | The `scroll_bars' and `condemned_scroll_bars' fields of a Lisp_Frame |
| 141 | are free for use by the scroll bar implementation in any way it sees |
| 142 | fit. They are marked by the garbage collector. */ |
| 143 | |
| 144 | |
| 145 | /* Set the vertical scroll bar for WINDOW to have its upper left corner |
| 146 | at (TOP, LEFT), and be LENGTH rows high. Set its handle to |
| 147 | indicate that we are displaying PORTION characters out of a total |
| 148 | of WHOLE characters, starting at POSITION. If WINDOW doesn't yet |
| 149 | have a scroll bar, create one for it. */ |
| 150 | extern void (*set_vertical_scroll_bar_hook) |
| 151 | P_ ((struct window *window, |
| 152 | int portion, int whole, int position)); |
| 153 | |
| 154 | |
| 155 | /* The following three hooks are used when we're doing a thorough |
| 156 | redisplay of the frame. We don't explicitly know which scroll bars |
| 157 | are going to be deleted, because keeping track of when windows go |
| 158 | away is a real pain - can you say set-window-configuration? |
| 159 | Instead, we just assert at the beginning of redisplay that *all* |
| 160 | scroll bars are to be removed, and then save scroll bars from the |
| 161 | fiery pit when we actually redisplay their window. */ |
| 162 | |
| 163 | /* Arrange for all scroll bars on FRAME to be removed at the next call |
| 164 | to `*judge_scroll_bars_hook'. A scroll bar may be spared if |
| 165 | `*redeem_scroll_bar_hook' is applied to its window before the judgement. |
| 166 | |
| 167 | This should be applied to each frame each time its window tree is |
| 168 | redisplayed, even if it is not displaying scroll bars at the moment; |
| 169 | if the HAS_SCROLL_BARS flag has just been turned off, only calling |
| 170 | this and the judge_scroll_bars_hook will get rid of them. |
| 171 | |
| 172 | If non-zero, this hook should be safe to apply to any frame, |
| 173 | whether or not it can support scroll bars, and whether or not it is |
| 174 | currently displaying them. */ |
| 175 | extern void (*condemn_scroll_bars_hook) P_ ((struct frame *frame)); |
| 176 | |
| 177 | /* Unmark WINDOW's scroll bar for deletion in this judgement cycle. |
| 178 | Note that it's okay to redeem a scroll bar that is not condemned. */ |
| 179 | extern void (*redeem_scroll_bar_hook) P_ ((struct window *window)); |
| 180 | |
| 181 | /* Remove all scroll bars on FRAME that haven't been saved since the |
| 182 | last call to `*condemn_scroll_bars_hook'. |
| 183 | |
| 184 | This should be applied to each frame after each time its window |
| 185 | tree is redisplayed, even if it is not displaying scroll bars at the |
| 186 | moment; if the HAS_SCROLL_BARS flag has just been turned off, only |
| 187 | calling this and condemn_scroll_bars_hook will get rid of them. |
| 188 | |
| 189 | If non-zero, this hook should be safe to apply to any frame, |
| 190 | whether or not it can support scroll bars, and whether or not it is |
| 191 | currently displaying them. */ |
| 192 | extern void (*judge_scroll_bars_hook) P_ ((struct frame *FRAME)); |
| 193 | |
| 194 | \f |
| 195 | /* Input queue declarations and hooks. */ |
| 196 | |
| 197 | /* Expedient hack: only provide the below definitions to files that |
| 198 | are prepared to handle lispy things. CONSP is defined iff lisp.h |
| 199 | has been included before this file. */ |
| 200 | #ifdef CONSP |
| 201 | |
| 202 | enum event_kind |
| 203 | { |
| 204 | no_event, /* nothing happened. This should never |
| 205 | actually appear in the event queue. */ |
| 206 | |
| 207 | ascii_keystroke, /* The ASCII code is in .code, perhaps |
| 208 | with modifiers applied. |
| 209 | .modifiers holds the state of the |
| 210 | modifier keys. |
| 211 | .frame_or_window is the frame in |
| 212 | which the key was typed. |
| 213 | .timestamp gives a timestamp (in |
| 214 | milliseconds) for the keystroke. */ |
| 215 | multibyte_char_keystroke, /* The multibye char code is in .code, |
| 216 | perhaps with modifiers applied. |
| 217 | The others are the same as |
| 218 | ascii_keystroke. This type of event |
| 219 | is generated only when we are using |
| 220 | XIM on X window. */ |
| 221 | non_ascii_keystroke, /* .code is a number identifying the |
| 222 | function key. A code N represents |
| 223 | a key whose name is |
| 224 | function_key_names[N]; function_key_names |
| 225 | is a table in keyboard.c to which you |
| 226 | should feel free to add missing keys. |
| 227 | .modifiers holds the state of the |
| 228 | modifier keys. |
| 229 | .frame_or_window is the frame in |
| 230 | which the key was typed. |
| 231 | .timestamp gives a timestamp (in |
| 232 | milliseconds) for the keystroke. */ |
| 233 | timer_event, /* A timer fired. */ |
| 234 | mouse_click, /* The button number is in .code; it must |
| 235 | be >= 0 and < NUM_MOUSE_BUTTONS, defined |
| 236 | below. |
| 237 | .modifiers holds the state of the |
| 238 | modifier keys. |
| 239 | .x and .y give the mouse position, |
| 240 | in characters, within the window. |
| 241 | .frame_or_window gives the frame |
| 242 | the mouse click occurred in. |
| 243 | .timestamp gives a timestamp (in |
| 244 | milliseconds) for the click. */ |
| 245 | #ifdef WINDOWSNT |
| 246 | mouse_wheel, /* A mouse-wheel event is generated |
| 247 | on WINDOWSNT by a |
| 248 | wheel on a mouse (e.g., MS Intellimouse). |
| 249 | The event contains a delta that corresponds |
| 250 | to the amount and direction that the wheel |
| 251 | is rotated. This delta is typically |
| 252 | used to implement a scroll or zoom. |
| 253 | .code gives the delta. |
| 254 | .modifiers holds the state of the |
| 255 | modifier keys. |
| 256 | .x and .y give the mouse position, |
| 257 | in characters, within the window. |
| 258 | .frame_or_window gives the frame |
| 259 | the wheel event occurred in. |
| 260 | .timestamp gives a timestamp (in |
| 261 | milliseconds) for the wheel event. */ |
| 262 | language_change_event, /* A language_change event is generated |
| 263 | on WINDOWSNT when the keyboard layout |
| 264 | or input language is changed by the |
| 265 | user. */ |
| 266 | #endif |
| 267 | scroll_bar_click, /* .code gives the number of the mouse button |
| 268 | that was clicked. |
| 269 | .modifiers holds the state of the modifier |
| 270 | keys. |
| 271 | .part is a lisp symbol indicating which |
| 272 | part of the scroll bar got clicked. |
| 273 | .x gives the distance from the start of the |
| 274 | scroll bar of the click; .y gives the total |
| 275 | length of the scroll bar. |
| 276 | .frame_or_window gives the window |
| 277 | whose scroll bar was clicked in. |
| 278 | .timestamp gives a timestamp (in |
| 279 | milliseconds) for the click. */ |
| 280 | #ifdef WINDOWSNT |
| 281 | w32_scroll_bar_click, /* as for scroll_bar_click, but only generated |
| 282 | by MS-Windows scroll bar controls. */ |
| 283 | #endif |
| 284 | selection_request_event, /* Another X client wants a selection from us. |
| 285 | See `struct selection_event'. */ |
| 286 | selection_clear_event, /* Another X client cleared our selection. */ |
| 287 | buffer_switch_event, /* A process filter has switched buffers. */ |
| 288 | delete_window_event, /* An X client said "delete this window". */ |
| 289 | MENU_BAR_EVENT, /* An event generated by the menu bar. |
| 290 | The frame_or_window field's cdr holds the |
| 291 | Lisp-level event value. |
| 292 | (Only the toolkit version uses these.) */ |
| 293 | iconify_event, /* An X client iconified this window. */ |
| 294 | deiconify_event, /* An X client deiconified this window. */ |
| 295 | menu_bar_activate_event, /* A button press in the menu bar |
| 296 | (toolkit version only). */ |
| 297 | drag_n_drop, /* A drag-n-drop event is generated when |
| 298 | files selected outside of Emacs are dropped |
| 299 | onto an Emacs window. |
| 300 | Currently used only on Windows NT. |
| 301 | .modifiers holds the state of the |
| 302 | modifier keys. |
| 303 | .x and .y give the mouse position, |
| 304 | in characters, within the window. |
| 305 | .frame_or_window is a cons of the frame |
| 306 | in which the drop was made and a list of |
| 307 | the filenames of the dropped files. |
| 308 | .timestamp gives a timestamp (in |
| 309 | milliseconds) for the click. */ |
| 310 | USER_SIGNAL_EVENT, /* A user signal. |
| 311 | code is a number identifying it, |
| 312 | index into lispy_user_signals. */ |
| 313 | |
| 314 | /* Help events. Member `frame_or_window' of the input_event is the |
| 315 | frame on which the event occurred, and member `arg' contains |
| 316 | the help to show. */ |
| 317 | HELP_EVENT, |
| 318 | |
| 319 | /* An event from a tool-bar. Member `arg' of the input event |
| 320 | contains the tool-bar item selected. If `frame_or_window' |
| 321 | and `arg' are equal, this is a prefix event. */ |
| 322 | TOOL_BAR_EVENT, |
| 323 | |
| 324 | /* Queued from XTread_socket on FocusIn events. Translated into |
| 325 | `switch-frame' events in kbd_buffer_get_event, if necessary. */ |
| 326 | FOCUS_IN_EVENT |
| 327 | }; |
| 328 | |
| 329 | /* If a struct input_event has a kind which is selection_request_event |
| 330 | or selection_clear_event, then its contents are really described |
| 331 | by `struct selection_event'; see xterm.h. */ |
| 332 | |
| 333 | /* The keyboard input buffer is an array of these structures. Each one |
| 334 | represents some sort of input event - a keystroke, a mouse click, or |
| 335 | a window system event. These get turned into their lispy forms when |
| 336 | they are removed from the event queue. */ |
| 337 | |
| 338 | struct input_event |
| 339 | { |
| 340 | /* What kind of event was this? */ |
| 341 | enum event_kind kind; |
| 342 | |
| 343 | /* For an ascii_keystroke and multibyte_char_keystroke, this is the |
| 344 | character. |
| 345 | For a non_ascii_keystroke, this is the keysym code. |
| 346 | For a mouse event, this is the button number. */ |
| 347 | /* In WindowsNT, for a mouse wheel event, this is the delta. */ |
| 348 | int code; |
| 349 | enum scroll_bar_part part; |
| 350 | |
| 351 | int modifiers; /* See enum below for interpretation. */ |
| 352 | |
| 353 | Lisp_Object x, y; |
| 354 | unsigned long timestamp; |
| 355 | |
| 356 | /* This is padding just to put the frame_or_window field |
| 357 | past the size of struct selection_event. */ |
| 358 | int *padding[2]; |
| 359 | |
| 360 | /* This field is copied into a vector while the event is in the queue, |
| 361 | so that garbage collections won't kill it. */ |
| 362 | /* In a menu_bar_event, this is a cons cell whose car is the frame |
| 363 | and whose cdr is the Lisp object that is the event's value. */ |
| 364 | /* This field is last so that struct selection_input_event |
| 365 | does not overlap with it. */ |
| 366 | Lisp_Object frame_or_window; |
| 367 | |
| 368 | /* Additional event argument. This is used for TOOL_BAR_EVENTs and |
| 369 | HELP_EVENTs and avoids calling Fcons during signal handling. */ |
| 370 | Lisp_Object arg; |
| 371 | }; |
| 372 | |
| 373 | /* Called to read input events. */ |
| 374 | extern int (*read_socket_hook) P_ ((int, struct input_event *, int, int)); |
| 375 | |
| 376 | /* Called when a frame's display becomes entirely up to date. */ |
| 377 | extern void (*frame_up_to_date_hook) P_ ((struct frame *)); |
| 378 | \f |
| 379 | |
| 380 | /* Bits in the modifiers member of the input_event structure. |
| 381 | Note that reorder_modifiers assumes that the bits are in canonical |
| 382 | order. |
| 383 | |
| 384 | The modifiers applied to mouse clicks are rather ornate. The |
| 385 | window-system-specific code should store mouse clicks with |
| 386 | up_modifier or down_modifier set. Having an explicit down modifier |
| 387 | simplifies some of window-system-independent code; without it, the |
| 388 | code would have to recognize down events by checking if the event |
| 389 | is a mouse click lacking the click and drag modifiers. |
| 390 | |
| 391 | The window-system independent code turns all up_modifier events |
| 392 | bits into drag_modifier, click_modifier, double_modifier, or |
| 393 | triple_modifier events. The click_modifier has no written |
| 394 | representation in the names of the symbols used as event heads, |
| 395 | but it does appear in the Qevent_symbol_components property of the |
| 396 | event heads. */ |
| 397 | enum { |
| 398 | up_modifier = 1, /* Only used on mouse buttons - always |
| 399 | turned into a click or a drag modifier |
| 400 | before lisp code sees the event. */ |
| 401 | down_modifier = 2, /* Only used on mouse buttons. */ |
| 402 | drag_modifier = 4, /* This is never used in the event |
| 403 | queue; it's only used internally by |
| 404 | the window-system-independent code. */ |
| 405 | click_modifier= 8, /* See drag_modifier. */ |
| 406 | double_modifier= 16, /* See drag_modifier. */ |
| 407 | triple_modifier= 32, /* See drag_modifier. */ |
| 408 | |
| 409 | /* The next four modifier bits are used also in keyboard events at |
| 410 | the Lisp level. |
| 411 | |
| 412 | It's probably not the greatest idea to use the 2^23 bit for any |
| 413 | modifier. It may or may not be the sign bit, depending on |
| 414 | VALBITS, so using it to represent a modifier key means that |
| 415 | characters thus modified have different integer equivalents |
| 416 | depending on the architecture they're running on. Oh, and |
| 417 | applying XINT to a character whose 2^23 bit is set sign-extends |
| 418 | it, so you get a bunch of bits in the mask you didn't want. |
| 419 | |
| 420 | The CHAR_ macros are defined in lisp.h. */ |
| 421 | alt_modifier = CHAR_ALT, /* Under X, the XK_Alt_[LR] keysyms. */ |
| 422 | super_modifier= CHAR_SUPER, /* Under X, the XK_Super_[LR] keysyms. */ |
| 423 | hyper_modifier= CHAR_HYPER, /* Under X, the XK_Hyper_[LR] keysyms. */ |
| 424 | shift_modifier= CHAR_SHIFT, |
| 425 | ctrl_modifier = CHAR_CTL, |
| 426 | meta_modifier = CHAR_META /* Under X, the XK_Meta_[LR] keysyms. */ |
| 427 | }; |
| 428 | |
| 429 | #endif |