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