git.chise.org Git - chise/xemacs-chise.git.1/blob - 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_ */