X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/cc885e42e330158bbc63699ca0c4f557a2e74fd7..df6304968670f3ead5a22d833b0442b9288d1ec7:/src/window.h diff --git a/src/window.h b/src/window.h index 0b0e0aa256..df359f37db 100644 --- a/src/window.h +++ b/src/window.h @@ -1,5 +1,6 @@ /* Window definitions for GNU Emacs. - Copyright (C) 1985, 1986, 1993, 1995 Free Software Foundation, Inc. + Copyright (C) 1985, 1986, 1993, 1995, 1997, 1998, 1999, 2000, 2001, + 2002, 2003, 2004, 2005 Free Software Foundation, Inc. This file is part of GNU Emacs. @@ -15,9 +16,15 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Emacs; see the file COPYING. If not, write to -the Free Software Foundation, Inc., 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +Boston, MA 02110-1301, USA. */ +#ifndef WINDOW_H_INCLUDED +#define WINDOW_H_INCLUDED + +#include "dispextern.h" + +extern Lisp_Object Qleft, Qright; /* Windows are allocated as if they were vectors, but then the Lisp data type is changed to Lisp_Window. They are garbage @@ -72,6 +79,15 @@ one and the same, so its prev and next members are nil. A dead window has its buffer, hchild, and vchild windows all nil. */ +struct cursor_pos +{ + /* Pixel position. These are always window relative. */ + int x, y; + + /* Glyph matrix position. */ + int hpos, vpos; +}; + struct window { /* The first two fields are really the header of a vector */ @@ -94,11 +110,11 @@ struct window Lisp_Object parent; /* The upper left corner coordinates of this window, as integers relative to upper left corner of frame = 0, 0 */ - Lisp_Object left; - Lisp_Object top; + Lisp_Object left_col; + Lisp_Object top_line; /* The size of the window */ - Lisp_Object height; - Lisp_Object width; + Lisp_Object total_lines; + Lisp_Object total_cols; /* The buffer displayed in this window */ /* Of the fields vchild, hchild and buffer, only one is non-nil. */ Lisp_Object buffer; @@ -112,8 +128,16 @@ struct window /* Non-nil means next redisplay must use the value of start set up for it in advance. Set by scrolling commands. */ Lisp_Object force_start; + /* Non-nil means we have explicitly changed the value of start, + but that the next redisplay is not obliged to use the new value. + This is used in Fdelete_other_windows to force a call to + Vwindow_scroll_functions; also by Frecenter with argument. */ + Lisp_Object optional_new_start; /* Number of columns display within the window is scrolled to the left. */ Lisp_Object hscroll; + /* Minimum hscroll for automatic hscrolling. This is the value + the user has set, by set-window-hscroll for example. */ + Lisp_Object min_hscroll; /* Number saying how recently window was selected */ Lisp_Object use_time; /* Unique number of window assigned when it was created */ @@ -136,25 +160,40 @@ struct window it yet, or if the frame doesn't have any scroll bars, this is nil. */ Lisp_Object vertical_scroll_bar; -/* The rest are currently not used or only half used */ - /* Frame coords of point at that time */ - Lisp_Object last_point_x; - Lisp_Object last_point_y; + /* Width of left and right marginal areas. A value of nil means + no margin. */ + Lisp_Object left_margin_cols, right_margin_cols; + + /* Width of left and right fringes. + A value of nil or t means use frame values. */ + Lisp_Object left_fringe_width, right_fringe_width; + + /* Non-nil means fringes are drawn outside display margins; + othersize draw them between margin areas and text. */ + Lisp_Object fringes_outside_margins; + + /* Pixel width of scroll bars. + A value of nil or t means use frame values. */ + Lisp_Object scroll_bar_width; + /* Type of vertical scroll bar. A value of nil means + no scroll bar. A value of t means use frame value. */ + Lisp_Object vertical_scroll_bar_type; + /* Frame coords of mark as of last time display completed */ /* May be nil if mark does not exist or was not on frame */ Lisp_Object last_mark_x; Lisp_Object last_mark_y; - /* Number of characters in buffer past bottom of window, - as of last redisplay that finished. */ + /* Z - the buffer position of the last glyph in the current matrix + of W. Only valid if WINDOW_END_VALID is not nil. */ Lisp_Object window_end_pos; + /* Glyph matrix row of the last glyph in the current matrix + of W. Only valid if WINDOW_END_VALID is not nil. */ + Lisp_Object window_end_vpos; /* t if window_end_pos is truly valid. This is nil if nontrivial redisplay is preempted since in that case the frame image that window_end_pos did not get onto the frame. */ Lisp_Object window_end_valid; - /* Vertical position (relative to window top) of that buffer position - of the first of those characters */ - Lisp_Object window_end_vpos; /* Non-nil means must regenerate mode line of this window */ Lisp_Object update_mode_line; /* Non-nil means current value of `start' @@ -182,11 +221,498 @@ struct window /* If redisplay in this window goes beyond this buffer position, must run the redisplay-end-trigger-hook. */ Lisp_Object redisplay_end_trigger; - }; + /* Non-nil means don't delete this window for becoming "too small". */ + Lisp_Object too_small_ok; + + /* Original window height and top before mini-window was + enlarged. */ + Lisp_Object orig_total_lines, orig_top_line; + + /* No Lisp data may follow below this point without changing + mark_object in alloc.c. The member current_matrix must be the + first non-Lisp member. */ + + /* Glyph matrices. */ + struct glyph_matrix *current_matrix; + struct glyph_matrix *desired_matrix; + + /* Scaling factor for the glyph_matrix size calculation in this window. + Used if window contains many small images or uses proportional fonts, + as the normal may yield a matrix which is too small. */ + int nrows_scale_factor, ncols_scale_factor; + + /* Cursor position as of last update that completed without + pause. This is the position of last_point. */ + struct cursor_pos last_cursor; + + /* Intended cursor position. This is a position within the + glyph matrix. */ + struct cursor_pos cursor; + + /* Where the cursor actually is. */ + struct cursor_pos phys_cursor; + + /* Cursor type and width of last cursor drawn on the window. + Used for X and w32 frames; -1 initially. */ + int phys_cursor_type, phys_cursor_width; + + /* This is handy for undrawing the cursor. */ + int phys_cursor_ascent, phys_cursor_height; + + /* Non-zero means the cursor is currently displayed. This can be + set to zero by functions overpainting the cursor image. */ + unsigned phys_cursor_on_p : 1; + + /* 0 means cursor is logically on, 1 means it's off. Used for + blinking cursor. */ + unsigned cursor_off_p : 1; + + /* Value of cursor_off_p as of the last redisplay. */ + unsigned last_cursor_off_p : 1; + + /* 1 means desired matrix has been build and window must be + updated in update_frame. */ + unsigned must_be_updated_p : 1; + + /* Flag indicating that this window is not a real one. + Currently only used for menu bar windows of frames. */ + unsigned pseudo_window_p : 1; + + /* Amount by which lines of this window are scrolled in + y-direction (smooth scrolling). */ + int vscroll; + + /* Z_BYTE - the buffer position of the last glyph in the current matrix + of W. Only valid if WINDOW_END_VALID is not nil. */ + int window_end_bytepos; + + /* 1 means the window start of this window is frozen and may not + be changed during redisplay. If point is not in the window, + accept that. */ + unsigned frozen_window_start_p : 1; + + /* 1 means that this window's height is temporarily fixed. Used + in resize_mini_window to precent resizing selected_window, if + possible. */ + unsigned height_fixed_p : 1; +}; /* 1 if W is a minibuffer window. */ -#define MINI_WINDOW_P(W) (!EQ ((W)->mini_p, Qnil)) +#define MINI_WINDOW_P(W) (!NILP ((W)->mini_p)) + +/* General window layout: + + LEFT_EDGE_COL RIGHT_EDGE_COL + | | + | | + | BOX_LEFT_EDGE_COL | + | | BOX_RIGHT_EDGE_COL | + | | | | + v v v v + <-><-><---><-----------><---><-><-> + ^ ^ ^ ^ ^ ^ ^ + | | | | | | | + | | | | | | +-- RIGHT_SCROLL_BAR_COLS + | | | | | +----- RIGHT_FRINGE_WIDTH + | | | | +--------- RIGHT_MARGIN_COLS + | | | | + | | | +------------------ TEXT_AREA_COLS + | | | + | | +--------------------------- LEFT_MARGIN_COLS + | +------------------------------- LEFT_FRINGE_WIDTH + +---------------------------------- LEFT_SCROLL_BAR_COLS + +*/ + + +/* A handy macro. */ + +#define WINDOW_XFRAME(W) \ + (XFRAME (WINDOW_FRAME ((W)))) + +/* Return the canonical column width of the frame of window W. */ + +#define WINDOW_FRAME_COLUMN_WIDTH(W) \ + (FRAME_COLUMN_WIDTH (WINDOW_XFRAME ((W)))) + +/* Return the canonical column width of the frame of window W. */ + +#define WINDOW_FRAME_LINE_HEIGHT(W) \ + (FRAME_LINE_HEIGHT (WINDOW_XFRAME ((W)))) + + +/* Return the frame width in canonical column units. + This includes scroll bars and fringes. */ + +#define WINDOW_TOTAL_COLS(W) \ + (XFASTINT ((W)->total_cols)) + +/* Return the frame height in canonical line units. + This includes header and mode lines, if any. */ + +#define WINDOW_TOTAL_LINES(W) \ + (XFASTINT ((W)->total_lines)) + + +/* Return the total pixel width of window W. */ + +#define WINDOW_TOTAL_WIDTH(W) \ + (WINDOW_TOTAL_COLS (W) * WINDOW_FRAME_COLUMN_WIDTH (W)) + +/* Return the total pixel height of window W. */ + +#define WINDOW_TOTAL_HEIGHT(W) \ + (WINDOW_TOTAL_LINES (W) * WINDOW_FRAME_LINE_HEIGHT (W)) + + +/* Return the canonical frame column at which window W starts. + This includes a left-hand scroll bar, if any. */ + +#define WINDOW_LEFT_EDGE_COL(W) \ + (XFASTINT ((W)->left_col)) + +/* Return the canonical frame column before which window W ends. + This includes a right-hand scroll bar, if any. */ + +#define WINDOW_RIGHT_EDGE_COL(W) \ + (WINDOW_LEFT_EDGE_COL (W) + WINDOW_TOTAL_COLS (W)) + +/* Return the canonical frame line at which window W starts. + This includes a header line, if any. */ + +#define WINDOW_TOP_EDGE_LINE(W) \ + (XFASTINT ((W)->top_line)) + +/* Return the canonical frame line before which window W ends. + This includes a mode line, if any. */ + +#define WINDOW_BOTTOM_EDGE_LINE(W) \ + (WINDOW_TOP_EDGE_LINE (W) + WINDOW_TOTAL_LINES (W)) + + +/* Return the frame x-position at which window W starts. + This includes a left-hand scroll bar, if any. */ + +#define WINDOW_LEFT_EDGE_X(W) \ + (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \ + + WINDOW_LEFT_EDGE_COL (W) * WINDOW_FRAME_COLUMN_WIDTH (W)) + +/* Return the frame x- position before which window W ends. + This includes a right-hand scroll bar, if any. */ + +#define WINDOW_RIGHT_EDGE_X(W) \ + (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \ + + WINDOW_RIGHT_EDGE_COL (W) * WINDOW_FRAME_COLUMN_WIDTH (W)) + +/* Return the frame y-position at which window W starts. + This includes a header line, if any. */ + +#define WINDOW_TOP_EDGE_Y(W) \ + (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \ + + WINDOW_TOP_EDGE_LINE (W) * WINDOW_FRAME_LINE_HEIGHT (W)) + +/* Return the frame y-position before which window W ends. + This includes a mode line, if any. */ + +#define WINDOW_BOTTOM_EDGE_Y(W) \ + (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \ + + WINDOW_BOTTOM_EDGE_LINE (W) * WINDOW_FRAME_LINE_HEIGHT (W)) + + +/* 1 if window W takes up the full width of its frame. */ + +#define WINDOW_FULL_WIDTH_P(W) \ + (WINDOW_TOTAL_COLS (W) == FRAME_TOTAL_COLS (WINDOW_XFRAME (W))) + +/* 1 if window W's has no other windows to its left in its frame. */ + +#define WINDOW_LEFTMOST_P(W) \ + (WINDOW_LEFT_EDGE_COL (W) == 0) + +/* 1 if window W's has no other windows to its right in its frame. */ + +#define WINDOW_RIGHTMOST_P(W) \ + (WINDOW_RIGHT_EDGE_COL (W) == FRAME_TOTAL_COLS (WINDOW_XFRAME (W))) + + +/* Return the frame column at which the text (or left fringe) in + window W starts. This is different from the `LEFT_EDGE' because it + does not include a left-hand scroll bar if any. */ + +#define WINDOW_BOX_LEFT_EDGE_COL(W) \ + (WINDOW_LEFT_EDGE_COL (W) \ + + WINDOW_LEFT_SCROLL_BAR_COLS (W)) + +/* Return the window column before which the text in window W ends. + This is different from WINDOW_RIGHT_EDGE_COL because it does not + include a scroll bar or window-separating line on the right edge. */ + +#define WINDOW_BOX_RIGHT_EDGE_COL(W) \ + (WINDOW_RIGHT_EDGE_COL (W) \ + - WINDOW_RIGHT_SCROLL_BAR_COLS (W)) + + +/* Return the frame position at which the text (or left fringe) in + window W starts. This is different from the `LEFT_EDGE' because it + does not include a left-hand scroll bar if any. */ + +#define WINDOW_BOX_LEFT_EDGE_X(W) \ + (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \ + + WINDOW_BOX_LEFT_EDGE_COL (W) * WINDOW_FRAME_COLUMN_WIDTH (W)) + +/* Return the window column before which the text in window W ends. + This is different from WINDOW_RIGHT_EDGE_COL because it does not + include a scroll bar or window-separating line on the right edge. */ + +#define WINDOW_BOX_RIGHT_EDGE_X(W) \ + (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \ + + WINDOW_BOX_RIGHT_EDGE_COL (W) * WINDOW_FRAME_COLUMN_WIDTH (W)) + + +/* Width of left margin area in columns. */ + +#define WINDOW_LEFT_MARGIN_COLS(W) \ + (NILP ((W)->left_margin_cols) \ + ? 0 \ + : XINT ((W)->left_margin_cols)) + +/* Width of right marginal area in columns. */ + +#define WINDOW_RIGHT_MARGIN_COLS(W) \ + (NILP ((W)->right_margin_cols) \ + ? 0 \ + : XINT ((W)->right_margin_cols)) + +/* Width of left margin area in pixels. */ + +#define WINDOW_LEFT_MARGIN_WIDTH(W) \ + (NILP ((W)->left_margin_cols) \ + ? 0 \ + : (XINT ((W)->left_margin_cols) \ + * WINDOW_FRAME_COLUMN_WIDTH (W))) + +/* Width of right marginal area in pixels. */ + +#define WINDOW_RIGHT_MARGIN_WIDTH(W) \ + (NILP ((W)->right_margin_cols) \ + ? 0 \ + : (XINT ((W)->right_margin_cols) \ + * WINDOW_FRAME_COLUMN_WIDTH (W))) + +/* Total width of fringes reserved for drawing truncation bitmaps, + continuation bitmaps and alike. The width is in canonical char + units of the frame. This must currently be the case because window + sizes aren't pixel values. If it weren't the case, we wouldn't be + able to split windows horizontally nicely. */ + +#define WINDOW_FRINGE_COLS(W) \ + ((INTEGERP ((W)->left_fringe_width) \ + || INTEGERP ((W)->right_fringe_width)) \ + ? ((WINDOW_LEFT_FRINGE_WIDTH (W) \ + + WINDOW_RIGHT_FRINGE_WIDTH (W) \ + + WINDOW_FRAME_COLUMN_WIDTH (W) - 1) \ + / WINDOW_FRAME_COLUMN_WIDTH (W)) \ + : FRAME_FRINGE_COLS (WINDOW_XFRAME (W))) + +/* Column-width of the left and right fringe. */ + +#define WINDOW_LEFT_FRINGE_COLS(W) \ + ((WINDOW_LEFT_FRINGE_WIDTH ((W)) \ + + WINDOW_FRAME_COLUMN_WIDTH (W) - 1) \ + / WINDOW_FRAME_COLUMN_WIDTH (W)) + +#define WINDOW_RIGHT_FRINGE_COLS(W) \ + ((WINDOW_RIGHT_FRINGE_WIDTH ((W)) \ + + WINDOW_FRAME_COLUMN_WIDTH (W) - 1) \ + / WINDOW_FRAME_COLUMN_WIDTH (W)) + +/* Pixel-width of the left and right fringe. */ + +#define WINDOW_LEFT_FRINGE_WIDTH(W) \ + (INTEGERP ((W)->left_fringe_width) \ + ? XFASTINT ((W)->left_fringe_width) \ + : FRAME_LEFT_FRINGE_WIDTH (WINDOW_XFRAME (W))) + +#define WINDOW_RIGHT_FRINGE_WIDTH(W) \ + (INTEGERP ((W)->right_fringe_width) \ + ? XFASTINT ((W)->right_fringe_width) \ + : FRAME_RIGHT_FRINGE_WIDTH (WINDOW_XFRAME (W))) + +/* Total width of fringes in pixels. */ + +#define WINDOW_TOTAL_FRINGE_WIDTH(W) \ + (WINDOW_LEFT_FRINGE_WIDTH (W) + WINDOW_RIGHT_FRINGE_WIDTH (W)) + +/* Are fringes outside display margins in window W. */ + +#define WINDOW_HAS_FRINGES_OUTSIDE_MARGINS(W) \ + (!NILP ((W)->fringes_outside_margins)) + +/* Say whether scroll bars are currently enabled for window W, + and which side they are on. */ + +#define WINDOW_VERTICAL_SCROLL_BAR_TYPE(w) \ + (EQ ((w)->vertical_scroll_bar_type, Qt) \ + ? FRAME_VERTICAL_SCROLL_BAR_TYPE (WINDOW_XFRAME (w)) \ + : EQ ((w)->vertical_scroll_bar_type, Qleft) \ + ? vertical_scroll_bar_left \ + : EQ ((w)->vertical_scroll_bar_type, Qright) \ + ? vertical_scroll_bar_right \ + : vertical_scroll_bar_none) \ + +#define WINDOW_HAS_VERTICAL_SCROLL_BAR(w) \ + (EQ ((w)->vertical_scroll_bar_type, Qt) \ + ? FRAME_HAS_VERTICAL_SCROLL_BARS (WINDOW_XFRAME (w)) \ + : !NILP ((w)->vertical_scroll_bar_type)) + +#define WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT(w) \ + (EQ ((w)->vertical_scroll_bar_type, Qt) \ + ? FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (WINDOW_XFRAME (w)) \ + : EQ ((w)->vertical_scroll_bar_type, Qleft)) + +#define WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT(w) \ + (EQ ((w)->vertical_scroll_bar_type, Qt) \ + ? FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (WINDOW_XFRAME (w))\ + : EQ ((w)->vertical_scroll_bar_type, Qright)) + +/* Width that a scroll bar in window W should have, if there is one. + Measured in pixels. If scroll bars are turned off, this is still + nonzero. */ + +#define WINDOW_CONFIG_SCROLL_BAR_WIDTH(w) \ + (INTEGERP ((w)->scroll_bar_width) \ + ? XFASTINT ((w)->scroll_bar_width) \ + : FRAME_CONFIG_SCROLL_BAR_WIDTH (WINDOW_XFRAME (w))) + +/* Width that a scroll bar in window W should have, if there is one. + Measured in columns (characters). If scroll bars are turned off, + this is still nonzero. */ + +#define WINDOW_CONFIG_SCROLL_BAR_COLS(w) \ + (INTEGERP ((w)->scroll_bar_width) \ + ? ((XFASTINT ((w)->scroll_bar_width) \ + + WINDOW_FRAME_COLUMN_WIDTH (w) - 1) \ + / WINDOW_FRAME_COLUMN_WIDTH (w)) \ + : FRAME_CONFIG_SCROLL_BAR_COLS (WINDOW_XFRAME (w))) + +/* Width of a scroll bar in window W, measured in columns (characters), + but only if scroll bars are on the left. If scroll bars are on + the right in this frame, or there are no scroll bars, value is 0. */ + +#define WINDOW_LEFT_SCROLL_BAR_COLS(w) \ + (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w) \ + ? (WINDOW_CONFIG_SCROLL_BAR_COLS (w)) \ + : 0) + +/* Width of a left scroll bar area in window W , measured in pixels. */ + +#define WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH(w) \ + (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w) \ + ? (WINDOW_CONFIG_SCROLL_BAR_COLS (w) * WINDOW_FRAME_COLUMN_WIDTH (w)) \ + : 0) + +/* Width of a scroll bar in window W, measured in columns (characters), + but only if scroll bars are on the right. If scroll bars are on + the left in this frame, or there are no scroll bars, value is 0. */ + +#define WINDOW_RIGHT_SCROLL_BAR_COLS(w) \ + (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w) \ + ? WINDOW_CONFIG_SCROLL_BAR_COLS (w) \ + : 0) + +/* Width of a left scroll bar area in window W , measured in pixels. */ + +#define WINDOW_RIGHT_SCROLL_BAR_AREA_WIDTH(w) \ + (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w) \ + ? (WINDOW_CONFIG_SCROLL_BAR_COLS (w) * WINDOW_FRAME_COLUMN_WIDTH (w)) \ + : 0) + + +/* Actual width of a scroll bar in window W, measured in columns. */ + +#define WINDOW_SCROLL_BAR_COLS(w) \ + (WINDOW_HAS_VERTICAL_SCROLL_BAR (w) \ + ? WINDOW_CONFIG_SCROLL_BAR_COLS (w) \ + : 0) + +/* Width of a left scroll bar area in window W , measured in pixels. */ + +#define WINDOW_SCROLL_BAR_AREA_WIDTH(w) \ + (WINDOW_HAS_VERTICAL_SCROLL_BAR (w) \ + ? (WINDOW_CONFIG_SCROLL_BAR_COLS (w) * WINDOW_FRAME_COLUMN_WIDTH (w)) \ + : 0) + + +/* Return the frame position where the scroll bar of window W starts. */ + +#define WINDOW_SCROLL_BAR_AREA_X(W) \ + (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (W) \ + ? WINDOW_BOX_RIGHT_EDGE_X (W) \ + : WINDOW_LEFT_EDGE_X (W)) + + +/* Height in pixels, and in lines, of the mode line. + May be zero if W doesn't have a mode line. */ + +#define WINDOW_MODE_LINE_HEIGHT(W) \ + (WINDOW_WANTS_MODELINE_P ((W)) \ + ? CURRENT_MODE_LINE_HEIGHT (W) \ + : 0) + +#define WINDOW_MODE_LINE_LINES(W) \ + (!! WINDOW_WANTS_MODELINE_P ((W))) + +/* Height in pixels, and in lines, of the header line. + Zero if W doesn't have a header line. */ + +#define WINDOW_HEADER_LINE_HEIGHT(W) \ + (WINDOW_WANTS_HEADER_LINE_P ((W)) \ + ? CURRENT_HEADER_LINE_HEIGHT (W) \ + : 0) + +#define WINDOW_HEADER_LINE_LINES(W) \ + (!! WINDOW_WANTS_HEADER_LINE_P ((W))) + +/* Pixel height of window W without mode line. */ + +#define WINDOW_BOX_HEIGHT_NO_MODE_LINE(W) \ + (WINDOW_TOTAL_HEIGHT ((W)) \ + - WINDOW_MODE_LINE_HEIGHT ((W))) + +/* Pixel height of window W without mode and header line. */ + +#define WINDOW_BOX_TEXT_HEIGHT(W) \ + (WINDOW_TOTAL_HEIGHT ((W)) \ + - WINDOW_MODE_LINE_HEIGHT ((W)) \ + - WINDOW_HEADER_LINE_HEIGHT ((W))) + + +/* Convert window W relative pixel X to frame pixel coordinates. */ + +#define WINDOW_TO_FRAME_PIXEL_X(W, X) \ + ((X) + WINDOW_BOX_LEFT_EDGE_X ((W))) + +/* Convert window W relative pixel Y to frame pixel coordinates. */ + +#define WINDOW_TO_FRAME_PIXEL_Y(W, Y) \ + ((Y) + WINDOW_TOP_EDGE_Y ((W))) + +/* Convert frame relative pixel X to window relative pixel X. */ + +#define FRAME_TO_WINDOW_PIXEL_X(W, X) \ + ((X) - WINDOW_BOX_LEFT_EDGE_X ((W))) + +/* Convert frame relative pixel Y to window relative pixel Y. */ + +#define FRAME_TO_WINDOW_PIXEL_Y(W, Y) \ + ((Y) - WINDOW_TOP_EDGE_Y ((W))) + +/* Convert a text area relative x-position in window W to frame X + pixel coordinates. */ + +#define WINDOW_TEXT_TO_FRAME_PIXEL_X(W, X) \ + (window_box_left ((W), TEXT_AREA) + (X)) /* This is the window in which the terminal's cursor should be left when nothing is being done with it. This must @@ -210,97 +736,167 @@ extern int window_select_count; extern Lisp_Object minibuf_window; -/* Non-nil => window to for C-M-v to scroll - when the minibuffer is selected. */ +/* Non-nil means it is the window whose mode line should be + shown as the selected window when the minibuffer is selected. */ + +extern Lisp_Object minibuf_selected_window; + +/* Non-nil => window to for C-M-v to scroll when the minibuffer is + selected. */ + extern Lisp_Object Vminibuf_scroll_window; -/* nil or a symbol naming the window system - under which emacs is running - ('x is the only current possibility) */ +/* Nil or a symbol naming the window system under which emacs is + running ('x is the only current possibility) */ + extern Lisp_Object Vwindow_system; /* Version number of X windows: 10, 11 or nil. */ + extern Lisp_Object Vwindow_system_version; /* Window that the mouse is over (nil if no mouse support). */ + extern Lisp_Object Vmouse_window; /* Last mouse-click event (nil if no mouse support). */ + extern Lisp_Object Vmouse_event; -extern Lisp_Object Fnext_window (); -extern Lisp_Object Fselect_window (); -extern Lisp_Object Fdisplay_buffer (); -extern Lisp_Object Fset_window_buffer (); -extern Lisp_Object make_window (); -extern Lisp_Object window_from_coordinates (); -extern Lisp_Object Fwindow_dedicated_p (); +EXFUN (Fnext_window, 3); +EXFUN (Fselect_window, 2); +EXFUN (Fdisplay_buffer, 3); +EXFUN (Fset_window_buffer, 3); +EXFUN (Fset_window_hscroll, 2); +EXFUN (Fwindow_hscroll, 1); +EXFUN (Fset_window_vscroll, 3); +EXFUN (Fwindow_vscroll, 2); +EXFUN (Fset_window_margins, 3); +EXFUN (Fwindow_live_p, 1); +EXFUN (Fset_window_point, 2); +extern Lisp_Object make_window P_ ((void)); +extern void delete_window P_ ((Lisp_Object)); +extern Lisp_Object window_from_coordinates P_ ((struct frame *, int, int, + enum window_part *, + int *, int*, int)); +EXFUN (Fwindow_dedicated_p, 1); +extern int window_height P_ ((Lisp_Object)); +extern int window_width P_ ((Lisp_Object)); +extern void set_window_height P_ ((Lisp_Object, int, int)); +extern void set_window_width P_ ((Lisp_Object, int, int)); +extern void change_window_heights P_ ((Lisp_Object, int)); +extern void delete_all_subwindows P_ ((struct window *)); +extern void freeze_window_starts P_ ((struct frame *, int)); +extern void foreach_window P_ ((struct frame *, + int (* fn) (struct window *, void *), + void *)); +extern void grow_mini_window P_ ((struct window *, int)); +extern void shrink_mini_window P_ ((struct window *)); + + +/* Make WINDOW display BUFFER as its contents. RUN_HOOKS_P non-zero + means it's allowed to run hooks. See make_frame for a case where + it's not allowed. */ + +void set_window_buffer P_ ((Lisp_Object window, Lisp_Object buffer, + int run_hooks_p, int keep_margins_p)); /* Prompt to display in front of the minibuffer contents. */ + extern Lisp_Object minibuf_prompt; /* The visual width of the above. */ -extern int minibuf_prompt_width; - -/* Message to display instead of minibuffer contents. - This is what the functions error and message make, - and command echoing uses it as well. It overrides the - minibuf_prompt as well as the buffer. */ -extern char *echo_area_glyphs; -/* This is the length of the message in echo_area_glyphs. */ -extern int echo_area_glyphs_length; +extern int minibuf_prompt_width; -/* Value of echo_area_glyphs when it was last acted on. - If this is nonzero, there is a message on the frame - in the minibuffer and it should be erased as soon - as it is no longer requested to appear. */ -extern char *previous_echo_glyphs; +/* This is the window where the echo area message was displayed. It + is always a minibuffer window, but it may not be the same window + currently active as a minibuffer. */ -/* This is the window where the echo area message was displayed. - It is always a minibuffer window, but it may not be the - same window currently active as a minibuffer. */ extern Lisp_Object echo_area_window; /* Depth in recursive edits. */ + extern int command_loop_level; /* Depth in minibuffer invocations. */ + extern int minibuf_level; /* true iff we should redraw the mode lines on the next redisplay. */ -extern int update_mode_lines; -/* Minimum value of GPT - BEG since last redisplay that finished. */ +extern int update_mode_lines; -extern int beg_unchanged; +/* Nonzero if BEGV - BEG or Z - ZV of current buffer has changed since + last redisplay that finished. */ -/* Minimum value of Z - GPT since last redisplay that finished. */ +extern int clip_changed; -extern int end_unchanged; +/* Nonzero if window sizes or contents have changed since last + redisplay that finished */ -/* MODIFF as of last redisplay that finished; - if it matches MODIFF, beg_unchanged and end_unchanged - contain no useful information. */ -extern int unchanged_modified; +extern int windows_or_buffers_changed; -/* BUF_OVERLAY_MODIFF of current buffer, as of last redisplay that finished; - if it matches BUF_OVERLAY_MODIFF, beg_unchanged and end_unchanged - contain no useful information. */ -extern int overlay_unchanged_modified; +/* Nonzero means a frame's cursor type has been changed. */ -/* Nonzero if BEGV - BEG or Z - ZV of current buffer has changed - since last redisplay that finished. */ -extern int clip_changed; +extern int cursor_type_changed; -/* Nonzero if window sizes or contents have changed - since last redisplay that finished */ -extern int windows_or_buffers_changed; +/* Number of windows displaying the selected buffer. Normally this is + 1, but it can be more. */ -/* Number of windows displaying the selected buffer. - Normally this is 1, but it can be more. */ extern int buffer_shared; /* If *ROWS or *COLS are too small a size for FRAME, set them to the minimum allowable size. */ -extern void check_frame_size ( /* FRAME_PTR frame, int *rows, int *cols */ ); + +extern void check_frame_size P_ ((struct frame *frame, int *rows, int *cols)); + +/* Return a pointer to the glyph W's physical cursor is on. Value is + null if W's current matrix is invalid, so that no meaningfull glyph + can be returned. */ + +struct glyph *get_phys_cursor_glyph P_ ((struct window *w)); + +/* Value is non-zero if WINDOW is a live window. */ + +#define WINDOW_LIVE_P(WINDOW) \ + (WINDOWP ((WINDOW)) && !NILP (XWINDOW ((WINDOW))->buffer)) + + +/* These used to be in lisp.h. */ + +extern Lisp_Object Qwindowp, Qwindow_live_p; +extern Lisp_Object Vwindow_list; + +EXFUN (Fwindow_end, 2); +EXFUN (Fselected_window, 0); +EXFUN (Fdelete_window, 1); +EXFUN (Fwindow_buffer, 1); +EXFUN (Fget_buffer_window, 2); +EXFUN (Fsave_window_excursion, UNEVALLED); +EXFUN (Fsplit_window, 3); +EXFUN (Fset_window_configuration, 1); +EXFUN (Fcurrent_window_configuration, 1); +extern int compare_window_configurations P_ ((Lisp_Object, Lisp_Object, int)); +EXFUN (Fcoordinates_in_window_p, 2); +EXFUN (Fwindow_at, 3); +EXFUN (Fpos_visible_in_window_p, 3); +extern void mark_window_cursors_off P_ ((struct window *)); +extern int window_internal_height P_ ((struct window *)); +extern int window_internal_width P_ ((struct window *)); +EXFUN (Frecenter, 1); +EXFUN (Fscroll_other_window, 1); +EXFUN (Fset_window_start, 3); +extern void temp_output_buffer_show P_ ((Lisp_Object)); +extern void replace_buffer_in_all_windows P_ ((Lisp_Object)); +extern void init_window_once P_ ((void)); +extern void init_window P_ ((void)); +extern void syms_of_window P_ ((void)); +extern void keys_of_window P_ ((void)); + +extern int window_box_text_cols P_ ((struct window *w)); + +#endif /* not WINDOW_H_INCLUDED */ + +/* arch-tag: d4a6942f-e433-4ffe-ac10-2c3574f28577 + (do not change this comment) */