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