Mercurial > hg > xemacs-beta

comparison src/device.h @ 0:376386a54a3c r19-14

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r19-14
author cvs
date Mon, 13 Aug 2007 08:45:50 +0200
parents
children ac2d302a0011
comparison
equal deleted inserted replaced
-1:000000000000 0:376386a54a3c
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 /* This is a bi-level cache, where the hash table in this slot here
143 indexes image-instance-type masks (there are currently 6
144 image-instance types and thus 64 possible masks) to key-weak hash
145 tables like the one for colors. */
146 Lisp_Object image_instance_cache;
147
148 /* A structure of auxiliary data specific to the device type.
149 struct x_device is used for X window frames; defined in console-x.h
150 struct tty_device is used to TTY's; defined in console-tty.h */
151 void *device_data;
152
153 /* redisplay flags */
154 unsigned int buffers_changed :1;
155 unsigned int clip_changed :1;
156 unsigned int extents_changed :1;
157 unsigned int faces_changed :1;
158 unsigned int frame_changed :1;
159 unsigned int icon_changed :1;
160 unsigned int menubar_changed :1;
161 unsigned int modeline_changed :1;
162 unsigned int point_changed :1;
163 unsigned int size_changed :1;
164 unsigned int toolbar_changed :1;
165 unsigned int windows_changed :1;
166 unsigned int windows_structure_changed :1;
167
168 unsigned int locked :1;
169
170 /* Cache information about last pixel position translated to a
171 glyph. The law of locality applies very heavily here so caching
172 the value leads to a significant win. At the moment this is
173 really X specific but once we have generic mouse support it won't
174 be. */
175 struct pixel_to_glyph_translation_cache pixel_to_glyph_cache;
176
177 /* Output baud rate of device; used for redisplay decisions. */
178 int baud_rate;
179
180 /* sound flags */
181 unsigned int on_console_p :1;
182 unsigned int connected_to_nas_p :1;
183
184 #ifdef HAVE_UNIXOID_EVENT_LOOP
185 /* File descriptors for input and output. Much of the time
186 (but not always) these will be the same. For an X device,
187 these both hold the file descriptor of the socket used
188 to communicate with the X server. For a TTY device, these
189 may or may not be the same and point to the terminal that
190 is used for I/O. */
191 int infd, outfd;
192
193 /* holds some data necessary for SIGIO control. Perhaps this should
194 be inside of device_data; but it is used for both TTY's and X
195 device. Perhaps it should be conditionalized on SIGIO; but
196 this requires including syssignal.h and systty.h. */
197 int old_sigio_flag;
198 int old_fcntl_owner;
199 unsigned int sigio_enabled :1;
200 #endif
201 };
202
203 DECLARE_LRECORD (device, struct device);
204 #define XDEVICE(x) XRECORD (x, device, struct device)
205 #define XSETDEVICE(x, p) XSETRECORD (x, p, device)
206 #define DEVICEP(x) RECORDP (x, device)
207 #define GC_DEVICEP(x) GC_RECORDP (x, device)
208 #define CHECK_DEVICE(x) CHECK_RECORD (x, device)
209 #define CONCHECK_DEVICE(x) CONCHECK_RECORD (x, device)
210
211 #define CHECK_LIVE_DEVICE(x) \
212 do { CHECK_DEVICE (x); \
213 if (! DEVICEP (x) \
214 || ! DEVICE_LIVE_P (XDEVICE (x))) \
215 dead_wrong_type_argument (Qdevice_live_p, (x)); } while (0)
216 #define CONCHECK_LIVE_DEVICE(x) \
217 do { CONCHECK_DEVICE (x); \
218 if (! DEVICEP (x) \
219 || ! DEVICE_LIVE_P (XDEVICE (x))) \
220 x = wrong_type_argument (Qdevice_live_p, (x)); } while (0)
221
222 #define DEVICE_TYPE_P(d, type) EQ (DEVICE_TYPE (d), Q##type)
223
224 #ifdef ERROR_CHECK_TYPECHECK
225 MAC_DECLARE_EXTERN (struct device *, MTdevice_data)
226 # define DEVICE_TYPE_DATA(d, type) \
227 MAC_BEGIN \
228 MAC_DECLARE (struct device *, MTdevice_data, d) \
229 assert (DEVICE_TYPE_P (MTdevice_data, type)) \
230 MAC_SEP \
231 (struct type##_device *) MTdevice_data->device_data \
232 MAC_END
233 #else
234 # define DEVICE_TYPE_DATA(d, type) \
235 ((struct type##_device *) (d)->device_data)
236 #endif
237
238 #define CHECK_DEVICE_TYPE(x, type) \
239 do { \
240 CHECK_DEVICE (x); \
241 if (!(DEVICEP (x) && DEVICE_TYPE_P (XDEVICE (x), \
242 type))) \
243 dead_wrong_type_argument \
244 (type##_console_methods->predicate_symbol, x); \
245 } while (0)
246 #define CONCHECK_DEVICE_TYPE(x, type) \
247 do { \
248 CONCHECK_DEVICE (x); \
249 if (!(DEVICEP (x) && DEVICE_TYPE_P (XDEVICE (x), \
250 type))) \
251 x = wrong_type_argument \
252 (type##_console_methods->predicate_symbol, x); \
253 } while (0)
254
255 /* #### These should be in the device-*.h files but there are
256 too many places where the abstraction is broken. Need to
257 fix. */
258
259 #define DEVICE_X_P(dev) CONSOLE_TYPESYM_X_P (DEVICE_TYPE (dev))
260 #define CHECK_X_DEVICE(z) CHECK_DEVICE_TYPE (z, x)
261 #define CONCHECK_X_DEVICE(z) CONCHECK_DEVICE_TYPE (z, x)
262
263 #define DEVICE_NS_P(dev) CONSOLE_TYPESYM_NS_P (DEVICE_TYPE (dev))
264 #define CHECK_NS_DEVICE(z) CHECK_DEVICE_TYPE (z, ns)
265 #define CONCHECK_NS_DEVICE(z) CONCHECK_DEVICE_TYPE (z, ns)
266
267 #define DEVICE_TTY_P(dev) CONSOLE_TYPESYM_TTY_P (DEVICE_TYPE (dev))
268 #define CHECK_TTY_DEVICE(z) CHECK_DEVICE_TYPE (z, tty)
269 #define CONCHECK_TTY_DEVICE(z) CONCHECK_DEVICE_TYPE (z, tty)
270
271 #define DEVICE_STREAM_P(dev) CONSOLE_TYPESYM_STREAM_P (DEVICE_TYPE (dev))
272 #define CHECK_STREAM_DEVICE(z) CHECK_DEVICE_TYPE (z, stream)
273 #define CONCHECK_STREAM_DEVICE(z) CONCHECK_DEVICE_TYPE (z, stream)
274
275 #define DEVICE_WIN_P(dev) CONSOLE_TYPESYM_WIN_P (DEVICE_TYPE (dev))
276
277 extern Lisp_Object Vdefault_device;
278 extern Lisp_Object Qdelete_device;
279 extern Lisp_Object Qdevice_live_p;
280
281 extern Lisp_Object Vdevice_class_list;
282
283 extern Lisp_Object Qcolor, Qgrayscale, Qmono;
284 int valid_device_class_p (Lisp_Object class);
285
286 #define DEVICE_LIVE_P(d) (!EQ (DEVICE_TYPE (d), Qdead))
287
288 #define DEVICE_REDISPLAY_INFO(d) ((d)->redisplay_info)
289
290 #define DEVICE_NAME(d) ((d)->name)
291 #define DEVICE_CLASS(d) ((d)->device_class)
292 /* Catch people attempting to set this. */
293 #define DEVICE_SELECTED_FRAME(d) NON_LVALUE ((d)->_selected_frame)
294 #define DEVICE_FRAME_WITH_FOCUS_REAL(d) ((d)->frame_with_focus_real)
295 #define DEVICE_FRAME_WITH_FOCUS_FOR_HOOKS(d) ((d)->frame_with_focus_for_hooks)
296 #define DEVICE_FRAME_THAT_OUGHT_TO_HAVE_FOCUS(d) \
297 ((d)->frame_that_ought_to_have_focus)
298 #define DEVICE_USER_DEFINED_TAGS(d) ((d)->user_defined_tags)
299 #define DEVICE_FRAME_LIST(d) ((d)->frame_list)
300 #define DEVICE_CONNECTION(d) ((d)->connection)
301 #define DEVICE_CANON_CONNECTION(d) ((d)->canon_connection)
302 #define DEVICE_CONSOLE(d) ((d)->console)
303 #define DEVICE_BAUD_RATE(d) ((d)->baud_rate)
304 #define DEVICE_INFD(d) ((d)->infd)
305 #define DEVICE_OUTFD(d) ((d)->outfd)
306 #define DEVICE_OLD_SIGIO_FLAG(d) ((d)->old_sigio_flag)
307 #define DEVICE_OLD_FCNTL_OWNER(d) ((d)->old_fcntl_owner)
308 #define DEVICE_ON_CONSOLE_P(d) ((d)->on_console_p)
309 #define DEVICE_CONNECTED_TO_NAS_P(d) ((d)->connected_to_nas_p)
310
311 #define LOCK_DEVICE(d) do { (d)->locked = 1; } while (0)
312 #define UNLOCK_DEVICE(d) do { (d)->locked = 0; } while (0)
313
314 #define INVALIDATE_DEVICE_PIXEL_TO_GLYPH_CACHE(d) \
315 (d)->pixel_to_glyph_cache.valid = 0
316
317 #define INVALIDATE_PIXEL_TO_GLYPH_CACHE do { \
318 Lisp_Object _devcons_, _concons_; \
319 DEVICE_LOOP_NO_BREAK (_devcons_, _concons_) \
320 INVALIDATE_DEVICE_PIXEL_TO_GLYPH_CACHE (XDEVICE (XCONS (_devcons_)->car));\
321 } while (0)
322
323 #define MARK_DEVICE_FACES_CHANGED(d) do { \
324 faces_changed = 1; \
325 (d)->faces_changed = 1; } while (0)
326
327 #define MARK_DEVICE_TOOLBARS_CHANGED(d) do { \
328 toolbar_changed = 1; \
329 (d)->toolbar_changed = 1; } while (0)
330
331 #define MARK_DEVICE_SIZE_CHANGED(d) do { \
332 size_changed = 1; \
333 (d)->size_changed = 1; } while (0)
334
335 #define MARK_DEVICE_FRAMES_FACES_CHANGED(d) do { \
336 Lisp_Object frmcons; \
337 DEVICE_FRAME_LOOP (frmcons, d) \
338 XFRAME (XCONS (frmcons)->car)->faces_changed = 1; \
339 MARK_DEVICE_FACES_CHANGED (d); } while (0)
340
341 #define MARK_DEVICE_FRAME_CHANGED(d) do { \
342 frame_changed = 1; \
343 (d)->frame_changed = 1; } while (0)
344
345 #define MARK_DEVICE_WINDOWS_CHANGED(d) do { \
346 windows_changed = 1; \
347 (d)->windows_changed = 1; } while (0)
348
349 #define MARK_DEVICE_WINDOWS_STRUCTURE_CHANGED(d) do { \
350 windows_structure_changed = 1; \
351 (d)->windows_structure_changed = 1; } while (0)
352
353 /* This turns out to be used heavily so we make it a macro to make it
354 inline. Also, the majority of the time the object will turn out to
355 be a window so we move it from being checked last to being checked
356 first. */
357 #define DFW_DEVICE(obj) \
358 (WINDOWP (obj) \
359 ? WINDOW_DEVICE (XWINDOW (obj)) \
360 : (FRAMEP (obj) \
361 ? FRAME_DEVICE (XFRAME (obj)) \
362 : (DEVICEP (obj) \
363 ? obj \
364 : Qnil)))
365
366 /* NO_BREAK means that "break" doesn't do what you think it does!
367 Use goto instead. "continue" is OK, though. */
368 #define DEVICE_LOOP_NO_BREAK(devcons, concons) \
369 CONSOLE_LOOP (concons) \
370 CONSOLE_DEVICE_LOOP (devcons, XCONSOLE (XCAR (concons)))
371 #define DEVICE_FRAME_LOOP(frmcons, d) \
372 LIST_LOOP (frmcons, DEVICE_FRAME_LIST (d))
373 #define CONSOLE_FRAME_LOOP_NO_BREAK(frmcons, devcons, con) \
374 CONSOLE_DEVICE_LOOP (devcons, con) \
375 DEVICE_FRAME_LOOP (frmcons, XDEVICE (XCAR (devcons)))
376
377 void select_device_1 (Lisp_Object);
378 struct device *decode_device (Lisp_Object);
379 Lisp_Object make_device (struct device *d);
380 void handle_asynch_device_change (void);
381 void call_critical_lisp_code (struct device *d, Lisp_Object function,
382 Lisp_Object object);
383 void delete_device_internal (struct device *d, int force,
384 int called_from_delete_console,
385 int from_io_error);
386 void io_error_delete_device (Lisp_Object device);
387 Lisp_Object find_nonminibuffer_frame_not_on_device (Lisp_Object device);
388 void set_device_selected_frame (struct device *d, Lisp_Object frame);
389
390 #endif /* _XEMACS_DEVICE_H_ */