|
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
|
|
398
|
23 #ifndef INCLUDED_frame_h_
|
|
|
24 #define INCLUDED_frame_h_
|
|
0
|
25
|
|
380
|
26 #ifdef HAVE_SCROLLBARS
|
|
0
|
27 #include "scrollbar.h"
|
|
380
|
28 #endif
|
|
|
29
|
|
|
30 #ifdef HAVE_TOOLBARS
|
|
0
|
31 #include "toolbar.h"
|
|
380
|
32 #endif
|
|
|
33
|
|
0
|
34 #include "device.h"
|
|
384
|
35 #include "glyphs.h"
|
|
398
|
36 #include "redisplay.h"
|
|
0
|
37
|
|
|
38 #define FRAME_TYPE_NAME(f) ((f)->framemeths->name)
|
|
|
39 #define FRAME_TYPE(f) ((f)->framemeths->symbol)
|
|
|
40
|
|
|
41 /******** Accessing / calling a frame method *********/
|
|
|
42
|
|
|
43 #define HAS_FRAMEMETH_P(f, m) HAS_CONTYPE_METH_P ((f)->framemeths, m)
|
|
|
44 #define FRAMEMETH(f, m, args) CONTYPE_METH ((f)->framemeths, m, args)
|
|
|
45 #define MAYBE_FRAMEMETH(f, m, args) \
|
|
|
46 MAYBE_CONTYPE_METH ((f)->framemeths, m, args)
|
|
|
47 #define FRAMEMETH_OR_GIVEN(f, m, args, given) \
|
|
|
48 CONTYPE_METH_OR_GIVEN((f)->framemeths, m, args, given)
|
|
|
49
|
|
|
50 struct frame
|
|
|
51 {
|
|
|
52 struct lcrecord_header header;
|
|
|
53
|
|
|
54 /* Methods for this frame's console. This can also be retrieved
|
|
|
55 through frame->device->console, but it's faster this way. */
|
|
|
56 struct console_methods *framemeths;
|
|
|
57
|
|
282
|
58 /* Size of text only area of this frame, excluding scrollbars,
|
|
380
|
59 toolbars and end of line glyphs. The size can be in characters
|
|
282
|
60 or pixels, depending on units in which window system resizes
|
|
|
61 its windows */
|
|
|
62 int height, width;
|
|
0
|
63
|
|
282
|
64 /* New height and width for pending size change, in the same units
|
|
|
65 as above. 0 if no change pending. */
|
|
|
66 int new_height, new_width;
|
|
|
67
|
|
|
68 /* Size of text-only are of the frame, in default font characters.
|
|
|
69 This may be inaccurate due to rounding error */
|
|
|
70 int char_height, char_width;
|
|
380
|
71
|
|
282
|
72 /* Size of the whole frame, including scrollbars, toolbars and end
|
|
|
73 of line glyphs, in pixels */
|
|
|
74 int pixheight, pixwidth;
|
|
0
|
75
|
|
149
|
76 #ifdef HAVE_TTY
|
|
|
77 /* The count of frame number. This applies to TTY frames only. */
|
|
|
78 int order_count;
|
|
|
79 #endif
|
|
|
80
|
|
398
|
81 /* Current page number for a printer frame. */
|
|
|
82 int page_number;
|
|
|
83
|
|
0
|
84 /* Width of the internal border. This is a line of background color
|
|
|
85 just inside the window's border. It is normally only non-zero on
|
|
|
86 X frames, but we put it here to avoid introducing window system
|
|
|
87 dependencies. */
|
|
|
88 int internal_border_width;
|
|
|
89
|
|
|
90 /* This frame's root window mirror. This structure exactly mirrors
|
|
|
91 the frame's window structure but contains only pointers to the
|
|
|
92 display structures. */
|
|
|
93 struct window_mirror *root_mirror;
|
|
|
94
|
|
|
95 int modiff;
|
|
|
96
|
|
384
|
97 /* subwindow cache elements for this frame */
|
|
|
98 subwindow_cachel_dynarr *subwindow_cachels;
|
|
|
99
|
|
398
|
100 struct expose_ignore* subwindow_exposures;
|
|
|
101 struct expose_ignore* subwindow_exposures_tail;
|
|
|
102
|
|
0
|
103 #ifdef HAVE_SCROLLBARS
|
|
|
104 /* frame-local scrollbar information. See scrollbar.c. */
|
|
|
105 int scrollbar_y_offset;
|
|
|
106
|
|
|
107 /* cache of created scrollbars */
|
|
|
108 struct scrollbar_instance *sb_vcache;
|
|
|
109 struct scrollbar_instance *sb_hcache;
|
|
|
110 #endif
|
|
|
111
|
|
|
112 #ifdef HAVE_TOOLBARS
|
|
286
|
113 /* Size of toolbars as seen by redisplay. This is used to determine
|
|
|
114 whether to re-layout windows by a call to change_frame_size early
|
|
|
115 in redisplay_frame. */
|
|
|
116 unsigned int current_toolbar_size[4];
|
|
0
|
117 #endif
|
|
|
118
|
|
404
|
119 /* Size of gutters as seen by redisplay. This is used to determine
|
|
|
120 whether to re-layout windows by a call to change_frame_size early
|
|
|
121 in redisplay_frame. */
|
|
|
122 unsigned int current_gutter_bounds[4];
|
|
|
123
|
|
|
124 /* Dynamic arrays of display lines for gutters */
|
|
|
125 display_line_dynarr *current_display_lines[4];
|
|
|
126 display_line_dynarr *desired_display_lines[4];
|
|
398
|
127
|
|
0
|
128 /* A structure of auxiliary data specific to the device type.
|
|
|
129 struct x_frame is used for X window frames; defined in console-x.h */
|
|
|
130 void *frame_data;
|
|
|
131
|
|
286
|
132 #define FRAME_SLOT_DECLARATION
|
|
0
|
133 #define MARKED_SLOT(x) Lisp_Object x
|
|
|
134 #include "frameslots.h"
|
|
|
135
|
|
108
|
136 /* Nonzero if frame is currently displayed.
|
|
380
|
137 Mutually exclusive with iconified
|
|
108
|
138 JV: This now a tristate flag:
|
|
|
139 Value : Emacs meaning :f-v-p : X meaning
|
|
|
140 0 : not displayed : nil : unmapped
|
|
|
141 >0 : user can access it,needs repainting : t : mapped and visible
|
|
|
142 <0 : user can access it,needs no repainting : hidden :mapped and invisible
|
|
|
143 where f-v-p is the return value of frame-visible-p */
|
|
|
144 int visible;
|
|
|
145
|
|
0
|
146 /* one-bit flags: */
|
|
|
147
|
|
|
148 /* Are we finished initializing? */
|
|
|
149 unsigned int init_finished :1;
|
|
|
150
|
|
|
151 /* Is frame marked for deletion? This is used in XSetErrorHandler(). */
|
|
|
152 unsigned int being_deleted :1;
|
|
|
153
|
|
|
154 /* Nonzero if this frame has been destroyed. */
|
|
|
155 unsigned int dead :1;
|
|
|
156
|
|
|
157 /* Nonzero if last attempt at redisplay on this frame was preempted. */
|
|
|
158 unsigned int display_preempted :1;
|
|
|
159
|
|
|
160 /* Nonzero if window is currently iconified.
|
|
|
161 This and visible are mutually exclusive. */
|
|
|
162 unsigned int iconified :1;
|
|
|
163
|
|
|
164 /* Nonzero if this frame should be cleared and then redrawn.
|
|
|
165 Setting this will also effectively set frame_changed. */
|
|
|
166 unsigned int clear :1;
|
|
|
167
|
|
|
168 /* True if frame actually has a minibuffer window on it.
|
|
|
169 0 if using a minibuffer window that isn't on this frame. */
|
|
|
170 unsigned int has_minibuffer :1;
|
|
185
|
171
|
|
0
|
172 /* True if frame's root window can't be split. */
|
|
|
173 unsigned int no_split :1;
|
|
|
174
|
|
|
175 unsigned int top_toolbar_was_visible :1;
|
|
|
176 unsigned int bottom_toolbar_was_visible :1;
|
|
|
177 unsigned int left_toolbar_was_visible :1;
|
|
|
178 unsigned int right_toolbar_was_visible :1;
|
|
398
|
179 /* gutter visibility */
|
|
|
180 unsigned int top_gutter_was_visible :1;
|
|
|
181 unsigned int bottom_gutter_was_visible :1;
|
|
|
182 unsigned int left_gutter_was_visible :1;
|
|
|
183 unsigned int right_gutter_was_visible :1;
|
|
0
|
184
|
|
|
185 /* redisplay flags */
|
|
|
186 unsigned int buffers_changed :1;
|
|
|
187 unsigned int clip_changed :1;
|
|
|
188 unsigned int extents_changed :1;
|
|
|
189 unsigned int faces_changed :1;
|
|
|
190 unsigned int frame_changed :1;
|
|
384
|
191 unsigned int subwindows_changed :1;
|
|
398
|
192 unsigned int subwindows_state_changed :1;
|
|
269
|
193 unsigned int glyphs_changed :1;
|
|
0
|
194 unsigned int icon_changed :1;
|
|
|
195 unsigned int menubar_changed :1;
|
|
|
196 unsigned int modeline_changed :1;
|
|
|
197 unsigned int point_changed :1;
|
|
|
198 unsigned int size_changed :1;
|
|
|
199 unsigned int toolbar_changed :1;
|
|
398
|
200 unsigned int gutter_changed :1;
|
|
0
|
201 unsigned int windows_changed :1;
|
|
|
202 unsigned int windows_structure_changed :1;
|
|
|
203 unsigned int window_face_cache_reset :1; /* used by expose handler */
|
|
217
|
204 unsigned int echo_area_garbaged :1; /* used by Fredisplay_echo_area */
|
|
282
|
205 unsigned int size_slipped :1;
|
|
0
|
206
|
|
|
207 unsigned int size_change_pending :1;
|
|
|
208 unsigned int mirror_dirty :1;
|
|
|
209
|
|
|
210 /* flag indicating if any window on this frame is displaying a subwindow */
|
|
74
|
211 unsigned int subwindows_being_displayed :1;
|
|
0
|
212 };
|
|
|
213
|
|
272
|
214 EXFUN (Fdelete_frame, 2);
|
|
|
215 EXFUN (Fframe_iconified_p, 1);
|
|
|
216 EXFUN (Fframe_name, 1);
|
|
|
217 EXFUN (Fframe_property, 3);
|
|
|
218 EXFUN (Fmake_frame, 2);
|
|
|
219 EXFUN (Fmake_frame_visible, 1);
|
|
|
220 EXFUN (Fraise_frame, 1);
|
|
|
221 EXFUN (Fselect_frame, 1);
|
|
|
222 EXFUN (Fset_frame_pointer, 2);
|
|
|
223 EXFUN (Fset_frame_position, 3);
|
|
398
|
224 EXFUN (Fset_frame_properties, 2);
|
|
272
|
225 EXFUN (Fset_frame_size, 4);
|
|
|
226
|
|
|
227 extern Lisp_Object Qbackground_toolbar_color, Qbell_volume, Qborder_color;
|
|
|
228 extern Lisp_Object Qborder_width, Qbottom_toolbar_shadow_color;
|
|
|
229 extern Lisp_Object Qbottom_toolbar_shadow_pixmap, Qdelete_frame;
|
|
|
230 extern Lisp_Object Qdeselect_frame_hook, Qdrag_and_drop_functions, Qgc_pointer;
|
|
|
231 extern Lisp_Object Qiconic, Qinitially_unmapped, Qinter_line_space;
|
|
|
232 extern Lisp_Object Qinternal_border_width, Qinvisible, Qmap_frame_hook;
|
|
|
233 extern Lisp_Object Qminibuffer, Qmodeline_pointer, Qmouse_enter_frame_hook;
|
|
|
234 extern Lisp_Object Qmouse_leave_frame_hook, Qpointer_background;
|
|
|
235 extern Lisp_Object Qpointer_color, Qpopup, Qscrollbar_placement;
|
|
|
236 extern Lisp_Object Qselect_frame_hook, Qspace_pointer;
|
|
|
237 extern Lisp_Object Qsynchronize_minibuffers, Qtext_pointer;
|
|
|
238 extern Lisp_Object Qtoolbar_shadow_thickness, Qtop_toolbar_shadow_color;
|
|
|
239 extern Lisp_Object Qtop_toolbar_shadow_pixmap, Qunmap_frame_hook;
|
|
|
240 extern Lisp_Object Qunsplittable, Quse_backing_store, Qvisible, Qvisual_bell;
|
|
|
241 extern Lisp_Object Vframe_icon_title_format, Vframe_title_format;
|
|
|
242 extern Lisp_Object Vmouse_motion_handler;
|
|
|
243
|
|
0
|
244
|
|
|
245 DECLARE_LRECORD (frame, struct frame);
|
|
|
246 #define XFRAME(x) XRECORD (x, frame, struct frame)
|
|
|
247 #define XSETFRAME(x, p) XSETRECORD (x, p, frame)
|
|
|
248 #define FRAMEP(x) RECORDP (x, frame)
|
|
|
249 #define CHECK_FRAME(x) CHECK_RECORD (x, frame)
|
|
|
250 #define CONCHECK_FRAME(x) CONCHECK_RECORD (x, frame)
|
|
|
251
|
|
272
|
252 #define CHECK_LIVE_FRAME(x) do { \
|
|
|
253 CHECK_FRAME (x); \
|
|
|
254 if (! FRAME_LIVE_P (XFRAME (x))) \
|
|
|
255 dead_wrong_type_argument (Qframe_live_p, (x)); \
|
|
|
256 } while (0)
|
|
|
257 #define CONCHECK_LIVE_FRAME(x) do { \
|
|
|
258 CONCHECK_FRAME (x); \
|
|
|
259 if (! FRAME_LIVE_P (XFRAME (x))) \
|
|
|
260 x = wrong_type_argument (Qframe_live_p, (x)); \
|
|
|
261 } while (0)
|
|
0
|
262
|
|
|
263 #define FRAME_TYPE_P(f, type) EQ (FRAME_TYPE (f), Q##type)
|
|
|
264
|
|
|
265 #ifdef ERROR_CHECK_TYPECHECK
|
|
404
|
266 INLINE_HEADER struct frame *
|
|
272
|
267 error_check_frame_type (struct frame * f, Lisp_Object sym);
|
|
404
|
268 INLINE_HEADER struct frame *
|
|
272
|
269 error_check_frame_type (struct frame * f, Lisp_Object sym)
|
|
|
270 {
|
|
|
271 assert (EQ (FRAME_TYPE (f), sym));
|
|
|
272 return f;
|
|
|
273 }
|
|
0
|
274 # define FRAME_TYPE_DATA(f, type) \
|
|
398
|
275 ((struct type##_frame *) error_check_frame_type (f, Q##type)->frame_data)
|
|
0
|
276 #else
|
|
|
277 # define FRAME_TYPE_DATA(f, type) \
|
|
|
278 ((struct type##_frame *) (f)->frame_data)
|
|
|
279 #endif
|
|
|
280
|
|
|
281 #define CHECK_FRAME_TYPE(x, type) \
|
|
|
282 do { \
|
|
|
283 CHECK_FRAME (x); \
|
|
|
284 if (!FRAME_TYPE_P (XFRAME (x), type)) \
|
|
|
285 dead_wrong_type_argument \
|
|
|
286 (type##_console_methods->predicate_symbol, x); \
|
|
|
287 } while (0)
|
|
|
288 #define CONCHECK_FRAME_TYPE(x, type) \
|
|
|
289 do { \
|
|
|
290 CONCHECK_FRAME (x); \
|
|
|
291 if (!FRAME_TYPE_P (XFRAME (x), type)) \
|
|
|
292 x = wrong_type_argument \
|
|
|
293 (type##_console_methods->predicate_symbol, x); \
|
|
|
294 } while (0)
|
|
|
295
|
|
398
|
296 #define FRAME_DISPLAY_P(frm) \
|
|
|
297 (DEVICE_DISPLAY_P (XDEVICE (FRAME_DEVICE (frm))))
|
|
|
298
|
|
|
299 #define CHECK_DISPLAY_FRAME(frm) \
|
|
|
300 do { \
|
|
|
301 CHECK_FRAME (frm); \
|
|
|
302 CHECK_LIVE_FRAME (frm); \
|
|
|
303 CHECK_DISPLAY_DEVICE (FRAME_DEVICE (XFRAME (frm))); \
|
|
|
304 } while (0)
|
|
|
305
|
|
|
306 #define CONCHECK_DISPLAY_FRAME(frm) \
|
|
|
307 do { \
|
|
|
308 CONCHECK_FRAME (frm); \
|
|
|
309 CONCHECK_LIVE_FRAME (frm); \
|
|
|
310 CONCHECK_DISPLAY_DEVICE (FRAME_DEVICE (XFRAME (frm))); \
|
|
|
311 } while (0)
|
|
|
312
|
|
|
313 #define FRAME_PRINTER_P(frm) \
|
|
|
314 (DEVICE_PRINTER_P (XDEVICE (FRAME_DEVICE (frm))))
|
|
|
315
|
|
|
316 #define CHECK_PRINTER_FRAME(frm) \
|
|
|
317 do { \
|
|
|
318 CHECK_FRAME (frm); \
|
|
|
319 CHECK_LIVE_FRAME (frm); \
|
|
|
320 CHECK_PRINTER_DEVICE (FRAME_DEVICE (XFRAME (frm))); \
|
|
|
321 } while (0)
|
|
|
322
|
|
|
323 #define CONCHECK_PRINTER_FRAME(frm) \
|
|
|
324 do { \
|
|
|
325 CONCHECK_FRAME (frm); \
|
|
|
326 CONCHECK_LIVE_FRAME (frm); \
|
|
|
327 CONCHECK_PRINTER_DEVICE (FRAME_DEVICE (XFRAME (frm))); \
|
|
|
328 } while (0)
|
|
|
329
|
|
0
|
330 /* #### These should be in the frame-*.h files but there are
|
|
|
331 too many places where the abstraction is broken. Need to
|
|
|
332 fix. */
|
|
|
333
|
|
|
334 #define FRAME_X_P(frm) CONSOLE_TYPESYM_X_P (FRAME_TYPE (frm))
|
|
|
335 #define CHECK_X_FRAME(z) CHECK_FRAME_TYPE (z, x)
|
|
|
336 #define CONCHECK_X_FRAME(z) CONCHECK_FRAME_TYPE (z, x)
|
|
|
337
|
|
|
338 #define FRAME_TTY_P(frm) CONSOLE_TYPESYM_TTY_P (FRAME_TYPE (frm))
|
|
|
339 #define CHECK_TTY_FRAME(z) CHECK_FRAME_TYPE (z, tty)
|
|
|
340 #define CONCHECK_TTY_FRAME(z) CONCHECK_FRAME_TYPE (z, tty)
|
|
|
341
|
|
|
342 #define FRAME_STREAM_P(frm) CONSOLE_TYPESYM_STREAM_P (FRAME_TYPE (frm))
|
|
|
343 #define CHECK_STREAM_FRAME(z) CHECK_FRAME_TYPE (z, stream)
|
|
|
344 #define CONCHECK_STREAM_FRAME(z) CONCHECK_FRAME_TYPE (z, stream)
|
|
|
345
|
|
|
346 #define FRAME_WIN_P(frm) CONSOLE_TYPESYM_WIN_P (FRAME_TYPE (frm))
|
|
|
347
|
|
|
348 extern int frame_changed;
|
|
|
349
|
|
272
|
350 #define MARK_FRAME_FACES_CHANGED(f) do { \
|
|
|
351 struct frame *mffc_f = (f); \
|
|
|
352 mffc_f->faces_changed = 1; \
|
|
|
353 mffc_f->modiff++; \
|
|
|
354 if (!NILP (mffc_f->device)) \
|
|
|
355 { \
|
|
|
356 struct device *mffc_d = XDEVICE (mffc_f->device); \
|
|
|
357 MARK_DEVICE_FACES_CHANGED (mffc_d); \
|
|
|
358 } \
|
|
|
359 else \
|
|
|
360 faces_changed = 1; \
|
|
|
361 } while (0)
|
|
0
|
362
|
|
272
|
363 #define MARK_FRAME_GLYPHS_CHANGED(f) do { \
|
|
|
364 struct frame *mfgc_f = (f); \
|
|
|
365 mfgc_f->glyphs_changed = 1; \
|
|
|
366 mfgc_f->modiff++; \
|
|
|
367 if (!NILP (mfgc_f->device)) \
|
|
|
368 { \
|
|
|
369 struct device *mfgc_d = XDEVICE (mfgc_f->device); \
|
|
|
370 MARK_DEVICE_GLYPHS_CHANGED (mfgc_d); \
|
|
|
371 } \
|
|
|
372 else \
|
|
|
373 glyphs_changed = 1; \
|
|
|
374 } while (0)
|
|
269
|
375
|
|
384
|
376 #define MARK_FRAME_SUBWINDOWS_CHANGED(f) do { \
|
|
|
377 struct frame *mfgc_f = (f); \
|
|
398
|
378 mfgc_f->subwindows_changed = 1; \
|
|
384
|
379 mfgc_f->modiff++; \
|
|
|
380 if (!NILP (mfgc_f->device)) \
|
|
|
381 { \
|
|
|
382 struct device *mfgc_d = XDEVICE (mfgc_f->device); \
|
|
|
383 MARK_DEVICE_SUBWINDOWS_CHANGED (mfgc_d); \
|
|
|
384 } \
|
|
|
385 else \
|
|
398
|
386 subwindows_changed = 1; \
|
|
|
387 } while (0)
|
|
|
388
|
|
|
389 #define MARK_FRAME_SUBWINDOWS_STATE_CHANGED(f) do { \
|
|
|
390 struct frame *mfgc_f = (f); \
|
|
|
391 mfgc_f->subwindows_state_changed = 1; \
|
|
|
392 mfgc_f->modiff++; \
|
|
|
393 if (!NILP (mfgc_f->device)) \
|
|
|
394 { \
|
|
|
395 struct device *mfgc_d = XDEVICE (mfgc_f->device); \
|
|
|
396 MARK_DEVICE_SUBWINDOWS_STATE_CHANGED (mfgc_d); \
|
|
|
397 } \
|
|
|
398 else \
|
|
|
399 subwindows_state_changed = 1; \
|
|
384
|
400 } while (0)
|
|
|
401
|
|
272
|
402 #define MARK_FRAME_TOOLBARS_CHANGED(f) do { \
|
|
|
403 struct frame *mftc_f = (f); \
|
|
|
404 mftc_f->toolbar_changed = 1; \
|
|
|
405 mftc_f->modiff++; \
|
|
|
406 if (!NILP (mftc_f->device)) \
|
|
|
407 { \
|
|
|
408 struct device *mftc_d = XDEVICE (mftc_f->device); \
|
|
|
409 MARK_DEVICE_TOOLBARS_CHANGED (mftc_d); \
|
|
|
410 } \
|
|
|
411 else \
|
|
|
412 toolbar_changed = 1; \
|
|
|
413 } while (0)
|
|
0
|
414
|
|
398
|
415 #define MARK_FRAME_GUTTERS_CHANGED(f) do { \
|
|
|
416 struct frame *mftc_f = (f); \
|
|
|
417 mftc_f->gutter_changed = 1; \
|
|
|
418 mftc_f->modiff++; \
|
|
|
419 if (!NILP (mftc_f->device)) \
|
|
|
420 { \
|
|
|
421 struct device *mftc_d = XDEVICE (mftc_f->device); \
|
|
|
422 MARK_DEVICE_GUTTERS_CHANGED (mftc_d); \
|
|
|
423 } \
|
|
|
424 else \
|
|
|
425 gutter_changed = 1; \
|
|
|
426 } while (0)
|
|
|
427
|
|
272
|
428 #define MARK_FRAME_SIZE_CHANGED(f) do { \
|
|
|
429 struct frame *mfsc_f = (f); \
|
|
|
430 mfsc_f->size_changed = 1; \
|
|
|
431 mfsc_f->size_change_pending = 1; \
|
|
|
432 mfsc_f->modiff++; \
|
|
|
433 if (!NILP (mfsc_f->device)) \
|
|
|
434 { \
|
|
|
435 struct device *mfsc_d = XDEVICE (mfsc_f->device); \
|
|
|
436 MARK_DEVICE_SIZE_CHANGED (mfsc_d); \
|
|
|
437 } \
|
|
|
438 else \
|
|
|
439 size_changed = 1; \
|
|
|
440 } while (0)
|
|
0
|
441
|
|
272
|
442 #define MARK_FRAME_CHANGED(f) do { \
|
|
|
443 struct frame *mfc_f = (f); \
|
|
|
444 mfc_f->frame_changed = 1; \
|
|
|
445 mfc_f->modiff++; \
|
|
|
446 if (!NILP (mfc_f->device)) \
|
|
|
447 { \
|
|
|
448 struct device *mfc_d = XDEVICE (mfc_f->device); \
|
|
|
449 MARK_DEVICE_FRAME_CHANGED (mfc_d); \
|
|
|
450 } \
|
|
|
451 else \
|
|
|
452 frame_changed = 1; \
|
|
|
453 } while (0)
|
|
0
|
454
|
|
272
|
455 #define MARK_FRAME_WINDOWS_CHANGED(f) do { \
|
|
|
456 struct frame *mfwc_f = (f); \
|
|
|
457 mfwc_f->windows_changed = 1; \
|
|
|
458 mfwc_f->modiff++; \
|
|
|
459 if (!NILP (mfwc_f->device)) \
|
|
|
460 { \
|
|
|
461 struct device *mfwc_d = XDEVICE (mfwc_f->device); \
|
|
|
462 MARK_DEVICE_WINDOWS_CHANGED (mfwc_d); \
|
|
|
463 } \
|
|
|
464 else \
|
|
|
465 windows_changed = 1; \
|
|
|
466 } while (0)
|
|
0
|
467
|
|
272
|
468 #define MARK_FRAME_WINDOWS_STRUCTURE_CHANGED(f) do { \
|
|
|
469 struct frame *fwsc_f = (f); \
|
|
|
470 fwsc_f->windows_structure_changed = 1; \
|
|
|
471 fwsc_f->modiff++; \
|
|
|
472 if (!NILP (fwsc_f->device)) \
|
|
|
473 { \
|
|
|
474 struct device *fwsc_d = XDEVICE (fwsc_f->device); \
|
|
|
475 MARK_DEVICE_WINDOWS_STRUCTURE_CHANGED (fwsc_d); \
|
|
|
476 } \
|
|
|
477 else \
|
|
|
478 windows_structure_changed = 1; \
|
|
284
|
479 invalidate_vertical_divider_cache_in_frame (fwsc_f); \
|
|
272
|
480 } while (0)
|
|
0
|
481
|
|
282
|
482 #define MARK_FRAME_SIZE_SLIPPED(f) do { \
|
|
|
483 struct frame *fwsc_f = (f); \
|
|
|
484 fwsc_f->size_slipped = 1; \
|
|
|
485 fwsc_f->modiff++; \
|
|
|
486 if (!NILP (fwsc_f->device)) \
|
|
|
487 { \
|
|
|
488 struct device *fwsc_d = XDEVICE (fwsc_f->device); \
|
|
|
489 MARK_DEVICE_FRAME_CHANGED (fwsc_d); \
|
|
|
490 } \
|
|
|
491 else \
|
|
|
492 frame_changed = 1; \
|
|
|
493 } while (0)
|
|
|
494
|
|
|
495 #define CLEAR_FRAME_SIZE_SLIPPED(f) do { \
|
|
|
496 struct frame *fwsc_f = (f); \
|
|
|
497 fwsc_f->size_slipped = 0; \
|
|
|
498 } while (0)
|
|
|
499
|
|
0
|
500 #define SET_FRAME_CLEAR(f) MARK_FRAME_CHANGED (f); (f)->clear = 1
|
|
|
501 #define FRAME_DEVICE(f) ((f)->device)
|
|
|
502 #define FRAME_CONSOLE(f) DEVICE_CONSOLE (XDEVICE (FRAME_DEVICE (f)))
|
|
|
503 #define FRAME_LIVE_P(f) (!(f)->dead)
|
|
|
504
|
|
|
505 #define FRAME_MINIBUF_ONLY_P(f) \
|
|
|
506 EQ (FRAME_ROOT_WINDOW (f), FRAME_MINIBUF_WINDOW (f))
|
|
398
|
507 #define FRAME_HAS_MINIBUF_P(f) ((f)->has_minibuffer)
|
|
|
508 #define FRAME_HEIGHT(f) ((f)->height)
|
|
|
509 #define FRAME_WIDTH(f) ((f)->width)
|
|
|
510 #define FRAME_CHARHEIGHT(f) ((f)->char_height)
|
|
|
511 #define FRAME_CHARWIDTH(f) ((f)->char_width)
|
|
|
512 #define FRAME_PIXHEIGHT(f) ((f)->pixheight)
|
|
|
513 #define FRAME_PIXWIDTH(f) ((f)->pixwidth)
|
|
|
514 #define FRAME_PAGENUMBER(f) ((f)->page_number + 0)
|
|
|
515 #define FRAME_SET_PAGENUMBER(f,x) (f)->page_number = (x);
|
|
0
|
516 #ifdef HAVE_SCROLLBARS
|
|
282
|
517 #define FRAME_SCROLLBAR_WIDTH(f) \
|
|
|
518 (NILP ((f)->vertical_scrollbar_visible_p) ? \
|
|
|
519 0 : XINT ((f)->scrollbar_width))
|
|
|
520 #define FRAME_SCROLLBAR_HEIGHT(f) \
|
|
|
521 (NILP ((f)->horizontal_scrollbar_visible_p) ? \
|
|
|
522 0 : XINT ((f)->scrollbar_height))
|
|
0
|
523 #else
|
|
|
524 #define FRAME_SCROLLBAR_WIDTH(f) 0
|
|
|
525 #define FRAME_SCROLLBAR_HEIGHT(f) 0
|
|
|
526 #endif
|
|
|
527
|
|
384
|
528 #define FW_FRAME(obj) \
|
|
|
529 (WINDOWP (obj) ? WINDOW_FRAME (XWINDOW (obj)) \
|
|
398
|
530 : (FRAMEP (obj) ? obj \
|
|
|
531 : Qnil))
|
|
384
|
532
|
|
0
|
533 #define FRAME_NEW_HEIGHT(f) ((f)->new_height)
|
|
|
534 #define FRAME_NEW_WIDTH(f) ((f)->new_width)
|
|
|
535 #define FRAME_CURSOR_X(f) ((f)->cursor_x)
|
|
|
536 #define FRAME_CURSOR_Y(f) ((f)->cursor_y)
|
|
|
537 #define FRAME_VISIBLE_P(f) ((f)->visible)
|
|
185
|
538 #define FRAME_REPAINT_P(f) ((f)->visible>0)
|
|
0
|
539 #define FRAME_NO_SPLIT_P(f) ((f)->no_split)
|
|
|
540 #define FRAME_ICONIFIED_P(f) ((f)->iconified)
|
|
|
541 #define FRAME_FOCUS_FRAME(f) ((f)->focus_frame)
|
|
|
542 #define FRAME_MINIBUF_WINDOW(f) ((f)->minibuffer_window)
|
|
|
543 #define FRAME_ROOT_WINDOW(f) ((f)->root_window)
|
|
|
544 /* Catch people attempting to set this. */
|
|
|
545 #define FRAME_SELECTED_WINDOW(f) NON_LVALUE ((f)->selected_window)
|
|
|
546 #define FRAME_LAST_NONMINIBUF_WINDOW(f) \
|
|
|
547 NON_LVALUE ((f)->last_nonminibuf_window)
|
|
|
548 #define FRAME_SB_VCACHE(f) ((f)->sb_vcache)
|
|
|
549 #define FRAME_SB_HCACHE(f) ((f)->sb_hcache)
|
|
384
|
550 #define FRAME_SUBWINDOW_CACHE(f) ((f)->subwindow_cachels)
|
|
0
|
551
|
|
|
552 #if 0 /* FSFmacs */
|
|
|
553
|
|
|
554 #define FRAME_VISIBLE_P(f) ((f)->visible != 0)
|
|
|
555 #define FRAME_SET_VISIBLE(f,p) \
|
|
|
556 ((f)->async_visible = (p), FRAME_SAMPLE_VISIBILITY (f))
|
|
|
557
|
|
|
558 /* Emacs's redisplay code could become confused if a frame's
|
|
|
559 visibility changes at arbitrary times. For example, if a frame is
|
|
|
560 visible while the desired glyphs are being built, but becomes
|
|
|
561 invisible before they are updated, then some rows of the
|
|
|
562 desired_glyphs will be left marked as enabled after redisplay is
|
|
|
563 complete, which should never happen. The next time the frame
|
|
|
564 becomes visible, redisplay will probably barf.
|
|
|
565
|
|
|
566 Currently, there are no similar situations involving iconified, but
|
|
|
567 the principle is the same.
|
|
|
568
|
|
|
569 So instead of having asynchronous input handlers directly set and
|
|
|
570 clear the frame's visibility and iconification flags, they just set
|
|
|
571 the async_visible and async_iconified flags; the redisplay code
|
|
|
572 calls the FRAME_SAMPLE_VISIBILITY macro before doing any redisplay,
|
|
|
573 which sets visible and iconified from their asynchronous
|
|
|
574 counterparts.
|
|
|
575
|
|
|
576 Synchronous code must use the FRAME_SET_VISIBLE macro.
|
|
|
577
|
|
|
578 Also, if a frame used to be invisible, but has just become visible,
|
|
|
579 it must be marked as garbaged, since redisplay hasn't been keeping
|
|
|
580 up its contents. */
|
|
|
581 #define FRAME_SAMPLE_VISIBILITY(f) \
|
|
|
582 (((f)->async_visible && ! (f)->visible) ? SET_FRAME_GARBAGED (f) : 0, \
|
|
|
583 (f)->visible = (f)->async_visible, \
|
|
|
584 (f)->iconified = (f)->async_iconified)
|
|
|
585
|
|
|
586 #endif /* FSFmacs */
|
|
|
587
|
|
|
588 #define FRAME_BORDER_WIDTH(f) ((f)->internal_border_width)
|
|
|
589 #define FRAME_BORDER_HEIGHT(f) ((f)->internal_border_width)
|
|
|
590
|
|
|
591 /* This returns the frame-local value; that tells you what you should
|
|
|
592 use when computing the frame size. It is *not* the actual toolbar
|
|
|
593 size because that depends on the selected window. Use the macros
|
|
|
594 below for that.
|
|
|
595 */
|
|
|
596
|
|
|
597 #ifdef HAVE_TOOLBARS
|
|
|
598 #define FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE(f, pos) \
|
|
286
|
599 (!NILP((f)->toolbar_buttons[pos]) && !NILP ((f)->toolbar_visible_p[pos]))
|
|
0
|
600 #define FRAME_RAW_THEORETICAL_TOOLBAR_SIZE(f, pos) \
|
|
286
|
601 (!NILP ((f)->toolbar_buttons[pos]) && INTP((f)->toolbar_size[pos]) ? \
|
|
263
|
602 (XINT ((f)->toolbar_size[pos])) : 0)
|
|
215
|
603 #define FRAME_RAW_THEORETICAL_TOOLBAR_BORDER_WIDTH(f, pos) \
|
|
286
|
604 (!NILP ((f)->toolbar_buttons[pos]) && INTP((f)->toolbar_border_width[pos]) ? \
|
|
263
|
605 (XINT ((f)->toolbar_border_width[pos])) : 0)
|
|
0
|
606 #else
|
|
|
607 #define FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE(f, pos) 0
|
|
|
608 #define FRAME_RAW_THEORETICAL_TOOLBAR_SIZE(f, pos) 0
|
|
215
|
609 #define FRAME_RAW_THEORETICAL_TOOLBAR_BORDER_WIDTH(f, pos) 0
|
|
0
|
610 #endif
|
|
|
611
|
|
|
612 #define FRAME_THEORETICAL_TOOLBAR_SIZE(f, pos) \
|
|
|
613 (FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE (f, pos) \
|
|
|
614 ? FRAME_RAW_THEORETICAL_TOOLBAR_SIZE (f, pos) \
|
|
|
615 : 0)
|
|
|
616
|
|
|
617 #define FRAME_THEORETICAL_TOP_TOOLBAR_HEIGHT(f) \
|
|
|
618 FRAME_THEORETICAL_TOOLBAR_SIZE (f, TOP_TOOLBAR)
|
|
|
619 #define FRAME_THEORETICAL_BOTTOM_TOOLBAR_HEIGHT(f) \
|
|
|
620 FRAME_THEORETICAL_TOOLBAR_SIZE (f, BOTTOM_TOOLBAR)
|
|
|
621 #define FRAME_THEORETICAL_LEFT_TOOLBAR_WIDTH(f) \
|
|
|
622 FRAME_THEORETICAL_TOOLBAR_SIZE (f, LEFT_TOOLBAR)
|
|
|
623 #define FRAME_THEORETICAL_RIGHT_TOOLBAR_WIDTH(f) \
|
|
|
624 FRAME_THEORETICAL_TOOLBAR_SIZE (f, RIGHT_TOOLBAR)
|
|
|
625
|
|
215
|
626 #define FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH(f, pos) \
|
|
398
|
627 (FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE (f, pos) \
|
|
215
|
628 ? FRAME_RAW_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, pos) \
|
|
|
629 : 0)
|
|
|
630
|
|
|
631 #define FRAME_THEORETICAL_TOP_TOOLBAR_BORDER_WIDTH(f) \
|
|
|
632 FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, TOP_TOOLBAR)
|
|
|
633 #define FRAME_THEORETICAL_BOTTOM_TOOLBAR_BORDER_WIDTH(f) \
|
|
|
634 FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, BOTTOM_TOOLBAR)
|
|
|
635 #define FRAME_THEORETICAL_LEFT_TOOLBAR_BORDER_WIDTH(f) \
|
|
|
636 FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, LEFT_TOOLBAR)
|
|
|
637 #define FRAME_THEORETICAL_RIGHT_TOOLBAR_BORDER_WIDTH(f) \
|
|
|
638 FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, RIGHT_TOOLBAR)
|
|
|
639
|
|
0
|
640 /* This returns the window-local value rather than the frame-local value;
|
|
|
641 that tells you about what's actually visible rather than what should
|
|
|
642 be used when computing the frame size. */
|
|
|
643
|
|
|
644 #ifdef HAVE_TOOLBARS
|
|
|
645 #define FRAME_RAW_REAL_TOOLBAR_VISIBLE(f, pos) \
|
|
267
|
646 (HAS_DEVMETH_P (XDEVICE (FRAME_DEVICE (f)), initialize_frame_toolbars) \
|
|
|
647 && !NILP (XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_visible_p[pos]))
|
|
215
|
648 #define FRAME_RAW_REAL_TOOLBAR_BORDER_WIDTH(f, pos) \
|
|
269
|
649 ((INTP (XWINDOW \
|
|
|
650 (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_border_width[pos])) ? \
|
|
|
651 (XINT (XWINDOW \
|
|
|
652 (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_border_width[pos])) \
|
|
|
653 : 0)
|
|
0
|
654 #define FRAME_RAW_REAL_TOOLBAR_SIZE(f, pos) \
|
|
269
|
655 ((INTP (XWINDOW \
|
|
|
656 (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_size[pos])) ? \
|
|
|
657 (XINT (XWINDOW \
|
|
|
658 (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_size[pos])) : 0)
|
|
0
|
659 #define FRAME_REAL_TOOLBAR(f, pos) \
|
|
|
660 (XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar[pos])
|
|
|
661 #else
|
|
|
662 #define FRAME_RAW_REAL_TOOLBAR_VISIBLE(f, pos) 0
|
|
215
|
663 #define FRAME_RAW_REAL_TOOLBAR_BORDER_WIDTH(f, pos) 0
|
|
0
|
664 #define FRAME_RAW_REAL_TOOLBAR_SIZE(f, pos) 0
|
|
|
665 #define FRAME_REAL_TOOLBAR(f, pos) Qnil
|
|
|
666 #endif
|
|
|
667
|
|
|
668 /* Note to Chuck
|
|
|
669 Note to Chuck
|
|
|
670 Note to Chuck:
|
|
|
671
|
|
|
672 The former definitions of FRAME_REAL_FOO_TOOLBAR_VISIBLE
|
|
|
673 looked at the toolbar data to see what was there. The
|
|
|
674 current ones look at the current values of the specifiers.
|
|
|
675 This is a semantic change; the former definition returned
|
|
|
676 what was *actually* there right at the moment, while the
|
|
|
677 current one returns what *ought* to be there once redisplay
|
|
|
678 has run to completion. I think this new definition is more
|
|
|
679 correct in almost all circumstances and is much less likely
|
|
|
680 to lead to strange race conditions. I'm not completely
|
|
|
681 sure that there aren't some places in the redisplay code
|
|
|
682 that use these macros and expect the former semantics, so
|
|
|
683 if you encounter some odd toolbar behavior, you might want
|
|
|
684 to look into this. --ben */
|
|
|
685
|
|
398
|
686 #define FRAME_REAL_TOOLBAR_VISIBLE(f, pos) \
|
|
|
687 ((!NILP (FRAME_REAL_TOOLBAR (f, pos)) \
|
|
|
688 && FRAME_RAW_REAL_TOOLBAR_SIZE (f, pos) > 0) \
|
|
|
689 ? FRAME_RAW_REAL_TOOLBAR_VISIBLE (f, pos) \
|
|
0
|
690 : 0)
|
|
398
|
691 #define FRAME_REAL_TOOLBAR_SIZE(f, pos) \
|
|
|
692 ((!NILP (FRAME_REAL_TOOLBAR (f, pos)) \
|
|
|
693 && FRAME_RAW_REAL_TOOLBAR_VISIBLE (f, pos)) \
|
|
|
694 ? FRAME_RAW_REAL_TOOLBAR_SIZE (f, pos) \
|
|
0
|
695 : 0)
|
|
215
|
696 #define FRAME_REAL_TOOLBAR_BORDER_WIDTH(f, pos) \
|
|
398
|
697 ((!NILP (FRAME_REAL_TOOLBAR (f, pos)) \
|
|
263
|
698 && FRAME_RAW_REAL_TOOLBAR_VISIBLE (f, pos)) \
|
|
215
|
699 ? FRAME_RAW_REAL_TOOLBAR_BORDER_WIDTH (f, pos) \
|
|
|
700 : 0)
|
|
0
|
701
|
|
|
702 #define FRAME_REAL_TOP_TOOLBAR_HEIGHT(f) \
|
|
|
703 FRAME_REAL_TOOLBAR_SIZE (f, TOP_TOOLBAR)
|
|
|
704 #define FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT(f) \
|
|
|
705 FRAME_REAL_TOOLBAR_SIZE (f, BOTTOM_TOOLBAR)
|
|
|
706 #define FRAME_REAL_LEFT_TOOLBAR_WIDTH(f) \
|
|
|
707 FRAME_REAL_TOOLBAR_SIZE (f, LEFT_TOOLBAR)
|
|
|
708 #define FRAME_REAL_RIGHT_TOOLBAR_WIDTH(f) \
|
|
|
709 FRAME_REAL_TOOLBAR_SIZE (f, RIGHT_TOOLBAR)
|
|
|
710
|
|
215
|
711 #define FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH(f) \
|
|
|
712 FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, TOP_TOOLBAR)
|
|
|
713 #define FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH(f) \
|
|
|
714 FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, BOTTOM_TOOLBAR)
|
|
|
715 #define FRAME_REAL_LEFT_TOOLBAR_BORDER_WIDTH(f) \
|
|
|
716 FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, LEFT_TOOLBAR)
|
|
|
717 #define FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH(f) \
|
|
|
718 FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, RIGHT_TOOLBAR)
|
|
|
719
|
|
0
|
720 #define FRAME_REAL_TOP_TOOLBAR_VISIBLE(f) \
|
|
|
721 FRAME_REAL_TOOLBAR_VISIBLE (f, TOP_TOOLBAR)
|
|
|
722 #define FRAME_REAL_BOTTOM_TOOLBAR_VISIBLE(f) \
|
|
|
723 FRAME_REAL_TOOLBAR_VISIBLE (f, BOTTOM_TOOLBAR)
|
|
|
724 #define FRAME_REAL_LEFT_TOOLBAR_VISIBLE(f) \
|
|
|
725 FRAME_REAL_TOOLBAR_VISIBLE (f, LEFT_TOOLBAR)
|
|
|
726 #define FRAME_REAL_RIGHT_TOOLBAR_VISIBLE(f) \
|
|
|
727 FRAME_REAL_TOOLBAR_VISIBLE (f, RIGHT_TOOLBAR)
|
|
|
728
|
|
398
|
729 #define FRAME_TOP_BORDER_START(f) \
|
|
|
730 (FRAME_REAL_TOP_TOOLBAR_HEIGHT (f) + \
|
|
215
|
731 2 * FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH (f))
|
|
398
|
732 #define FRAME_TOP_BORDER_END(f) \
|
|
0
|
733 (FRAME_TOP_BORDER_START (f) + FRAME_BORDER_HEIGHT (f))
|
|
|
734
|
|
398
|
735 #define FRAME_BOTTOM_BORDER_START(f) \
|
|
|
736 (FRAME_PIXHEIGHT (f) - FRAME_BORDER_HEIGHT (f) - \
|
|
|
737 FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) - \
|
|
215
|
738 2 * FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f))
|
|
398
|
739 #define FRAME_BOTTOM_BORDER_END(f) \
|
|
|
740 (FRAME_PIXHEIGHT (f) - FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) - \
|
|
215
|
741 2 * FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f))
|
|
0
|
742
|
|
398
|
743 #define FRAME_LEFT_BORDER_START(f) \
|
|
|
744 (FRAME_REAL_LEFT_TOOLBAR_WIDTH (f) + \
|
|
215
|
745 2 * FRAME_REAL_LEFT_TOOLBAR_BORDER_WIDTH (f))
|
|
398
|
746 #define FRAME_LEFT_BORDER_END(f) \
|
|
0
|
747 (FRAME_LEFT_BORDER_START (f) + FRAME_BORDER_WIDTH (f))
|
|
|
748
|
|
398
|
749 #define FRAME_RIGHT_BORDER_START(f) \
|
|
|
750 (FRAME_PIXWIDTH (f) - FRAME_BORDER_WIDTH (f) - \
|
|
|
751 FRAME_REAL_RIGHT_TOOLBAR_WIDTH(f) - \
|
|
235
|
752 2 * FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH (f))
|
|
398
|
753 #define FRAME_RIGHT_BORDER_END(f) \
|
|
|
754 (FRAME_PIXWIDTH (f) - FRAME_REAL_RIGHT_TOOLBAR_WIDTH (f) - \
|
|
215
|
755 2 * FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH(f))
|
|
0
|
756
|
|
|
757 /* Equivalent in FSF Emacs:
|
|
|
758
|
|
|
759 FOR_EACH_FRAME (LIST_VAR, FRAME_VAR) followed by a statement is a
|
|
|
760 `for' loop which iterates over the elements of Vframe_list. The
|
|
|
761 loop will set FRAME_VAR, a Lisp_Object, to each frame in
|
|
|
762 Vframe_list in succession and execute the statement. LIST_VAR
|
|
|
763 should be a Lisp_Object too; it is used to iterate through the
|
|
|
764 Vframe_list.
|
|
|
765 */
|
|
|
766
|
|
|
767 /* NO_BREAK means that "break" doesn't do what you think it does!
|
|
|
768 Use goto instead. "continue" is OK, though. */
|
|
|
769 #define FRAME_LOOP_NO_BREAK(frmcons, devcons, concons) \
|
|
|
770 DEVICE_LOOP_NO_BREAK (devcons, concons) \
|
|
|
771 DEVICE_FRAME_LOOP (frmcons, XDEVICE (XCAR (devcons)))
|
|
|
772
|
|
|
773 void update_frame_title (struct frame *f);
|
|
|
774 Lisp_Object next_frame (Lisp_Object f, Lisp_Object frametype,
|
|
|
775 Lisp_Object console);
|
|
371
|
776 Lisp_Object prev_frame (Lisp_Object f, Lisp_Object frametype,
|
|
0
|
777 Lisp_Object console);
|
|
|
778 void pixel_to_char_size (struct frame *f, int pixel_width, int pixel_height,
|
|
|
779 int *char_width, int *char_height);
|
|
|
780 void char_to_pixel_size (struct frame *f, int char_width, int char_height,
|
|
|
781 int *pixel_width, int *pixel_height);
|
|
|
782 void round_size_to_char (struct frame *f, int in_width, int in_height,
|
|
|
783 int *out_width, int *out_height);
|
|
269
|
784 void pixel_to_real_char_size (struct frame *f, int pixel_width, int pixel_height,
|
|
|
785 int *char_width, int *char_height);
|
|
|
786 void char_to_real_pixel_size (struct frame *f, int char_width, int char_height,
|
|
|
787 int *pixel_width, int *pixel_height);
|
|
|
788 void round_size_to_real_char (struct frame *f, int in_width, int in_height,
|
|
|
789 int *out_width, int *out_height);
|
|
0
|
790 void change_frame_size (struct frame *frame,
|
|
185
|
791 int newlength, int newwidth,
|
|
0
|
792 int delay);
|
|
282
|
793 void adjust_frame_size (struct frame *frame);
|
|
|
794 void frame_size_slipped (Lisp_Object specifier, struct frame *f,
|
|
|
795 Lisp_Object oldval);
|
|
0
|
796 void hold_frame_size_changes (void);
|
|
|
797 void unhold_one_frame_size_changes (struct frame *f);
|
|
|
798 void unhold_frame_size_changes (void);
|
|
|
799 void select_frame_1 (Lisp_Object frame);
|
|
149
|
800 void select_frame_2 (Lisp_Object frame);
|
|
0
|
801 struct frame *selected_frame (void);
|
|
|
802 struct frame *device_selected_frame (struct device *d);
|
|
|
803 struct frame *decode_frame (Lisp_Object frame);
|
|
|
804 struct frame *decode_frame_or_selected (Lisp_Object cdf);
|
|
|
805 Lisp_Object make_frame (struct frame *f);
|
|
|
806 int other_visible_frames (struct frame *f);
|
|
|
807 void delete_frame_internal (struct frame *f, int force,
|
|
|
808 int called_from_delete_device,
|
|
|
809 int from_io_error);
|
|
|
810 void io_error_delete_frame (Lisp_Object frame);
|
|
|
811 Lisp_Object find_some_frame (int (*predicate) (Lisp_Object, void *),
|
|
|
812 void *closure);
|
|
371
|
813 int device_matches_console_spec (Lisp_Object frame, Lisp_Object device,
|
|
|
814 Lisp_Object console);
|
|
0
|
815 Lisp_Object frame_first_window (struct frame *f);
|
|
|
816 int show_gc_cursor (struct frame *f, Lisp_Object cursor);
|
|
|
817 void set_frame_selected_window (struct frame *f, Lisp_Object window);
|
|
|
818 int is_surrogate_for_selected_frame (struct frame *f);
|
|
|
819 void update_frame_icon (struct frame *f);
|
|
284
|
820 void invalidate_vertical_divider_cache_in_frame (struct frame *f);
|
|
0
|
821
|
|
398
|
822 void init_frame (void);
|
|
|
823
|
|
|
824 #endif /* INCLUDED_frame_h_ */
|
