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   unsigned 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   unsigned 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 subwindows_changed :1;
 192   unsigned int subwindows_state_changed :1;
 193   unsigned int glyphs_changed :1;
 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;
 200   unsigned int gutter_changed :1;
 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 */
 204   unsigned int echo_area_garbaged :1;   /* used by Fredisplay_echo_area */
 205   unsigned int size_slipped :1;
 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 */
 211   unsigned int subwindows_being_displayed :1;
 212 };
 213
 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);
 224 EXFUN (Fset_frame_properties, 2);
 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
 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 wrap_frame(p) wrap_object (p)
 249 #define FRAMEP(x) RECORDP (x, frame)
 250 #define CHECK_FRAME(x) CHECK_RECORD (x, frame)
 251 #define CONCHECK_FRAME(x) CONCHECK_RECORD (x, frame)
 252
 253 #define CHECK_LIVE_FRAME(x) do {                        \
 254   CHECK_FRAME (x);                                      \
 255   if (! FRAME_LIVE_P (XFRAME (x)))                      \
 256     dead_wrong_type_argument (Qframe_live_p, (x));      \
 257 } while (0)
 258 #define CONCHECK_LIVE_FRAME(x) do {                     \
 259   CONCHECK_FRAME (x);                                   \
 260   if (! FRAME_LIVE_P (XFRAME (x)))                      \
 261     x = wrong_type_argument (Qframe_live_p, (x));       \
 262 } while (0)
 263
 264 #define FRAME_TYPE_P(f, type)   EQ (FRAME_TYPE (f), Q##type)
 265
 266 #ifdef ERROR_CHECK_TYPECHECK
 267 INLINE_HEADER struct frame *
 268 error_check_frame_type (struct frame * f, Lisp_Object sym);
 269 INLINE_HEADER struct frame *
 270 error_check_frame_type (struct frame * f, Lisp_Object sym)
 271 {
 272   assert (EQ (FRAME_TYPE (f), sym));
 273   return f;
 274 }
 275 # define FRAME_TYPE_DATA(f, type)                       \
 276  ((struct type##_frame *) error_check_frame_type (f, Q##type)->frame_data)
 277 #else
 278 # define FRAME_TYPE_DATA(f, type)                       \
 279   ((struct type##_frame *) (f)->frame_data)
 280 #endif
 281
 282 #define CHECK_FRAME_TYPE(x, type)                       \
 283   do {                                                  \
 284     CHECK_FRAME (x);                                    \
 285     if (!FRAME_TYPE_P (XFRAME (x), type))               \
 286       dead_wrong_type_argument                          \
 287         (type##_console_methods->predicate_symbol, x);  \
 288   } while (0)
 289 #define CONCHECK_FRAME_TYPE(x, type)                    \
 290   do {                                                  \
 291     CONCHECK_FRAME (x);                                 \
 292     if (!FRAME_TYPE_P (XFRAME (x), type))               \
 293       x = wrong_type_argument                           \
 294         (type##_console_methods->predicate_symbol, x);  \
 295   } while (0)
 296
 297 #define FRAME_DISPLAY_P(frm)                            \
 298   (DEVICE_DISPLAY_P (XDEVICE (FRAME_DEVICE (frm))))
 299
 300 #define CHECK_DISPLAY_FRAME(frm)                        \
 301   do {                                                  \
 302     CHECK_FRAME (frm);                                  \
 303     CHECK_LIVE_FRAME (frm);                             \
 304     CHECK_DISPLAY_DEVICE (FRAME_DEVICE (XFRAME (frm))); \
 305   } while (0)
 306
 307 #define CONCHECK_DISPLAY_FRAME(frm)                     \
 308   do {                                                  \
 309     CONCHECK_FRAME (frm);                               \
 310     CONCHECK_LIVE_FRAME (frm);                          \
 311     CONCHECK_DISPLAY_DEVICE (FRAME_DEVICE (XFRAME (frm))); \
 312   } while (0)
 313
 314 #define FRAME_PRINTER_P(frm)                            \
 315   (DEVICE_PRINTER_P (XDEVICE (FRAME_DEVICE (frm))))
 316
 317 #define CHECK_PRINTER_FRAME(frm)                        \
 318   do {                                                  \
 319     CHECK_FRAME (frm);                                  \
 320     CHECK_LIVE_FRAME (frm);                             \
 321     CHECK_PRINTER_DEVICE (FRAME_DEVICE (XFRAME (frm))); \
 322   } while (0)
 323
 324 #define CONCHECK_PRINTER_FRAME(frm)                     \
 325   do {                                                  \
 326     CONCHECK_FRAME (frm);                               \
 327     CONCHECK_LIVE_FRAME (frm);                          \
 328     CONCHECK_PRINTER_DEVICE (FRAME_DEVICE (XFRAME (frm))); \
 329   } while (0)
 330
 331 /* #### These should be in the frame-*.h files but there are
 332    too many places where the abstraction is broken.  Need to
 333    fix. */
 334
 335 #define FRAME_X_P(frm) CONSOLE_TYPESYM_X_P (FRAME_TYPE (frm))
 336 #define CHECK_X_FRAME(z) CHECK_FRAME_TYPE (z, x)
 337 #define CONCHECK_X_FRAME(z) CONCHECK_FRAME_TYPE (z, x)
 338
 339 #define FRAME_TTY_P(frm) CONSOLE_TYPESYM_TTY_P (FRAME_TYPE (frm))
 340 #define CHECK_TTY_FRAME(z) CHECK_FRAME_TYPE (z, tty)
 341 #define CONCHECK_TTY_FRAME(z) CONCHECK_FRAME_TYPE (z, tty)
 342
 343 #define FRAME_STREAM_P(frm) CONSOLE_TYPESYM_STREAM_P (FRAME_TYPE (frm))
 344 #define CHECK_STREAM_FRAME(z) CHECK_FRAME_TYPE (z, stream)
 345 #define CONCHECK_STREAM_FRAME(z) CONCHECK_FRAME_TYPE (z, stream)
 346
 347 #define FRAME_WIN_P(frm) CONSOLE_TYPESYM_WIN_P (FRAME_TYPE (frm))
 348
 349 extern int frame_changed;
 350
 351 #define MARK_FRAME_FACES_CHANGED(f) do {                \
 352   struct frame *mffc_f = (f);                           \
 353   mffc_f->faces_changed = 1;                            \
 354   mffc_f->modiff++;                                     \
 355   if (!NILP (mffc_f->device))                           \
 356     {                                                   \
 357       struct device *mffc_d = XDEVICE (mffc_f->device); \
 358       MARK_DEVICE_FACES_CHANGED (mffc_d);               \
 359     }                                                   \
 360   else                                                  \
 361     faces_changed = 1;                                  \
 362 } while (0)
 363
 364 #define MARK_FRAME_GLYPHS_CHANGED(f) do {               \
 365   struct frame *mfgc_f = (f);                           \
 366   mfgc_f->glyphs_changed = 1;                           \
 367   mfgc_f->modiff++;                                     \
 368   if (!NILP (mfgc_f->device))                           \
 369     {                                                   \
 370       struct device *mfgc_d = XDEVICE (mfgc_f->device); \
 371       MARK_DEVICE_GLYPHS_CHANGED (mfgc_d);              \
 372     }                                                   \
 373   else                                                  \
 374     glyphs_changed = 1;                                 \
 375 } while (0)
 376
 377 #define MARK_FRAME_SUBWINDOWS_CHANGED(f) do {           \
 378   struct frame *mfgc_f = (f);                           \
 379   mfgc_f->subwindows_changed = 1;                       \
 380   mfgc_f->modiff++;                                     \
 381   if (!NILP (mfgc_f->device))                           \
 382     {                                                   \
 383       struct device *mfgc_d = XDEVICE (mfgc_f->device); \
 384       MARK_DEVICE_SUBWINDOWS_CHANGED (mfgc_d);          \
 385     }                                                   \
 386   else                                                  \
 387     subwindows_changed = 1;                             \
 388 } while (0)
 389
 390 #define MARK_FRAME_SUBWINDOWS_STATE_CHANGED(f) do {     \
 391   struct frame *mfgc_f = (f);                           \
 392   mfgc_f->subwindows_state_changed = 1;                 \
 393   mfgc_f->modiff++;                                     \
 394   if (!NILP (mfgc_f->device))                           \
 395     {                                                   \
 396       struct device *mfgc_d = XDEVICE (mfgc_f->device); \
 397       MARK_DEVICE_SUBWINDOWS_STATE_CHANGED (mfgc_d);    \
 398     }                                                   \
 399   else                                                  \
 400     subwindows_state_changed = 1;                       \
 401 } while (0)
 402
 403 #define MARK_FRAME_TOOLBARS_CHANGED(f) do {             \
 404   struct frame *mftc_f = (f);                           \
 405   mftc_f->toolbar_changed = 1;                          \
 406   mftc_f->modiff++;                                     \
 407   if (!NILP (mftc_f->device))                           \
 408     {                                                   \
 409       struct device *mftc_d = XDEVICE (mftc_f->device); \
 410       MARK_DEVICE_TOOLBARS_CHANGED (mftc_d);            \
 411     }                                                   \
 412   else                                                  \
 413     toolbar_changed = 1;                                \
 414 } while (0)
 415
 416 #define MARK_FRAME_GUTTERS_CHANGED(f) do {              \
 417   struct frame *mftc_f = (f);                           \
 418   mftc_f->gutter_changed = 1;                           \
 419   mftc_f->modiff++;                                     \
 420   if (!NILP (mftc_f->device))                           \
 421     {                                                   \
 422       struct device *mftc_d = XDEVICE (mftc_f->device); \
 423       MARK_DEVICE_GUTTERS_CHANGED (mftc_d);             \
 424     }                                                   \
 425   else                                                  \
 426     gutter_changed = 1;                                 \
 427 } while (0)
 428
 429 #define MARK_FRAME_SIZE_CHANGED(f) do {                 \
 430   struct frame *mfsc_f = (f);                           \
 431   mfsc_f->size_changed = 1;                             \
 432   mfsc_f->size_change_pending = 1;                      \
 433   mfsc_f->modiff++;                                     \
 434   if (!NILP (mfsc_f->device))                           \
 435     {                                                   \
 436       struct device *mfsc_d = XDEVICE (mfsc_f->device); \
 437       MARK_DEVICE_SIZE_CHANGED (mfsc_d);                \
 438     }                                                   \
 439   else                                                  \
 440     size_changed = 1;                                   \
 441 } while (0)
 442
 443 #define MARK_FRAME_CHANGED(f) do {                      \
 444   struct frame *mfc_f = (f);                            \
 445   mfc_f->frame_changed = 1;                             \
 446   mfc_f->modiff++;                                      \
 447   if (!NILP (mfc_f->device))                            \
 448     {                                                   \
 449       struct device *mfc_d = XDEVICE (mfc_f->device);   \
 450       MARK_DEVICE_FRAME_CHANGED (mfc_d);                \
 451     }                                                   \
 452   else                                                  \
 453     frame_changed = 1;                                  \
 454 } while (0)
 455
 456 #define MARK_FRAME_WINDOWS_CHANGED(f) do {              \
 457   struct frame *mfwc_f = (f);                           \
 458   mfwc_f->windows_changed = 1;                          \
 459   mfwc_f->modiff++;                                     \
 460   if (!NILP (mfwc_f->device))                           \
 461     {                                                   \
 462       struct device *mfwc_d = XDEVICE (mfwc_f->device); \
 463       MARK_DEVICE_WINDOWS_CHANGED (mfwc_d);             \
 464     }                                                   \
 465   else                                                  \
 466     windows_changed = 1;                                \
 467 } while (0)
 468
 469 #define MARK_FRAME_WINDOWS_STRUCTURE_CHANGED(f) do {    \
 470   struct frame *fwsc_f = (f);                           \
 471   fwsc_f->windows_structure_changed = 1;                \
 472   fwsc_f->modiff++;                                     \
 473   if (!NILP (fwsc_f->device))                           \
 474     {                                                   \
 475       struct device *fwsc_d = XDEVICE (fwsc_f->device); \
 476       MARK_DEVICE_WINDOWS_STRUCTURE_CHANGED (fwsc_d);   \
 477     }                                                   \
 478   else                                                  \
 479     windows_structure_changed = 1;                      \
 480   invalidate_vertical_divider_cache_in_frame (fwsc_f);  \
 481 } while (0)
 482
 483 #define MARK_FRAME_SIZE_SLIPPED(f) do {                 \
 484   struct frame *fwsc_f = (f);                           \
 485   fwsc_f->size_slipped = 1;                             \
 486   fwsc_f->modiff++;                                     \
 487   if (!NILP (fwsc_f->device))                           \
 488     {                                                   \
 489       struct device *fwsc_d = XDEVICE (fwsc_f->device); \
 490       MARK_DEVICE_FRAME_CHANGED (fwsc_d);               \
 491     }                                                   \
 492   else                                                  \
 493     frame_changed = 1;                                  \
 494 } while (0)
 495
 496 #define CLEAR_FRAME_SIZE_SLIPPED(f) do {                \
 497   struct frame *fwsc_f = (f);                           \
 498   fwsc_f->size_slipped = 0;                             \
 499 } while (0)
 500
 501 #define SET_FRAME_CLEAR(f) MARK_FRAME_CHANGED (f); (f)->clear = 1
 502 #define FRAME_DEVICE(f) ((f)->device)
 503 #define FRAME_CONSOLE(f) DEVICE_CONSOLE (XDEVICE (FRAME_DEVICE (f)))
 504 #define FRAME_LIVE_P(f) (!(f)->dead)
 505
 506 #define FRAME_MINIBUF_ONLY_P(f) \
 507   EQ (FRAME_ROOT_WINDOW (f), FRAME_MINIBUF_WINDOW (f))
 508 #define FRAME_HAS_MINIBUF_P(f)  ((f)->has_minibuffer)
 509 #define FRAME_HEIGHT(f)         ((f)->height)
 510 #define FRAME_WIDTH(f)          ((f)->width)
 511 #define FRAME_CHARHEIGHT(f)     ((f)->char_height)
 512 #define FRAME_CHARWIDTH(f)      ((f)->char_width)
 513 #define FRAME_PIXHEIGHT(f)      ((f)->pixheight)
 514 #define FRAME_PIXWIDTH(f)       ((f)->pixwidth)
 515 #define FRAME_PAGENUMBER(f)     ((f)->page_number + 0)
 516 #define FRAME_SET_PAGENUMBER(f,x) (f)->page_number = (x);
 517 #ifdef HAVE_SCROLLBARS
 518 #define FRAME_SCROLLBAR_WIDTH(f)                \
 519   (NILP ((f)->vertical_scrollbar_visible_p) ?   \
 520     0 : XINT ((f)->scrollbar_width))
 521 #define FRAME_SCROLLBAR_HEIGHT(f)               \
 522   (NILP ((f)->horizontal_scrollbar_visible_p) ? \
 523     0 : XINT ((f)->scrollbar_height))
 524 #else
 525 #define FRAME_SCROLLBAR_WIDTH(f) 0
 526 #define FRAME_SCROLLBAR_HEIGHT(f) 0
 527 #endif
 528
 529 #define FW_FRAME(obj)                                   \
 530    (WINDOWP (obj) ? WINDOW_FRAME (XWINDOW (obj))        \
 531     : (FRAMEP  (obj) ? obj                              \
 532        : Qnil))
 533
 534 #define FRAME_NEW_HEIGHT(f) ((f)->new_height)
 535 #define FRAME_NEW_WIDTH(f) ((f)->new_width)
 536 #define FRAME_CURSOR_X(f) ((f)->cursor_x)
 537 #define FRAME_CURSOR_Y(f) ((f)->cursor_y)
 538 #define FRAME_VISIBLE_P(f) ((f)->visible)
 539 #define FRAME_REPAINT_P(f) ((f)->visible>0)
 540 #define FRAME_NO_SPLIT_P(f) ((f)->no_split)
 541 #define FRAME_ICONIFIED_P(f) ((f)->iconified)
 542 #define FRAME_FOCUS_FRAME(f) ((f)->focus_frame)
 543 #define FRAME_MINIBUF_WINDOW(f) ((f)->minibuffer_window)
 544 #define FRAME_ROOT_WINDOW(f) ((f)->root_window)
 545 /* Catch people attempting to set this. */
 546 #define FRAME_SELECTED_WINDOW(f) NON_LVALUE ((f)->selected_window)
 547 #define FRAME_LAST_NONMINIBUF_WINDOW(f) \
 548   NON_LVALUE ((f)->last_nonminibuf_window)
 549 #define FRAME_SB_VCACHE(f) ((f)->sb_vcache)
 550 #define FRAME_SB_HCACHE(f) ((f)->sb_hcache)
 551 #define FRAME_SUBWINDOW_CACHE(f) ((f)->subwindow_instance_cache)
 552
 553 #if 0 /* FSFmacs */
 554
 555 #define FRAME_VISIBLE_P(f) ((f)->visible != 0)
 556 #define FRAME_SET_VISIBLE(f,p) \
 557   ((f)->async_visible = (p), FRAME_SAMPLE_VISIBILITY (f))
 558
 559 /* Emacs's redisplay code could become confused if a frame's
 560    visibility changes at arbitrary times.  For example, if a frame is
 561    visible while the desired glyphs are being built, but becomes
 562    invisible before they are updated, then some rows of the
 563    desired_glyphs will be left marked as enabled after redisplay is
 564    complete, which should never happen.  The next time the frame
 565    becomes visible, redisplay will probably barf.
 566
 567    Currently, there are no similar situations involving iconified, but
 568    the principle is the same.
 569
 570    So instead of having asynchronous input handlers directly set and
 571    clear the frame's visibility and iconification flags, they just set
 572    the async_visible and async_iconified flags; the redisplay code
 573    calls the FRAME_SAMPLE_VISIBILITY macro before doing any redisplay,
 574    which sets visible and iconified from their asynchronous
 575    counterparts.
 576
 577    Synchronous code must use the FRAME_SET_VISIBLE macro.
 578
 579    Also, if a frame used to be invisible, but has just become visible,
 580    it must be marked as garbaged, since redisplay hasn't been keeping
 581    up its contents.  */
 582 #define FRAME_SAMPLE_VISIBILITY(f) \
 583   (((f)->async_visible && ! (f)->visible) ? SET_FRAME_GARBAGED (f) : 0, \
 584    (f)->visible = (f)->async_visible, \
 585    (f)->iconified = (f)->async_iconified)
 586
 587 #endif /* FSFmacs */
 588
 589 #define FRAME_BORDER_WIDTH(f) ((f)->internal_border_width)
 590 #define FRAME_BORDER_HEIGHT(f) ((f)->internal_border_width)
 591
 592 /* This returns the frame-local value; that tells you what you should
 593    use when computing the frame size.  It is *not* the actual toolbar
 594    size because that depends on the selected window.  Use the macros
 595    below for that.
 596 */
 597
 598 #ifdef HAVE_TOOLBARS
 599 #define FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE(f, pos) \
 600   (!NILP((f)->toolbar_buttons[pos]) && !NILP ((f)->toolbar_visible_p[pos]))
 601 #define FRAME_RAW_THEORETICAL_TOOLBAR_SIZE(f, pos) \
 602   (!NILP ((f)->toolbar_buttons[pos]) && INTP((f)->toolbar_size[pos]) ? \
 603    (XINT ((f)->toolbar_size[pos])) : 0)
 604 #define FRAME_RAW_THEORETICAL_TOOLBAR_BORDER_WIDTH(f, pos) \
 605   (!NILP ((f)->toolbar_buttons[pos]) && INTP((f)->toolbar_border_width[pos]) ? \
 606    (XINT ((f)->toolbar_border_width[pos])) : 0)
 607 #else
 608 #define FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE(f, pos) 0
 609 #define FRAME_RAW_THEORETICAL_TOOLBAR_SIZE(f, pos) 0
 610 #define FRAME_RAW_THEORETICAL_TOOLBAR_BORDER_WIDTH(f, pos) 0
 611 #endif
 612
 613 #define FRAME_THEORETICAL_TOOLBAR_SIZE(f, pos)          \
 614   (FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE (f, pos)       \
 615    ? FRAME_RAW_THEORETICAL_TOOLBAR_SIZE (f, pos)        \
 616    : 0)
 617
 618 #define FRAME_THEORETICAL_TOP_TOOLBAR_HEIGHT(f) \
 619   FRAME_THEORETICAL_TOOLBAR_SIZE (f, TOP_TOOLBAR)
 620 #define FRAME_THEORETICAL_BOTTOM_TOOLBAR_HEIGHT(f) \
 621   FRAME_THEORETICAL_TOOLBAR_SIZE (f, BOTTOM_TOOLBAR)
 622 #define FRAME_THEORETICAL_LEFT_TOOLBAR_WIDTH(f) \
 623   FRAME_THEORETICAL_TOOLBAR_SIZE (f, LEFT_TOOLBAR)
 624 #define FRAME_THEORETICAL_RIGHT_TOOLBAR_WIDTH(f) \
 625   FRAME_THEORETICAL_TOOLBAR_SIZE (f, RIGHT_TOOLBAR)
 626
 627 #define FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH(f, pos)          \
 628   (FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE (f, pos)               \
 629    ? FRAME_RAW_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, pos)        \
 630    : 0)
 631
 632 #define FRAME_THEORETICAL_TOP_TOOLBAR_BORDER_WIDTH(f) \
 633   FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, TOP_TOOLBAR)
 634 #define FRAME_THEORETICAL_BOTTOM_TOOLBAR_BORDER_WIDTH(f) \
 635   FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, BOTTOM_TOOLBAR)
 636 #define FRAME_THEORETICAL_LEFT_TOOLBAR_BORDER_WIDTH(f) \
 637   FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, LEFT_TOOLBAR)
 638 #define FRAME_THEORETICAL_RIGHT_TOOLBAR_BORDER_WIDTH(f) \
 639   FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, RIGHT_TOOLBAR)
 640
 641 /* This returns the window-local value rather than the frame-local value;
 642    that tells you about what's actually visible rather than what should
 643    be used when computing the frame size. */
 644
 645 #ifdef HAVE_TOOLBARS
 646 #define FRAME_RAW_REAL_TOOLBAR_VISIBLE(f, pos) \
 647   (HAS_DEVMETH_P (XDEVICE (FRAME_DEVICE (f)), initialize_frame_toolbars) \
 648    && !NILP (XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_visible_p[pos]))
 649 #define FRAME_RAW_REAL_TOOLBAR_BORDER_WIDTH(f, pos) \
 650      ((INTP (XWINDOW \
 651              (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_border_width[pos])) ? \
 652       (XINT (XWINDOW \
 653              (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_border_width[pos])) \
 654       : 0)
 655 #define FRAME_RAW_REAL_TOOLBAR_SIZE(f, pos) \
 656      ((INTP (XWINDOW \
 657              (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_size[pos])) ? \
 658       (XINT (XWINDOW \
 659              (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_size[pos])) : 0)
 660 #define FRAME_REAL_TOOLBAR(f, pos) \
 661   (XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar[pos])
 662 #else
 663 #define FRAME_RAW_REAL_TOOLBAR_VISIBLE(f, pos) 0
 664 #define FRAME_RAW_REAL_TOOLBAR_BORDER_WIDTH(f, pos) 0
 665 #define FRAME_RAW_REAL_TOOLBAR_SIZE(f, pos) 0
 666 #define FRAME_REAL_TOOLBAR(f, pos) Qnil
 667 #endif
 668
 669 /* Note to Chuck
 670    Note to Chuck
 671    Note to Chuck:
 672
 673    The former definitions of FRAME_REAL_FOO_TOOLBAR_VISIBLE
 674    looked at the toolbar data to see what was there.  The
 675    current ones look at the current values of the specifiers.
 676    This is a semantic change; the former definition returned
 677    what was *actually* there right at the moment, while the
 678    current one returns what *ought* to be there once redisplay
 679    has run to completion.  I think this new definition is more
 680    correct in almost all circumstances and is much less likely
 681    to lead to strange race conditions.  I'm not completely
 682    sure that there aren't some places in the redisplay code
 683    that use these macros and expect the former semantics, so
 684    if you encounter some odd toolbar behavior, you might want
 685    to look into this. --ben */
 686
 687 #define FRAME_REAL_TOOLBAR_VISIBLE(f, pos)              \
 688   ((!NILP (FRAME_REAL_TOOLBAR (f, pos))                 \
 689   && FRAME_RAW_REAL_TOOLBAR_SIZE (f, pos) > 0)          \
 690    ? FRAME_RAW_REAL_TOOLBAR_VISIBLE (f, pos)            \
 691    : 0)
 692 #define FRAME_REAL_TOOLBAR_SIZE(f, pos)                 \
 693   ((!NILP (FRAME_REAL_TOOLBAR (f, pos))                 \
 694   && FRAME_RAW_REAL_TOOLBAR_VISIBLE (f, pos))           \
 695    ? FRAME_RAW_REAL_TOOLBAR_SIZE (f, pos)               \
 696    : 0)
 697 #define FRAME_REAL_TOOLBAR_BORDER_WIDTH(f, pos)         \
 698   ((!NILP (FRAME_REAL_TOOLBAR (f, pos))                 \
 699   && FRAME_RAW_REAL_TOOLBAR_VISIBLE (f, pos))           \
 700    ? FRAME_RAW_REAL_TOOLBAR_BORDER_WIDTH (f, pos)       \
 701    : 0)
 702
 703 #define FRAME_REAL_TOP_TOOLBAR_HEIGHT(f) \
 704   FRAME_REAL_TOOLBAR_SIZE (f, TOP_TOOLBAR)
 705 #define FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT(f) \
 706   FRAME_REAL_TOOLBAR_SIZE (f, BOTTOM_TOOLBAR)
 707 #define FRAME_REAL_LEFT_TOOLBAR_WIDTH(f) \
 708   FRAME_REAL_TOOLBAR_SIZE (f, LEFT_TOOLBAR)
 709 #define FRAME_REAL_RIGHT_TOOLBAR_WIDTH(f) \
 710   FRAME_REAL_TOOLBAR_SIZE (f, RIGHT_TOOLBAR)
 711
 712 #define FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH(f) \
 713   FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, TOP_TOOLBAR)
 714 #define FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH(f) \
 715   FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, BOTTOM_TOOLBAR)
 716 #define FRAME_REAL_LEFT_TOOLBAR_BORDER_WIDTH(f) \
 717   FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, LEFT_TOOLBAR)
 718 #define FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH(f) \
 719   FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, RIGHT_TOOLBAR)
 720
 721 #define FRAME_REAL_TOP_TOOLBAR_VISIBLE(f) \
 722   FRAME_REAL_TOOLBAR_VISIBLE (f, TOP_TOOLBAR)
 723 #define FRAME_REAL_BOTTOM_TOOLBAR_VISIBLE(f) \
 724   FRAME_REAL_TOOLBAR_VISIBLE (f, BOTTOM_TOOLBAR)
 725 #define FRAME_REAL_LEFT_TOOLBAR_VISIBLE(f) \
 726   FRAME_REAL_TOOLBAR_VISIBLE (f, LEFT_TOOLBAR)
 727 #define FRAME_REAL_RIGHT_TOOLBAR_VISIBLE(f) \
 728   FRAME_REAL_TOOLBAR_VISIBLE (f, RIGHT_TOOLBAR)
 729
 730 #define FRAME_TOP_BORDER_START(f)                               \
 731   (FRAME_REAL_TOP_TOOLBAR_HEIGHT (f) +                          \
 732    2 * FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH (f))
 733 #define FRAME_TOP_BORDER_END(f)                                 \
 734   (FRAME_TOP_BORDER_START (f) + FRAME_BORDER_HEIGHT (f))
 735
 736 #define FRAME_BOTTOM_BORDER_START(f)                            \
 737   (FRAME_PIXHEIGHT (f) - FRAME_BORDER_HEIGHT (f) -              \
 738    FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) -                       \
 739    2 * FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f))
 740 #define FRAME_BOTTOM_BORDER_END(f)                              \
 741   (FRAME_PIXHEIGHT (f) - FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) - \
 742    2 * FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f))
 743
 744 #define FRAME_LEFT_BORDER_START(f)                              \
 745   (FRAME_REAL_LEFT_TOOLBAR_WIDTH (f) +                          \
 746    2 * FRAME_REAL_LEFT_TOOLBAR_BORDER_WIDTH (f))
 747 #define FRAME_LEFT_BORDER_END(f)                                \
 748   (FRAME_LEFT_BORDER_START (f) + FRAME_BORDER_WIDTH (f))
 749
 750 #define FRAME_RIGHT_BORDER_START(f)                             \
 751   (FRAME_PIXWIDTH (f) - FRAME_BORDER_WIDTH (f) -                \
 752    FRAME_REAL_RIGHT_TOOLBAR_WIDTH(f) -                          \
 753    2 * FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH (f))
 754 #define FRAME_RIGHT_BORDER_END(f)                               \
 755   (FRAME_PIXWIDTH (f) - FRAME_REAL_RIGHT_TOOLBAR_WIDTH (f) -    \
 756    2 * FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH(f))
 757
 758 /* Equivalent in FSF Emacs:
 759
 760    FOR_EACH_FRAME (LIST_VAR, FRAME_VAR) followed by a statement is a
 761    `for' loop which iterates over the elements of Vframe_list.  The
 762    loop will set FRAME_VAR, a Lisp_Object, to each frame in
 763    Vframe_list in succession and execute the statement.  LIST_VAR
 764    should be a Lisp_Object too; it is used to iterate through the
 765    Vframe_list.
 766    */
 767
 768 /* NO_BREAK means that "break" doesn't do what you think it does!
 769    Use goto instead.  "continue" is OK, though. */
 770 #define FRAME_LOOP_NO_BREAK(frmcons, devcons, concons)          \
 771   DEVICE_LOOP_NO_BREAK (devcons, concons)                       \
 772     DEVICE_FRAME_LOOP (frmcons, XDEVICE (XCAR (devcons)))
 773
 774 void update_frame_title (struct frame *f);
 775 Lisp_Object next_frame (Lisp_Object, Lisp_Object, Lisp_Object);
 776 Lisp_Object previous_frame (Lisp_Object, Lisp_Object, Lisp_Object);
 777 void pixel_to_char_size (struct frame *f, int pixel_width, int pixel_height,
 778                          int *char_width, int *char_height);
 779 void char_to_pixel_size (struct frame *f, int char_width, int char_height,
 780                          int *pixel_width, int *pixel_height);
 781 void round_size_to_char (struct frame *f, int in_width, int in_height,
 782                          int *out_width, int *out_height);
 783 void pixel_to_real_char_size (struct frame *f, int pixel_width, int pixel_height,
 784                          int *char_width, int *char_height);
 785 void char_to_real_pixel_size (struct frame *f, int char_width, int char_height,
 786                          int *pixel_width, int *pixel_height);
 787 void round_size_to_real_char (struct frame *f, int in_width, int in_height,
 788                               int *out_width, int *out_height);
 789 void change_frame_size (struct frame *frame,
 790                         int newlength, int newwidth,
 791                         int delay);
 792 void adjust_frame_size (struct frame *frame);
 793 void frame_size_slipped (Lisp_Object specifier, struct frame *f,
 794                          Lisp_Object oldval);
 795 void hold_frame_size_changes (void);
 796 void unhold_one_frame_size_changes (struct frame *f);
 797 void unhold_frame_size_changes (void);
 798 void select_frame_1 (Lisp_Object frame);
 799 void select_frame_2 (Lisp_Object frame);
 800 struct frame *selected_frame (void);
 801 struct frame *device_selected_frame (struct device *d);
 802 struct frame *decode_frame (Lisp_Object frame);
 803 struct frame *decode_frame_or_selected (Lisp_Object cdf);
 804 Lisp_Object make_frame (struct frame *f);
 805 int other_visible_frames (struct frame *f);
 806 void delete_frame_internal (struct frame *f, int force,
 807                             int called_from_delete_device,
 808                             int from_io_error);
 809 void io_error_delete_frame (Lisp_Object frame);
 810 Lisp_Object find_some_frame (int (*predicate) (Lisp_Object, void *),
 811                              void *closure);
 812 int device_matches_device_spec (Lisp_Object device, Lisp_Object device_spec);
 813 Lisp_Object frame_first_window (struct frame *f);
 814 int show_gc_cursor (struct frame *f, Lisp_Object cursor);
 815 void set_frame_selected_window (struct frame *f, Lisp_Object window);
 816 int is_surrogate_for_selected_frame (struct frame *f);
 817 void update_frame_icon (struct frame *f);
 818 void invalidate_vertical_divider_cache_in_frame (struct frame *f);
 819
 820 void init_frame (void);
 821
 822 #endif /* INCLUDED_frame_h_ */