cgit.sxemacs.org Git - sxemacs/blob - src/ui/device.h

   1 /* Define device-object for XEmacs.
   2    Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
   3    Copyright (C) 1995 Ben Wing
   4    Copyright (C) 1995 Sun Microsystems
   5
   6 This file is part of SXEmacs
   7
   8 SXEmacs is free software: you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation, either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 SXEmacs is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  20
  21
  22 /* Synched up with: Not in FSF. */
  23
  24 /* Written by Chuck Thompson and Ben Wing. */
  25
  26 #ifndef INCLUDED_device_h_
  27 #define INCLUDED_device_h_
  28
  29 #include "console.h"
  30
  31 /* This should really be in redisplay.h but by putting it here we
  32    won't have to ensure that redisplay.h is always included before
  33    this file. */
  34 struct pixel_to_glyph_translation_cache {
  35         unsigned int valid:1;
  36         struct frame *frame;
  37         int low_x_coord, high_x_coord, col, obj_x;
  38         int low_y_coord, high_y_coord, row, obj_y;
  39         struct window *w;
  40         Bufpos bufpos;
  41         Bufpos closest;
  42         Charcount modeline_closest;
  43         Lisp_Object obj1, obj2;
  44         int retval;
  45 };
  46
  47 #define DEVICE_TYPE_NAME(d) ((d)->devmeths->name)
  48 #define DEVICE_TYPE(d) ((d)->devmeths->symbol)
  49 #define DEVICE_IMPL_FLAG(d, f) CONMETH_IMPL_FLAG ((d)->devmeths, (f))
  50 #define DEVICE_SPECIFIC_FRAME_PROPS(d) \
  51   ((d)->devmeths->device_specific_frame_props)
  52
  53 /******** Accessing / calling a device method *********/
  54
  55 #define HAS_DEVMETH_P(d, m) HAS_CONTYPE_METH_P ((d)->devmeths, m)
  56 #define DEVMETH(d, m, args) CONTYPE_METH ((d)->devmeths, m, args)
  57 #define MAYBE_DEVMETH(d, m, args) MAYBE_CONTYPE_METH ((d)->devmeths, m, args)
  58 #define DEVMETH_OR_GIVEN(d, m, args, given) \
  59   CONTYPE_METH_OR_GIVEN((d)->devmeths, m, args, given)
  60 #define MAYBE_INT_DEVMETH(d, m, args) \
  61   MAYBE_INT_CONTYPE_METH ((d)->devmeths, m, args)
  62 #define MAYBE_LISP_DEVMETH(d, m, args) \
  63   MAYBE_LISP_CONTYPE_METH ((d)->devmeths, m, args)
  64
  65 struct device {
  66         struct lcrecord_header header;
  67
  68         /* Methods for this device's console.  This can also be retrieved
  69            through device->console, but it's faster this way. */
  70         struct console_methods *devmeths;
  71
  72         /* Name of this device, for resourcing and printing purposes.
  73            If not explicitly given, it's initialized in a device-specific
  74            manner. */
  75         Lisp_Object name;
  76
  77         /* What this device is connected to */
  78         Lisp_Object connection;
  79
  80         /* A canonical name for the connection that is used to determine
  81            whether `make-device' is being called on an existing device. */
  82         Lisp_Object canon_connection;
  83
  84         /* List of frames on this device. */
  85         Lisp_Object frame_list;
  86
  87         /* The console this device is on. */
  88         Lisp_Object console;
  89
  90         /* Frame which is "currently selected".  This is what `selected-frame'
  91            returns and is the default frame for many operations.  This may
  92            not be the same as frame_with_focus; `select-frame' changes the
  93            selected_frame but not the frame_with_focus.  However, eventually
  94            either the two values will be the same, or frame_with_focus will
  95            be nil: right before waiting for an event, the focus is changed
  96            to point to the selected_frame if XEmacs currently has the focus
  97            on this device.  Note that frame_with_focus may be nil (none of the
  98            frames on this device have the window-system focus), but
  99            selected_frame will never be nil if there are any frames on
 100            the device. */
 101         Lisp_Object selected_frame;
 102         /* Frame that currently contains the window-manager focus, or none.
 103            Note that we've split frame_with_focus into two variables.
 104            frame_with_focus_real is the value we use most of the time,
 105            but frame_with_focus_for_hooks is used for running the select-frame-hook
 106            and deselect-frame-hook.  We do this because we split the focus handling
 107            into two parts: one part (deals with drawing the solid/box cursor)
 108            runs as soon as a focus event is received; the other (running the
 109            hooks) runs after any pending sit-for/sleep-for/accept-process-output
 110            calls are done. */
 111         Lisp_Object frame_with_focus_real;
 112         Lisp_Object frame_with_focus_for_hooks;
 113         /* If we have recently issued a request to change the focus as a
 114            result of select-frame having been called, the following variable
 115            records the frame we are trying to focus on.  The reason for this
 116            is that the window manager may not grant our request to change
 117            the focus (so we can't just change frame_with_focus), and we don't
 118            want to keep sending requests again and again to the window manager.
 119            This variable is reset whenever a focus-change event is seen. */
 120         Lisp_Object frame_that_ought_to_have_focus;
 121
 122         /* Color class of this device. */
 123         Lisp_Object device_class;
 124
 125         /* Alist of values for user-defined tags in this device. */
 126         Lisp_Object user_defined_tags;
 127
 128         /* Hash tables for device-specific objects (fonts, colors, etc).
 129            These are key-weak hash tables (or hash tables containing key-weak
 130            hash tables) so that they disappear when the key goes away. */
 131
 132         /* This is a simple key-weak hash table hashing color names to
 133            instances. */
 134         Lisp_Object color_instance_cache;
 135
 136         /* This is a simple key-weak hash table hashing font names to
 137            instances. */
 138         Lisp_Object font_instance_cache;
 139
 140 #ifdef MULE
 141         /* This is a bi-level cache, where the hash table in this slot here
 142            indexes charset objects to key-weak hash tables, which in turn
 143            index font names to more specific font names that match the
 144            given charset's registry.  This speeds up the horrendously
 145            slow XListFonts() operation that needs to be done in order
 146            to determine an appropriate font. */
 147         Lisp_Object charset_font_cache;
 148 #endif
 149
 150         /* This is a bi-level cache, where the hash table in this slot here
 151            indexes image-instance-type masks (there are currently 6
 152            image-instance types and thus 64 possible masks) to key-weak hash
 153            tables like the one for colors. */
 154         Lisp_Object image_instance_cache;
 155
 156         /* A structure of auxiliary data specific to the device type.
 157            struct x_device is used for X window frames; defined in console-x.h
 158            struct tty_device is used to TTY's; defined in console-tty.h */
 159         void *device_data;
 160
 161         /* redisplay flags */
 162         unsigned int buffers_changed:1;
 163         unsigned int clip_changed:1;
 164         unsigned int extents_changed:1;
 165         unsigned int faces_changed:1;
 166         unsigned int frame_changed:1;
 167         unsigned int frame_layout_changed:1;    /* The layout of frame
 168                                                    elements has changed. */
 169         unsigned int glyphs_changed:1;
 170         unsigned int subwindows_changed:1;
 171         unsigned int subwindows_state_changed:1;
 172         unsigned int icon_changed:1;
 173         unsigned int menubar_changed:1;
 174         unsigned int modeline_changed:1;
 175         unsigned int point_changed:1;
 176         unsigned int size_changed:1;
 177         unsigned int gutter_changed:1;
 178         unsigned int toolbar_changed:1;
 179         unsigned int windows_changed:1;
 180         unsigned int windows_structure_changed:1;
 181
 182         unsigned int locked:1;
 183
 184         /* Cache information about last pixel position translated to a
 185            glyph.  The law of locality applies very heavily here so caching
 186            the value leads to a significant win.  At the moment this is
 187            really X specific but once we have generic mouse support it won't
 188            be. */
 189         struct pixel_to_glyph_translation_cache pixel_to_glyph_cache;
 190
 191         /* Output baud rate of device; used for redisplay decisions.  */
 192         int baud_rate;
 193
 194         /* sound flags */
 195         unsigned int on_console_p:1;
 196         unsigned int connected_to_nas_p:1;
 197
 198         /* File descriptors for input and output.  Much of the time
 199            (but not always) these will be the same.  For an X device,
 200            these both hold the file descriptor of the socket used
 201            to communicate with the X server.  For a TTY device, these
 202            may or may not be the same and point to the terminal that
 203            is used for I/O. */
 204         int infd, outfd;
 205
 206         /* infd and outfd are moved outside HAVE_UNIXOID_EVENT_LOOP conditionals,
 207            because Win32, presumably the first port which does not use select()
 208            polling, DOES have handles for a console device. -- kkm */
 209
 210         /* We removed Win32 support, but does it make sense to move infd
 211            and outfd back inside HAVE_UNIXOID_EVENT_LOOP conditionals?
 212            -- njsf */
 213
 214 #ifdef HAVE_UNIXOID_EVENT_LOOP
 215         /* holds some data necessary for SIGIO control.  Perhaps this should
 216            be inside of device_data; but it is used for both TTY's and X
 217            device.  Perhaps it should be conditionalized on SIGIO; but
 218            this requires including syssignal.h and systty.h. */
 219         int old_fcntl_owner;
 220 #endif
 221 };
 222
 223 DECLARE_LRECORD(device, struct device);
 224 #define XDEVICE(x) XRECORD (x, device, struct device)
 225 #define XSETDEVICE(x, p) XSETRECORD (x, p, device)
 226 #define wrap_device(p) wrap_object (p)
 227 #define DEVICEP(x) RECORDP (x, device)
 228 #define CHECK_DEVICE(x) CHECK_RECORD (x, device)
 229 #define CONCHECK_DEVICE(x) CONCHECK_RECORD (x, device)
 230
 231 #define CHECK_LIVE_DEVICE(x) do {                       \
 232   CHECK_DEVICE (x);                                     \
 233   if (! DEVICE_LIVE_P (XDEVICE (x)))                    \
 234     dead_wrong_type_argument (Qdevice_live_p, (x));     \
 235 } while (0)
 236 #define CONCHECK_LIVE_DEVICE(x) do {                    \
 237   CONCHECK_DEVICE (x);                                  \
 238   if (! DEVICE_LIVE_P (XDEVICE (x)))                    \
 239     x = wrong_type_argument (Qdevice_live_p, (x));      \
 240 } while (0)
 241
 242 #define DEVICE_TYPE_P(d, type)  EQ (DEVICE_TYPE (d), Q##type)
 243
 244 #ifdef ERROR_CHECK_TYPECHECK
 245 extern_inline struct device *error_check_device_type(struct device *d,
 246                                                      Lisp_Object sym);
 247 extern_inline struct device *error_check_device_type(struct device *d,
 248                                                      Lisp_Object sym)
 249 {
 250         assert(EQ(DEVICE_TYPE(d), sym));
 251         return d;
 252 }
 253
 254 # define DEVICE_TYPE_DATA(d, type)                      \
 255   ((struct type##_device *) error_check_device_type (d, Q##type)->device_data)
 256 #else
 257 # define DEVICE_TYPE_DATA(d, type)                      \
 258   ((struct type##_device *) (d)->device_data)
 259 #endif
 260
 261 #define CHECK_DEVICE_TYPE(x, type)                      \
 262   do {                                                  \
 263     CHECK_DEVICE (x);                                   \
 264     if (!(DEVICEP (x) && DEVICE_TYPE_P (XDEVICE (x),    \
 265                                          type)))        \
 266       dead_wrong_type_argument                          \
 267         (type##_console_methods->predicate_symbol, x);  \
 268   } while (0)
 269 #define CONCHECK_DEVICE_TYPE(x, type)                   \
 270   do {                                                  \
 271     CONCHECK_DEVICE (x);                                \
 272     if (!(DEVICEP (x) && DEVICE_TYPE_P (XDEVICE (x),    \
 273                                          type)))        \
 274       x = wrong_type_argument                           \
 275         (type##_console_methods->predicate_symbol, x);  \
 276   } while (0)
 277
 278 #define DEVICE_DISPLAY_P(dev)                           \
 279   (DEVICE_LIVE_P (dev) &&                               \
 280     !DEVICE_IMPL_FLAG (dev, XDEVIMPF_IS_A_PRINTER))
 281
 282 #define CHECK_DISPLAY_DEVICE(dev)                       \
 283   do {                                                  \
 284     CHECK_DEVICE (dev);                                 \
 285     if (!(DEVICEP (dev)                                 \
 286           && DEVICE_DISPLAY_P (XDEVICE (dev))))         \
 287       dead_wrong_type_argument (Qdisplay, dev);         \
 288   } while (0)
 289
 290 #define CONCHECK_DISPLAY_DEVICE(dev)                    \
 291   do {                                                  \
 292     CONCHECK_DEVICE (dev);                              \
 293     if (!(DEVICEP (dev)                                 \
 294           && DEVICE_DISPLAY_P (XDEVICE (dev))))         \
 295       wrong_type_argument (Qdisplay, dev);              \
 296   } while (0)
 297
 298 #define DEVICE_PRINTER_P(dev)                           \
 299   (DEVICE_LIVE_P (dev) && !DEVICE_DISPLAY_P (dev))
 300
 301 #define CHECK_PRINTER_DEVICE(dev)                       \
 302   do {                                                  \
 303     CHECK_DEVICE (dev);                                 \
 304     if (!(DEVICEP (dev)                                 \
 305           && DEVICE_PRINTER_P (XDEVICE (dev))))         \
 306       dead_wrong_type_argument (Qprinter, dev);         \
 307   } while (0)
 308
 309 #define CONCHECK_PRINTER_DEVICE(dev)                    \
 310   do {                                                  \
 311     CONCHECK_DEVICE (dev);                              \
 312     if (!(DEVICEP (dev)                                 \
 313           && DEVICE_PRINTER_P (XDEVICE (dev))))         \
 314       wrong_type_argument (Qprinter, dev);              \
 315   } while (0)
 316
 317 /* #### These should be in the device-*.h files but there are
 318    too many places where the abstraction is broken.  Need to
 319    fix. */
 320
 321 #define DEVICE_X_P(dev) CONSOLE_TYPESYM_X_P (DEVICE_TYPE (dev))
 322 #define CHECK_X_DEVICE(z) CHECK_DEVICE_TYPE (z, x)
 323 #define CONCHECK_X_DEVICE(z) CONCHECK_DEVICE_TYPE (z, x)
 324
 325 #define DEVICE_TTY_P(dev) CONSOLE_TYPESYM_TTY_P (DEVICE_TYPE (dev))
 326 #define CHECK_TTY_DEVICE(z) CHECK_DEVICE_TYPE (z, tty)
 327 #define CONCHECK_TTY_DEVICE(z) CONCHECK_DEVICE_TYPE (z, tty)
 328
 329 #define DEVICE_STREAM_P(dev) CONSOLE_TYPESYM_STREAM_P (DEVICE_TYPE (dev))
 330 #define CHECK_STREAM_DEVICE(z) CHECK_DEVICE_TYPE (z, stream)
 331 #define CONCHECK_STREAM_DEVICE(z) CONCHECK_DEVICE_TYPE (z, stream)
 332
 333 #define DEVICE_WIN_P(dev) CONSOLE_TYPESYM_WIN_P (DEVICE_TYPE (dev))
 334
 335 EXFUN(Fdevice_console, 1);
 336 EXFUN(Fdevice_name, 1);
 337 EXFUN(Ffind_device, 2);
 338 EXFUN(Fmake_device, 3);
 339 EXFUN(Fselected_device, 1);
 340
 341 extern Lisp_Object Qcreate_device_hook, Qdelete_device_hook, Qgrayscale;
 342 extern Lisp_Object Qinit_post_tty_win, Qmono, Vdefault_x_device;
 343 extern Lisp_Object Vdevice_class_list;
 344
 345 int valid_device_class_p(Lisp_Object class);
 346
 347 #define DEVICE_LIVE_P(d) (!EQ (DEVICE_TYPE (d), Qdead))
 348
 349 #define DEVICE_REDISPLAY_INFO(d) ((d)->redisplay_info)
 350
 351 #define DEVICE_NAME(d) ((d)->name)
 352 #define DEVICE_CLASS(d) ((d)->device_class)
 353 /* Catch people attempting to set this. */
 354 #define DEVICE_SELECTED_FRAME(d) NON_LVALUE ((d)->selected_frame)
 355 #define DEVICE_FRAME_WITH_FOCUS_REAL(d) ((d)->frame_with_focus_real)
 356 #define DEVICE_FRAME_WITH_FOCUS_FOR_HOOKS(d) ((d)->frame_with_focus_for_hooks)
 357 #define DEVICE_FRAME_THAT_OUGHT_TO_HAVE_FOCUS(d)                        \
 358   ((d)->frame_that_ought_to_have_focus)
 359 #define DEVICE_USER_DEFINED_TAGS(d) ((d)->user_defined_tags)
 360 #define DEVICE_FRAME_LIST(d) ((d)->frame_list)
 361 #define DEVICE_CONNECTION(d) ((d)->connection)
 362 #define DEVICE_CANON_CONNECTION(d) ((d)->canon_connection)
 363 #define DEVICE_CONSOLE(d) ((d)->console)
 364 #define DEVICE_BAUD_RATE(d) ((d)->baud_rate)
 365 #define DEVICE_INFD(d) ((d)->infd)
 366 #define DEVICE_OUTFD(d) ((d)->outfd)
 367 #define DEVICE_OLD_FCNTL_OWNER(d) ((d)->old_fcntl_owner)
 368 #define DEVICE_ON_CONSOLE_P(d) ((d)->on_console_p)
 369 #define DEVICE_CONNECTED_TO_NAS_P(d) ((d)->connected_to_nas_p)
 370
 371 #define LOCK_DEVICE(d) ((void) ((d)->locked = 1))
 372 #define UNLOCK_DEVICE(d) ((void) ((d)->locked = 0))
 373
 374 #define INVALIDATE_DEVICE_PIXEL_TO_GLYPH_CACHE(d)                       \
 375   ((void) ((d)->pixel_to_glyph_cache.valid = 0))
 376
 377 #define INVALIDATE_PIXEL_TO_GLYPH_CACHE do {                                    \
 378   Lisp_Object IPTGC_devcons, IPTGC_concons;                                     \
 379   DEVICE_LOOP_NO_BREAK (IPTGC_devcons, IPTGC_concons)                           \
 380     INVALIDATE_DEVICE_PIXEL_TO_GLYPH_CACHE (XDEVICE (XCAR (IPTGC_devcons)));    \
 381 } while (0)
 382
 383 #define MARK_DEVICE_FACES_CHANGED(d)                    \
 384   ((void) (faces_changed = (d)->faces_changed = 1))
 385
 386 #define MARK_DEVICE_GLYPHS_CHANGED(d)                   \
 387   ((void) (glyphs_changed = (d)->glyphs_changed = 1))
 388
 389 #define MARK_DEVICE_SUBWINDOWS_CHANGED(d)                       \
 390   ((void) (subwindows_changed = (d)->subwindows_changed = 1))
 391
 392 #define MARK_DEVICE_SUBWINDOWS_STATE_CHANGED(d)         \
 393   ((void) (subwindows_state_changed = (d)->subwindows_state_changed = 1))
 394
 395 #define MARK_DEVICE_TOOLBARS_CHANGED(d)                 \
 396   ((void) (toolbar_changed = (d)->toolbar_changed = 1))
 397
 398 #define MARK_DEVICE_GUTTERS_CHANGED(d)          \
 399   ((void) (gutter_changed = (d)->gutter_changed = 1))
 400
 401 #define MARK_DEVICE_SIZE_CHANGED(d)                     \
 402   ((void) (size_changed = (d)->size_changed = 1))
 403
 404 #define MARK_DEVICE_FRAMES_FACES_CHANGED(d) do {        \
 405   struct device *mdffc_d = (d);                         \
 406   Lisp_Object frmcons;                                  \
 407   DEVICE_FRAME_LOOP (frmcons, mdffc_d)                  \
 408     XFRAME (XCAR (frmcons))->faces_changed = 1;         \
 409   MARK_DEVICE_FACES_CHANGED (mdffc_d);                  \
 410 } while (0)
 411
 412 #define MARK_DEVICE_FRAMES_GLYPHS_CHANGED(d) do {       \
 413   struct device *mdffc_d = (d);                         \
 414   Lisp_Object frmcons;                                  \
 415   DEVICE_FRAME_LOOP (frmcons, mdffc_d)                  \
 416     XFRAME (XCAR (frmcons))->glyphs_changed = 1;                \
 417   MARK_DEVICE_GLYPHS_CHANGED (mdffc_d);         \
 418 } while (0)
 419
 420 #define MARK_DEVICE_FRAME_CHANGED(d)                    \
 421   ((void) (frame_changed = (d)->frame_changed = 1))
 422
 423 #define MARK_DEVICE_FRAME_LAYOUT_CHANGED(d)                     \
 424   ((void) (frame_layout_changed = (d)->frame_layout_changed = 1))
 425
 426 #define MARK_DEVICE_WINDOWS_CHANGED(d)                  \
 427   ((void) (windows_changed = (d)->windows_changed = 1))
 428
 429 #define MARK_DEVICE_WINDOWS_STRUCTURE_CHANGED(d)        \
 430   ((void) (windows_structure_changed = (d)->windows_structure_changed = 1))
 431
 432 /* #### unify this with DOMAIN_DEVICE once the latter has image instances
 433    expunged from it. */
 434 /* This turns out to be used heavily so we make it a macro to make it
 435    inline.  Also, the majority of the time the object will turn out to
 436    be a window so we move it from being checked last to being checked
 437    first. */
 438 #define DFW_DEVICE(obj)                                 \
 439    (WINDOWP (obj) ? WINDOW_DEVICE (XWINDOW (obj))       \
 440  : (FRAMEP  (obj) ? FRAME_DEVICE (XFRAME (obj))         \
 441  : (DEVICEP (obj) ? obj                                 \
 442  : Qnil)))
 443
 444 /* NO_BREAK means that "break" doesn't do what you think it does!
 445    Use goto instead.  "continue" is OK, though. */
 446 #define DEVICE_LOOP_NO_BREAK(devcons, concons)                  \
 447   CONSOLE_LOOP (concons)                                        \
 448     CONSOLE_DEVICE_LOOP (devcons, XCONSOLE (XCAR (concons)))
 449 #define DEVICE_FRAME_LOOP(frmcons, d) \
 450   LIST_LOOP (frmcons, DEVICE_FRAME_LIST (d))
 451 #define CONSOLE_FRAME_LOOP_NO_BREAK(frmcons, devcons, con) \
 452   CONSOLE_DEVICE_LOOP (devcons, con)                       \
 453     DEVICE_FRAME_LOOP (frmcons, XDEVICE (XCAR (devcons)))
 454
 455 void select_device_1(Lisp_Object);
 456 struct device *decode_device(Lisp_Object);
 457 void handle_asynch_device_change(void);
 458 void call_critical_lisp_code(struct device *d, Lisp_Object function,
 459                              Lisp_Object object);
 460 void delete_device_internal(struct device *d, int force,
 461                             int called_from_delete_console, int from_io_error);
 462 void io_error_delete_device(Lisp_Object device);
 463 Lisp_Object find_nonminibuffer_frame_not_on_device(Lisp_Object device);
 464 void set_device_selected_frame(struct device *d, Lisp_Object frame);
 465 Lisp_Object domain_device_type(Lisp_Object domain);
 466 int window_system_pixelated_geometry(Lisp_Object domain);
 467
 468 #endif                          /* INCLUDED_device_h_ */