|
0
|
1 /* Define frame-object for XEmacs.
|
|
|
2 Copyright (C) 1988, 1992, 1993, 1994 Free Software Foundation, Inc.
|
|
|
3
|
|
|
4 This file is part of XEmacs.
|
|
|
5
|
|
|
6 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
7 under the terms of the GNU General Public License as published by the
|
|
|
8 Free Software Foundation; either version 2, or (at your option) any
|
|
|
9 later version.
|
|
|
10
|
|
|
11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
14 for more details.
|
|
|
15
|
|
|
16 You should have received a copy of the GNU General Public License
|
|
|
17 along with XEmacs; see the file COPYING. If not, write to
|
|
|
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
19 Boston, MA 02111-1307, USA. */
|
|
|
20
|
|
|
21 /* Synched up with: FSF 19.30. */
|
|
|
22
|
|
|
23 #ifndef _XEMACS_FRAME_H_
|
|
|
24 #define _XEMACS_FRAME_H_
|
|
|
25
|
|
|
26 #include "scrollbar.h"
|
|
|
27 #include "toolbar.h"
|
|
|
28 #include "device.h"
|
|
|
29
|
|
|
30 #define FRAME_TYPE_NAME(f) ((f)->framemeths->name)
|
|
|
31 #define FRAME_TYPE(f) ((f)->framemeths->symbol)
|
|
|
32
|
|
|
33 /******** Accessing / calling a frame method *********/
|
|
|
34
|
|
|
35 #define HAS_FRAMEMETH_P(f, m) HAS_CONTYPE_METH_P ((f)->framemeths, m)
|
|
|
36 #define FRAMEMETH(f, m, args) CONTYPE_METH ((f)->framemeths, m, args)
|
|
|
37 #define MAYBE_FRAMEMETH(f, m, args) \
|
|
|
38 MAYBE_CONTYPE_METH ((f)->framemeths, m, args)
|
|
|
39 #define FRAMEMETH_OR_GIVEN(f, m, args, given) \
|
|
|
40 CONTYPE_METH_OR_GIVEN((f)->framemeths, m, args, given)
|
|
|
41 #define MAYBE_INT_FRAMEMETH(f, m, args) \
|
|
|
42 MAYBE_INT_CONTYPE_METH ((f)->framemeths, m, args)
|
|
|
43 #define MAYBE_LISP_FRAMEMETH(f, m, args) \
|
|
|
44 MAYBE_LISP_CONTYPE_METH ((f)->framemeths, m, args)
|
|
|
45
|
|
|
46 struct frame
|
|
|
47 {
|
|
|
48 struct lcrecord_header header;
|
|
|
49
|
|
|
50 /* Methods for this frame's console. This can also be retrieved
|
|
|
51 through frame->device->console, but it's faster this way. */
|
|
|
52 struct console_methods *framemeths;
|
|
|
53
|
|
|
54 /* Size of this frame, in units of characters. */
|
|
|
55 int height;
|
|
|
56 int width;
|
|
|
57
|
|
|
58 /* Size of this frame, in units of pixels. */
|
|
|
59 int pixheight;
|
|
|
60 int pixwidth;
|
|
|
61
|
|
|
62 /* Width of the internal border. This is a line of background color
|
|
|
63 just inside the window's border. It is normally only non-zero on
|
|
|
64 X frames, but we put it here to avoid introducing window system
|
|
|
65 dependencies. */
|
|
|
66 int internal_border_width;
|
|
|
67
|
|
|
68 /* New height and width for pending size change. 0 if no change pending. */
|
|
|
69 int new_height, new_width;
|
|
|
70
|
|
|
71 /* This frame's root window mirror. This structure exactly mirrors
|
|
|
72 the frame's window structure but contains only pointers to the
|
|
|
73 display structures. */
|
|
|
74 struct window_mirror *root_mirror;
|
|
|
75
|
|
|
76 int modiff;
|
|
|
77
|
|
|
78 #ifdef HAVE_SCROLLBARS
|
|
|
79 /* frame-local scrollbar information. See scrollbar.c. */
|
|
|
80 int scrollbar_y_offset;
|
|
|
81 int scrollbar_on_left;
|
|
|
82 int scrollbar_on_top;
|
|
|
83
|
|
|
84 /* cache of created scrollbars */
|
|
|
85 struct scrollbar_instance *sb_vcache;
|
|
|
86 struct scrollbar_instance *sb_hcache;
|
|
|
87 #endif
|
|
|
88
|
|
|
89 #ifdef HAVE_TOOLBARS
|
|
|
90 /* We handle these specially rather than putting them in
|
|
|
91 frameslots.h because we want them to be arrays. */
|
|
|
92
|
|
|
93 /* Data representing each currently displayed toolbar. See
|
|
|
94 toolbar.c */
|
|
|
95 Lisp_Object toolbar_data[4];
|
|
|
96
|
|
|
97 /* Cached specifiers: */
|
|
|
98
|
|
|
99 /* Size of the toolbars. The frame-local toolbar space is
|
|
|
100 subtracted before the windows are arranged. Window and buffer
|
|
|
101 local toolbars overlay their windows. */
|
|
|
102 Lisp_Object toolbar_size[4];
|
|
|
103 /* Visibility of the toolbars. This acts as a valve for toolbar_size. */
|
|
|
104 Lisp_Object toolbar_visible_p[4];
|
|
|
105 #endif
|
|
|
106
|
|
|
107 /* A structure of auxiliary data specific to the device type.
|
|
|
108 struct x_frame is used for X window frames; defined in console-x.h */
|
|
|
109 void *frame_data;
|
|
|
110
|
|
|
111 #define MARKED_SLOT(x) Lisp_Object x
|
|
|
112 #include "frameslots.h"
|
|
|
113 #undef MARKED_SLOT
|
|
|
114
|
|
108
|
115 /* Nonzero if frame is currently displayed.
|
|
|
116 Mutally exclusive with iconfied
|
|
|
117 JV: This now a tristate flag:
|
|
|
118 Value : Emacs meaning :f-v-p : X meaning
|
|
|
119 0 : not displayed : nil : unmapped
|
|
|
120 >0 : user can access it,needs repainting : t : mapped and visible
|
|
|
121 <0 : user can access it,needs no repainting : hidden :mapped and invisible
|
|
|
122 where f-v-p is the return value of frame-visible-p */
|
|
|
123 int visible;
|
|
|
124
|
|
0
|
125 /* one-bit flags: */
|
|
|
126
|
|
|
127 /* Are we finished initializing? */
|
|
|
128 unsigned int init_finished :1;
|
|
|
129
|
|
|
130 /* Is frame marked for deletion? This is used in XSetErrorHandler(). */
|
|
|
131 unsigned int being_deleted :1;
|
|
|
132
|
|
|
133 /* Nonzero if this frame has been destroyed. */
|
|
|
134 unsigned int dead :1;
|
|
|
135
|
|
|
136 /* Nonzero if last attempt at redisplay on this frame was preempted. */
|
|
|
137 unsigned int display_preempted :1;
|
|
|
138
|
|
|
139 /* Nonzero if window is currently iconified.
|
|
|
140 This and visible are mutually exclusive. */
|
|
|
141 unsigned int iconified :1;
|
|
|
142
|
|
|
143 /* Nonzero if this frame should be cleared and then redrawn.
|
|
|
144 Setting this will also effectively set frame_changed. */
|
|
|
145 unsigned int clear :1;
|
|
|
146
|
|
|
147 /* True if frame actually has a minibuffer window on it.
|
|
|
148 0 if using a minibuffer window that isn't on this frame. */
|
|
|
149 unsigned int has_minibuffer :1;
|
|
|
150
|
|
|
151 /* True if frame's root window can't be split. */
|
|
|
152 unsigned int no_split :1;
|
|
|
153
|
|
|
154 unsigned int top_toolbar_was_visible :1;
|
|
|
155 unsigned int bottom_toolbar_was_visible :1;
|
|
|
156 unsigned int left_toolbar_was_visible :1;
|
|
|
157 unsigned int right_toolbar_was_visible :1;
|
|
|
158
|
|
|
159 /* redisplay flags */
|
|
|
160 unsigned int buffers_changed :1;
|
|
|
161 unsigned int clip_changed :1;
|
|
|
162 unsigned int extents_changed :1;
|
|
|
163 unsigned int faces_changed :1;
|
|
|
164 unsigned int frame_changed :1;
|
|
|
165 unsigned int icon_changed :1;
|
|
|
166 unsigned int menubar_changed :1;
|
|
|
167 unsigned int modeline_changed :1;
|
|
|
168 unsigned int point_changed :1;
|
|
|
169 unsigned int size_changed :1;
|
|
|
170 unsigned int toolbar_changed :1;
|
|
|
171 unsigned int windows_changed :1;
|
|
|
172 unsigned int windows_structure_changed :1;
|
|
|
173 unsigned int window_face_cache_reset :1; /* used by expose handler */
|
|
|
174
|
|
|
175 unsigned int size_change_pending :1;
|
|
|
176 unsigned int mirror_dirty :1;
|
|
|
177
|
|
|
178 /* flag indicating if any window on this frame is displaying a subwindow */
|
|
74
|
179 unsigned int subwindows_being_displayed :1;
|
|
0
|
180 };
|
|
|
181
|
|
|
182 /* If this is non-nil, it is the frame that make-frame is currently
|
|
|
183 creating. We can't set the current frame to this in case the
|
|
|
184 debugger goes off because it would try and display to it. However,
|
|
|
185 there are some places which need to reference it which have no
|
|
|
186 other way of getting it if it isn't the selected frame. */
|
|
|
187 extern Lisp_Object Vframe_being_created;
|
|
|
188
|
|
|
189 DECLARE_LRECORD (frame, struct frame);
|
|
|
190 #define XFRAME(x) XRECORD (x, frame, struct frame)
|
|
|
191 #define XSETFRAME(x, p) XSETRECORD (x, p, frame)
|
|
|
192 #define FRAMEP(x) RECORDP (x, frame)
|
|
|
193 #define GC_FRAMEP(x) GC_RECORDP (x, frame)
|
|
|
194 #define CHECK_FRAME(x) CHECK_RECORD (x, frame)
|
|
|
195 #define CONCHECK_FRAME(x) CONCHECK_RECORD (x, frame)
|
|
|
196
|
|
|
197 #define CHECK_LIVE_FRAME(x) \
|
|
|
198 do { CHECK_FRAME (x); \
|
|
|
199 if (! FRAMEP (x) \
|
|
|
200 || ! FRAME_LIVE_P (XFRAME (x))) \
|
|
|
201 dead_wrong_type_argument (Qframe_live_p, (x)); } while (0)
|
|
|
202 #define CONCHECK_LIVE_FRAME(x) \
|
|
|
203 do { CONCHECK_FRAME (x); \
|
|
|
204 if (! FRAMEP (x) \
|
|
|
205 || ! FRAME_LIVE_P (XFRAME (x))) \
|
|
|
206 x = wrong_type_argument (Qframe_live_p, (x)); } while (0)
|
|
|
207
|
|
|
208 #define FRAME_TYPE_P(f, type) EQ (FRAME_TYPE (f), Q##type)
|
|
|
209
|
|
|
210 #ifdef ERROR_CHECK_TYPECHECK
|
|
|
211 MAC_DECLARE_EXTERN (struct frame *, MTframe_data)
|
|
|
212 # define FRAME_TYPE_DATA(f, type) \
|
|
|
213 MAC_BEGIN \
|
|
|
214 MAC_DECLARE (struct frame *, MTframe_data, f) \
|
|
|
215 assert (FRAME_TYPE_P (MTframe_data, type)) \
|
|
|
216 MAC_SEP \
|
|
|
217 (struct type##_frame *) MTframe_data->frame_data \
|
|
|
218 MAC_END
|
|
|
219 #else
|
|
|
220 # define FRAME_TYPE_DATA(f, type) \
|
|
|
221 ((struct type##_frame *) (f)->frame_data)
|
|
|
222 #endif
|
|
|
223
|
|
|
224 #define CHECK_FRAME_TYPE(x, type) \
|
|
|
225 do { \
|
|
|
226 CHECK_FRAME (x); \
|
|
|
227 if (!FRAME_TYPE_P (XFRAME (x), type)) \
|
|
|
228 dead_wrong_type_argument \
|
|
|
229 (type##_console_methods->predicate_symbol, x); \
|
|
|
230 } while (0)
|
|
|
231 #define CONCHECK_FRAME_TYPE(x, type) \
|
|
|
232 do { \
|
|
|
233 CONCHECK_FRAME (x); \
|
|
|
234 if (!FRAME_TYPE_P (XFRAME (x), type)) \
|
|
|
235 x = wrong_type_argument \
|
|
|
236 (type##_console_methods->predicate_symbol, x); \
|
|
|
237 } while (0)
|
|
|
238
|
|
|
239 /* #### These should be in the frame-*.h files but there are
|
|
|
240 too many places where the abstraction is broken. Need to
|
|
|
241 fix. */
|
|
|
242
|
|
|
243 #define FRAME_X_P(frm) CONSOLE_TYPESYM_X_P (FRAME_TYPE (frm))
|
|
|
244 #define CHECK_X_FRAME(z) CHECK_FRAME_TYPE (z, x)
|
|
|
245 #define CONCHECK_X_FRAME(z) CONCHECK_FRAME_TYPE (z, x)
|
|
|
246
|
|
|
247 #define FRAME_NS_P(frm) CONSOLE_TYPESYM_NS_P (FRAME_TYPE (frm))
|
|
|
248 #define CHECK_NS_FRAME(z) CHECK_FRAME_TYPE (z, ns)
|
|
|
249 #define CONCHECK_NS_FRAME(z) CONCHECK_FRAME_TYPE (z, ns)
|
|
|
250
|
|
|
251 #define FRAME_TTY_P(frm) CONSOLE_TYPESYM_TTY_P (FRAME_TYPE (frm))
|
|
|
252 #define CHECK_TTY_FRAME(z) CHECK_FRAME_TYPE (z, tty)
|
|
|
253 #define CONCHECK_TTY_FRAME(z) CONCHECK_FRAME_TYPE (z, tty)
|
|
|
254
|
|
|
255 #define FRAME_STREAM_P(frm) CONSOLE_TYPESYM_STREAM_P (FRAME_TYPE (frm))
|
|
|
256 #define CHECK_STREAM_FRAME(z) CHECK_FRAME_TYPE (z, stream)
|
|
|
257 #define CONCHECK_STREAM_FRAME(z) CONCHECK_FRAME_TYPE (z, stream)
|
|
|
258
|
|
|
259 #define FRAME_WIN_P(frm) CONSOLE_TYPESYM_WIN_P (FRAME_TYPE (frm))
|
|
|
260
|
|
|
261 extern Lisp_Object Qframe_live_p;
|
|
|
262 extern Lisp_Object Qframe_x_p, Qframe_tty_p;
|
|
|
263 extern Lisp_Object Vframe_title_format, Vframe_icon_title_format;
|
|
|
264
|
|
|
265 extern int frame_changed;
|
|
|
266
|
|
|
267 #define MARK_FRAME_FACES_CHANGED(f) do { \
|
|
|
268 (f)->faces_changed = 1; \
|
|
|
269 (f)->modiff++; \
|
|
|
270 if (!NILP ((f)->device)) \
|
|
|
271 MARK_DEVICE_FACES_CHANGED (XDEVICE ((f)->device)); \
|
|
|
272 else \
|
|
|
273 faces_changed = 1; } while (0)
|
|
|
274
|
|
|
275 #define MARK_FRAME_TOOLBARS_CHANGED(f) do { \
|
|
|
276 (f)->toolbar_changed = 1; \
|
|
|
277 (f)->modiff++; \
|
|
|
278 if (!NILP ((f)->device)) \
|
|
|
279 MARK_DEVICE_TOOLBARS_CHANGED (XDEVICE ((f)->device)); \
|
|
|
280 else \
|
|
|
281 toolbar_changed = 1; } while (0)
|
|
|
282
|
|
|
283 #define MARK_FRAME_SIZE_CHANGED(f) do { \
|
|
|
284 (f)->size_changed = 1; \
|
|
|
285 (f)->size_change_pending = 1; \
|
|
|
286 (f)->modiff++; \
|
|
|
287 if (!NILP ((f)->device)) \
|
|
|
288 MARK_DEVICE_SIZE_CHANGED (XDEVICE ((f)->device)); \
|
|
|
289 else \
|
|
|
290 size_changed = 1; } while (0)
|
|
|
291
|
|
|
292 #define MARK_FRAME_CHANGED(f) do { \
|
|
|
293 (f)->frame_changed = 1; \
|
|
|
294 (f)->modiff++; \
|
|
|
295 if (!NILP ((f)->device)) \
|
|
|
296 MARK_DEVICE_FRAME_CHANGED (XDEVICE ((f)->device)); \
|
|
|
297 else \
|
|
|
298 frame_changed = 1; } while (0)
|
|
|
299
|
|
|
300 #define MARK_FRAME_WINDOWS_CHANGED(f) do { \
|
|
|
301 (f)->windows_changed = 1; \
|
|
|
302 (f)->modiff++; \
|
|
|
303 if (!NILP ((f)->device)) \
|
|
|
304 MARK_DEVICE_WINDOWS_CHANGED (XDEVICE ((f)->device)); \
|
|
|
305 else \
|
|
|
306 windows_changed = 1; } while (0)
|
|
|
307
|
|
|
308 #define MARK_FRAME_WINDOWS_STRUCTURE_CHANGED(f) do { \
|
|
|
309 (f)->windows_structure_changed = 1; \
|
|
|
310 (f)->modiff++; \
|
|
|
311 if (!NILP ((f)->device)) \
|
|
|
312 MARK_DEVICE_WINDOWS_STRUCTURE_CHANGED (XDEVICE ((f)->device)); \
|
|
|
313 else \
|
|
|
314 windows_structure_changed = 1; } while (0)
|
|
|
315
|
|
|
316
|
|
|
317 #define SET_FRAME_CLEAR(f) MARK_FRAME_CHANGED (f); (f)->clear = 1
|
|
|
318 #define FRAME_DEVICE(f) ((f)->device)
|
|
|
319 #define FRAME_CONSOLE(f) DEVICE_CONSOLE (XDEVICE (FRAME_DEVICE (f)))
|
|
|
320 #define FRAME_LIVE_P(f) (!(f)->dead)
|
|
|
321
|
|
|
322 #define FRAME_MINIBUF_ONLY_P(f) \
|
|
|
323 EQ (FRAME_ROOT_WINDOW (f), FRAME_MINIBUF_WINDOW (f))
|
|
|
324 #define FRAME_HAS_MINIBUF_P(f) ((f)->has_minibuffer)
|
|
|
325 #define FRAME_HEIGHT(f) ((f)->height)
|
|
|
326 #define FRAME_WIDTH(f) ((f)->width)
|
|
|
327 #define FRAME_PIXHEIGHT(f) ((f)->pixheight)
|
|
|
328 #define FRAME_PIXWIDTH(f) ((f)->pixwidth)
|
|
|
329 #ifdef HAVE_SCROLLBARS
|
|
|
330 #define FRAME_SCROLLBAR_WIDTH(f) XINT ((f)->scrollbar_width)
|
|
|
331 #define FRAME_SCROLLBAR_HEIGHT(f) XINT ((f)->scrollbar_height)
|
|
|
332 #else
|
|
|
333 #define FRAME_SCROLLBAR_WIDTH(f) 0
|
|
|
334 #define FRAME_SCROLLBAR_HEIGHT(f) 0
|
|
|
335 #endif
|
|
|
336
|
|
|
337 #define FRAME_NEW_HEIGHT(f) ((f)->new_height)
|
|
|
338 #define FRAME_NEW_WIDTH(f) ((f)->new_width)
|
|
|
339 #define FRAME_CURSOR_X(f) ((f)->cursor_x)
|
|
|
340 #define FRAME_CURSOR_Y(f) ((f)->cursor_y)
|
|
|
341 #define FRAME_VISIBLE_P(f) ((f)->visible)
|
|
108
|
342 #define FRAME_REPAINT_P(f) ((f)->visible>0)
|
|
0
|
343 #define FRAME_NO_SPLIT_P(f) ((f)->no_split)
|
|
|
344 #define FRAME_ICONIFIED_P(f) ((f)->iconified)
|
|
|
345 #define FRAME_FOCUS_FRAME(f) ((f)->focus_frame)
|
|
|
346 #define FRAME_MINIBUF_WINDOW(f) ((f)->minibuffer_window)
|
|
|
347 #define FRAME_ROOT_WINDOW(f) ((f)->root_window)
|
|
|
348 /* Catch people attempting to set this. */
|
|
|
349 #define FRAME_SELECTED_WINDOW(f) NON_LVALUE ((f)->selected_window)
|
|
|
350 #define FRAME_LAST_NONMINIBUF_WINDOW(f) \
|
|
|
351 NON_LVALUE ((f)->last_nonminibuf_window)
|
|
|
352 #define FRAME_SB_VCACHE(f) ((f)->sb_vcache)
|
|
|
353 #define FRAME_SB_HCACHE(f) ((f)->sb_hcache)
|
|
|
354
|
|
|
355 #if 0 /* FSFmacs */
|
|
|
356
|
|
|
357 #define FRAME_VISIBLE_P(f) ((f)->visible != 0)
|
|
|
358 #define FRAME_SET_VISIBLE(f,p) \
|
|
|
359 ((f)->async_visible = (p), FRAME_SAMPLE_VISIBILITY (f))
|
|
|
360
|
|
|
361 /* Emacs's redisplay code could become confused if a frame's
|
|
|
362 visibility changes at arbitrary times. For example, if a frame is
|
|
|
363 visible while the desired glyphs are being built, but becomes
|
|
|
364 invisible before they are updated, then some rows of the
|
|
|
365 desired_glyphs will be left marked as enabled after redisplay is
|
|
|
366 complete, which should never happen. The next time the frame
|
|
|
367 becomes visible, redisplay will probably barf.
|
|
|
368
|
|
|
369 Currently, there are no similar situations involving iconified, but
|
|
|
370 the principle is the same.
|
|
|
371
|
|
|
372 So instead of having asynchronous input handlers directly set and
|
|
|
373 clear the frame's visibility and iconification flags, they just set
|
|
|
374 the async_visible and async_iconified flags; the redisplay code
|
|
|
375 calls the FRAME_SAMPLE_VISIBILITY macro before doing any redisplay,
|
|
|
376 which sets visible and iconified from their asynchronous
|
|
|
377 counterparts.
|
|
|
378
|
|
|
379 Synchronous code must use the FRAME_SET_VISIBLE macro.
|
|
|
380
|
|
|
381 Also, if a frame used to be invisible, but has just become visible,
|
|
|
382 it must be marked as garbaged, since redisplay hasn't been keeping
|
|
|
383 up its contents. */
|
|
|
384 #define FRAME_SAMPLE_VISIBILITY(f) \
|
|
|
385 (((f)->async_visible && ! (f)->visible) ? SET_FRAME_GARBAGED (f) : 0, \
|
|
|
386 (f)->visible = (f)->async_visible, \
|
|
|
387 (f)->iconified = (f)->async_iconified)
|
|
|
388
|
|
|
389 #endif /* FSFmacs */
|
|
|
390
|
|
|
391 #define FRAME_BORDER_WIDTH(f) ((f)->internal_border_width)
|
|
|
392 #define FRAME_BORDER_HEIGHT(f) ((f)->internal_border_width)
|
|
|
393
|
|
|
394 /* This returns the frame-local value; that tells you what you should
|
|
|
395 use when computing the frame size. It is *not* the actual toolbar
|
|
|
396 size because that depends on the selected window. Use the macros
|
|
|
397 below for that.
|
|
|
398 */
|
|
|
399
|
|
|
400 #ifdef HAVE_TOOLBARS
|
|
|
401 #define FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE(f, pos) \
|
|
|
402 (!NILP ((f)->toolbar_visible_p[pos]))
|
|
|
403 #define FRAME_RAW_THEORETICAL_TOOLBAR_SIZE(f, pos) \
|
|
|
404 (XINT ((f)->toolbar_size[pos]))
|
|
|
405 #else
|
|
|
406 #define FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE(f, pos) 0
|
|
|
407 #define FRAME_RAW_THEORETICAL_TOOLBAR_SIZE(f, pos) 0
|
|
|
408 #endif
|
|
|
409
|
|
|
410 #define FRAME_THEORETICAL_TOOLBAR_SIZE(f, pos) \
|
|
|
411 (FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE (f, pos) \
|
|
|
412 ? FRAME_RAW_THEORETICAL_TOOLBAR_SIZE (f, pos) \
|
|
|
413 : 0)
|
|
|
414
|
|
|
415 #define FRAME_THEORETICAL_TOP_TOOLBAR_HEIGHT(f) \
|
|
|
416 FRAME_THEORETICAL_TOOLBAR_SIZE (f, TOP_TOOLBAR)
|
|
|
417 #define FRAME_THEORETICAL_BOTTOM_TOOLBAR_HEIGHT(f) \
|
|
|
418 FRAME_THEORETICAL_TOOLBAR_SIZE (f, BOTTOM_TOOLBAR)
|
|
|
419 #define FRAME_THEORETICAL_LEFT_TOOLBAR_WIDTH(f) \
|
|
|
420 FRAME_THEORETICAL_TOOLBAR_SIZE (f, LEFT_TOOLBAR)
|
|
|
421 #define FRAME_THEORETICAL_RIGHT_TOOLBAR_WIDTH(f) \
|
|
|
422 FRAME_THEORETICAL_TOOLBAR_SIZE (f, RIGHT_TOOLBAR)
|
|
|
423
|
|
|
424 /* This returns the window-local value rather than the frame-local value;
|
|
|
425 that tells you about what's actually visible rather than what should
|
|
|
426 be used when computing the frame size. */
|
|
|
427
|
|
|
428 #ifdef HAVE_TOOLBARS
|
|
|
429 #define FRAME_RAW_REAL_TOOLBAR_VISIBLE(f, pos) \
|
|
|
430 (!NILP (XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_visible_p[pos]))
|
|
|
431 #define FRAME_RAW_REAL_TOOLBAR_SIZE(f, pos) \
|
|
|
432 (XINT (XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_size[pos]))
|
|
|
433 #define FRAME_REAL_TOOLBAR(f, pos) \
|
|
|
434 (XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar[pos])
|
|
|
435 #else
|
|
|
436 #define FRAME_RAW_REAL_TOOLBAR_VISIBLE(f, pos) 0
|
|
|
437 #define FRAME_RAW_REAL_TOOLBAR_SIZE(f, pos) 0
|
|
|
438 #define FRAME_REAL_TOOLBAR(f, pos) Qnil
|
|
|
439 #endif
|
|
|
440
|
|
|
441 /* Note to Chuck
|
|
|
442 Note to Chuck
|
|
|
443 Note to Chuck:
|
|
|
444
|
|
|
445 The former definitions of FRAME_REAL_FOO_TOOLBAR_VISIBLE
|
|
|
446 looked at the toolbar data to see what was there. The
|
|
|
447 current ones look at the current values of the specifiers.
|
|
|
448 This is a semantic change; the former definition returned
|
|
|
449 what was *actually* there right at the moment, while the
|
|
|
450 current one returns what *ought* to be there once redisplay
|
|
|
451 has run to completion. I think this new definition is more
|
|
|
452 correct in almost all circumstances and is much less likely
|
|
|
453 to lead to strange race conditions. I'm not completely
|
|
|
454 sure that there aren't some places in the redisplay code
|
|
|
455 that use these macros and expect the former semantics, so
|
|
|
456 if you encounter some odd toolbar behavior, you might want
|
|
|
457 to look into this. --ben */
|
|
|
458
|
|
|
459 #define FRAME_REAL_TOOLBAR_VISIBLE(f, pos) \
|
|
|
460 (FRAME_RAW_REAL_TOOLBAR_SIZE (f, pos) > 0 \
|
|
|
461 && !NILP (FRAME_REAL_TOOLBAR (f, pos)) \
|
|
|
462 ? FRAME_RAW_REAL_TOOLBAR_VISIBLE (f, pos) \
|
|
|
463 : 0)
|
|
|
464 #define FRAME_REAL_TOOLBAR_SIZE(f, pos) \
|
|
|
465 (FRAME_RAW_REAL_TOOLBAR_VISIBLE (f, pos) \
|
|
|
466 && !NILP (FRAME_REAL_TOOLBAR (f, pos)) \
|
|
|
467 ? FRAME_RAW_REAL_TOOLBAR_SIZE (f, pos) \
|
|
|
468 : 0)
|
|
|
469
|
|
|
470 #define FRAME_REAL_TOP_TOOLBAR_HEIGHT(f) \
|
|
|
471 FRAME_REAL_TOOLBAR_SIZE (f, TOP_TOOLBAR)
|
|
|
472 #define FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT(f) \
|
|
|
473 FRAME_REAL_TOOLBAR_SIZE (f, BOTTOM_TOOLBAR)
|
|
|
474 #define FRAME_REAL_LEFT_TOOLBAR_WIDTH(f) \
|
|
|
475 FRAME_REAL_TOOLBAR_SIZE (f, LEFT_TOOLBAR)
|
|
|
476 #define FRAME_REAL_RIGHT_TOOLBAR_WIDTH(f) \
|
|
|
477 FRAME_REAL_TOOLBAR_SIZE (f, RIGHT_TOOLBAR)
|
|
|
478
|
|
|
479 #define FRAME_REAL_TOP_TOOLBAR_VISIBLE(f) \
|
|
|
480 FRAME_REAL_TOOLBAR_VISIBLE (f, TOP_TOOLBAR)
|
|
|
481 #define FRAME_REAL_BOTTOM_TOOLBAR_VISIBLE(f) \
|
|
|
482 FRAME_REAL_TOOLBAR_VISIBLE (f, BOTTOM_TOOLBAR)
|
|
|
483 #define FRAME_REAL_LEFT_TOOLBAR_VISIBLE(f) \
|
|
|
484 FRAME_REAL_TOOLBAR_VISIBLE (f, LEFT_TOOLBAR)
|
|
|
485 #define FRAME_REAL_RIGHT_TOOLBAR_VISIBLE(f) \
|
|
|
486 FRAME_REAL_TOOLBAR_VISIBLE (f, RIGHT_TOOLBAR)
|
|
|
487
|
|
|
488 #define FRAME_TOP_BORDER_START(f) (FRAME_REAL_TOP_TOOLBAR_HEIGHT (f))
|
|
|
489 #define FRAME_TOP_BORDER_END(f) \
|
|
|
490 (FRAME_TOP_BORDER_START (f) + FRAME_BORDER_HEIGHT (f))
|
|
|
491
|
|
|
492 #define FRAME_BOTTOM_BORDER_START(f) \
|
|
|
493 (FRAME_PIXHEIGHT (f) - FRAME_BORDER_HEIGHT (f) - \
|
|
|
494 FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f))
|
|
|
495 #define FRAME_BOTTOM_BORDER_END(f) \
|
|
|
496 (FRAME_PIXHEIGHT (f) - FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f))
|
|
|
497
|
|
|
498 #define FRAME_LEFT_BORDER_START(f) (FRAME_REAL_LEFT_TOOLBAR_WIDTH (f))
|
|
|
499 #define FRAME_LEFT_BORDER_END(f) \
|
|
|
500 (FRAME_LEFT_BORDER_START (f) + FRAME_BORDER_WIDTH (f))
|
|
|
501
|
|
|
502 #define FRAME_RIGHT_BORDER_START(f) \
|
|
|
503 (FRAME_PIXWIDTH (f) - FRAME_BORDER_WIDTH (f) - \
|
|
|
504 FRAME_REAL_RIGHT_TOOLBAR_WIDTH (f))
|
|
|
505 #define FRAME_RIGHT_BORDER_END(f) \
|
|
|
506 (FRAME_PIXWIDTH (f) - FRAME_REAL_RIGHT_TOOLBAR_WIDTH (f))
|
|
|
507
|
|
|
508 /* Equivalent in FSF Emacs:
|
|
|
509
|
|
|
510 FOR_EACH_FRAME (LIST_VAR, FRAME_VAR) followed by a statement is a
|
|
|
511 `for' loop which iterates over the elements of Vframe_list. The
|
|
|
512 loop will set FRAME_VAR, a Lisp_Object, to each frame in
|
|
|
513 Vframe_list in succession and execute the statement. LIST_VAR
|
|
|
514 should be a Lisp_Object too; it is used to iterate through the
|
|
|
515 Vframe_list.
|
|
|
516 */
|
|
|
517
|
|
|
518 /* NO_BREAK means that "break" doesn't do what you think it does!
|
|
|
519 Use goto instead. "continue" is OK, though. */
|
|
|
520 #define FRAME_LOOP_NO_BREAK(frmcons, devcons, concons) \
|
|
|
521 DEVICE_LOOP_NO_BREAK (devcons, concons) \
|
|
|
522 DEVICE_FRAME_LOOP (frmcons, XDEVICE (XCAR (devcons)))
|
|
|
523
|
|
|
524 extern Lisp_Object Vdefault_frame_name;
|
|
|
525
|
|
|
526 void update_frame_title (struct frame *f);
|
|
|
527 Lisp_Object next_frame (Lisp_Object f, Lisp_Object frametype,
|
|
|
528 Lisp_Object console);
|
|
|
529 Lisp_Object prev_frame (Lisp_Object f, Lisp_Object frametype,
|
|
|
530 Lisp_Object console);
|
|
|
531 void store_in_alist (Lisp_Object *alistptr,
|
|
|
532 CONST char *propname,
|
|
|
533 Lisp_Object val);
|
|
|
534 void pixel_to_char_size (struct frame *f, int pixel_width, int pixel_height,
|
|
|
535 int *char_width, int *char_height);
|
|
|
536 void char_to_pixel_size (struct frame *f, int char_width, int char_height,
|
|
|
537 int *pixel_width, int *pixel_height);
|
|
|
538 void round_size_to_char (struct frame *f, int in_width, int in_height,
|
|
|
539 int *out_width, int *out_height);
|
|
|
540 void change_frame_size (struct frame *frame,
|
|
|
541 int newlength, int newwidth,
|
|
|
542 int delay);
|
|
|
543 void hold_frame_size_changes (void);
|
|
|
544 void unhold_one_frame_size_changes (struct frame *f);
|
|
|
545 void unhold_frame_size_changes (void);
|
|
|
546 void select_frame_1 (Lisp_Object frame);
|
|
|
547 struct frame *selected_frame (void);
|
|
|
548 struct frame *device_selected_frame (struct device *d);
|
|
|
549 struct frame *decode_frame (Lisp_Object frame);
|
|
|
550 struct frame *decode_frame_or_selected (Lisp_Object cdf);
|
|
|
551 Lisp_Object make_frame (struct frame *f);
|
|
|
552 int other_visible_frames (struct frame *f);
|
|
|
553 void delete_frame_internal (struct frame *f, int force,
|
|
|
554 int called_from_delete_device,
|
|
|
555 int from_io_error);
|
|
|
556 void io_error_delete_frame (Lisp_Object frame);
|
|
|
557 Lisp_Object find_some_frame (int (*predicate) (Lisp_Object, void *),
|
|
|
558 void *closure);
|
|
|
559 int device_matches_console_spec (Lisp_Object frame, Lisp_Object device,
|
|
|
560 Lisp_Object console);
|
|
|
561 Lisp_Object frame_first_window (struct frame *f);
|
|
|
562 int show_gc_cursor (struct frame *f, Lisp_Object cursor);
|
|
|
563 void set_frame_selected_window (struct frame *f, Lisp_Object window);
|
|
|
564 int is_surrogate_for_selected_frame (struct frame *f);
|
|
|
565 void update_frame_icon (struct frame *f);
|
|
|
566
|
|
|
567 #endif /* _XEMACS_FRAME_H_ */
|
