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