src/frame.h

   1 /* Don't multiply include: dispextern.h includes macterm.h which includes frame.h
   2    some emacs source includes both dispextern.h and frame.h */
   3 #ifndef _XFRAME_H_
   4 #define _XFRAME_H_
   5
   6 /* Define frame-object for GNU Emacs.
   7    Copyright (C) 1993, 1994 Free Software Foundation, Inc.
   8
   9 This file is part of GNU Emacs.
  10
  11 GNU Emacs is free software; you can redistribute it and/or modify
  12 it under the terms of the GNU General Public License as published by
  13 the Free Software Foundation; either version 2, or (at your option)
  14 any later version.
  15
  16 GNU Emacs is distributed in the hope that it will be useful,
  17 but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 GNU General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with GNU Emacs; see the file COPYING.  If not, write to
  23 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  24 Boston, MA 02111-1307, USA.  */
  25
  26 \f
  27 /* Miscellanea.  */
  28
  29 /* Nonzero means don't assume anything about current contents of
  30    actual terminal frame */
  31
  32 extern int frame_garbaged;
  33
  34 /* Nonzero means FRAME_MESSAGE_BUF (selected_frame) is being used by
  35    print.  */
  36
  37 extern int message_buf_print;
  38
  39 \f
  40 /* The structure representing a frame.  */
  41
  42 enum output_method
  43 {
  44   output_termcap,
  45   output_x_window,
  46   output_msdos_raw,
  47   output_w32,
  48   output_mac
  49 };
  50
  51 enum vertical_scroll_bar_type
  52 {
  53   vertical_scroll_bar_none,
  54   vertical_scroll_bar_left,
  55   vertical_scroll_bar_right
  56 };
  57
  58 #if !defined(MSDOS) && !defined(WINDOWSNT) && !defined(macintosh)
  59
  60 #if !defined(HAVE_X_WINDOWS)
  61
  62 #define PIX_TYPE int
  63
  64 /* A (mostly empty) x_output structure definition for building Emacs
  65    on Unix and GNU/Linux without X support.  */
  66 struct x_output
  67 {
  68   PIX_TYPE background_pixel;
  69   PIX_TYPE foreground_pixel;
  70 };
  71
  72 #endif /* ! HAVE_X_WINDOWS */
  73
  74
  75 #define FRAME_FOREGROUND_PIXEL(f) ((f)->output_data.x->foreground_pixel)
  76 #define FRAME_BACKGROUND_PIXEL(f) ((f)->output_data.x->background_pixel)
  77
  78 /* A structure describing a termcap frame display.  */
  79 extern struct x_output tty_display;
  80
  81 #endif /* ! MSDOS && ! WINDOWSNT && ! macintosh */
  82
  83 struct frame
  84 {
  85   EMACS_INT size;
  86   struct Lisp_Vector *next;
  87
  88   /* All Lisp_Object components must come first.
  89      Only EMACS_INT values can be intermixed with them.
  90      That ensures they are all aligned normally.  */
  91
  92   /* Name of this frame: a Lisp string.  It is used for looking up resources,
  93      as well as for the title in some cases.  */
  94   Lisp_Object name;
  95
  96   /* The name to use for the icon, the last time
  97      it was refreshed.  nil means not explicitly specified.  */
  98   Lisp_Object icon_name;
  99
 100   /* This is the frame title specified explicitly, if any.
 101      Usually it is nil.  */
 102   Lisp_Object title;
 103
 104   /* The frame which should receive keystrokes that occur in this
 105      frame, or nil if they should go to the frame itself.  This is
 106      usually nil, but if the frame is minibufferless, we can use this
 107      to redirect keystrokes to a surrogate minibuffer frame when
 108      needed.
 109
 110      Note that a value of nil is different than having the field point
 111      to the frame itself.  Whenever the Fselect_frame function is used
 112      to shift from one frame to the other, any redirections to the
 113      original frame are shifted to the newly selected frame; if
 114      focus_frame is nil, Fselect_frame will leave it alone.  */
 115   Lisp_Object focus_frame;
 116
 117   /* This frame's root window.  Every frame has one.
 118      If the frame has only a minibuffer window, this is it.
 119      Otherwise, if the frame has a minibuffer window, this is its sibling.  */
 120   Lisp_Object root_window;
 121
 122   /* This frame's selected window.
 123      Each frame has its own window hierarchy
 124      and one of the windows in it is selected within the frame.
 125      The selected window of the selected frame is Emacs's selected window.  */
 126   Lisp_Object selected_window;
 127
 128   /* This frame's minibuffer window.
 129      Most frames have their own minibuffer windows,
 130      but only the selected frame's minibuffer window
 131      can actually appear to exist.  */
 132   Lisp_Object minibuffer_window;
 133
 134   /* Parameter alist of this frame.
 135      These are the parameters specified when creating the frame
 136      or modified with modify-frame-parameters.  */
 137   Lisp_Object param_alist;
 138
 139   /* List of scroll bars on this frame.
 140      Actually, we don't specify exactly what is stored here at all; the
 141      scroll bar implementation code can use it to store anything it likes.
 142      This field is marked by the garbage collector.  It is here
 143      instead of in the `display' structure so that the garbage
 144      collector doesn't need to look inside the window-system-dependent
 145      structure.  */
 146   Lisp_Object scroll_bars;
 147   Lisp_Object condemned_scroll_bars;
 148
 149   /* Vector describing the items to display in the menu bar.
 150      Each item has four elements in this vector.
 151      They are KEY, STRING, SUBMAP, and HPOS.
 152      (HPOS is not used in when the X toolkit is in use.)
 153      There are four additional elements of nil at the end, to terminate.  */
 154   Lisp_Object menu_bar_items;
 155
 156   /* Alist of elements (FACE-NAME . FACE-VECTOR-DATA).  */
 157   Lisp_Object face_alist;
 158
 159   /* A vector that records the entire structure of this frame's menu bar.
 160      For the format of the data, see extensive comments in xmenu.c.
 161      Only the X toolkit version uses this.  */
 162   Lisp_Object menu_bar_vector;
 163   /* Number of elements in the vector that have meaningful data.  */
 164   EMACS_INT menu_bar_items_used;
 165
 166   /* Predicate for selecting buffers for other-buffer.  */
 167   Lisp_Object buffer_predicate;
 168
 169   /* List of buffers viewed in this frame, for other-buffer.  */
 170   Lisp_Object buffer_list;
 171
 172   /* A dummy window used to display menu bars under X when no X
 173      toolkit support is available.  */
 174   Lisp_Object menu_bar_window;
 175
 176   /* A window used to display the tool-bar of a frame.  */
 177   Lisp_Object tool_bar_window;
 178
 179   /* Desired and current tool-bar items.  */
 180   Lisp_Object desired_tool_bar_items, current_tool_bar_items;
 181
 182   /* Desired and current contents displayed in tool_bar_window.  */
 183   Lisp_Object desired_tool_bar_string, current_tool_bar_string;
 184
 185   /* beyond here, there should be no more Lisp_Object components.  */
 186
 187   /* Cache of realized faces.  */
 188   struct face_cache *face_cache;
 189
 190   /* A buffer to hold the frame's name.  We can't use the Lisp
 191      string's pointer (`name', above) because it might get relocated.  */
 192   char *namebuf;
 193
 194   /* Glyph pool and matrix. */
 195   struct glyph_pool *current_pool;
 196   struct glyph_pool *desired_pool;
 197   struct glyph_matrix *desired_matrix;
 198   struct glyph_matrix *current_matrix;
 199
 200   /* 1 means that glyphs on this frame have been initialized so it can
 201      be used for output.  */
 202   unsigned glyphs_initialized_p : 1;
 203
 204   /* Margin at the top of the frame.  Used to display the tool-bar.  */
 205   int tool_bar_lines;
 206
 207   int n_desired_tool_bar_items;
 208   int n_current_tool_bar_items;
 209
 210   /* A buffer for decode_mode_line. */
 211   char *decode_mode_spec_buffer;
 212
 213   /* See do_line_insertion_deletion_costs for info on these arrays. */
 214   /* Cost of inserting 1 line on this frame */
 215   int *insert_line_cost;
 216   /* Cost of deleting 1 line on this frame */
 217   int *delete_line_cost;
 218   /* Cost of inserting n lines on this frame */
 219   int *insert_n_lines_cost;
 220   /* Cost of deleting n lines on this frame */
 221   int *delete_n_lines_cost;
 222
 223   /* Size of this frame, in units of characters.  */
 224   EMACS_INT height;
 225   EMACS_INT width;
 226   EMACS_INT window_width;
 227   EMACS_INT window_height;
 228
 229   /* New height and width for pending size change.  0 if no change pending.  */
 230   int new_height, new_width;
 231
 232   /* The output method says how the contents of this frame
 233      are displayed.  It could be using termcap, or using an X window.  */
 234   enum output_method output_method;
 235
 236   /* A structure of auxiliary data used for displaying the contents.
 237      struct x_output is used for X window frames;
 238      it is defined in xterm.h.
 239      struct w32_output is used for W32 window frames;
 240      it is defined in w32term.h.  */
 241   union output_data
 242   {
 243     struct x_output *x;
 244     struct w32_output *w32;
 245     struct mac_output *mac;
 246     int nothing;
 247   }
 248   output_data;
 249
 250 #ifdef MULTI_KBOARD
 251   /* A pointer to the kboard structure associated with this frame.
 252      For termcap frames, this points to initial_kboard.  For X frames,
 253      it will be the same as display.x->display_info->kboard.  */
 254   struct kboard *kboard;
 255 #endif
 256
 257   /* Number of lines of menu bar.  */
 258   int menu_bar_lines;
 259
 260 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
 261   /* Nonzero means using a menu bar that comes from the X toolkit.  */
 262   int external_menu_bar;
 263 #endif
 264
 265   /* Nonzero if last attempt at redisplay on this frame was preempted.  */
 266   char display_preempted;
 267
 268   /* visible is nonzero if the frame is currently displayed; we check
 269      it to see if we should bother updating the frame's contents.
 270      DON'T SET IT DIRECTLY; instead, use FRAME_SET_VISIBLE.
 271
 272      Note that, since invisible frames aren't updated, whenever a
 273      frame becomes visible again, it must be marked as garbaged.  The
 274      FRAME_SAMPLE_VISIBILITY macro takes care of this.
 275
 276      On Windows NT/9X, to avoid wasting effort updating visible frames
 277      that are actually completely obscured by other windows on the
 278      display, we bend the meaning of visible slightly: if greater than
 279      1, then the frame is obscured - we still consider it to be
 280      "visible" as seen from lisp, but we don't bother updating it.  We
 281      must take care to garbage the frame when it ceaces to be obscured
 282      though.  Note that these semantics are only used on NT/9X.
 283
 284      iconified is nonzero if the frame is currently iconified.
 285
 286      Asynchronous input handlers should NOT change these directly;
 287      instead, they should change async_visible or async_iconified, and
 288      let the FRAME_SAMPLE_VISIBILITY macro set visible and iconified
 289      at the next redisplay.
 290
 291      These should probably be considered read-only by everyone except
 292      FRAME_SAMPLE_VISIBILITY.
 293
 294      These two are mutually exclusive.  They might both be zero, if the
 295      frame has been made invisible without an icon.  */
 296   char visible, iconified;
 297
 298   /* Asynchronous input handlers change these, and
 299      FRAME_SAMPLE_VISIBILITY copies them into visible and iconified.
 300      See FRAME_SAMPLE_VISIBILITY, below.  */
 301 #ifdef __STDC__
 302   volatile
 303 #endif
 304   char async_visible, async_iconified;
 305
 306   /* Nonzero if this frame should be redrawn.  */
 307 #ifdef __STDC__
 308   volatile
 309 #endif
 310   char garbaged;
 311
 312   /* True if frame actually has a minibuffer window on it.
 313      0 if using a minibuffer window that isn't on this frame.  */
 314   char has_minibuffer;
 315
 316   /* 0 means, if this frame has just one window,
 317      show no modeline for that window.  */
 318   char wants_modeline;
 319
 320   /* Non-zero if the hardware device this frame is displaying on can
 321      support scroll bars.  */
 322   char can_have_scroll_bars;
 323
 324   /* If can_have_scroll_bars is non-zero, this is non-zero if we should
 325      actually display them on this frame.  */
 326   enum vertical_scroll_bar_type vertical_scroll_bar_type;
 327
 328   /* Non-0 means raise this frame to the top of the heap when selected.  */
 329   char auto_raise;
 330
 331   /* Non-0 means lower this frame to the bottom of the stack when left.  */
 332   char auto_lower;
 333
 334   /* True if frame's root window can't be split.  */
 335   char no_split;
 336
 337   /* If this is set, then Emacs won't change the frame name to indicate
 338      the current buffer, etcetera.  If the user explicitly sets the frame
 339      name, this gets set.  If the user sets the name to Qnil, this is
 340      cleared.  */
 341   char explicit_name;
 342
 343   /* Nonzero if size of some window on this frame has changed.  */
 344   char window_sizes_changed;
 345
 346   /* Storage for messages to this frame. */
 347   char *message_buf;
 348
 349   /* Nonnegative if current redisplay should not do scroll computation
 350      for lines beyond a certain vpos.  This is the vpos.  */
 351   int scroll_bottom_vpos;
 352
 353   /* Width of the scroll bar, in pixels and in characters.
 354      scroll_bar_cols tracks scroll_bar_pixel_width if the latter is positive;
 355      a zero value in scroll_bar_pixel_width means to compute the actual width
 356      on the fly, using scroll_bar_cols and the current font width.  */
 357   int scroll_bar_pixel_width;
 358   int scroll_bar_cols;
 359
 360   /* Width of area for drawing truncation marks and overlay arrow.  */
 361   int trunc_area_pixel_width, trunc_area_cols;
 362
 363   /* The baud rate that was used to calculate costs for this frame.  */
 364   int cost_calculation_baud_rate;
 365
 366   /* A pointer to the data structure containing all information of
 367      fontsets associated with this frame.  See the comments in
 368      fontset.h for more detail.  */
 369   struct fontset_data *fontset_data;
 370
 371   /* Nonzero if the mouse has moved on this display
 372      since the last time we checked.  */
 373   char mouse_moved;
 374
 375   /* Exponent for gamma correction of colors.  1/(VIEWING_GAMMA *
 376      SCREEN_GAMMA) where viewing_gamma is 0.4545 and SCREEN_GAMMA is a
 377      frame parameter.  0 means don't do gamma correction.  */
 378   double gamma;
 379 };
 380
 381 #ifdef MULTI_KBOARD
 382 #define FRAME_KBOARD(f) ((f)->kboard)
 383 #else
 384 #define FRAME_KBOARD(f) (&the_only_kboard)
 385 #endif
 386
 387 typedef struct frame *FRAME_PTR;
 388
 389 #define XFRAME(p) ((struct frame *) XPNTR (p))
 390 #define XSETFRAME(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_FRAME))
 391
 392 /* Given a window, return its frame as a Lisp_Object.  */
 393 #define WINDOW_FRAME(w) (w)->frame
 394
 395 /* Test a frame for particular kinds of display methods.  */
 396 #define FRAME_TERMCAP_P(f) ((f)->output_method == output_termcap)
 397 #define FRAME_X_P(f) ((f)->output_method == output_x_window)
 398 #define FRAME_W32_P(f) ((f)->output_method == output_w32)
 399 #define FRAME_MSDOS_P(f) ((f)->output_method == output_msdos_raw)
 400 #define FRAME_MAC_P(f) ((f)->output_method == output_mac)
 401
 402 /* FRAME_WINDOW_P tests whether the frame is a window, and is
 403    defined to be the predicate for the window system being used.  */
 404
 405 #ifdef HAVE_X_WINDOWS
 406 #define FRAME_WINDOW_P(f) FRAME_X_P (f)
 407 #endif
 408 #ifdef HAVE_NTGUI
 409 #define FRAME_WINDOW_P(f) FRAME_W32_P (f)
 410 #endif
 411 #ifdef macintosh
 412 #define FRAME_WINDOW_P(f) FRAME_MAC_P (f)
 413 #endif
 414 #ifndef FRAME_WINDOW_P
 415 #define FRAME_WINDOW_P(f) (0)
 416 #endif
 417
 418 /* Nonzero if frame F is still alive (not deleted).  */
 419 #define FRAME_LIVE_P(f) ((f)->output_data.nothing != 0)
 420
 421 /* Nonzero if frame F is a minibuffer-only frame.  */
 422 #define FRAME_MINIBUF_ONLY_P(f) \
 423   EQ (FRAME_ROOT_WINDOW (f), FRAME_MINIBUF_WINDOW (f))
 424
 425 /* Nonzero if frame F contains a minibuffer window.
 426    (If this is 0, F must use some other minibuffer window.)  */
 427 #define FRAME_HAS_MINIBUF_P(f) ((f)->has_minibuffer)
 428 #define FRAME_HEIGHT(f) (f)->height
 429
 430 /* Width of frame F, measured in character columns,
 431    not including scroll bars if any.  */
 432 #define FRAME_WIDTH(f) (f)->width
 433
 434 /* Number of lines of frame F used for menu bar.
 435    This is relevant on terminal frames and on
 436    X Windows when not using the X toolkit.
 437    These lines are counted in FRAME_HEIGHT.  */
 438 #define FRAME_MENU_BAR_LINES(f) (f)->menu_bar_lines
 439
 440 /* Number of lines of frame F used for the tool-bar.  */
 441
 442 #define FRAME_TOOL_BAR_LINES(f) (f)->tool_bar_lines
 443
 444 /* Lines above the top-most window in frame F.  */
 445
 446 #define FRAME_TOP_MARGIN(F) \
 447      (FRAME_MENU_BAR_LINES (F) + FRAME_TOOL_BAR_LINES (F))
 448
 449 /* Nonzero if this frame should display a menu bar
 450    in a way that does not use any text lines.  */
 451 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
 452 #define FRAME_EXTERNAL_MENU_BAR(f) (f)->external_menu_bar
 453 #else
 454 #define FRAME_EXTERNAL_MENU_BAR(f) 0
 455 #endif
 456 #define FRAME_VISIBLE_P(f) ((f)->visible != 0)
 457
 458 /* Nonzero if frame F is currently visible but hidden.  */
 459 #define FRAME_OBSCURED_P(f) ((f)->visible > 1)
 460
 461 /* Nonzero if frame F is currently iconified.  */
 462 #define FRAME_ICONIFIED_P(f) (f)->iconified
 463
 464 #define FRAME_SET_VISIBLE(f,p) \
 465   ((f)->async_visible = (p), FRAME_SAMPLE_VISIBILITY (f))
 466 #define SET_FRAME_GARBAGED(f) (frame_garbaged = 1, f->garbaged = 1)
 467 #define FRAME_GARBAGED_P(f) (f)->garbaged
 468
 469 /* Nonzero means do not allow splitting this frame's window.  */
 470 #define FRAME_NO_SPLIT_P(f) (f)->no_split
 471
 472 /* Not really implemented.  */
 473 #define FRAME_WANTS_MODELINE_P(f) (f)->wants_modeline
 474
 475 /* Nonzero if a size change has been requested for frame F
 476    but not yet really put into effect.  This can be true temporarily
 477    when an X event comes in at a bad time.  */
 478 #define FRAME_WINDOW_SIZES_CHANGED(f) (f)->window_sizes_changed
 479 /* When a size change is pending, these are the requested new sizes.  */
 480 #define FRAME_NEW_HEIGHT(f) (f)->new_height
 481 #define FRAME_NEW_WIDTH(f) (f)->new_width
 482
 483 /* The minibuffer window of frame F, if it has one; otherwise nil.  */
 484 #define FRAME_MINIBUF_WINDOW(f) (f)->minibuffer_window
 485
 486 /* The root window of the window tree of frame F.  */
 487 #define FRAME_ROOT_WINDOW(f) (f)->root_window
 488
 489 /* The currently selected window of the window tree of frame F.  */
 490 #define FRAME_SELECTED_WINDOW(f) (f)->selected_window
 491
 492 #define FRAME_INSERT_COST(f) (f)->insert_line_cost
 493 #define FRAME_DELETE_COST(f) (f)->delete_line_cost
 494 #define FRAME_INSERTN_COST(f) (f)->insert_n_lines_cost
 495 #define FRAME_DELETEN_COST(f) (f)->delete_n_lines_cost
 496 #define FRAME_MESSAGE_BUF(f) (f)->message_buf
 497 #define FRAME_SCROLL_BOTTOM_VPOS(f) (f)->scroll_bottom_vpos
 498 #define FRAME_FOCUS_FRAME(f) (f)->focus_frame
 499
 500 /* Nonzero if frame F supports scroll bars.
 501    If this is zero, then it is impossible to enable scroll bars
 502    on frame F.  */
 503 #define FRAME_CAN_HAVE_SCROLL_BARS(f) ((f)->can_have_scroll_bars)
 504
 505 /* This frame slot says whether scroll bars are currently enabled for frame F,
 506    and which side they are on.  */
 507 #define FRAME_VERTICAL_SCROLL_BAR_TYPE(f) ((f)->vertical_scroll_bar_type)
 508 #define FRAME_HAS_VERTICAL_SCROLL_BARS(f) \
 509      ((f)->vertical_scroll_bar_type != vertical_scroll_bar_none)
 510 #define FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT(f) \
 511      ((f)->vertical_scroll_bar_type == vertical_scroll_bar_left)
 512 #define FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT(f) \
 513      ((f)->vertical_scroll_bar_type == vertical_scroll_bar_right)
 514
 515 /* Width that a scroll bar in frame F should have, if there is one.
 516    Measured in pixels.
 517    If scroll bars are turned off, this is still nonzero.  */
 518 #define FRAME_SCROLL_BAR_PIXEL_WIDTH(f) ((f)->scroll_bar_pixel_width)
 519
 520 /* Width that a scroll bar in frame F should have, if there is one.
 521    Measured in columns (characters).
 522    If scroll bars are turned off, this is still nonzero.  */
 523 #define FRAME_SCROLL_BAR_COLS(f) ((f)->scroll_bar_cols)
 524
 525 /* Width of a scroll bar in frame F, measured in columns (characters),
 526    but only if scroll bars are on the left.
 527    If scroll bars are on the right in this frame, it is 0.  */
 528 #define FRAME_LEFT_SCROLL_BAR_WIDTH(f) \
 529      (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f) \
 530       ? FRAME_SCROLL_BAR_COLS (f) \
 531       : 0)
 532
 533 /* Width of a scroll bar in frame F, measured in columns (characters).  */
 534 #define FRAME_SCROLL_BAR_WIDTH(f) \
 535      (FRAME_HAS_VERTICAL_SCROLL_BARS (f) \
 536       ? FRAME_SCROLL_BAR_COLS (f) \
 537       : 0)
 538
 539 /* Total width of frame F, in columns (characters),
 540    including the width used by scroll bars if any.  */
 541 #define FRAME_WINDOW_WIDTH(f) ((f)->window_width)
 542
 543 /* Set the width of frame F to VAL.
 544    VAL is the width of a full-frame window,
 545    not including scroll bars.  */
 546 #define SET_FRAME_WIDTH(f, val)                                         \
 547      ((f)->width = (val),                                               \
 548       (f)->window_width = FRAME_WINDOW_WIDTH_ARG (f, (f)->width))
 549
 550 /* Given a value WIDTH for frame F's nominal width,
 551    return the value that FRAME_WINDOW_WIDTH should have.  */
 552 #define FRAME_WINDOW_WIDTH_ARG(f, width)        \
 553      ((width)                                   \
 554       + FRAME_SCROLL_BAR_WIDTH (f)              \
 555       + FRAME_FLAGS_AREA_COLS (f))
 556
 557 /* Maximum + 1 legitimate value for FRAME_CURSOR_X.  */
 558 #define FRAME_CURSOR_X_LIMIT(f) \
 559      (FRAME_WIDTH (f) + FRAME_LEFT_SCROLL_BAR_WIDTH (f))
 560
 561 /* Nonzero if frame F has scroll bars.  */
 562 #define FRAME_SCROLL_BARS(f) ((f)->scroll_bars)
 563
 564 #define FRAME_CONDEMNED_SCROLL_BARS(f) ((f)->condemned_scroll_bars)
 565 #define FRAME_MENU_BAR_ITEMS(f) ((f)->menu_bar_items)
 566 #define FRAME_COST_BAUD_RATE(f) ((f)->cost_calculation_baud_rate)
 567 #define FRAME_FONTSET_DATA(f) ((f)->fontset_data)
 568
 569 /* Return a pointer to the face cache of frame F.  */
 570
 571 #define FRAME_FACE_CACHE(F)     (F)->face_cache
 572
 573 /* Return the size of message_buf of the frame F.  We multiply the
 574    width of the frame by 4 because multi-byte form may require at most
 575    4-byte for a character.  */
 576
 577 #define FRAME_MESSAGE_BUF_SIZE(f) (((int) (f)->width) * 4)
 578
 579 /* Emacs's redisplay code could become confused if a frame's
 580    visibility changes at arbitrary times.  For example, if a frame is
 581    visible while the desired glyphs are being built, but becomes
 582    invisible before they are updated, then some rows of the
 583    desired_glyphs will be left marked as enabled after redisplay is
 584    complete, which should never happen.  The next time the frame
 585    becomes visible, redisplay will probably barf.
 586
 587    Currently, there are no similar situations involving iconified, but
 588    the principle is the same.
 589
 590    So instead of having asynchronous input handlers directly set and
 591    clear the frame's visibility and iconification flags, they just set
 592    the async_visible and async_iconified flags; the redisplay code
 593    calls the FRAME_SAMPLE_VISIBILITY macro before doing any redisplay,
 594    which sets visible and iconified from their asynchronous
 595    counterparts.
 596
 597    Synchronous code must use the FRAME_SET_VISIBLE macro.
 598
 599    Also, if a frame used to be invisible, but has just become visible,
 600    it must be marked as garbaged, since redisplay hasn't been keeping
 601    up its contents.  */
 602
 603 #define FRAME_SAMPLE_VISIBILITY(f) \
 604   (((f)->async_visible && (f)->visible != (f)->async_visible) ? \
 605    SET_FRAME_GARBAGED (f) : 0, \
 606    (f)->visible = (f)->async_visible, \
 607    (f)->iconified = (f)->async_iconified)
 608
 609 #define CHECK_FRAME(x, i)                               \
 610      do {                                               \
 611        if (! FRAMEP (x))                                \
 612          x = wrong_type_argument (Qframep, (x));        \
 613      } while (0)
 614
 615 #define CHECK_LIVE_FRAME(x, i)                          \
 616      do {                                               \
 617        if (! FRAMEP (x)                                 \
 618            || ! FRAME_LIVE_P (XFRAME (x)))              \
 619          x = wrong_type_argument (Qframe_live_p, (x));  \
 620      } while (0)
 621
 622 /* FOR_EACH_FRAME (LIST_VAR, FRAME_VAR) followed by a statement is a
 623    `for' loop which iterates over the elements of Vframe_list.  The
 624    loop will set FRAME_VAR, a Lisp_Object, to each frame in
 625    Vframe_list in succession and execute the statement.  LIST_VAR
 626    should be a Lisp_Object too; it is used to iterate through the
 627    Vframe_list.
 628
 629    This macro is a holdover from a time when multiple frames weren't always
 630    supported.  An alternate definition of the macro would expand to
 631    something which executes the statement once.  */
 632
 633 #define FOR_EACH_FRAME(list_var, frame_var)                     \
 634   for ((list_var) = Vframe_list;                                \
 635        (CONSP (list_var)                                        \
 636         && (frame_var = XCAR (list_var), 1));           \
 637        list_var = XCDR (list_var))
 638
 639
 640 extern Lisp_Object Qframep, Qframe_live_p, Qicon;
 641
 642 extern struct frame *last_nonminibuf_frame;
 643
 644 extern struct frame *make_terminal_frame P_ ((void));
 645 extern struct frame *make_frame P_ ((int));
 646 #ifdef HAVE_WINDOW_SYSTEM
 647 extern struct frame *make_minibuffer_frame P_ ((void));
 648 extern struct frame *make_frame_without_minibuffer P_ ((Lisp_Object,
 649                                                         struct kboard *,
 650                                                         Lisp_Object));
 651 #endif /* HAVE_WINDOW_SYSTEM */
 652 extern int other_visible_frames P_ ((struct frame *));
 653
 654 extern Lisp_Object Vframe_list;
 655 extern Lisp_Object Vdefault_frame_alist;
 656
 657 extern Lisp_Object Vterminal_frame;
 658 \f
 659 /* Device-independent scroll bar stuff.  */
 660
 661 /* Return the starting column (zero-based) of the vertical scroll bar
 662    for window W.  The column before this one is the last column we can
 663    use for text.  If the window touches the right edge of the frame,
 664    we have extra space allocated for it.  Otherwise, the scroll bar
 665    takes over the window's rightmost columns.  */
 666
 667 #define WINDOW_VERTICAL_SCROLL_BAR_COLUMN(w) \
 668   (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (XFRAME (WINDOW_FRAME (w))) ? \
 669     (((XINT ((w)->left) + XINT ((w)->width)) \
 670       < FRAME_WIDTH (XFRAME (WINDOW_FRAME (w)))) \
 671      ? (XINT ((w)->left) + XINT ((w)->width) \
 672        - FRAME_SCROLL_BAR_COLS (XFRAME (WINDOW_FRAME (w)))) \
 673      : FRAME_WIDTH (XFRAME (WINDOW_FRAME (w)))) \
 674   : XINT ((w)->left))
 675
 676 /* Return the height in lines of the vertical scroll bar in w.  If the
 677    window has a mode line, don't make the scroll bar extend that far.  */
 678
 679 #define WINDOW_VERTICAL_SCROLL_BAR_HEIGHT(w) (window_internal_height (w))
 680
 681 /* The currently selected frame.  */
 682
 683 extern Lisp_Object selected_frame;
 684
 685 /* Value is a pointer to the selected frame.  If the selected frame
 686    isn't life, abort.  */
 687
 688 #define SELECTED_FRAME()                                \
 689      ((FRAMEP (selected_frame)                          \
 690        && FRAME_LIVE_P (XFRAME (selected_frame)))       \
 691       ? XFRAME (selected_frame)                         \
 692       : (struct frame *) (abort (), NULL))
 693
 694 \f
 695 /***********************************************************************
 696                         Display-related Macros
 697  ***********************************************************************/
 698
 699 /* Canonical y-unit on frame F.  This value currently equals the line
 700    height of the frame.  Terminal specific header files are expected
 701    to define the macro FRAME_LINE_HEIGHT.  */
 702
 703 #define CANON_Y_UNIT(F) \
 704      (FRAME_WINDOW_P (F) ? FRAME_LINE_HEIGHT (F) : 1)
 705
 706 /* Canonical x-unit on frame F.  This is currently equal to the width
 707    of the default font of F.  Terminal specific headers are expected
 708    to define the macro FRAME_DEFAULT_FONT_WIDTH.  */
 709
 710 #define CANON_X_UNIT(F) \
 711      (FRAME_WINDOW_P (F) ? FRAME_DEFAULT_FONT_WIDTH (F) : 1)
 712
 713 /* Pixel width of areas used to display truncation marks, continuation
 714    marks, overlay arrows.  This is 0 for terminal frames.  */
 715
 716 #ifdef HAVE_WINDOW_SYSTEM
 717 #define FRAME_FLAGS_AREA_COLS(F) \
 718      (FRAME_WINDOW_P ((F)) ? FRAME_X_FLAGS_AREA_COLS ((F)) : 0)
 719 #define FRAME_FLAGS_AREA_WIDTH(F) FRAME_X_FLAGS_AREA_WIDTH (F)
 720 #define FRAME_LEFT_FLAGS_AREA_WIDTH(F) FRAME_X_LEFT_FLAGS_AREA_WIDTH (F)
 721
 722 #else
 723 #define FRAME_FLAGS_AREA_WIDTH(F)       0
 724 #define FRAME_FLAGS_AREA_COLS(F)        0
 725 #define FRAME_LEFT_FLAGS_AREA_WIDTH(F)  0
 726 #endif
 727
 728
 729
 730 \f
 731 /***********************************************************************
 732             Conversion between canonical units and pixels
 733  ***********************************************************************/
 734
 735 /* Canonical x-values are fractions of CANON_X_UNIT, canonical y-unit
 736    are fractions of CANON_Y_UNIT of a frame.  Both are represented as
 737    Lisp numbers, i.e. integers or floats.  */
 738
 739 /* Convert canonical value X to pixels.  F is the frame whose
 740    canonical char width is to be used.  X must be a Lisp integer or
 741    float.  Value is a C integer.  */
 742
 743 #define PIXEL_X_FROM_CANON_X(F, X)                      \
 744      (INTEGERP (X)                                      \
 745       ? XINT (X) * CANON_X_UNIT (F)                     \
 746       : (int) (XFLOAT_DATA (X) * CANON_X_UNIT (F)))
 747
 748 /* Convert canonical value Y to pixels.  F is the frame whose
 749    canonical character height is to be used.  X must be a Lisp integer
 750    or float.  Value is a C integer.  */
 751
 752 #define PIXEL_Y_FROM_CANON_Y(F, Y)                      \
 753      (INTEGERP (Y)                                      \
 754       ? XINT (Y) * CANON_Y_UNIT (F)                     \
 755       : (int) (XFLOAT_DATA (Y) * CANON_Y_UNIT (F)))
 756
 757 /* Convert pixel-value X to canonical units.  F is the frame whose
 758    canonical character width is to be used.  X is a C integer.  Result
 759    is a Lisp float if X is not a multiple of the canon width,
 760    otherwise it's a Lisp integer.  */
 761
 762 #define CANON_X_FROM_PIXEL_X(F, X)                      \
 763      ((X) % CANON_X_UNIT (F) != 0                       \
 764       ? make_float ((double) (X) / CANON_X_UNIT (F))    \
 765       : make_number ((X) / CANON_X_UNIT (F)))
 766
 767 /* Convert pixel-value Y to canonical units.  F is the frame whose
 768    canonical character height is to be used.  Y is a C integer.
 769    Result is a Lisp float if Y is not a multiple of the canon width,
 770    otherwise it's a Lisp integer.  */
 771
 772 #define CANON_Y_FROM_PIXEL_Y(F, Y)                      \
 773      ((Y) % CANON_Y_UNIT (F)                            \
 774       ? make_float ((double) (Y) / CANON_Y_UNIT (F))    \
 775       : make_number ((Y) / CANON_Y_UNIT (F)))
 776
 777 #endif /* not defined _FRAME_H_ */