|
872
|
1 /* Window definitions for XEmacs.
|
|
|
2 Copyright (C) 1985, 1986, 1992, 1993, 1994, 1995
|
|
|
3 Free Software Foundation, Inc.
|
|
|
4 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
|
|
|
5 Copyright (C) 1995, 1996, 2002 Ben Wing.
|
|
|
6 Copyright (C) 1996 Chuck Thompson.
|
|
|
7
|
|
|
8 This file is part of XEmacs.
|
|
|
9
|
|
|
10 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
11 under the terms of the GNU General Public License as published by the
|
|
|
12 Free Software Foundation; either version 2, or (at your option) any
|
|
|
13 later version.
|
|
|
14
|
|
|
15 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
18 for more details.
|
|
|
19
|
|
|
20 You should have received a copy of the GNU General Public License
|
|
|
21 along with XEmacs; see the file COPYING. If not, write to
|
|
|
22 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
23 Boston, MA 02111-1307, USA. */
|
|
|
24
|
|
|
25 /* Synched up with: FSF 19.30. */
|
|
|
26
|
|
|
27 #ifndef INCLUDED_window_impl_h_
|
|
|
28 #define INCLUDED_window_impl_h_
|
|
|
29
|
|
|
30 #include "window.h"
|
|
|
31
|
|
|
32 /* All windows in use are arranged into a tree, with pointers up and down.
|
|
|
33
|
|
|
34 Windows that are leaves of the tree are actually displayed
|
|
|
35 and show the contents of buffers. Windows that are not leaves
|
|
|
36 are used for representing the way groups of leaf windows are
|
|
|
37 arranged on the frame. Leaf windows never become non-leaves.
|
|
|
38 They are deleted only by calling delete-window on them (but
|
|
|
39 this can be done implicitly). Combination windows can be created
|
|
|
40 and deleted at any time.
|
|
|
41
|
|
|
42 A leaf window has a non-nil buffer field, and also
|
|
|
43 has markers in its start and pointm fields. Non-leaf windows
|
|
|
44 have nil in these fields.
|
|
|
45
|
|
|
46 Non-leaf windows are either vertical or horizontal combinations.
|
|
|
47
|
|
|
48 A vertical combination window has children that are arranged on the frame
|
|
|
49 one above the next. Its vchild field points to the uppermost child.
|
|
|
50 The parent field of each of the children points to the vertical
|
|
|
51 combination window. The next field of each child points to the
|
|
|
52 child below it, or is nil for the lowest child. The prev field
|
|
|
53 of each child points to the child above it, or is nil for the
|
|
|
54 highest child.
|
|
|
55
|
|
|
56 A horizontal combination window has children that are side by side.
|
|
|
57 Its hchild field points to the leftmost child. In each child
|
|
|
58 the next field points to the child to the right and the prev field
|
|
|
59 points to the child to the left.
|
|
|
60
|
|
|
61 The children of a vertical combination window may be leaf windows
|
|
|
62 or horizontal combination windows. The children of a horizontal
|
|
|
63 combination window may be leaf windows or vertical combination windows.
|
|
|
64
|
|
|
65 At the top of the tree are two windows which have nil as parent.
|
|
|
66 The second of these is minibuf_window. The first one manages all
|
|
|
67 the frame area that is not minibuffer, and is called the root window.
|
|
|
68 Different windows can be the root at different times;
|
|
|
69 initially the root window is a leaf window, but if more windows
|
|
|
70 are created then that leaf window ceases to be root and a newly
|
|
|
71 made combination window becomes root instead.
|
|
|
72
|
|
|
73 In any case, on screens which have an ordinary window and a
|
|
|
74 minibuffer, prev of the minibuf window is the root window and next of
|
|
|
75 the root window is the minibuf window. On minibufferless screens or
|
|
|
76 minibuffer-only screens, the root window and the minibuffer window are
|
|
|
77 one and the same, so its prev and next members are nil.
|
|
|
78
|
|
|
79 A dead window has the `dead' flag set on it. Note that unlike other
|
|
|
80 dead objects, dead windows can be made live again through restoring a
|
|
|
81 window configuration. This means that the values in a dead window
|
|
|
82 need to be preserved, except for those that are reconstructed by from
|
|
|
83 the window configuration. */
|
|
|
84
|
|
|
85 struct window
|
|
|
86 {
|
|
2720
|
87 #ifdef MC_ALLOC
|
|
|
88 struct lrecord_header header;
|
|
|
89 #else /* MC_ALLOC */
|
|
872
|
90 struct lcrecord_header header;
|
|
2720
|
91 #endif /* MC_ALLOC */
|
|
872
|
92
|
|
|
93 /* The upper left corner coordinates of this window,
|
|
|
94 as integers (pixels) relative to upper left corner of frame = 0, 0 */
|
|
|
95 int pixel_left;
|
|
|
96 int pixel_top;
|
|
|
97 /* The size of the window (in pixels) */
|
|
|
98 int pixel_height;
|
|
|
99 int pixel_width;
|
|
|
100
|
|
|
101 /* Number of columns display within the window is scrolled to the left. */
|
|
|
102 int hscroll;
|
|
|
103 /* Idem for the window's modeline */
|
|
|
104 Charcount modeline_hscroll;
|
|
|
105 /* Amount to clip off the top line for pixel-based scrolling. Point
|
|
|
106 will remain constant but this will be incremented to
|
|
|
107 incrementally shift lines up. */
|
|
|
108 int top_yoffset;
|
|
|
109 /* Amount to clip off the left of the lines for pixel-based
|
|
|
110 scrolling. Hscroll will remain constant but this will be
|
|
|
111 incremented to incrementally shift lines left.*/
|
|
|
112 int left_xoffset;
|
|
|
113
|
|
|
114 /* face cache elements correct for this window and its current buffer */
|
|
|
115 face_cachel_dynarr *face_cachels;
|
|
|
116 /* glyph cache elements correct for this window and its current buffer */
|
|
|
117 glyph_cachel_dynarr *glyph_cachels;
|
|
|
118 /* List of starting positions for display lines. Only valid if
|
|
|
119 buffer has not changed. */
|
|
|
120 line_start_cache_dynarr *line_start_cache;
|
|
|
121 int line_cache_validation_override;
|
|
|
122
|
|
|
123 /* Length of longest line currently displayed. Used to control the
|
|
|
124 width of the horizontal scrollbars. */
|
|
|
125 int max_line_len;
|
|
|
126
|
|
|
127 /* Frame coords of point at that time */
|
|
|
128 int last_point_x[3];
|
|
|
129 int last_point_y[3];
|
|
|
130
|
|
|
131 /* Number of characters in buffer past bottom of window,
|
|
|
132 as of last redisplay that finished. */
|
|
|
133 /* need one for each set of display structures */
|
|
|
134 int window_end_pos[3];
|
|
|
135
|
|
|
136 /* Set by the extent code when extents in the gutter are changed. */
|
|
|
137 int gutter_extent_modiff[4];
|
|
|
138
|
|
|
139 /* Set by redisplay to the last position seen. This is used
|
|
|
140 to implement the redisplay-end-trigger-functions. */
|
|
|
141 Charbpos last_redisplay_pos;
|
|
|
142
|
|
|
143 #define WINDOW_SLOT_DECLARATION
|
|
|
144 #define WINDOW_SLOT(slot) Lisp_Object slot;
|
|
|
145 #include "winslots.h"
|
|
|
146
|
|
|
147 /* one-bit flags: */
|
|
|
148
|
|
|
149 /* marker used when restoring a window configuration */
|
|
|
150 unsigned int config_mark :1;
|
|
|
151 /* Non-zero means window was dead. */
|
|
|
152 unsigned int dead :1;
|
|
|
153 /* Non-zero means next redisplay must use the value of start
|
|
|
154 set up for it in advance. Set by scrolling commands. */
|
|
|
155 unsigned int force_start :1;
|
|
|
156 /* Non-zero means must regenerate modeline of this window */
|
|
|
157 unsigned int redo_modeline :1;
|
|
|
158 /* Non-zero means current value of `start'
|
|
|
159 was the beginning of a line when it was chosen. */
|
|
|
160 unsigned int start_at_line_beg :1;
|
|
|
161 /* new redisplay flag */
|
|
|
162 unsigned int windows_changed :1;
|
|
|
163 unsigned int shadow_thickness_changed :1;
|
|
|
164 /* Vertical divider flag and validity of it */
|
|
|
165 unsigned int need_vertical_divider_p :1;
|
|
|
166 unsigned int need_vertical_divider_valid_p :1;
|
|
|
167 };
|
|
|
168
|
|
|
169 #define CURRENT_DISP 0
|
|
|
170 #define DESIRED_DISP 1
|
|
|
171 #define CMOTION_DISP 2
|
|
|
172
|
|
|
173 struct window_mirror
|
|
|
174 {
|
|
2720
|
175 #ifdef MC_ALLOC
|
|
|
176 struct lrecord_header header;
|
|
|
177 #else /* MC_ALLOC */
|
|
872
|
178 struct lcrecord_header header;
|
|
2720
|
179 #endif /* MC_ALLOC */
|
|
872
|
180
|
|
|
181 /* Frame this mirror is on. */
|
|
|
182 struct frame *frame;
|
|
|
183
|
|
|
184 /* Following child (to right or down) at same level of tree */
|
|
|
185 struct window_mirror *next;
|
|
|
186
|
|
|
187 /* There is no prev field because we never traverse this structure
|
|
|
188 backwards. Same goes for the parent field. */
|
|
|
189
|
|
|
190 /* First child of this window. */
|
|
|
191 /* vchild is used if this is a vertical combination,
|
|
|
192 hchild if this is a horizontal combination. */
|
|
|
193 struct window_mirror *hchild, *vchild;
|
|
|
194
|
|
|
195 /* Dynamic array of display lines */
|
|
|
196 display_line_dynarr *current_display_lines;
|
|
|
197 display_line_dynarr *desired_display_lines;
|
|
|
198
|
|
|
199 /* Buffer current_display_lines represent. */
|
|
|
200 struct buffer *buffer;
|
|
|
201
|
|
|
202 #ifdef HAVE_SCROLLBARS
|
|
|
203 /* Scrollbars associated with window, if any. */
|
|
|
204 struct scrollbar_instance *scrollbar_vertical_instance;
|
|
|
205 struct scrollbar_instance *scrollbar_horizontal_instance;
|
|
|
206 #endif /* HAVE_SCROLLBARS */
|
|
|
207
|
|
|
208 /* Flag indicating whether a subwindow is currently being displayed. */
|
|
|
209 unsigned int subwindows_being_displayed :1;
|
|
|
210
|
|
|
211 /* Keep track of the truncation status in this window so we can
|
|
|
212 detect when it has changed. #### Magic variables would be a huge
|
|
|
213 win here. */
|
|
|
214 unsigned int truncate_win :1;
|
|
|
215 };
|
|
|
216
|
|
|
217 /* Redefine basic properties more efficiently */
|
|
|
218
|
|
|
219 #undef WINDOW_LIVE_P
|
|
|
220 #define WINDOW_LIVE_P(x) (!(x)->dead)
|
|
|
221 #undef WINDOW_FRAME
|
|
|
222 #define WINDOW_FRAME(w) ((w)->frame)
|
|
|
223 #undef WINDOW_BUFFER
|
|
|
224 #define WINDOW_BUFFER(w) ((w)->buffer)
|
|
|
225
|
|
|
226 /* 1 if W is a minibuffer window. */
|
|
|
227 #define MINI_WINDOW_P(W) (!NILP ((W)->mini_p))
|
|
|
228
|
|
|
229 /* 1 if we are dealing with a parentless window (this includes the
|
|
|
230 root window on a frame and the minibuffer window; both of these
|
|
|
231 are siblings). */
|
|
|
232 #define TOP_LEVEL_WINDOW_P(w) NILP ((w)->parent)
|
|
|
233
|
|
|
234 /* Set all redisplay flags indicating a window has changed */
|
|
|
235 #define MARK_WINDOWS_CHANGED(w) do { \
|
|
|
236 (w)->windows_changed = 1; \
|
|
|
237 if (!NILP (w->frame)) \
|
|
|
238 { \
|
|
|
239 struct frame *mwc_frame = XFRAME (w->frame); \
|
|
|
240 MARK_FRAME_WINDOWS_CHANGED (mwc_frame); \
|
|
|
241 } \
|
|
|
242 else \
|
|
|
243 windows_changed = 1; \
|
|
|
244 } while (0)
|
|
|
245
|
|
|
246 /* #### This should be fixed not to call MARK_FRAME_CHANGED because
|
|
|
247 faces are cached per window. Also, other code which changes window's
|
|
|
248 face should use this macro.
|
|
|
249 */
|
|
|
250 #define MARK_WINDOW_FACES_CHANGED(w) \
|
|
|
251 MARK_FRAME_FACES_CHANGED (XFRAME ((w)->frame))
|
|
|
252
|
|
|
253 #define WINDOW_TTY_P(w) FRAME_TTY_P (XFRAME ((w)->frame))
|
|
|
254 #define WINDOW_X_P(w) FRAME_X_P (XFRAME ((w)->frame))
|
|
|
255 #define WINDOW_NS_P(w) FRAME_NS_P (XFRAME ((w)->frame))
|
|
|
256 #define WINDOW_WIN_P(w) FRAME_WIN_P (XFRAME ((w)->frame))
|
|
|
257
|
|
|
258 /* XEmacs window size and positioning macros. */
|
|
|
259 #define WINDOW_TOP(w) ((w)->pixel_top)
|
|
|
260 #define WINDOW_TEXT_TOP(w) (WINDOW_TOP (w) + window_top_gutter_height (w))
|
|
|
261 #define WINDOW_TEXT_TOP_CLIP(w) ((w)->top_yoffset)
|
|
|
262 #define WINDOW_BOTTOM(w) ((w)->pixel_top + (w)->pixel_height)
|
|
|
263 #define WINDOW_TEXT_BOTTOM(w) (WINDOW_BOTTOM (w) - window_bottom_gutter_height (w))
|
|
|
264 #define WINDOW_LEFT(w) ((w)->pixel_left)
|
|
|
265 #define WINDOW_TEXT_LEFT(w) (WINDOW_LEFT (w) + window_left_gutter_width (w, 0))
|
|
|
266 #define WINDOW_MODELINE_LEFT(w) \
|
|
|
267 (WINDOW_LEFT (w) + window_left_gutter_width (w, 1))
|
|
|
268 #define WINDOW_RIGHT(w) ((w)->pixel_left + (w)->pixel_width)
|
|
|
269 #define WINDOW_TEXT_RIGHT(w) \
|
|
|
270 (WINDOW_RIGHT (w) - window_right_gutter_width (w, 0))
|
|
|
271 #define WINDOW_MODELINE_RIGHT(w) \
|
|
|
272 (WINDOW_RIGHT (w) - window_right_gutter_width (w, 1))
|
|
|
273
|
|
|
274 #define WINDOW_HEIGHT(w) ((w)->pixel_height)
|
|
|
275 #define WINDOW_TEXT_HEIGHT(w) (WINDOW_TEXT_BOTTOM (w) - WINDOW_TEXT_TOP (w))
|
|
|
276 #define WINDOW_WIDTH(w) ((w)->pixel_width)
|
|
|
277 #define WINDOW_TEXT_WIDTH(w) (WINDOW_TEXT_RIGHT (w) - WINDOW_TEXT_LEFT (w))
|
|
|
278
|
|
|
279 #define WINDOW_HAS_MODELINE_P(w) (!NILP (w->has_modeline_p))
|
|
|
280
|
|
|
281 #define MODELINE_OFF_SHADOW_THICKNESS_ADJUSTED(win) \
|
|
|
282 abs ((!WINDOW_HAS_MODELINE_P (win) \
|
|
|
283 ? ((XINT (win->modeline_shadow_thickness) > 1) \
|
|
|
284 ? XINT (win->modeline_shadow_thickness) - 1 \
|
|
|
285 : ((XINT (win->modeline_shadow_thickness) < -1) \
|
|
|
286 ? XINT (win->modeline_shadow_thickness) + 1 \
|
|
|
287 : XINT (win->modeline_shadow_thickness))) \
|
|
|
288 : XINT (win->modeline_shadow_thickness)))
|
|
|
289
|
|
|
290 #define MODELINE_SHADOW_THICKNESS(win) \
|
|
|
291 (MODELINE_OFF_SHADOW_THICKNESS_ADJUSTED (win) > 10 \
|
|
|
292 ? 10 \
|
|
|
293 : MODELINE_OFF_SHADOW_THICKNESS_ADJUSTED (win))
|
|
|
294
|
|
|
295 #endif /* INCLUDED_window_impl_h_ */
|
