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