src/frame.h

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