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(macintosh)
  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 && ! macintosh */
  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 (macintosh)
 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   /* Width of area for drawing truncation marks and overlay arrow.  */
 358   int trunc_area_pixel_width, trunc_area_cols;
 359
 360   /* The baud rate that was used to calculate costs for this frame.  */
 361   int cost_calculation_baud_rate;
 362
 363   /* Nonzero if the mouse has moved on this display
 364      since the last time we checked.  */
 365   char mouse_moved;
 366
 367   /* Exponent for gamma correction of colors.  1/(VIEWING_GAMMA *
 368      SCREEN_GAMMA) where viewing_gamma is 0.4545 and SCREEN_GAMMA is a
 369      frame parameter.  0 means don't do gamma correction.  */
 370   double gamma;
 371
 372   /* Additional space to put between text lines on this frame.  */
 373   int extra_line_spacing;
 374 };
 375
 376 #ifdef MULTI_KBOARD
 377 #define FRAME_KBOARD(f) ((f)->kboard)
 378 #else
 379 #define FRAME_KBOARD(f) (&the_only_kboard)
 380 #endif
 381
 382 typedef struct frame *FRAME_PTR;
 383
 384 #define XFRAME(p) (eassert (GC_FRAMEP(p)),(struct frame *) XPNTR (p))
 385 #define XSETFRAME(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_FRAME))
 386
 387 /* Given a window, return its frame as a Lisp_Object.  */
 388 #define WINDOW_FRAME(w) (w)->frame
 389
 390 /* Test a frame for particular kinds of display methods.  */
 391 #define FRAME_TERMCAP_P(f) ((f)->output_method == output_termcap)
 392 #define FRAME_X_P(f) ((f)->output_method == output_x_window)
 393 #define FRAME_W32_P(f) ((f)->output_method == output_w32)
 394 #define FRAME_MSDOS_P(f) ((f)->output_method == output_msdos_raw)
 395 #define FRAME_MAC_P(f) ((f)->output_method == output_mac)
 396
 397 /* FRAME_WINDOW_P tests whether the frame is a window, and is
 398    defined to be the predicate for the window system being used.  */
 399
 400 #ifdef HAVE_X_WINDOWS
 401 #define FRAME_WINDOW_P(f) FRAME_X_P (f)
 402 #endif
 403 #ifdef HAVE_NTGUI
 404 #define FRAME_WINDOW_P(f) FRAME_W32_P (f)
 405 #endif
 406 #ifdef macintosh
 407 #define FRAME_WINDOW_P(f) FRAME_MAC_P (f)
 408 #endif
 409 #ifndef FRAME_WINDOW_P
 410 #define FRAME_WINDOW_P(f) (0)
 411 #endif
 412
 413 /* Nonzero if frame F is still alive (not deleted).  */
 414 #define FRAME_LIVE_P(f) ((f)->output_data.nothing != 0)
 415
 416 /* Nonzero if frame F is a minibuffer-only frame.  */
 417 #define FRAME_MINIBUF_ONLY_P(f) \
 418   EQ (FRAME_ROOT_WINDOW (f), FRAME_MINIBUF_WINDOW (f))
 419
 420 /* Nonzero if frame F contains a minibuffer window.
 421    (If this is 0, F must use some other minibuffer window.)  */
 422 #define FRAME_HAS_MINIBUF_P(f) ((f)->has_minibuffer)
 423 #define FRAME_HEIGHT(f) (f)->height
 424
 425 /* Width of frame F, measured in character columns,
 426    not including scroll bars if any.  */
 427 #define FRAME_WIDTH(f) (f)->width
 428
 429 /* Number of lines of frame F used for menu bar.
 430    This is relevant on terminal frames and on
 431    X Windows when not using the X toolkit.
 432    These lines are counted in FRAME_HEIGHT.  */
 433 #define FRAME_MENU_BAR_LINES(f) (f)->menu_bar_lines
 434
 435 /* Number of lines of frame F used for the tool-bar.  */
 436
 437 #define FRAME_TOOL_BAR_LINES(f) (f)->tool_bar_lines
 438
 439 /* Lines above the top-most window in frame F.  */
 440
 441 #define FRAME_TOP_MARGIN(F) \
 442      (FRAME_MENU_BAR_LINES (F) + FRAME_TOOL_BAR_LINES (F))
 443
 444 /* Nonzero if this frame should display a menu bar
 445    in a way that does not use any text lines.  */
 446 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (macintosh)
 447 #define FRAME_EXTERNAL_MENU_BAR(f) (f)->external_menu_bar
 448 #else
 449 #define FRAME_EXTERNAL_MENU_BAR(f) 0
 450 #endif
 451 #define FRAME_VISIBLE_P(f) ((f)->visible != 0)
 452
 453 /* Nonzero if frame F is currently visible but hidden.  */
 454 #define FRAME_OBSCURED_P(f) ((f)->visible > 1)
 455
 456 /* Nonzero if frame F is currently iconified.  */
 457 #define FRAME_ICONIFIED_P(f) (f)->iconified
 458
 459 #define FRAME_SET_VISIBLE(f,p) \
 460   ((f)->async_visible = (p), FRAME_SAMPLE_VISIBILITY (f))
 461 #define SET_FRAME_GARBAGED(f) (frame_garbaged = 1, f->garbaged = 1)
 462 #define FRAME_GARBAGED_P(f) (f)->garbaged
 463
 464 /* Nonzero means do not allow splitting this frame's window.  */
 465 #define FRAME_NO_SPLIT_P(f) (f)->no_split
 466
 467 /* Not really implemented.  */
 468 #define FRAME_WANTS_MODELINE_P(f) (f)->wants_modeline
 469
 470 /* Nonzero if a size change has been requested for frame F
 471    but not yet really put into effect.  This can be true temporarily
 472    when an X event comes in at a bad time.  */
 473 #define FRAME_WINDOW_SIZES_CHANGED(f) (f)->window_sizes_changed
 474 /* When a size change is pending, these are the requested new sizes.  */
 475 #define FRAME_NEW_HEIGHT(f) (f)->new_height
 476 #define FRAME_NEW_WIDTH(f) (f)->new_width
 477
 478 /* The minibuffer window of frame F, if it has one; otherwise nil.  */
 479 #define FRAME_MINIBUF_WINDOW(f) (f)->minibuffer_window
 480
 481 /* The root window of the window tree of frame F.  */
 482 #define FRAME_ROOT_WINDOW(f) (f)->root_window
 483
 484 /* The currently selected window of the window tree of frame F.  */
 485 #define FRAME_SELECTED_WINDOW(f) (f)->selected_window
 486
 487 #define FRAME_INSERT_COST(f) (f)->insert_line_cost
 488 #define FRAME_DELETE_COST(f) (f)->delete_line_cost
 489 #define FRAME_INSERTN_COST(f) (f)->insert_n_lines_cost
 490 #define FRAME_DELETEN_COST(f) (f)->delete_n_lines_cost
 491 #define FRAME_MESSAGE_BUF(f) (f)->message_buf
 492 #define FRAME_SCROLL_BOTTOM_VPOS(f) (f)->scroll_bottom_vpos
 493 #define FRAME_FOCUS_FRAME(f) (f)->focus_frame
 494
 495 /* Nonzero if frame F supports scroll bars.
 496    If this is zero, then it is impossible to enable scroll bars
 497    on frame F.  */
 498 #define FRAME_CAN_HAVE_SCROLL_BARS(f) ((f)->can_have_scroll_bars)
 499
 500 /* This frame slot says whether scroll bars are currently enabled for frame F,
 501    and which side they are on.  */
 502 #define FRAME_VERTICAL_SCROLL_BAR_TYPE(f) ((f)->vertical_scroll_bar_type)
 503 #define FRAME_HAS_VERTICAL_SCROLL_BARS(f) \
 504      ((f)->vertical_scroll_bar_type != vertical_scroll_bar_none)
 505 #define FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT(f) \
 506      ((f)->vertical_scroll_bar_type == vertical_scroll_bar_left)
 507 #define FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT(f) \
 508      ((f)->vertical_scroll_bar_type == vertical_scroll_bar_right)
 509
 510 /* Width that a scroll bar in frame F should have, if there is one.
 511    Measured in pixels.
 512    If scroll bars are turned off, this is still nonzero.  */
 513 #define FRAME_SCROLL_BAR_PIXEL_WIDTH(f) ((f)->scroll_bar_pixel_width)
 514
 515 /* Width that a scroll bar in frame F should have, if there is one.
 516    Measured in columns (characters).
 517    If scroll bars are turned off, this is still nonzero.  */
 518 #define FRAME_SCROLL_BAR_COLS(f) ((f)->scroll_bar_cols)
 519
 520 /* Width of a scroll bar in frame F, measured in columns (characters),
 521    but only if scroll bars are on the left.  If scroll bars are on
 522    the right in this frame, or there are no scroll bars, value is 0.  */
 523
 524 #define FRAME_LEFT_SCROLL_BAR_WIDTH(f)                  \
 525      (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f)        \
 526       ? FRAME_SCROLL_BAR_COLS (f)                       \
 527       : 0)
 528
 529 /* Width of a scroll bar in frame F, measured in columns (characters),
 530    but only if scroll bars are on the right.  If scroll bars are on
 531    the left in this frame, or there are no scroll bars, value is 0.  */
 532
 533 #define FRAME_RIGHT_SCROLL_BAR_WIDTH(f)                 \
 534      (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f)       \
 535       ? FRAME_SCROLL_BAR_COLS (f)                       \
 536       : 0)
 537
 538 /* Width of a scroll bar in frame F, measured in columns (characters).  */
 539 #define FRAME_SCROLL_BAR_WIDTH(f) \
 540      (FRAME_HAS_VERTICAL_SCROLL_BARS (f) \
 541       ? FRAME_SCROLL_BAR_COLS (f) \
 542       : 0)
 543
 544 /* Total width of frame F, in columns (characters),
 545    including the width used by scroll bars if any.  */
 546 #define FRAME_WINDOW_WIDTH(f) ((f)->window_width)
 547
 548 /* Set the width of frame F to VAL.
 549    VAL is the width of a full-frame window,
 550    not including scroll bars.  */
 551 #define SET_FRAME_WIDTH(f, val)                                         \
 552      ((f)->width = (val),                                               \
 553       (f)->window_width = FRAME_WINDOW_WIDTH_ARG (f, (f)->width))
 554
 555 /* Given a value WIDTH for frame F's nominal width,
 556    return the value that FRAME_WINDOW_WIDTH should have.  */
 557 #define FRAME_WINDOW_WIDTH_ARG(f, width)        \
 558      ((width)                                   \
 559       + FRAME_SCROLL_BAR_WIDTH (f)              \
 560       + FRAME_FLAGS_AREA_COLS (f))
 561
 562 /* Maximum + 1 legitimate value for FRAME_CURSOR_X.  */
 563 #define FRAME_CURSOR_X_LIMIT(f) \
 564      (FRAME_WIDTH (f) + FRAME_LEFT_SCROLL_BAR_WIDTH (f))
 565
 566 /* Nonzero if frame F has scroll bars.  */
 567 #define FRAME_SCROLL_BARS(f) ((f)->scroll_bars)
 568
 569 #define FRAME_CONDEMNED_SCROLL_BARS(f) ((f)->condemned_scroll_bars)
 570 #define FRAME_MENU_BAR_ITEMS(f) ((f)->menu_bar_items)
 571 #define FRAME_COST_BAUD_RATE(f) ((f)->cost_calculation_baud_rate)
 572
 573 /* Return a pointer to the face cache of frame F.  */
 574
 575 #define FRAME_FACE_CACHE(F)     (F)->face_cache
 576
 577 /* Return the size of message_buf of the frame F.  We multiply the
 578    width of the frame by 4 because multi-byte form may require at most
 579    4-byte for a character.  */
 580
 581 #define FRAME_MESSAGE_BUF_SIZE(f) (((int) (f)->width) * 4)
 582
 583 /* Emacs's redisplay code could become confused if a frame's
 584    visibility changes at arbitrary times.  For example, if a frame is
 585    visible while the desired glyphs are being built, but becomes
 586    invisible before they are updated, then some rows of the
 587    desired_glyphs will be left marked as enabled after redisplay is
 588    complete, which should never happen.  The next time the frame
 589    becomes visible, redisplay will probably barf.
 590
 591    Currently, there are no similar situations involving iconified, but
 592    the principle is the same.
 593
 594    So instead of having asynchronous input handlers directly set and
 595    clear the frame's visibility and iconification flags, they just set
 596    the async_visible and async_iconified flags; the redisplay code
 597    calls the FRAME_SAMPLE_VISIBILITY macro before doing any redisplay,
 598    which sets visible and iconified from their asynchronous
 599    counterparts.
 600
 601    Synchronous code must use the FRAME_SET_VISIBLE macro.
 602
 603    Also, if a frame used to be invisible, but has just become visible,
 604    it must be marked as garbaged, since redisplay hasn't been keeping
 605    up its contents.  */
 606
 607 #define FRAME_SAMPLE_VISIBILITY(f) \
 608   (((f)->async_visible && (f)->visible != (f)->async_visible) ? \
 609    SET_FRAME_GARBAGED (f) : 0, \
 610    (f)->visible = (f)->async_visible, \
 611    (f)->iconified = (f)->async_iconified)
 612
 613 #define CHECK_FRAME(x, i)                               \
 614      do {                                               \
 615        if (! FRAMEP (x))                                \
 616          x = wrong_type_argument (Qframep, (x));        \
 617      } while (0)
 618
 619 #define CHECK_LIVE_FRAME(x, i)                          \
 620      do {                                               \
 621        if (! FRAMEP (x)                                 \
 622            || ! FRAME_LIVE_P (XFRAME (x)))              \
 623          x = wrong_type_argument (Qframe_live_p, (x));  \
 624      } while (0)
 625
 626 /* FOR_EACH_FRAME (LIST_VAR, FRAME_VAR) followed by a statement is a
 627    `for' loop which iterates over the elements of Vframe_list.  The
 628    loop will set FRAME_VAR, a Lisp_Object, to each frame in
 629    Vframe_list in succession and execute the statement.  LIST_VAR
 630    should be a Lisp_Object too; it is used to iterate through the
 631    Vframe_list.
 632
 633    This macro is a holdover from a time when multiple frames weren't always
 634    supported.  An alternate definition of the macro would expand to
 635    something which executes the statement once.  */
 636
 637 #define FOR_EACH_FRAME(list_var, frame_var)                     \
 638   for ((list_var) = Vframe_list;                                \
 639        (CONSP (list_var)                                        \
 640         && (frame_var = XCAR (list_var), 1));           \
 641        list_var = XCDR (list_var))
 642
 643
 644 extern Lisp_Object Qframep, Qframe_live_p, Qicon;
 645
 646 extern struct frame *last_nonminibuf_frame;
 647
 648 extern struct frame *make_terminal_frame P_ ((void));
 649 extern struct frame *make_frame P_ ((int));
 650 #ifdef HAVE_WINDOW_SYSTEM
 651 extern struct frame *make_minibuffer_frame P_ ((void));
 652 extern struct frame *make_frame_without_minibuffer P_ ((Lisp_Object,
 653                                                         struct kboard *,
 654                                                         Lisp_Object));
 655 #endif /* HAVE_WINDOW_SYSTEM */
 656 extern int other_visible_frames P_ ((struct frame *));
 657
 658 extern Lisp_Object Vframe_list;
 659 extern Lisp_Object Vdefault_frame_alist;
 660
 661 extern Lisp_Object Vterminal_frame;
 662 \f
 663 /* Device-independent scroll bar stuff.  */
 664
 665 /* Return the starting column (zero-based) of the vertical scroll bar
 666    for window W.  The column before this one is the last column we can
 667    use for text.  If the window touches the right edge of the frame,
 668    we have extra space allocated for it.  Otherwise, the scroll bar
 669    takes over the window's rightmost columns.  */
 670
 671 #define WINDOW_VERTICAL_SCROLL_BAR_COLUMN(w) \
 672   (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (XFRAME (WINDOW_FRAME (w))) ? \
 673     (((XINT ((w)->left) + XINT ((w)->width)) \
 674       < FRAME_WIDTH (XFRAME (WINDOW_FRAME (w)))) \
 675      ? (XINT ((w)->left) + XINT ((w)->width) \
 676        - FRAME_SCROLL_BAR_COLS (XFRAME (WINDOW_FRAME (w)))) \
 677      : FRAME_WIDTH (XFRAME (WINDOW_FRAME (w)))) \
 678   : XINT ((w)->left))
 679
 680 /* Return the height in lines of the vertical scroll bar in w.  If the
 681    window has a mode line, don't make the scroll bar extend that far.  */
 682
 683 #define WINDOW_VERTICAL_SCROLL_BAR_HEIGHT(w) (window_internal_height (w))
 684
 685 /* The currently selected frame.  */
 686
 687 extern Lisp_Object selected_frame;
 688
 689 /* Value is a pointer to the selected frame.  If the selected frame
 690    isn't live, abort.  */
 691
 692 #define SELECTED_FRAME()                                \
 693      ((FRAMEP (selected_frame)                          \
 694        && FRAME_LIVE_P (XFRAME (selected_frame)))       \
 695       ? XFRAME (selected_frame)                         \
 696       : (abort (), (struct frame *) 0))
 697
 698 \f
 699 /***********************************************************************
 700                         Display-related Macros
 701  ***********************************************************************/
 702
 703 /* Canonical y-unit on frame F.  This value currently equals the line
 704    height of the frame.  Terminal specific header files are expected
 705    to define the macro FRAME_LINE_HEIGHT.  */
 706
 707 #define CANON_Y_UNIT(F) \
 708      (FRAME_WINDOW_P (F) ? FRAME_LINE_HEIGHT (F) : 1)
 709
 710 /* Canonical x-unit on frame F.  This is currently equal to the width
 711    of the default font of F.  Terminal specific headers are expected
 712    to define the macro FRAME_DEFAULT_FONT_WIDTH.  */
 713
 714 #define CANON_X_UNIT(F) \
 715      (FRAME_WINDOW_P (F) ? FRAME_DEFAULT_FONT_WIDTH (F) : 1)
 716
 717 /* Pixel width of areas used to display truncation marks, continuation
 718    marks, overlay arrows.  This is 0 for terminal frames.  */
 719
 720 #ifdef HAVE_WINDOW_SYSTEM
 721
 722 #define FRAME_FLAGS_AREA_COLS(F) \
 723      (FRAME_WINDOW_P (F) ? FRAME_X_FLAGS_AREA_COLS (F) : 0)
 724 #define FRAME_FLAGS_AREA_WIDTH(F) \
 725      (FRAME_WINDOW_P (F) ? FRAME_X_FLAGS_AREA_WIDTH (F) : 0)
 726 #define FRAME_LEFT_FLAGS_AREA_WIDTH(F) \
 727      (FRAME_WINDOW_P (F) ? FRAME_X_LEFT_FLAGS_AREA_WIDTH (F) : 0)
 728
 729 #else /* not HAVE_WINDOW_SYSTEM */
 730
 731 #define FRAME_FLAGS_AREA_WIDTH(F)       0
 732 #define FRAME_FLAGS_AREA_COLS(F)        0
 733 #define FRAME_LEFT_FLAGS_AREA_WIDTH(F)  0
 734
 735 #endif /* not HAVE_WINDOW_SYSTEM */
 736
 737
 738
 739 \f
 740 /***********************************************************************
 741             Conversion between canonical units and pixels
 742  ***********************************************************************/
 743
 744 /* Canonical x-values are fractions of CANON_X_UNIT, canonical y-unit
 745    are fractions of CANON_Y_UNIT of a frame.  Both are represented as
 746    Lisp numbers, i.e. integers or floats.  */
 747
 748 /* Convert canonical value X to pixels.  F is the frame whose
 749    canonical char width is to be used.  X must be a Lisp integer or
 750    float.  Value is a C integer.  */
 751
 752 #define PIXEL_X_FROM_CANON_X(F, X)                      \
 753      (INTEGERP (X)                                      \
 754       ? XINT (X) * CANON_X_UNIT (F)                     \
 755       : (int) (XFLOAT_DATA (X) * CANON_X_UNIT (F)))
 756
 757 /* Convert canonical value Y to pixels.  F is the frame whose
 758    canonical character height is to be used.  X must be a Lisp integer
 759    or float.  Value is a C integer.  */
 760
 761 #define PIXEL_Y_FROM_CANON_Y(F, Y)                      \
 762      (INTEGERP (Y)                                      \
 763       ? XINT (Y) * CANON_Y_UNIT (F)                     \
 764       : (int) (XFLOAT_DATA (Y) * CANON_Y_UNIT (F)))
 765
 766 /* Convert pixel-value X to canonical units.  F is the frame whose
 767    canonical character width is to be used.  X is a C integer.  Result
 768    is a Lisp float if X is not a multiple of the canon width,
 769    otherwise it's a Lisp integer.  */
 770
 771 #define CANON_X_FROM_PIXEL_X(F, X)                      \
 772      ((X) % CANON_X_UNIT (F) != 0                       \
 773       ? make_float ((double) (X) / CANON_X_UNIT (F))    \
 774       : make_number ((X) / CANON_X_UNIT (F)))
 775
 776 /* Convert pixel-value Y to canonical units.  F is the frame whose
 777    canonical character height is to be used.  Y is a C integer.
 778    Result is a Lisp float if Y is not a multiple of the canon width,
 779    otherwise it's a Lisp integer.  */
 780
 781 #define CANON_Y_FROM_PIXEL_Y(F, Y)                      \
 782      ((Y) % CANON_Y_UNIT (F)                            \
 783       ? make_float ((double) (Y) / CANON_Y_UNIT (F))    \
 784       : make_number ((Y) / CANON_Y_UNIT (F)))
 785
 786 #endif /* not EMACS_FRAME_H */