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