261
|
1 /* Define screen-object for GNU Emacs.
|
732
|
2 Copyright (C) 1988, 1992 Free Software Foundation, Inc.
|
261
|
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
|
732
|
8 the Free Software Foundation; either version 2, or (at your option)
|
261
|
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, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
19
|
|
20
|
732
|
21 /* The structure representing a screen.
|
|
22
|
|
23 We declare this even if MULTI_SCREEN is not defined, because when
|
|
24 we lack multi-screen support, we use one instance of this structure
|
|
25 to represent the one screen we support. This is cleaner than
|
|
26 having miscellaneous random variables scattered about. */
|
261
|
27
|
|
28 enum output_method
|
|
29 { output_termcap, output_x_window };
|
|
30
|
|
31 struct screen
|
|
32 {
|
|
33 int size;
|
|
34 struct Lisp_Vector *next;
|
|
35
|
|
36 /* glyphs as they appear on the screen */
|
|
37 struct screen_glyphs *current_glyphs;
|
|
38
|
|
39 /* glyphs we'd like to appear on the screen */
|
|
40 struct screen_glyphs *desired_glyphs;
|
|
41
|
732
|
42 /* See do_line_insertion_deletion_costs for info on these arrays. */
|
261
|
43 /* Cost of inserting 1 line on this screen */
|
|
44 int *insert_line_cost;
|
|
45 /* Cost of deleting 1 line on this screen */
|
|
46 int *delete_line_cost;
|
|
47 /* Cost of inserting n lines on this screen */
|
|
48 int *insert_n_lines_cost;
|
|
49 /* Cost of deleting n lines on this screen */
|
|
50 int *delete_n_lines_cost;
|
|
51
|
|
52 /* glyphs for the mode line */
|
|
53 struct screen_glyphs *temp_glyphs;
|
|
54
|
|
55 /* Intended cursor position of this screen.
|
|
56 Measured in characters, counting from upper left corner
|
|
57 within the screen. */
|
|
58 int cursor_x;
|
|
59 int cursor_y;
|
|
60
|
485
|
61 /* Actual cursor position of this screen, and the character under it.
|
261
|
62 (Not used for terminal screens.) */
|
|
63 int phys_cursor_x;
|
|
64 int phys_cursor_y;
|
485
|
65 /* This is handy for undrawing the cursor, because current_glyphs is
|
|
66 not always accurate when in do_scrolling. */
|
|
67 GLYPH phys_cursor_glyph;
|
261
|
68
|
|
69 /* Size of this screen, in units of characters. */
|
|
70 int height;
|
|
71 int width;
|
|
72
|
|
73 /* New height and width for pending size change. 0 if no change pending. */
|
|
74 int new_height, new_width;
|
|
75
|
|
76 /* Name of this screen: a Lisp string. */
|
|
77 Lisp_Object name;
|
|
78
|
357
|
79 /* The screen which should recieve keystrokes that occur in this
|
|
80 screen. This is usually the screen itself, but if the screen is
|
|
81 minibufferless, this points to the minibuffer screen when it is
|
|
82 active. */
|
|
83 Lisp_Object focus_screen;
|
|
84
|
261
|
85 /* This screen's root window. Every screen has one.
|
|
86 If the screen has only a minibuffer window, this is it.
|
|
87 Otherwise, if the screen has a minibuffer window, this is its sibling. */
|
|
88 Lisp_Object root_window;
|
|
89
|
|
90 /* This screen's selected window.
|
|
91 Each screen has its own window hierarchy
|
|
92 and one of the windows in it is selected within the screen.
|
|
93 The selected window of the selected screen is Emacs's selected window. */
|
|
94 Lisp_Object selected_window;
|
|
95
|
|
96 /* This screen's minibuffer window.
|
|
97 Most screens have their own minibuffer windows,
|
|
98 but only the selected screen's minibuffer window
|
|
99 can actually appear to exist. */
|
|
100 Lisp_Object minibuffer_window;
|
|
101
|
|
102 /* Parameter alist of this screen.
|
|
103 These are the parameters specified when creating the screen
|
|
104 or modified with modify-screen-parameters. */
|
|
105 Lisp_Object param_alist;
|
|
106
|
|
107 /* The output method says how the contents of this screen
|
|
108 are displayed. It could be using termcap, or using an X window. */
|
|
109 enum output_method output_method;
|
|
110
|
|
111 /* A structure of auxiliary data used for displaying the contents.
|
|
112 struct x_display is used for X window screens;
|
|
113 it is defined in xterm.h. */
|
|
114 union display { struct x_display *x; int nothing; } display;
|
|
115
|
|
116 /* Nonzero if last attempt at redisplay on this screen was preempted. */
|
|
117 char display_preempted;
|
|
118
|
|
119 /* Nonzero if screen is currently displayed. */
|
|
120 char visible;
|
|
121
|
|
122 /* Nonzero if window is currently iconified.
|
|
123 This and visible are mutually exclusive. */
|
|
124 char iconified;
|
|
125
|
|
126 /* Nonzero if this screen should be redrawn. */
|
|
127 char garbaged;
|
|
128
|
485
|
129 /* True if screen actually has a minibuffer window on it.
|
261
|
130 0 if using a minibuffer window that isn't on this screen. */
|
|
131 char has_minibuffer;
|
|
132
|
|
133 /* 0 means, if this screen has just one window,
|
|
134 show no modeline for that window. */
|
|
135 char wants_modeline;
|
|
136
|
|
137 /* Non-0 means raise this screen to the top of the heap when selected. */
|
|
138 char auto_raise;
|
|
139
|
|
140 /* Non-0 means lower this screen to the bottom of the stack when left. */
|
|
141 char auto_lower;
|
|
142
|
|
143 /* True if screen's root window can't be split. */
|
|
144 char no_split;
|
|
145
|
|
146 /* Storage for messages to this screen. */
|
|
147 char *message_buf;
|
|
148
|
|
149 /* Nonnegative if current redisplay should not do scroll computation
|
|
150 for lines beyond a certain vpos. This is the vpos. */
|
|
151 int scroll_bottom_vpos;
|
|
152 };
|
|
153
|
732
|
154 #ifdef MULTI_SCREEN
|
|
155
|
261
|
156 typedef struct screen *SCREEN_PTR;
|
|
157
|
|
158 #define XSCREEN(p) ((struct screen *) XPNTR (p))
|
|
159 #define XSETSCREEN(p, v) ((struct screen *) XSETPNTR (p, v))
|
|
160
|
|
161 #define WINDOW_SCREEN(w) (w)->screen
|
|
162
|
485
|
163 #define SCREENP(s) (XTYPE(s) == Lisp_Screen)
|
|
164 #define SCREEN_LIVE_P(s) ((s)->display.nothing != 0)
|
261
|
165 #define SCREEN_IS_TERMCAP(s) ((s)->output_method == output_termcap)
|
|
166 #define SCREEN_IS_X(s) ((s)->output_method == output_x_window)
|
485
|
167 #define SCREEN_MINIBUF_ONLY_P(s) \
|
|
168 EQ (SCREEN_ROOT_WINDOW (s), SCREEN_MINIBUF_WINDOW (s))
|
|
169 #define SCREEN_HAS_MINIBUF(s) ((s)->has_minibuffer)
|
261
|
170 #define SCREEN_CURRENT_GLYPHS(s) (s)->current_glyphs
|
|
171 #define SCREEN_DESIRED_GLYPHS(s) (s)->desired_glyphs
|
|
172 #define SCREEN_TEMP_GLYPHS(s) (s)->temp_glyphs
|
|
173 #define SCREEN_HEIGHT(s) (s)->height
|
|
174 #define SCREEN_WIDTH(s) (s)->width
|
|
175 #define SCREEN_NEW_HEIGHT(s) (s)->new_height
|
|
176 #define SCREEN_NEW_WIDTH(s) (s)->new_width
|
|
177 #define SCREEN_CURSOR_X(s) (s)->cursor_x
|
|
178 #define SCREEN_CURSOR_Y(s) (s)->cursor_y
|
|
179 #define SCREEN_VISIBLE_P(s) (s)->visible
|
732
|
180 #define SET_SCREEN_GARBAGED(s) (screen_garbaged = 1, s->garbaged = 1)
|
261
|
181 #define SCREEN_GARBAGED_P(s) (s)->garbaged
|
|
182 #define SCREEN_NO_SPLIT_P(s) (s)->no_split
|
|
183 #define SCREEN_WANTS_MODELINE_P(s) (s)->wants_modeline
|
|
184 #define SCREEN_ICONIFIED_P(s) (s)->iconified
|
|
185 #define SCREEN_MINIBUF_WINDOW(s) (s)->minibuffer_window
|
|
186 #define SCREEN_ROOT_WINDOW(s) (s)->root_window
|
|
187 #define SCREEN_SELECTED_WINDOW(s) (s)->selected_window
|
|
188 #define SET_GLYPHS_SCREEN(glyphs,screen) ((glyphs)->screen = (screen))
|
|
189 #define SCREEN_INSERT_COST(s) (s)->insert_line_cost
|
|
190 #define SCREEN_DELETE_COST(s) (s)->delete_line_cost
|
|
191 #define SCREEN_INSERTN_COST(s) (s)->insert_n_lines_cost
|
|
192 #define SCREEN_DELETEN_COST(s) (s)->delete_n_lines_cost
|
|
193 #define SCREEN_MESSAGE_BUF(s) (s)->message_buf
|
|
194 #define SCREEN_SCROLL_BOTTOM_VPOS(s) (s)->scroll_bottom_vpos
|
357
|
195 #define SCREEN_FOCUS_SCREEN(s) (s)->focus_screen
|
261
|
196
|
485
|
197 #define CHECK_SCREEN(x, i) \
|
|
198 { \
|
|
199 if (! SCREENP (x)) \
|
|
200 x = wrong_type_argument (Qscreenp, (x)); \
|
|
201 }
|
|
202
|
|
203 #define CHECK_LIVE_SCREEN(x, i) \
|
|
204 { \
|
|
205 if (! SCREENP (x) \
|
|
206 || ! SCREEN_LIVE_P (XSCREEN (x))) \
|
|
207 x = wrong_type_argument (Qlive_screen_p, (x)); \
|
|
208 }
|
|
209
|
732
|
210 /* FOR_EACH_SCREEN (LIST_VAR, SCREEN_VAR) followed by a statement is a
|
|
211 `for' loop which iterates over the elements of Vscreen_list. The
|
|
212 loop will set SCREEN_VAR, a SCREEN_PTR, to each screen in
|
|
213 Vscreen_list in succession and execute the statement. LIST_VAR
|
|
214 should be a Lisp_Object; it is used to iterate through the
|
|
215 Vscreen_list.
|
|
216
|
|
217 If MULTI_SCREEN isn't defined, then this loop expands to something which
|
|
218 executes the statement once. */
|
|
219 #define FOR_EACH_SCREEN(list_var, screen_var) \
|
|
220 for ((list_var) = Vscreen_list; \
|
|
221 (CONSP (list_var) \
|
|
222 && (screen_var = XSCREEN (XCONS (list_var)->car), 1)); \
|
|
223 list_var = XCONS (list_var)->cdr)
|
|
224
|
|
225
|
485
|
226 extern Lisp_Object Qscreenp, Qlive_screen_p;
|
261
|
227
|
|
228 extern struct screen *selected_screen;
|
357
|
229 extern struct screen *last_nonminibuf_screen;
|
261
|
230
|
|
231 extern struct screen *make_terminal_screen ();
|
|
232 extern struct screen *make_screen ();
|
|
233 extern struct screen *make_minibuffer_screen ();
|
|
234 extern struct screen *make_screen_without_minibuffer ();
|
|
235
|
732
|
236 /* Nonzero means SCREEN_MESSAGE_BUF (selected_screen) is being used by
|
|
237 print. */
|
|
238 extern int message_buf_print;
|
|
239
|
261
|
240 extern Lisp_Object Vscreen_list;
|
385
|
241 extern Lisp_Object Vdefault_screen_alist;
|
261
|
242
|
|
243 extern Lisp_Object Vterminal_screen;
|
|
244
|
|
245 #else /* not MULTI_SCREEN */
|
|
246
|
|
247 /* These definitions are used in a single-screen version of Emacs. */
|
|
248
|
|
249 #define SCREEN_PTR int
|
|
250
|
732
|
251 extern struct screen the_only_screen;
|
|
252
|
261
|
253 extern int selected_screen;
|
732
|
254 extern int last_nonminibuf_screen;
|
|
255
|
|
256 /* Nonzero means SCREEN_MESSAGE_BUF (selected_screen) is being used by
|
|
257 print. */
|
|
258 extern int message_buf_print;
|
261
|
259
|
|
260 #define XSCREEN(s) selected_screen
|
|
261 #define WINDOW_SCREEN(w) selected_screen
|
|
262
|
485
|
263 #define SCREENP(s) (XTYPE(s) == Lisp_Screen)
|
|
264 #define SCREEN_LIVE_P(s) 1
|
261
|
265 #define SCREEN_IS_TERMCAP(s) 1
|
485
|
266 #define SCREEN_IS_X(s) 0
|
732
|
267 #define SCREEN_MINIBUF_ONLY_P(s) 0
|
485
|
268 #define SCREEN_HAS_MINIBUF(s) 1
|
732
|
269 #define SCREEN_CURRENT_GLYPHS(s) the_only_screen.current_glyphs
|
|
270 #define SCREEN_DESIRED_GLYPHS(s) the_only_screen.desired_glyphs
|
|
271 #define SCREEN_TEMP_GLYPHS(s) the_only_screen.temp_glyphs
|
|
272 #define SCREEN_HEIGHT(s) the_only_screen.height
|
|
273 #define SCREEN_WIDTH(s) the_only_screen.width
|
|
274 #define SCREEN_NEW_HEIGHT(s) the_only_screen.new_height
|
|
275 #define SCREEN_NEW_WIDTH(s) the_only_screen.new_width
|
|
276 #define SCREEN_CURSOR_X(s) the_only_screen.cursor_x
|
|
277 #define SCREEN_CURSOR_Y(s) the_only_screen.cursor_y
|
261
|
278 #define SCREEN_VISIBLE_P(s) 1
|
732
|
279 #define SET_SCREEN_GARBAGED(s) (screen_garbaged = 1)
|
261
|
280 #define SCREEN_GARBAGED_P(s) screen_garbaged
|
|
281 #define SCREEN_NO_SPLIT_P(s) 0
|
|
282 #define SCREEN_WANTS_MODELINE_P(s) 1
|
|
283 #define SCREEN_ICONIFIED_P(s) 0
|
|
284 #define SCREEN_MINIBUF_WINDOW(s) minibuf_window
|
732
|
285 #define SCREEN_ROOT_WINDOW(s) the_only_screen.root_window
|
261
|
286 #define SCREEN_SELECTED_WINDOW(s) selected_window
|
|
287 #define SET_GLYPHS_SCREEN(glyphs,screen)
|
732
|
288 #define SCREEN_INSERT_COST(screen) the_only_screen.insert_line_cost
|
|
289 #define SCREEN_DELETE_COST(screen) the_only_screen.delete_line_cost
|
|
290 #define SCREEN_INSERTN_COST(screen) the_only_screen.insert_n_lines_cost
|
|
291 #define SCREEN_DELETEN_COST(screen) the_only_screen.delete_n_lines_cost
|
|
292 #define SCREEN_MESSAGE_BUF(s) the_only_screen.message_buf
|
|
293 #define SCREEN_SCROLL_BOTTOM_VPOS(s) the_only_screen.scroll_bottom_vpos
|
|
294 #define SCREEN_FOCUS_SCREEN(s) 0
|
357
|
295
|
|
296 #define CHECK_SCREEN(x, i) { ; }
|
732
|
297 #define CHECK_LIVE_SCREEN(x, y) { ; }
|
261
|
298
|
732
|
299 /* FOR_EACH_SCREEN (LIST_VAR, SCREEN_VAR) followed by a statement is a
|
|
300 `for' loop which iterates over the elements of Vscreen_list. The
|
|
301 loop will set SCREEN_VAR, a SCREEN_PTR, to each screen in
|
|
302 Vscreen_list in succession and execute the statement. LIST_VAR
|
|
303 should be a Lisp_Object; it is used to iterate through the
|
|
304 Vscreen_list.
|
|
305
|
|
306 If MULTI_SCREEN _is_ defined, then this loop expands to a real
|
|
307 `for' loop which traverses Vscreen_list using LIST_VAR and
|
|
308 SCREEN_VAR. */
|
|
309 #define FOR_EACH_SCREEN(list_var, screen_var) \
|
|
310 for (screen_var = (SCREEN_PTR) 1; screen_var; screen_var = (SCREEN_PTR) 0)
|
261
|
311
|
|
312 #endif /* not MULTI_SCREEN */
|