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
6 This file is part of XEmacs.
8 XEmacs is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with XEmacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Synched up with: Not in FSF. */
25 /* Written by Chuck Thompson and Ben Wing. */
27 #ifndef INCLUDED_device_h_
28 #define INCLUDED_device_h_
32 /* This should really be in redisplay.h but by putting it here we
33 won't have to ensure that redisplay.h is always included before
35 struct pixel_to_glyph_translation_cache
37 unsigned int valid :1;
39 int low_x_coord, high_x_coord, col, obj_x;
40 int low_y_coord, high_y_coord, row, obj_y;
44 Charcount modeline_closest;
45 Lisp_Object obj1, obj2;
49 #define DEVICE_TYPE_NAME(d) ((d)->devmeths->name)
50 #define DEVICE_TYPE(d) ((d)->devmeths->symbol)
51 #define DEVICE_IMPL_FLAG(d, f) CONMETH_IMPL_FLAG ((d)->devmeths, (f))
52 #define DEVICE_SPECIFIC_FRAME_PROPS(d) \
53 ((d)->devmeths->device_specific_frame_props)
55 /******** Accessing / calling a device method *********/
57 #define HAS_DEVMETH_P(d, m) HAS_CONTYPE_METH_P ((d)->devmeths, m)
58 #define DEVMETH(d, m, args) CONTYPE_METH ((d)->devmeths, m, args)
59 #define MAYBE_DEVMETH(d, m, args) MAYBE_CONTYPE_METH ((d)->devmeths, m, args)
60 #define DEVMETH_OR_GIVEN(d, m, args, given) \
61 CONTYPE_METH_OR_GIVEN((d)->devmeths, m, args, given)
62 #define MAYBE_INT_DEVMETH(d, m, args) \
63 MAYBE_INT_CONTYPE_METH ((d)->devmeths, m, args)
64 #define MAYBE_LISP_DEVMETH(d, m, args) \
65 MAYBE_LISP_CONTYPE_METH ((d)->devmeths, m, args)
69 struct lcrecord_header header;
71 /* Methods for this device's console. This can also be retrieved
72 through device->console, but it's faster this way. */
73 struct console_methods *devmeths;
75 /* Name of this device, for resourcing and printing purposes.
76 If not explicitly given, it's initialized in a device-specific
80 /* What this device is connected to */
81 Lisp_Object connection;
83 /* A canonical name for the connection that is used to determine
84 whether `make-device' is being called on an existing device. */
85 Lisp_Object canon_connection;
87 /* List of frames on this device. */
88 Lisp_Object frame_list;
90 /* The console this device is on. */
93 /* Frame which is "currently selected". This is what `selected-frame'
94 returns and is the default frame for many operations. This may
95 not be the same as frame_with_focus; `select-frame' changes the
96 selected_frame but not the frame_with_focus. However, eventually
97 either the two values will be the same, or frame_with_focus will
98 be nil: right before waiting for an event, the focus is changed
99 to point to the selected_frame if XEmacs currently has the focus
100 on this device. Note that frame_with_focus may be nil (none of the
101 frames on this device have the window-system focus), but
102 selected_frame will never be nil if there are any frames on
104 Lisp_Object selected_frame;
105 /* Frame that currently contains the window-manager focus, or none.
106 Note that we've split frame_with_focus into two variables.
107 frame_with_focus_real is the value we use most of the time,
108 but frame_with_focus_for_hooks is used for running the select-frame-hook
109 and deselect-frame-hook. We do this because we split the focus handling
110 into two parts: one part (deals with drawing the solid/box cursor)
111 runs as soon as a focus event is received; the other (running the
112 hooks) runs after any pending sit-for/sleep-for/accept-process-output
114 Lisp_Object frame_with_focus_real;
115 Lisp_Object frame_with_focus_for_hooks;
116 /* If we have recently issued a request to change the focus as a
117 result of select-frame having been called, the following variable
118 records the frame we are trying to focus on. The reason for this
119 is that the window manager may not grant our request to change
120 the focus (so we can't just change frame_with_focus), and we don't
121 want to keep sending requests again and again to the window manager.
122 This variable is reset whenever a focus-change event is seen. */
123 Lisp_Object frame_that_ought_to_have_focus;
125 /* Color class of this device. */
126 Lisp_Object device_class;
128 /* Alist of values for user-defined tags in this device. */
129 Lisp_Object user_defined_tags;
131 /* Hash tables for device-specific objects (fonts, colors, etc).
132 These are key-weak hash tables (or hash tables containing key-weak
133 hash tables) so that they disappear when the key goes away. */
135 /* This is a simple key-weak hash table hashing color names to
137 Lisp_Object color_instance_cache;
139 /* This is a simple key-weak hash table hashing font names to
141 Lisp_Object font_instance_cache;
144 /* This is a bi-level cache, where the hash table in this slot here
145 indexes charset objects to key-weak hash tables, which in turn
146 index font names to more specific font names that match the
147 given charset's registry. This speeds up the horrendously
148 slow XListFonts() operation that needs to be done in order
149 to determine an appropriate font. */
150 Lisp_Object charset_font_cache;
153 /* This is a bi-level cache, where the hash table in this slot here
154 indexes image-instance-type masks (there are currently 6
155 image-instance types and thus 64 possible masks) to key-weak hash
156 tables like the one for colors. */
157 Lisp_Object image_instance_cache;
159 /* A structure of auxiliary data specific to the device type.
160 struct x_device is used for X window frames; defined in console-x.h
161 struct tty_device is used to TTY's; defined in console-tty.h */
164 /* redisplay flags */
165 unsigned int buffers_changed :1;
166 unsigned int clip_changed :1;
167 unsigned int extents_changed :1;
168 unsigned int faces_changed :1;
169 unsigned int frame_changed :1;
170 unsigned int frame_layout_changed :1; /* The layout of frame
171 elements has changed. */
172 unsigned int glyphs_changed :1;
173 unsigned int subwindows_changed :1;
174 unsigned int subwindows_state_changed :1;
175 unsigned int icon_changed :1;
176 unsigned int menubar_changed :1;
177 unsigned int modeline_changed :1;
178 unsigned int point_changed :1;
179 unsigned int size_changed :1;
180 unsigned int gutter_changed :1;
181 unsigned int toolbar_changed :1;
182 unsigned int windows_changed :1;
183 unsigned int windows_structure_changed :1;
185 unsigned int locked :1;
187 /* Cache information about last pixel position translated to a
188 glyph. The law of locality applies very heavily here so caching
189 the value leads to a significant win. At the moment this is
190 really X specific but once we have generic mouse support it won't
192 struct pixel_to_glyph_translation_cache pixel_to_glyph_cache;
194 /* Output baud rate of device; used for redisplay decisions. */
198 unsigned int on_console_p :1;
199 unsigned int connected_to_nas_p :1;
202 /* File descriptors for input and output. Much of the time
203 (but not always) these will be the same. For an X device,
204 these both hold the file descriptor of the socket used
205 to communicate with the X server. For a TTY device, these
206 may or may not be the same and point to the terminal that
210 /* infd and outfd are moved outside HAVE_UNIXOID_EVENT_LOOP conditionals,
211 because Win32, presumably the first port which does not use select()
212 polling, DOES have handles for a console device. -- kkm */
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. */
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)
231 #define CHECK_LIVE_DEVICE(x) do { \
233 if (! DEVICE_LIVE_P (XDEVICE (x))) \
234 dead_wrong_type_argument (Qdevice_live_p, (x)); \
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)); \
242 #define DEVICE_TYPE_P(d, type) EQ (DEVICE_TYPE (d), Q##type)
244 #ifdef ERROR_CHECK_TYPECHECK
245 INLINE_HEADER struct device *
246 error_check_device_type (struct device *d, Lisp_Object sym);
247 INLINE_HEADER struct device *
248 error_check_device_type (struct device *d, Lisp_Object sym)
250 assert (EQ (DEVICE_TYPE (d), sym));
253 # define DEVICE_TYPE_DATA(d, type) \
254 ((struct type##_device *) error_check_device_type (d, Q##type)->device_data)
256 # define DEVICE_TYPE_DATA(d, type) \
257 ((struct type##_device *) (d)->device_data)
260 #define CHECK_DEVICE_TYPE(x, type) \
263 if (!(DEVICEP (x) && DEVICE_TYPE_P (XDEVICE (x), \
265 dead_wrong_type_argument \
266 (type##_console_methods->predicate_symbol, x); \
268 #define CONCHECK_DEVICE_TYPE(x, type) \
270 CONCHECK_DEVICE (x); \
271 if (!(DEVICEP (x) && DEVICE_TYPE_P (XDEVICE (x), \
273 x = wrong_type_argument \
274 (type##_console_methods->predicate_symbol, x); \
277 #define DEVICE_DISPLAY_P(dev) \
278 (DEVICE_LIVE_P (dev) && \
279 !DEVICE_IMPL_FLAG (dev, XDEVIMPF_IS_A_PRINTER))
281 #define CHECK_DISPLAY_DEVICE(dev) \
283 CHECK_DEVICE (dev); \
284 if (!(DEVICEP (dev) \
285 && DEVICE_DISPLAY_P (XDEVICE (dev)))) \
286 dead_wrong_type_argument (Qdisplay, dev); \
289 #define CONCHECK_DISPLAY_DEVICE(dev) \
291 CONCHECK_DEVICE (dev); \
292 if (!(DEVICEP (dev) \
293 && DEVICE_DISPLAY_P (XDEVICE (dev)))) \
294 wrong_type_argument (Qdisplay, dev); \
297 #define DEVICE_PRINTER_P(dev) \
298 (DEVICE_LIVE_P (dev) && !DEVICE_DISPLAY_P (dev))
300 #define CHECK_PRINTER_DEVICE(dev) \
302 CHECK_DEVICE (dev); \
303 if (!(DEVICEP (dev) \
304 && DEVICE_PRINTER_P (XDEVICE (dev)))) \
305 dead_wrong_type_argument (Qprinter, dev); \
308 #define CONCHECK_PRINTER_DEVICE(dev) \
310 CONCHECK_DEVICE (dev); \
311 if (!(DEVICEP (dev) \
312 && DEVICE_PRINTER_P (XDEVICE (dev)))) \
313 wrong_type_argument (Qprinter, dev); \
316 /* #### These should be in the device-*.h files but there are
317 too many places where the abstraction is broken. Need to
320 #define DEVICE_X_P(dev) CONSOLE_TYPESYM_X_P (DEVICE_TYPE (dev))
321 #define CHECK_X_DEVICE(z) CHECK_DEVICE_TYPE (z, x)
322 #define CONCHECK_X_DEVICE(z) CONCHECK_DEVICE_TYPE (z, x)
324 #define DEVICE_GTK_P(dev) CONSOLE_TYPESYM_GTK_P (DEVICE_TYPE (dev))
325 #define CHECK_GTK_DEVICE(z) CHECK_DEVICE_TYPE (z, gtk)
326 #define CONCHECK_GTK_DEVICE(z) CONCHECK_DEVICE_TYPE (z, gtk)
328 #define DEVICE_MSWINDOWS_P(dev) CONSOLE_TYPESYM_MSWINDOWS_P (DEVICE_TYPE (dev))
329 #define CHECK_MSWINDOWS_DEVICE(z) CHECK_DEVICE_TYPE (z, mswindows)
330 #define CONCHECK_MSWINDOWS_DEVICE(z) CONCHECK_DEVICE_TYPE (z, mswindows)
332 #define DEVICE_TTY_P(dev) CONSOLE_TYPESYM_TTY_P (DEVICE_TYPE (dev))
333 #define CHECK_TTY_DEVICE(z) CHECK_DEVICE_TYPE (z, tty)
334 #define CONCHECK_TTY_DEVICE(z) CONCHECK_DEVICE_TYPE (z, tty)
336 #define DEVICE_STREAM_P(dev) CONSOLE_TYPESYM_STREAM_P (DEVICE_TYPE (dev))
337 #define CHECK_STREAM_DEVICE(z) CHECK_DEVICE_TYPE (z, stream)
338 #define CONCHECK_STREAM_DEVICE(z) CONCHECK_DEVICE_TYPE (z, stream)
340 #define DEVICE_WIN_P(dev) CONSOLE_TYPESYM_WIN_P (DEVICE_TYPE (dev))
342 EXFUN (Fdevice_console, 1);
343 EXFUN (Fdevice_name, 1);
344 EXFUN (Ffind_device, 2);
345 EXFUN (Fmake_device, 3);
346 EXFUN (Fselected_device, 1);
348 extern Lisp_Object Qcreate_device_hook, Qdelete_device_hook, Qgrayscale;
349 extern Lisp_Object Qinit_post_tty_win, Qmono, Vdefault_x_device, Vdefault_gtk_device;
350 extern Lisp_Object Vdevice_class_list;
352 int valid_device_class_p (Lisp_Object class);
354 #define DEVICE_LIVE_P(d) (!EQ (DEVICE_TYPE (d), Qdead))
356 #define DEVICE_REDISPLAY_INFO(d) ((d)->redisplay_info)
358 #define DEVICE_NAME(d) ((d)->name)
359 #define DEVICE_CLASS(d) ((d)->device_class)
360 /* Catch people attempting to set this. */
361 #define DEVICE_SELECTED_FRAME(d) NON_LVALUE ((d)->selected_frame)
362 #define DEVICE_FRAME_WITH_FOCUS_REAL(d) ((d)->frame_with_focus_real)
363 #define DEVICE_FRAME_WITH_FOCUS_FOR_HOOKS(d) ((d)->frame_with_focus_for_hooks)
364 #define DEVICE_FRAME_THAT_OUGHT_TO_HAVE_FOCUS(d) \
365 ((d)->frame_that_ought_to_have_focus)
366 #define DEVICE_USER_DEFINED_TAGS(d) ((d)->user_defined_tags)
367 #define DEVICE_FRAME_LIST(d) ((d)->frame_list)
368 #define DEVICE_CONNECTION(d) ((d)->connection)
369 #define DEVICE_CANON_CONNECTION(d) ((d)->canon_connection)
370 #define DEVICE_CONSOLE(d) ((d)->console)
371 #define DEVICE_BAUD_RATE(d) ((d)->baud_rate)
372 #define DEVICE_INFD(d) ((d)->infd)
373 #define DEVICE_OUTFD(d) ((d)->outfd)
374 #define DEVICE_OLD_FCNTL_OWNER(d) ((d)->old_fcntl_owner)
375 #define DEVICE_ON_CONSOLE_P(d) ((d)->on_console_p)
376 #define DEVICE_CONNECTED_TO_NAS_P(d) ((d)->connected_to_nas_p)
378 #define LOCK_DEVICE(d) ((void) ((d)->locked = 1))
379 #define UNLOCK_DEVICE(d) ((void) ((d)->locked = 0))
381 #define INVALIDATE_DEVICE_PIXEL_TO_GLYPH_CACHE(d) \
382 ((void) ((d)->pixel_to_glyph_cache.valid = 0))
384 #define INVALIDATE_PIXEL_TO_GLYPH_CACHE do { \
385 Lisp_Object IPTGC_devcons, IPTGC_concons; \
386 DEVICE_LOOP_NO_BREAK (IPTGC_devcons, IPTGC_concons) \
387 INVALIDATE_DEVICE_PIXEL_TO_GLYPH_CACHE (XDEVICE (XCAR (IPTGC_devcons))); \
390 #define MARK_DEVICE_FACES_CHANGED(d) \
391 ((void) (faces_changed = (d)->faces_changed = 1))
393 #define MARK_DEVICE_GLYPHS_CHANGED(d) \
394 ((void) (glyphs_changed = (d)->glyphs_changed = 1))
396 #define MARK_DEVICE_SUBWINDOWS_CHANGED(d) \
397 ((void) (subwindows_changed = (d)->subwindows_changed = 1))
399 #define MARK_DEVICE_SUBWINDOWS_STATE_CHANGED(d) \
400 ((void) (subwindows_state_changed = (d)->subwindows_state_changed = 1))
402 #define MARK_DEVICE_TOOLBARS_CHANGED(d) \
403 ((void) (toolbar_changed = (d)->toolbar_changed = 1))
405 #define MARK_DEVICE_GUTTERS_CHANGED(d) \
406 ((void) (gutter_changed = (d)->gutter_changed = 1))
408 #define MARK_DEVICE_SIZE_CHANGED(d) \
409 ((void) (size_changed = (d)->size_changed = 1))
411 #define MARK_DEVICE_FRAMES_FACES_CHANGED(d) do { \
412 struct device *mdffc_d = (d); \
413 Lisp_Object frmcons; \
414 DEVICE_FRAME_LOOP (frmcons, mdffc_d) \
415 XFRAME (XCAR (frmcons))->faces_changed = 1; \
416 MARK_DEVICE_FACES_CHANGED (mdffc_d); \
419 #define MARK_DEVICE_FRAMES_GLYPHS_CHANGED(d) do { \
420 struct device *mdffc_d = (d); \
421 Lisp_Object frmcons; \
422 DEVICE_FRAME_LOOP (frmcons, mdffc_d) \
423 XFRAME (XCAR (frmcons))->glyphs_changed = 1; \
424 MARK_DEVICE_GLYPHS_CHANGED (mdffc_d); \
427 #define MARK_DEVICE_FRAME_CHANGED(d) \
428 ((void) (frame_changed = (d)->frame_changed = 1))
430 #define MARK_DEVICE_FRAME_LAYOUT_CHANGED(d) \
431 ((void) (frame_layout_changed = (d)->frame_layout_changed = 1))
433 #define MARK_DEVICE_WINDOWS_CHANGED(d) \
434 ((void) (windows_changed = (d)->windows_changed = 1))
436 #define MARK_DEVICE_WINDOWS_STRUCTURE_CHANGED(d) \
437 ((void) (windows_structure_changed = (d)->windows_structure_changed = 1))
439 /* #### unify this with DOMAIN_DEVICE once the latter has image instances
441 /* This turns out to be used heavily so we make it a macro to make it
442 inline. Also, the majority of the time the object will turn out to
443 be a window so we move it from being checked last to being checked
445 #define DFW_DEVICE(obj) \
446 (WINDOWP (obj) ? WINDOW_DEVICE (XWINDOW (obj)) \
447 : (FRAMEP (obj) ? FRAME_DEVICE (XFRAME (obj)) \
448 : (DEVICEP (obj) ? obj \
451 /* NO_BREAK means that "break" doesn't do what you think it does!
452 Use goto instead. "continue" is OK, though. */
453 #define DEVICE_LOOP_NO_BREAK(devcons, concons) \
454 CONSOLE_LOOP (concons) \
455 CONSOLE_DEVICE_LOOP (devcons, XCONSOLE (XCAR (concons)))
456 #define DEVICE_FRAME_LOOP(frmcons, d) \
457 LIST_LOOP (frmcons, DEVICE_FRAME_LIST (d))
458 #define CONSOLE_FRAME_LOOP_NO_BREAK(frmcons, devcons, con) \
459 CONSOLE_DEVICE_LOOP (devcons, con) \
460 DEVICE_FRAME_LOOP (frmcons, XDEVICE (XCAR (devcons)))
462 void select_device_1 (Lisp_Object);
463 struct device *decode_device (Lisp_Object);
464 void handle_asynch_device_change (void);
465 void call_critical_lisp_code (struct device *d, Lisp_Object function,
467 void delete_device_internal (struct device *d, int force,
468 int called_from_delete_console,
470 void io_error_delete_device (Lisp_Object device);
471 Lisp_Object find_nonminibuffer_frame_not_on_device (Lisp_Object device);
472 void set_device_selected_frame (struct device *d, Lisp_Object frame);
473 Lisp_Object domain_device_type (Lisp_Object domain);
474 int window_system_pixelated_geometry (Lisp_Object domain);
476 #endif /* INCLUDED_device_h_ */