|
0
|
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 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 _XEMACS_WINDOW_H_
|
|
|
28 #define _XEMACS_WINDOW_H_
|
|
|
29
|
|
|
30 #include "redisplay.h"
|
|
|
31 #include "scrollbar.h"
|
|
|
32
|
|
|
33 /* All windows in use are arranged into a tree, with pointers up and down.
|
|
|
34
|
|
|
35 Windows that are leaves of the tree are actually displayed
|
|
|
36 and show the contents of buffers. Windows that are not leaves
|
|
|
37 are used for representing the way groups of leaf windows are
|
|
|
38 arranged on the frame. Leaf windows never become non-leaves.
|
|
|
39 They are deleted only by calling delete-window on them (but
|
|
|
40 this can be done implicitly). Combination windows can be created
|
|
|
41 and deleted at any time.
|
|
|
42
|
|
|
43 A leaf window has a non-nil buffer field, and also
|
|
|
44 has markers in its start and pointm fields. Non-leaf windows
|
|
|
45 have nil in these fields.
|
|
|
46
|
|
|
47 Non-leaf windows are either vertical or horizontal combinations.
|
|
|
48
|
|
|
49 A vertical combination window has children that are arranged on the frame
|
|
|
50 one above the next. Its vchild field points to the uppermost child.
|
|
|
51 The parent field of each of the children points to the vertical
|
|
|
52 combination window. The next field of each child points to the
|
|
|
53 child below it, or is nil for the lowest child. The prev field
|
|
|
54 of each child points to the child above it, or is nil for the
|
|
|
55 highest child.
|
|
|
56
|
|
|
57 A horizontal combination window has children that are side by side.
|
|
|
58 Its hchild field points to the leftmost child. In each child
|
|
|
59 the next field points to the child to the right and the prev field
|
|
|
60 points to the child to the left.
|
|
|
61
|
|
|
62 The children of a vertical combination window may be leaf windows
|
|
|
63 or horizontal combination windows. The children of a horizontal
|
|
|
64 combination window may be leaf windows or vertical combination windows.
|
|
|
65
|
|
|
66 At the top of the tree are two windows which have nil as parent.
|
|
|
67 The second of these is minibuf_window. The first one manages all
|
|
|
68 the frame area that is not minibuffer, and is called the root window.
|
|
|
69 Different windows can be the root at different times;
|
|
|
70 initially the root window is a leaf window, but if more windows
|
|
|
71 are created then that leaf window ceases to be root and a newly
|
|
|
72 made combination window becomes root instead.
|
|
|
73
|
|
|
74 In any case, on screens which have an ordinary window and a
|
|
|
75 minibuffer, prev of the minibuf window is the root window and next of
|
|
|
76 the root window is the minibuf window. On minibufferless screens or
|
|
|
77 minibuffer-only screens, the root window and the minibuffer window are
|
|
|
78 one and the same, so its prev and next members are nil.
|
|
|
79
|
|
|
80 A dead window has the `dead' flag set on it. Note that unlike other
|
|
|
81 dead objects, dead windows can be made live again through restoring a
|
|
|
82 window configuration. This means that the values in a dead window
|
|
|
83 need to be preserved, except for those that are reconstructed by from
|
|
|
84 the window configuration. */
|
|
|
85
|
|
|
86 struct window
|
|
|
87 {
|
|
|
88 struct lcrecord_header header;
|
|
|
89
|
|
|
90 /* The frame this window is on. */
|
|
|
91 Lisp_Object frame;
|
|
|
92 /* t if this window is a minibuffer window. */
|
|
|
93 Lisp_Object mini_p;
|
|
|
94 /* Following child (to right or down) at same level of tree */
|
|
|
95 Lisp_Object next;
|
|
|
96 /* Preceding child (to left or up) at same level of tree */
|
|
|
97 Lisp_Object prev;
|
|
|
98 /* First child of this window. */
|
|
|
99 /* vchild is used if this is a vertical combination,
|
|
|
100 hchild if this is a horizontal combination. */
|
|
|
101 Lisp_Object hchild, vchild;
|
|
|
102 /* The window this one is a child of. */
|
|
|
103 Lisp_Object parent;
|
|
|
104
|
|
|
105 /* The upper left corner coordinates of this window,
|
|
|
106 as integers (pixels) relative to upper left corner of frame = 0, 0 */
|
|
|
107 int pixel_left;
|
|
|
108 int pixel_top;
|
|
|
109 /* The size of the window (in pixels) */
|
|
|
110 int pixel_height;
|
|
|
111 int pixel_width;
|
|
|
112
|
|
|
113 /* The buffer displayed in this window */
|
|
|
114 /* Of the fields vchild, hchild and buffer, only one is non-nil. */
|
|
|
115 Lisp_Object buffer;
|
|
|
116 /* A marker pointing to where in the text to start displaying */
|
|
|
117 /* need one for each set of display structures */
|
|
|
118 Lisp_Object start[3];
|
|
|
119 /* A marker pointing to where in the text point is in this window,
|
|
|
120 used only when the window is not selected.
|
|
|
121 This exists so that when multiple windows show one buffer
|
|
|
122 each one can have its own value of point. */
|
|
|
123 /* need one for each set of display structures */
|
|
|
124 Lisp_Object pointm[3];
|
|
|
125 /* A marker pointing to where in the text the scrollbar is pointing */
|
|
|
126 Lisp_Object sb_point;
|
|
|
127 /* Number of columns display within the window is scrolled to the left. */
|
|
|
128 int hscroll;
|
|
257
|
129 /* Idem for the window's modeline */
|
|
|
130 int modeline_hscroll;
|
|
0
|
131 /* Number saying how recently window was selected */
|
|
|
132 Lisp_Object use_time;
|
|
|
133 /* text.modified of displayed buffer as of last time display completed */
|
|
|
134 Lisp_Object last_modified[3];
|
|
|
135 /* Value of point at that time */
|
|
|
136 Lisp_Object last_point[3];
|
|
|
137 /* Value of start at that time */
|
|
|
138 Lisp_Object last_start[3];
|
|
|
139 /* buf.face_change as of last time display completed */
|
|
|
140 Lisp_Object last_facechange[3];
|
|
|
141
|
|
|
142 /* face cache elements correct for this window and its current buffer */
|
|
|
143 face_cachel_dynarr *face_cachels;
|
|
|
144 /* glyph cache elements correct for this window and its current buffer */
|
|
|
145 glyph_cachel_dynarr *glyph_cachels;
|
|
|
146
|
|
|
147
|
|
|
148 /* List of starting positions for display lines. Only valid if
|
|
|
149 buffer has not changed. */
|
|
|
150 line_start_cache_dynarr *line_start_cache;
|
|
|
151 Lisp_Object line_cache_last_updated;
|
|
|
152 int line_cache_validation_override;
|
|
|
153
|
|
|
154 /* Length of longest line currently displayed. Used to control the
|
|
|
155 width of the horizontal scrollbars. */
|
|
|
156 int max_line_len;
|
|
|
157
|
|
|
158 /* Frame coords of point at that time */
|
|
|
159 int last_point_x[3];
|
|
|
160 int last_point_y[3];
|
|
|
161
|
|
|
162 /* Number of characters in buffer past bottom of window,
|
|
|
163 as of last redisplay that finished. */
|
|
|
164 /* need one for each set of display structures */
|
|
|
165 int window_end_pos[3];
|
|
|
166
|
|
|
167 /* Non-nil means window is marked as dedicated. */
|
|
|
168 Lisp_Object dedicated;
|
|
|
169
|
|
|
170 #if 0 /* FSFmacs */
|
|
|
171 /* The column number currently displayed in this window's mode line,
|
|
|
172 or nil if column numbers are not being displayed. */
|
|
|
173 Lisp_Object column_number_displayed;
|
|
|
174 #endif
|
|
|
175 /* If redisplay in this window goes beyond this buffer position,
|
|
|
176 must run the redisplay-end-trigger-functions. */
|
|
|
177 Lisp_Object redisplay_end_trigger;
|
|
|
178
|
|
|
179 /* Set by redisplay to the last position seen. This is used
|
|
|
180 to implement the redisplay-end-trigger-functions. */
|
|
|
181 Bufpos last_redisplay_pos;
|
|
|
182
|
|
|
183 /* specifier values cached in the struct window: */
|
|
|
184
|
|
|
185 /* Display-table to use for displaying chars in this window. */
|
|
|
186 Lisp_Object display_table;
|
|
|
187 /* Thickness of modeline shadow, in pixels. If negative, draw
|
|
|
188 as recessed. */
|
|
|
189 Lisp_Object modeline_shadow_thickness;
|
|
|
190 /* Non-nil means to display a modeline for the buffer. */
|
|
|
191 Lisp_Object has_modeline_p;
|
|
|
192 #ifdef HAVE_SCROLLBARS
|
|
|
193 /* Width of vertical scrollbars. */
|
|
|
194 Lisp_Object scrollbar_width;
|
|
|
195 /* Height of horizontal scrollbars. */
|
|
|
196 Lisp_Object scrollbar_height;
|
|
282
|
197 /* Whether the scrollbars are visible */
|
|
|
198 Lisp_Object horizontal_scrollbar_visible_p;
|
|
|
199 Lisp_Object vertical_scrollbar_visible_p;
|
|
|
200 /* Scrollbar positions */
|
|
|
201 Lisp_Object scrollbar_on_left_p;
|
|
|
202 Lisp_Object scrollbar_on_top_p;
|
|
0
|
203 /* Pointer to use for vertical and horizontal scrollbars. */
|
|
|
204 Lisp_Object scrollbar_pointer;
|
|
187
|
205 #endif /* HAVE_SCROLLBARS */
|
|
0
|
206 #ifdef HAVE_TOOLBARS
|
|
|
207 /* Toolbar specification for each of the four positions.
|
|
|
208 This is not a size hog because the value here is not copied,
|
|
|
209 and will be shared with the specs in the specifier. */
|
|
|
210 Lisp_Object toolbar[4];
|
|
|
211 /* Toolbar size for each of the four positions. */
|
|
|
212 Lisp_Object toolbar_size[4];
|
|
215
|
213 /* Toolbar border width for each of the four positions. */
|
|
|
214 Lisp_Object toolbar_border_width[4];
|
|
0
|
215 /* Toolbar visibility status for each of the four positions. */
|
|
|
216 Lisp_Object toolbar_visible_p[4];
|
|
|
217 /* Caption status of toolbar. */
|
|
|
218 Lisp_Object toolbar_buttons_captioned_p;
|
|
215
|
219 /* The following five don't really need to be cached except
|
|
0
|
220 that we need to know when they've changed. */
|
|
|
221 Lisp_Object default_toolbar;
|
|
|
222 Lisp_Object default_toolbar_width, default_toolbar_height;
|
|
|
223 Lisp_Object default_toolbar_visible_p;
|
|
215
|
224 Lisp_Object default_toolbar_border_width;
|
|
187
|
225 #endif /* HAVE_TOOLBARS */
|
|
0
|
226 Lisp_Object left_margin_width, right_margin_width;
|
|
|
227 Lisp_Object minimum_line_ascent, minimum_line_descent;
|
|
|
228 Lisp_Object use_left_overflow, use_right_overflow;
|
|
|
229 #ifdef HAVE_MENUBARS
|
|
|
230 /* Visibility of menubar. */
|
|
|
231 Lisp_Object menubar_visible_p;
|
|
187
|
232 #endif /* HAVE_MENUBARS */
|
|
0
|
233 Lisp_Object text_cursor_visible_p;
|
|
|
234
|
|
|
235 /* one-bit flags: */
|
|
|
236
|
|
|
237 /* marker used when restoring a window configuration */
|
|
|
238 unsigned int config_mark :1;
|
|
|
239 /* Non-zero means window was dead. */
|
|
|
240 unsigned int dead :1;
|
|
|
241 /* Non-zero means next redisplay must use the value of start
|
|
|
242 set up for it in advance. Set by scrolling commands. */
|
|
|
243 unsigned int force_start :1;
|
|
|
244 /* Non-zero means must regenerate modeline of this window */
|
|
|
245 unsigned int redo_modeline :1;
|
|
|
246 /* Non-zero means current value of `start'
|
|
|
247 was the beginning of a line when it was chosen. */
|
|
|
248 unsigned int start_at_line_beg :1;
|
|
|
249 /* new redisplay flag */
|
|
|
250 unsigned int windows_changed :1;
|
|
|
251 unsigned int shadow_thickness_changed :1;
|
|
187
|
252 };
|
|
0
|
253
|
|
187
|
254 #define CURRENT_DISP 0
|
|
|
255 #define DESIRED_DISP 1
|
|
|
256 #define CMOTION_DISP 2
|
|
0
|
257
|
|
|
258 struct window_mirror
|
|
|
259 {
|
|
|
260 /* Frame this mirror is on. */
|
|
|
261 struct frame *frame;
|
|
|
262
|
|
|
263 /* Following child (to right or down) at same level of tree */
|
|
|
264 struct window_mirror *next;
|
|
|
265
|
|
|
266 /* There is no prev field because we never traverse this structure
|
|
|
267 backwards. Same goes for the parent field. */
|
|
|
268
|
|
|
269 /* First child of this window. */
|
|
|
270 /* vchild is used if this is a vertical combination,
|
|
|
271 hchild if this is a horizontal combination. */
|
|
|
272 struct window_mirror *hchild, *vchild;
|
|
|
273
|
|
|
274 /* Dynamic array of display lines */
|
|
|
275 display_line_dynarr *current_display_lines;
|
|
|
276 display_line_dynarr *desired_display_lines;
|
|
|
277
|
|
|
278 /* Buffer current_display_lines represent. */
|
|
|
279 struct buffer *buffer;
|
|
|
280
|
|
|
281 #ifdef HAVE_SCROLLBARS
|
|
|
282 /* Scrollbars associated with window, if any. */
|
|
|
283 struct scrollbar_instance *scrollbar_vertical_instance;
|
|
|
284 struct scrollbar_instance *scrollbar_horizontal_instance;
|
|
187
|
285 #endif /* HAVE_SCROLLBARS */
|
|
0
|
286
|
|
|
287 /* Flag indicating whether a subwindow is currently being displayed. */
|
|
74
|
288 unsigned int subwindows_being_displayed :1;
|
|
0
|
289
|
|
|
290 /* Keep track of the truncation status in this window so we can
|
|
|
291 detect when it has changed. #### Magic variables would be a huge
|
|
|
292 win here. */
|
|
74
|
293 unsigned int truncate_win :1;
|
|
0
|
294 };
|
|
|
295
|
|
|
296 #ifdef emacs /* some things other than emacs want the structs */
|
|
|
297
|
|
|
298 DECLARE_LRECORD (window, struct window);
|
|
|
299 #define XWINDOW(x) XRECORD (x, window, struct window)
|
|
|
300 #define XSETWINDOW(x, p) XSETRECORD (x, p, window)
|
|
|
301 #define WINDOWP(x) RECORDP (x, window)
|
|
|
302 #define GC_WINDOWP(x) GC_RECORDP (x, window)
|
|
|
303 #define CHECK_WINDOW(x) CHECK_RECORD (x, window)
|
|
|
304 #define CONCHECK_WINDOW(x) CONCHECK_RECORD (x, window)
|
|
|
305
|
|
|
306 #define WINDOW_LIVE_P(x) (!(x)->dead)
|
|
187
|
307 #define CHECK_LIVE_WINDOW(x) do { \
|
|
|
308 CHECK_WINDOW (x); \
|
|
|
309 if (!WINDOW_LIVE_P (XWINDOW (x))) \
|
|
|
310 dead_wrong_type_argument (Qwindow_live_p, (x)); \
|
|
|
311 } while (0)
|
|
|
312 #define CONCHECK_LIVE_WINDOW(x) do { \
|
|
|
313 CONCHECK_WINDOW (x); \
|
|
|
314 if (!WINDOW_LIVE_P (XWINDOW (x))) \
|
|
|
315 x = wrong_type_argument (Qwindow_live_p, (x)); \
|
|
|
316 } while (0)
|
|
0
|
317
|
|
|
318 /* 1 if W is a minibuffer window. */
|
|
272
|
319 #define MINI_WINDOW_P(W) (!NILP ((W)->mini_p))
|
|
0
|
320
|
|
|
321 /* 1 if we are dealing with a parentless window (this includes the
|
|
|
322 root window on a frame and the minibuffer window; both of these
|
|
|
323 are siblings). */
|
|
|
324 #define TOP_LEVEL_WINDOW_P(w) NILP ((w)->parent)
|
|
|
325
|
|
|
326 /* Set all redisplay flags indicating a window has changed */
|
|
187
|
327 #define MARK_WINDOWS_CHANGED(w) do { \
|
|
|
328 (w)->windows_changed = 1; \
|
|
|
329 if (!NILP (w->frame)) \
|
|
272
|
330 { \
|
|
|
331 struct frame *mwc_frame = XFRAME (w->frame); \
|
|
|
332 MARK_FRAME_WINDOWS_CHANGED (mwc_frame); \
|
|
|
333 } \
|
|
187
|
334 else \
|
|
|
335 windows_changed = 1; \
|
|
|
336 } while (0)
|
|
0
|
337
|
|
|
338 #define WINDOW_TTY_P(w) FRAME_TTY_P (XFRAME ((w)->frame))
|
|
187
|
339 #define WINDOW_X_P(w) FRAME_X_P (XFRAME ((w)->frame))
|
|
|
340 #define WINDOW_NS_P(w) FRAME_NS_P (XFRAME ((w)->frame))
|
|
0
|
341 #define WINDOW_WIN_P(w) FRAME_WIN_P (XFRAME ((w)->frame))
|
|
|
342
|
|
|
343 DECLARE_LRECORD (window_configuration, struct window_config);
|
|
|
344
|
|
272
|
345 EXFUN (Fget_buffer_window, 3);
|
|
|
346 EXFUN (Fmove_to_window_line, 2);
|
|
|
347 EXFUN (Frecenter, 2);
|
|
|
348 EXFUN (Freplace_buffer_in_windows, 1);
|
|
282
|
349 EXFUN (Fselect_window, 2);
|
|
272
|
350 EXFUN (Fselected_window, 1);
|
|
|
351 EXFUN (Fset_window_buffer, 2);
|
|
|
352 EXFUN (Fset_window_hscroll, 2);
|
|
|
353 EXFUN (Fset_window_point, 2);
|
|
|
354 EXFUN (Fset_window_start, 3);
|
|
|
355 EXFUN (Fwindow_buffer, 1);
|
|
|
356 EXFUN (Fwindow_highest_p, 1);
|
|
|
357 EXFUN (Fwindow_point, 1);
|
|
|
358 EXFUN (Fwindow_start, 1);
|
|
|
359
|
|
0
|
360 /* The minibuffer window of the selected frame.
|
|
|
361 Note that you cannot test for minibufferness of an arbitrary window
|
|
|
362 by comparing against this; but you can test for minibufferness of
|
|
|
363 the selected window or of any window that is displayed. */
|
|
|
364 extern Lisp_Object minibuf_window;
|
|
|
365
|
|
|
366 /* Prompt to display in front of the minibuffer contents, or nil */
|
|
|
367 extern Lisp_Object Vminibuf_prompt;
|
|
110
|
368 /* Prompt to display in front of the minibuffer prompt, or nil */
|
|
|
369 extern Lisp_Object Vminibuf_preprompt;
|
|
0
|
370
|
|
|
371 Lisp_Object allocate_window (void);
|
|
|
372 int window_char_width (struct window *, int include_margins_p);
|
|
|
373 int window_char_height (struct window *, int include_gutters_p);
|
|
|
374 int window_displayed_height (struct window *);
|
|
|
375 int window_is_leftmost (struct window *w);
|
|
|
376 int window_is_rightmost (struct window *w);
|
|
|
377 int window_truncation_on (struct window *w);
|
|
|
378 int window_needs_vertical_divider (struct window *);
|
|
|
379 int window_scrollbar_width (struct window *w);
|
|
|
380 int window_scrollbar_height (struct window *w);
|
|
|
381 int window_modeline_height (struct window *w);
|
|
|
382 int window_left_margin_width (struct window *w);
|
|
|
383 int window_right_margin_width (struct window *w);
|
|
|
384 int window_top_gutter_height (struct window *w);
|
|
|
385 int window_bottom_gutter_height (struct window *w);
|
|
|
386 int window_left_gutter_width (struct window *w, int modeline);
|
|
|
387 int window_right_gutter_width (struct window *w, int modeline);
|
|
|
388 int window_bottom_toolbar_height (struct window *w);
|
|
|
389
|
|
|
390 void delete_all_subwindows (struct window *w);
|
|
|
391 void set_window_pixheight (Lisp_Object window, int pixheight,
|
|
|
392 int nodelete);
|
|
|
393 void set_window_pixwidth (Lisp_Object window, int pixwidth,
|
|
|
394 int nodelete);
|
|
|
395 void window_scroll (Lisp_Object window, Lisp_Object n, int direction,
|
|
|
396 Error_behavior errb);
|
|
|
397 int buffer_window_count (struct buffer *b, struct frame *f);
|
|
|
398 int buffer_window_mru (struct window *w);
|
|
|
399 void check_frame_size (struct frame *frame, int *rows, int *cols);
|
|
|
400 struct window *decode_window (Lisp_Object window);
|
|
272
|
401 struct window *find_window_by_pixel_pos (int pix_x, int pix_y, Lisp_Object win);
|
|
0
|
402
|
|
|
403 /* new functions to handle the window mirror */
|
|
|
404 void free_window_mirror (struct window_mirror *mir);
|
|
|
405 Lisp_Object real_window (struct window_mirror *mir, int no_abort);
|
|
|
406 struct window_mirror *find_window_mirror (struct window *w);
|
|
|
407 display_line_dynarr *window_display_lines (struct window *w, int);
|
|
|
408 struct buffer *window_display_buffer (struct window *w);
|
|
|
409 void set_window_display_buffer (struct window *w, struct buffer *b);
|
|
|
410 void update_frame_window_mirror (struct frame *f);
|
|
|
411
|
|
251
|
412 void map_windows (struct frame *f,
|
|
|
413 int (*mapfun) (struct window *w, void *closure),
|
|
|
414 void *closure);
|
|
0
|
415 void some_window_value_changed (Lisp_Object specifier, struct window *w,
|
|
|
416 Lisp_Object oldval);
|
|
|
417
|
|
|
418 #define WINDOW_FRAME(w) ((w)->frame)
|
|
|
419 #define WINDOW_BUFFER(w) ((w)->buffer)
|
|
|
420 #define WINDOW_DEVICE(w) FRAME_DEVICE (XFRAME (WINDOW_FRAME (w)))
|
|
|
421 #define WINDOW_CONSOLE(w) DEVICE_CONSOLE (XDEVICE (WINDOW_DEVICE (w)))
|
|
|
422
|
|
|
423 /* XEmacs window size and positioning macros. */
|
|
|
424 #define WINDOW_TOP(w) ((w)->pixel_top)
|
|
|
425 #define WINDOW_TEXT_TOP(w) (WINDOW_TOP (w) + window_top_gutter_height (w))
|
|
|
426 #define WINDOW_BOTTOM(w) ((w)->pixel_top + (w)->pixel_height)
|
|
|
427 #define WINDOW_TEXT_BOTTOM(w) (WINDOW_BOTTOM (w) - window_bottom_gutter_height (w))
|
|
|
428 #define WINDOW_LEFT(w) ((w)->pixel_left)
|
|
|
429 #define WINDOW_TEXT_LEFT(w) (WINDOW_LEFT (w) + window_left_gutter_width (w, 0))
|
|
|
430 #define WINDOW_MODELINE_LEFT(w) \
|
|
|
431 (WINDOW_LEFT (w) + window_left_gutter_width (w, 1))
|
|
|
432 #define WINDOW_RIGHT(w) ((w)->pixel_left + (w)->pixel_width)
|
|
|
433 #define WINDOW_TEXT_RIGHT(w) \
|
|
|
434 (WINDOW_RIGHT (w) - window_right_gutter_width (w, 0))
|
|
|
435 #define WINDOW_MODELINE_RIGHT(w) \
|
|
|
436 (WINDOW_RIGHT (w) - window_right_gutter_width (w, 1))
|
|
|
437
|
|
|
438 #define WINDOW_HEIGHT(w) ((w)->pixel_height)
|
|
|
439 #define WINDOW_TEXT_HEIGHT(w) (WINDOW_TEXT_BOTTOM (w) - WINDOW_TEXT_TOP (w))
|
|
|
440 #define WINDOW_WIDTH(w) ((w)->pixel_width)
|
|
|
441 #define WINDOW_TEXT_WIDTH(w) (WINDOW_TEXT_RIGHT (w) - WINDOW_TEXT_LEFT (w))
|
|
|
442
|
|
|
443 #define WINDOW_HAS_MODELINE_P(w) (!NILP (w->has_modeline_p))
|
|
|
444
|
|
|
445 #define MODELINE_OFF_SHADOW_THICKNESS_ADJUSTED(win) \
|
|
|
446 abs ((!WINDOW_HAS_MODELINE_P (win) \
|
|
|
447 ? ((XINT (win->modeline_shadow_thickness) > 1) \
|
|
|
448 ? XINT (win->modeline_shadow_thickness) - 1 \
|
|
|
449 : ((XINT (win->modeline_shadow_thickness) < -1) \
|
|
|
450 ? XINT (win->modeline_shadow_thickness) + 1 \
|
|
|
451 : XINT (win->modeline_shadow_thickness))) \
|
|
|
452 : XINT (win->modeline_shadow_thickness)))
|
|
|
453
|
|
|
454 #define MODELINE_SHADOW_THICKNESS(win) \
|
|
|
455 (MODELINE_OFF_SHADOW_THICKNESS_ADJUSTED (win) > 10 \
|
|
|
456 ? 10 \
|
|
|
457 : MODELINE_OFF_SHADOW_THICKNESS_ADJUSTED (win))
|
|
|
458
|
|
|
459 #endif /* emacs */
|
|
|
460
|
|
|
461 #endif /* _XEMACS_WINDOW_H_ */
|
