Mercurial > emacs
annotate src/window.c @ 4413:5a00cec8e9b0
(fill-region-as-paragraph): When we take one word
after the fill column, don't stop at period with just one space.
When checking whether at beginning of line, if no fill prefix,
ignore intervening whitespace.
author | Richard M. Stallman <rms@gnu.org> |
---|---|
date | Mon, 02 Aug 1993 05:55:56 +0000 |
parents | d6b289b1a6dc |
children | 9fc21d8d9441 |
rev | line source |
---|---|
265 | 1 /* Window creation, deletion and examination for GNU Emacs. |
2 Does not include redisplay. | |
2961 | 3 Copyright (C) 1985, 1986, 1987, 1993 Free Software Foundation, Inc. |
265 | 4 |
5 This file is part of GNU Emacs. | |
6 | |
7 GNU Emacs is free software; you can redistribute it and/or modify | |
8 it under the terms of the GNU General Public License as published by | |
708 | 9 the Free Software Foundation; either version 2, or (at your option) |
265 | 10 any later version. |
11 | |
12 GNU Emacs is distributed in the hope that it will be useful, | |
13 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 GNU General Public License for more details. | |
16 | |
17 You should have received a copy of the GNU General Public License | |
18 along with GNU Emacs; see the file COPYING. If not, write to | |
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
20 | |
21 #include "config.h" | |
22 #include "lisp.h" | |
23 #include "buffer.h" | |
769 | 24 #include "frame.h" |
265 | 25 #include "window.h" |
26 #include "commands.h" | |
27 #include "indent.h" | |
28 #include "termchar.h" | |
29 #include "disptab.h" | |
522 | 30 #include "keyboard.h" |
265 | 31 |
2210
22d78dbb3cc7
Rename `live-window-p' to `window-live-p', for consistency with
Jim Blandy <jimb@redhat.com>
parents:
2190
diff
changeset
|
32 Lisp_Object Qwindowp, Qwindow_live_p; |
265 | 33 |
34 Lisp_Object Fnext_window (), Fdelete_window (), Fselect_window (); | |
35 Lisp_Object Fset_window_buffer (), Fsplit_window (), Frecenter (); | |
36 | |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
37 void delete_all_subwindows (); |
265 | 38 static struct window *decode_window(); |
39 | |
40 /* This is the window in which the terminal's cursor should | |
41 be left when nothing is being done with it. This must | |
42 always be a leaf window, and its buffer is selected by | |
43 the top level editing loop at the end of each command. | |
44 | |
45 This value is always the same as | |
769 | 46 FRAME_SELECTED_WINDOW (selected_frame). */ |
265 | 47 |
48 Lisp_Object selected_window; | |
49 | |
769 | 50 /* The minibuffer window of the selected frame. |
265 | 51 Note that you cannot test for minibufferness of an arbitrary window |
52 by comparing against this; but you can test for minibufferness of | |
53 the selected window. */ | |
54 Lisp_Object minibuf_window; | |
55 | |
56 /* Non-nil means it is the window for C-M-v to scroll | |
57 when the minibuffer is selected. */ | |
58 Lisp_Object Vminibuf_scroll_window; | |
59 | |
60 /* Non-nil means this is the buffer whose window C-M-v should scroll. */ | |
61 Lisp_Object Vother_window_scroll_buffer; | |
62 | |
63 /* Non-nil means it's function to call to display temp buffers. */ | |
64 Lisp_Object Vtemp_buffer_show_function; | |
65 | |
66 /* If a window gets smaller than either of these, it is removed. */ | |
67 int window_min_height; | |
68 int window_min_width; | |
69 | |
70 /* Nonzero implies Fdisplay_buffer should create windows. */ | |
71 int pop_up_windows; | |
72 | |
769 | 73 /* Nonzero implies make new frames for Fdisplay_buffer. */ |
74 int pop_up_frames; | |
265 | 75 |
76 /* Non-nil means use this function instead of default */ | |
769 | 77 Lisp_Object Vpop_up_frame_function; |
265 | 78 |
79 /* Function to call to handle Fdisplay_buffer. */ | |
80 Lisp_Object Vdisplay_buffer_function; | |
81 | |
82 /* Fdisplay_buffer always splits the largest window | |
83 if that window is more than this high. */ | |
84 int split_height_threshold; | |
85 | |
86 /* Number of lines of continuity in scrolling by screenfuls. */ | |
87 int next_screen_context_lines; | |
88 | |
89 /* Incremented for each window created. */ | |
90 static int sequence_number; | |
91 | |
92 #define min(a, b) ((a) < (b) ? (a) : (b)) | |
93 | |
94 DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0, | |
95 "Returns t if OBJ is a window.") | |
96 (obj) | |
97 Lisp_Object obj; | |
98 { | |
99 return XTYPE (obj) == Lisp_Window ? Qt : Qnil; | |
100 } | |
101 | |
2210
22d78dbb3cc7
Rename `live-window-p' to `window-live-p', for consistency with
Jim Blandy <jimb@redhat.com>
parents:
2190
diff
changeset
|
102 DEFUN ("window-live-p", Fwindow_live_p, Swindow_live_p, 1, 1, 0, |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
103 "Returns t if OBJ is a window which is currently visible.") |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
104 (obj) |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
105 Lisp_Object obj; |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
106 { |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
107 return ((XTYPE (obj) == Lisp_Window |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
108 && ! NILP (XWINDOW (obj)->buffer)) |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
109 ? Qt : Qnil); |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
110 } |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
111 |
265 | 112 Lisp_Object |
113 make_window () | |
114 { | |
115 register Lisp_Object val; | |
116 register struct window *p; | |
117 | |
118 /* Add sizeof (Lisp_Object) here because sizeof (struct Lisp_Vector) | |
119 includes the first element. */ | |
120 val = Fmake_vector ( | |
121 make_number ((sizeof (struct window) - sizeof (struct Lisp_Vector) | |
122 + sizeof (Lisp_Object)) | |
123 / sizeof (Lisp_Object)), | |
124 Qnil); | |
125 XSETTYPE (val, Lisp_Window); | |
126 p = XWINDOW (val); | |
127 XFASTINT (p->sequence_number) = ++sequence_number; | |
128 XFASTINT (p->left) = XFASTINT (p->top) | |
129 = XFASTINT (p->height) = XFASTINT (p->width) | |
130 = XFASTINT (p->hscroll) = 0; | |
131 XFASTINT (p->last_point_x) = XFASTINT (p->last_point_y) = 0; | |
132 p->start = Fmake_marker (); | |
133 p->pointm = Fmake_marker (); | |
134 XFASTINT (p->use_time) = 0; | |
769 | 135 p->frame = Qnil; |
265 | 136 p->display_table = Qnil; |
137 p->dedicated = Qnil; | |
138 return val; | |
139 } | |
140 | |
141 DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 0, 0, | |
142 "Return the window that the cursor now appears in and commands apply to.") | |
143 () | |
144 { | |
145 return selected_window; | |
146 } | |
147 | |
1123
55e605674fb1
* window.c (minibuffer_window): Accept an optional FRAME argument;
Jim Blandy <jimb@redhat.com>
parents:
1049
diff
changeset
|
148 DEFUN ("minibuffer-window", Fminibuffer_window, Sminibuffer_window, 0, 1, 0, |
55e605674fb1
* window.c (minibuffer_window): Accept an optional FRAME argument;
Jim Blandy <jimb@redhat.com>
parents:
1049
diff
changeset
|
149 "Return the window used now for minibuffers.\n\ |
55e605674fb1
* window.c (minibuffer_window): Accept an optional FRAME argument;
Jim Blandy <jimb@redhat.com>
parents:
1049
diff
changeset
|
150 If the optional argument FRAME is specified, return the minibuffer window\n\ |
55e605674fb1
* window.c (minibuffer_window): Accept an optional FRAME argument;
Jim Blandy <jimb@redhat.com>
parents:
1049
diff
changeset
|
151 used by that frame.") |
55e605674fb1
* window.c (minibuffer_window): Accept an optional FRAME argument;
Jim Blandy <jimb@redhat.com>
parents:
1049
diff
changeset
|
152 (frame) |
55e605674fb1
* window.c (minibuffer_window): Accept an optional FRAME argument;
Jim Blandy <jimb@redhat.com>
parents:
1049
diff
changeset
|
153 Lisp_Object frame; |
265 | 154 { |
769 | 155 #ifdef MULTI_FRAME |
1123
55e605674fb1
* window.c (minibuffer_window): Accept an optional FRAME argument;
Jim Blandy <jimb@redhat.com>
parents:
1049
diff
changeset
|
156 if (NILP (frame)) |
55e605674fb1
* window.c (minibuffer_window): Accept an optional FRAME argument;
Jim Blandy <jimb@redhat.com>
parents:
1049
diff
changeset
|
157 XSET (frame, Lisp_Frame, selected_frame); |
55e605674fb1
* window.c (minibuffer_window): Accept an optional FRAME argument;
Jim Blandy <jimb@redhat.com>
parents:
1049
diff
changeset
|
158 else |
55e605674fb1
* window.c (minibuffer_window): Accept an optional FRAME argument;
Jim Blandy <jimb@redhat.com>
parents:
1049
diff
changeset
|
159 CHECK_LIVE_FRAME (frame, 0); |
55e605674fb1
* window.c (minibuffer_window): Accept an optional FRAME argument;
Jim Blandy <jimb@redhat.com>
parents:
1049
diff
changeset
|
160 #endif |
55e605674fb1
* window.c (minibuffer_window): Accept an optional FRAME argument;
Jim Blandy <jimb@redhat.com>
parents:
1049
diff
changeset
|
161 |
55e605674fb1
* window.c (minibuffer_window): Accept an optional FRAME argument;
Jim Blandy <jimb@redhat.com>
parents:
1049
diff
changeset
|
162 return FRAME_MINIBUF_WINDOW (XFRAME (frame)); |
265 | 163 } |
164 | |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
165 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, Swindow_minibuffer_p, 0, 1, 0, |
265 | 166 "Returns non-nil if WINDOW is a minibuffer window.") |
167 (window) | |
168 Lisp_Object window; | |
169 { | |
170 struct window *w = decode_window (window); | |
171 return (MINI_WINDOW_P (w) ? Qt : Qnil); | |
172 } | |
173 | |
174 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p, | |
175 Spos_visible_in_window_p, 0, 2, 0, | |
769 | 176 "Return t if position POS is currently on the frame in WINDOW.\n\ |
265 | 177 Returns nil if that position is scrolled vertically out of view.\n\ |
178 POS defaults to point; WINDOW, to the selected window.") | |
179 (pos, window) | |
180 Lisp_Object pos, window; | |
181 { | |
182 register struct window *w; | |
183 register int top; | |
184 register int height; | |
185 register int posint; | |
186 register struct buffer *buf; | |
187 struct position posval; | |
188 | |
485 | 189 if (NILP (pos)) |
265 | 190 posint = point; |
191 else | |
192 { | |
193 CHECK_NUMBER_COERCE_MARKER (pos, 0); | |
194 posint = XINT (pos); | |
195 } | |
196 | |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
197 w = decode_window (window); |
265 | 198 top = marker_position (w->start); |
199 | |
200 if (posint < top) | |
201 return Qnil; | |
202 | |
203 height = XFASTINT (w->height) - ! MINI_WINDOW_P (w); | |
204 | |
205 buf = XBUFFER (w->buffer); | |
206 if (XFASTINT (w->last_modified) >= BUF_MODIFF (buf)) | |
207 { | |
769 | 208 /* If frame is up to date, |
265 | 209 use the info recorded about how much text fit on it. */ |
210 if (posint < BUF_Z (buf) - XFASTINT (w->window_end_pos) | |
211 || (XFASTINT (w->window_end_vpos) < height)) | |
212 return Qt; | |
213 return Qnil; | |
214 } | |
215 else | |
216 { | |
217 if (posint > BUF_Z (buf)) | |
218 return Qnil; | |
219 | |
220 /* If that info is not correct, calculate afresh */ | |
221 posval = *compute_motion (top, 0, 0, posint, height, 0, | |
1783
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
222 window_internal_width (w) - 1, |
265 | 223 XINT (w->hscroll), 0); |
224 | |
225 return posval.vpos < height ? Qt : Qnil; | |
226 } | |
227 } | |
228 | |
229 static struct window * | |
230 decode_window (window) | |
231 register Lisp_Object window; | |
232 { | |
485 | 233 if (NILP (window)) |
265 | 234 return XWINDOW (selected_window); |
235 | |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
236 CHECK_LIVE_WINDOW (window, 0); |
265 | 237 return XWINDOW (window); |
238 } | |
239 | |
240 DEFUN ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0, | |
241 "Return the buffer that WINDOW is displaying.") | |
242 (window) | |
243 Lisp_Object window; | |
244 { | |
245 return decode_window (window)->buffer; | |
246 } | |
247 | |
248 DEFUN ("window-height", Fwindow_height, Swindow_height, 0, 1, 0, | |
249 "Return the number of lines in WINDOW (including its mode line).") | |
250 (window) | |
251 Lisp_Object window; | |
252 { | |
253 return decode_window (window)->height; | |
254 } | |
255 | |
256 DEFUN ("window-width", Fwindow_width, Swindow_width, 0, 1, 0, | |
257 "Return the number of columns in WINDOW.") | |
258 (window) | |
259 Lisp_Object window; | |
260 { | |
261 register struct window *w = decode_window (window); | |
1525
f79a22ad87d0
* window.c (Fwindow_width, Fset_window_hscroll): Use accessors on
Jim Blandy <jimb@redhat.com>
parents:
1444
diff
changeset
|
262 register int width = XFASTINT (w->width); |
265 | 263 |
1783
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
264 return make_number (window_internal_width (w)); |
265 | 265 } |
266 | |
267 DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0, | |
268 "Return the number of columns by which WINDOW is scrolled from left margin.") | |
269 (window) | |
270 Lisp_Object window; | |
271 { | |
272 return decode_window (window)->hscroll; | |
273 } | |
274 | |
275 DEFUN ("set-window-hscroll", Fset_window_hscroll, Sset_window_hscroll, 2, 2, 0, | |
276 "Set number of columns WINDOW is scrolled from left margin to NCOL.\n\ | |
277 NCOL should be zero or positive.") | |
278 (window, ncol) | |
279 register Lisp_Object window, ncol; | |
280 { | |
281 register struct window *w; | |
282 | |
283 CHECK_NUMBER (ncol, 1); | |
284 if (XINT (ncol) < 0) XFASTINT (ncol) = 0; | |
285 if (XFASTINT (ncol) >= (1 << (SHORTBITS - 1))) | |
286 args_out_of_range (ncol, Qnil); | |
287 w = decode_window (window); | |
1525
f79a22ad87d0
* window.c (Fwindow_width, Fset_window_hscroll): Use accessors on
Jim Blandy <jimb@redhat.com>
parents:
1444
diff
changeset
|
288 if (XINT (w->hscroll) != XINT (ncol)) |
265 | 289 clip_changed = 1; /* Prevent redisplay shortcuts */ |
290 w->hscroll = ncol; | |
291 return ncol; | |
292 } | |
293 | |
294 DEFUN ("window-edges", Fwindow_edges, Swindow_edges, 0, 1, 0, | |
295 "Return a list of the edge coordinates of WINDOW.\n\ | |
769 | 296 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.\n\ |
265 | 297 RIGHT is one more than the rightmost column used by WINDOW,\n\ |
298 and BOTTOM is one more than the bottommost row used by WINDOW\n\ | |
299 and its mode-line.") | |
300 (window) | |
301 Lisp_Object window; | |
302 { | |
303 register struct window *w = decode_window (window); | |
304 | |
305 return Fcons (w->left, Fcons (w->top, | |
306 Fcons (make_number (XFASTINT (w->left) + XFASTINT (w->width)), | |
307 Fcons (make_number (XFASTINT (w->top) | |
308 + XFASTINT (w->height)), | |
309 Qnil)))); | |
310 } | |
311 | |
432 | 312 /* Test if the character at column *x, row *y is within window *w. |
313 If it is not, return 0; | |
314 if it is in the window's text area, | |
315 set *x and *y to its location relative to the upper left corner | |
316 of the window, and | |
317 return 1; | |
318 if it is on the window's modeline, return 2; | |
319 if it is on the border between the window and its right sibling, | |
320 return 3. */ | |
321 static int | |
322 coordinates_in_window (w, x, y) | |
323 register struct window *w; | |
324 register int *x, *y; | |
325 { | |
326 register int left = XINT (w->left); | |
327 register int width = XINT (w->width); | |
328 register int window_height = XINT (w->height); | |
329 register int top = XFASTINT (w->top); | |
330 | |
331 if ( *x < left || *x >= left + width | |
332 || *y < top || *y >= top + window_height) | |
333 return 0; | |
334 | |
335 /* Is the character is the mode line? */ | |
336 if (*y == top + window_height - 1 | |
1049
25046e48ce9a
* window.c (coordinates_in_window): Do not assume that all
Jim Blandy <jimb@redhat.com>
parents:
1016
diff
changeset
|
337 && ! MINI_WINDOW_P (w)) |
432 | 338 return 2; |
339 | |
340 /* Is the character in the right border? */ | |
341 if (*x == left + width - 1 | |
769 | 342 && left + width != FRAME_WIDTH (XFRAME (w->frame))) |
432 | 343 return 3; |
344 | |
345 *x -= left; | |
346 *y -= top; | |
347 return 1; | |
348 } | |
349 | |
350 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p, | |
351 Scoordinates_in_window_p, 2, 2, 0, | |
352 "Return non-nil if COORDINATES are in WINDOW.\n\ | |
708 | 353 COORDINATES is a cons of the form (X . Y), X and Y being distances\n\ |
769 | 354 measured in characters from the upper-left corner of the frame.\n\ |
708 | 355 (0 . 0) denotes the character in the upper left corner of the\n\ |
769 | 356 frame.\n\ |
432 | 357 If COORDINATES are in the text portion of WINDOW,\n\ |
358 the coordinates relative to the window are returned.\n\ | |
732 | 359 If they are in the mode line of WINDOW, `mode-line' is returned.\n\ |
432 | 360 If they are on the border between WINDOW and its right sibling,\n\ |
732 | 361 `vertical-line' is returned.") |
432 | 362 (coordinates, window) |
363 register Lisp_Object coordinates, window; | |
364 { | |
365 int x, y; | |
366 | |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
367 CHECK_LIVE_WINDOW (window, 0); |
432 | 368 CHECK_CONS (coordinates, 1); |
369 x = XINT (Fcar (coordinates)); | |
370 y = XINT (Fcdr (coordinates)); | |
371 | |
372 switch (coordinates_in_window (XWINDOW (window), &x, &y)) | |
373 { | |
374 case 0: /* NOT in window at all. */ | |
375 return Qnil; | |
376 | |
377 case 1: /* In text part of window. */ | |
378 return Fcons (x, y); | |
379 | |
380 case 2: /* In mode line of window. */ | |
381 return Qmode_line; | |
382 | |
383 case 3: /* On right border of window. */ | |
732 | 384 return Qvertical_line; |
432 | 385 |
386 default: | |
387 abort (); | |
388 } | |
389 } | |
390 | |
265 | 391 /* Find the window containing column x, row y, and return it as a |
432 | 392 Lisp_Object. If x, y is on the window's modeline, set *part |
393 to 1; if it is on the separating line between the window and its | |
394 right sibling, set it to 2; otherwise set it to 0. If there is no | |
395 window under x, y return nil and leave *part unmodified. */ | |
265 | 396 Lisp_Object |
769 | 397 window_from_coordinates (frame, x, y, part) |
398 FRAME_PTR frame; | |
265 | 399 int x, y; |
432 | 400 int *part; |
265 | 401 { |
402 register Lisp_Object tem, first; | |
403 | |
769 | 404 tem = first = FRAME_SELECTED_WINDOW (frame); |
265 | 405 |
432 | 406 do |
265 | 407 { |
408 int found = coordinates_in_window (XWINDOW (tem), &x, &y); | |
409 | |
410 if (found) | |
411 { | |
432 | 412 *part = found - 1; |
265 | 413 return tem; |
414 } | |
415 | |
432 | 416 tem = Fnext_window (tem, Qt, Qlambda); |
265 | 417 } |
432 | 418 while (! EQ (tem, first)); |
419 | |
420 return Qnil; | |
265 | 421 } |
422 | |
681
026f978690be
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
555
diff
changeset
|
423 DEFUN ("window-at", Fwindow_at, Swindow_at, 2, 3, 0, |
1798 | 424 "Return window containing coordinates X and Y on FRAME.\n\ |
769 | 425 If omitted, FRAME defaults to the currently selected frame.\n\ |
426 The top left corner of the frame is considered to be row 0,\n\ | |
548 | 427 column 0.") |
1798 | 428 (x, y, frame) |
429 Lisp_Object x, y, frame; | |
265 | 430 { |
431 int part; | |
432 | |
983
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
433 #ifdef MULTI_FRAME |
769 | 434 if (NILP (frame)) |
435 XSET (frame, Lisp_Frame, selected_frame); | |
432 | 436 else |
769 | 437 CHECK_LIVE_FRAME (frame, 2); |
983
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
438 #endif |
1798 | 439 CHECK_NUMBER (x, 0); |
440 CHECK_NUMBER (y, 1); | |
265 | 441 |
769 | 442 return window_from_coordinates (XFRAME (frame), |
1798 | 443 XINT (x), XINT (y), |
265 | 444 &part); |
445 } | |
446 | |
447 DEFUN ("window-point", Fwindow_point, Swindow_point, 0, 1, 0, | |
448 "Return current value of point in WINDOW.\n\ | |
449 For a nonselected window, this is the value point would have\n\ | |
450 if that window were selected.\n\ | |
451 \n\ | |
452 Note that, when WINDOW is the selected window and its buffer\n\ | |
453 is also currently selected, the value returned is the same as (point).\n\ | |
454 It would be more strictly correct to return the `top-level' value\n\ | |
455 of point, outside of any save-excursion forms.\n\ | |
456 But that is hard to define.") | |
457 (window) | |
458 Lisp_Object window; | |
459 { | |
460 register struct window *w = decode_window (window); | |
461 | |
462 if (w == XWINDOW (selected_window) | |
463 && current_buffer == XBUFFER (w->buffer)) | |
464 return Fpoint (); | |
465 return Fmarker_position (w->pointm); | |
466 } | |
467 | |
468 DEFUN ("window-start", Fwindow_start, Swindow_start, 0, 1, 0, | |
469 "Return position at which display currently starts in WINDOW.") | |
470 (window) | |
471 Lisp_Object window; | |
472 { | |
473 return Fmarker_position (decode_window (window)->start); | |
474 } | |
475 | |
476 DEFUN ("window-end", Fwindow_end, Swindow_end, 0, 1, 0, | |
477 "Return position at which display currently ends in WINDOW.") | |
478 (window) | |
479 Lisp_Object window; | |
480 { | |
481 Lisp_Object value; | |
482 struct window *w = decode_window (window); | |
4292
990f6ee7f527
(Fset_window_buffer): Clear window_end_{pos,valid}.
Richard M. Stallman <rms@gnu.org>
parents:
4145
diff
changeset
|
483 Lisp_Object buf; |
990f6ee7f527
(Fset_window_buffer): Clear window_end_{pos,valid}.
Richard M. Stallman <rms@gnu.org>
parents:
4145
diff
changeset
|
484 |
990f6ee7f527
(Fset_window_buffer): Clear window_end_{pos,valid}.
Richard M. Stallman <rms@gnu.org>
parents:
4145
diff
changeset
|
485 buf = w->buffer; |
990f6ee7f527
(Fset_window_buffer): Clear window_end_{pos,valid}.
Richard M. Stallman <rms@gnu.org>
parents:
4145
diff
changeset
|
486 CHECK_BUFFER (buf, 0); |
990f6ee7f527
(Fset_window_buffer): Clear window_end_{pos,valid}.
Richard M. Stallman <rms@gnu.org>
parents:
4145
diff
changeset
|
487 |
265 | 488 XSET (value, Lisp_Int, |
4292
990f6ee7f527
(Fset_window_buffer): Clear window_end_{pos,valid}.
Richard M. Stallman <rms@gnu.org>
parents:
4145
diff
changeset
|
489 BUF_Z (XBUFFER (buf)) - XFASTINT (w->window_end_pos)); |
265 | 490 |
491 return value; | |
492 } | |
493 | |
494 DEFUN ("set-window-point", Fset_window_point, Sset_window_point, 2, 2, 0, | |
495 "Make point value in WINDOW be at position POS in WINDOW's buffer.") | |
496 (window, pos) | |
497 Lisp_Object window, pos; | |
498 { | |
499 register struct window *w = decode_window (window); | |
500 | |
501 CHECK_NUMBER_COERCE_MARKER (pos, 1); | |
502 if (w == XWINDOW (selected_window)) | |
503 Fgoto_char (pos); | |
504 else | |
505 set_marker_restricted (w->pointm, pos, w->buffer); | |
506 | |
507 return pos; | |
508 } | |
509 | |
510 DEFUN ("set-window-start", Fset_window_start, Sset_window_start, 2, 3, 0, | |
511 "Make display in WINDOW start at position POS in WINDOW's buffer.\n\ | |
512 Optional third arg NOFORCE non-nil inhibits next redisplay\n\ | |
513 from overriding motion of point in order to display at this exact start.") | |
514 (window, pos, noforce) | |
515 Lisp_Object window, pos, noforce; | |
516 { | |
517 register struct window *w = decode_window (window); | |
518 | |
519 CHECK_NUMBER_COERCE_MARKER (pos, 1); | |
520 set_marker_restricted (w->start, pos, w->buffer); | |
521 /* this is not right, but much easier than doing what is right. */ | |
522 w->start_at_line_beg = Qnil; | |
485 | 523 if (NILP (noforce)) |
265 | 524 w->force_start = Qt; |
525 w->update_mode_line = Qt; | |
526 XFASTINT (w->last_modified) = 0; | |
338 | 527 if (!EQ (window, selected_window)) |
528 windows_or_buffers_changed++; | |
265 | 529 return pos; |
530 } | |
531 | |
532 DEFUN ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p, | |
533 1, 1, 0, | |
534 "Return WINDOW's dedicated object, usually t or nil.\n\ | |
2865
427eadecebd6
* window.c (window-dedicated-p): Doc fix.
Jim Blandy <jimb@redhat.com>
parents:
2693
diff
changeset
|
535 See also `set-window-dedicated-p'.") |
265 | 536 (window) |
537 Lisp_Object window; | |
538 { | |
539 return decode_window (window)->dedicated; | |
540 } | |
541 | |
722
0a2391511b46
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
708
diff
changeset
|
542 DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p, |
0a2391511b46
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
708
diff
changeset
|
543 Sset_window_dedicated_p, 2, 2, 0, |
0a2391511b46
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
708
diff
changeset
|
544 "Control whether WINDOW is dedicated to the buffer it displays.\n\ |
0a2391511b46
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
708
diff
changeset
|
545 If it is dedicated, Emacs will not automatically change\n\ |
0a2391511b46
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
708
diff
changeset
|
546 which buffer appears in it.\n\ |
0a2391511b46
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
708
diff
changeset
|
547 The second argument is the new value for the dedication flag;\n\ |
0a2391511b46
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
708
diff
changeset
|
548 non-nil means yes.") |
265 | 549 (window, arg) |
550 Lisp_Object window, arg; | |
551 { | |
552 register struct window *w = decode_window (window); | |
553 | |
485 | 554 if (NILP (arg)) |
265 | 555 w->dedicated = Qnil; |
556 else | |
722
0a2391511b46
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
708
diff
changeset
|
557 w->dedicated = Qt; |
265 | 558 |
559 return w->dedicated; | |
560 } | |
561 | |
562 DEFUN ("window-display-table", Fwindow_display_table, Swindow_display_table, | |
563 0, 1, 0, | |
564 "Return the display-table that WINDOW is using.") | |
565 (window) | |
566 Lisp_Object window; | |
567 { | |
568 return decode_window (window)->display_table; | |
569 } | |
570 | |
571 /* Get the display table for use currently on window W. | |
572 This is either W's display table or W's buffer's display table. | |
573 Ignore the specified tables if they are not valid; | |
574 if no valid table is specified, return 0. */ | |
575 | |
576 struct Lisp_Vector * | |
577 window_display_table (w) | |
578 struct window *w; | |
579 { | |
580 Lisp_Object tem; | |
581 tem = w->display_table; | |
582 if (XTYPE (tem) == Lisp_Vector && XVECTOR (tem)->size == DISP_TABLE_SIZE) | |
583 return XVECTOR (tem); | |
584 tem = XBUFFER (w->buffer)->display_table; | |
585 if (XTYPE (tem) == Lisp_Vector && XVECTOR (tem)->size == DISP_TABLE_SIZE) | |
586 return XVECTOR (tem); | |
587 tem = Vstandard_display_table; | |
588 if (XTYPE (tem) == Lisp_Vector && XVECTOR (tem)->size == DISP_TABLE_SIZE) | |
589 return XVECTOR (tem); | |
590 return 0; | |
591 } | |
592 | |
555 | 593 DEFUN ("set-window-display-table", Fset_window_display_table, Sset_window_display_table, 2, 2, 0, |
265 | 594 "Set WINDOW's display-table to TABLE.") |
595 (window, table) | |
596 register Lisp_Object window, table; | |
597 { | |
598 register struct window *w; | |
599 register Lisp_Object z; /* Return value. */ | |
600 | |
601 w = decode_window (window); | |
602 w->display_table = table; | |
603 return table; | |
604 } | |
605 | |
606 /* Record info on buffer window w is displaying | |
607 when it is about to cease to display that buffer. */ | |
608 static | |
609 unshow_buffer (w) | |
610 register struct window *w; | |
611 { | |
612 Lisp_Object buf = w->buffer; | |
613 | |
614 if (XBUFFER (buf) != XMARKER (w->pointm)->buffer) | |
615 abort (); | |
616 | |
617 if (w == XWINDOW (selected_window) | |
618 || ! EQ (buf, XWINDOW (selected_window)->buffer)) | |
619 /* Do this except when the selected window's buffer | |
620 is being removed from some other window. */ | |
621 XBUFFER (buf)->last_window_start = marker_position (w->start); | |
622 | |
623 /* Point in the selected window's buffer | |
624 is actually stored in that buffer, and the window's pointm isn't used. | |
625 So don't clobber point in that buffer. */ | |
626 if (! EQ (buf, XWINDOW (selected_window)->buffer)) | |
627 BUF_PT (XBUFFER (buf)) | |
628 = clip_to_bounds (BUF_BEGV (XBUFFER (buf)), | |
629 marker_position (w->pointm), | |
630 BUF_ZV (XBUFFER (buf))); | |
631 } | |
632 | |
633 /* Put replacement into the window structure in place of old. */ | |
634 static | |
635 replace_window (old, replacement) | |
636 Lisp_Object old, replacement; | |
637 { | |
638 register Lisp_Object tem; | |
639 register struct window *o = XWINDOW (old), *p = XWINDOW (replacement); | |
640 | |
769 | 641 /* If OLD is its frame's root_window, then replacement is the new |
642 root_window for that frame. */ | |
265 | 643 |
1525
f79a22ad87d0
* window.c (Fwindow_width, Fset_window_hscroll): Use accessors on
Jim Blandy <jimb@redhat.com>
parents:
1444
diff
changeset
|
644 if (EQ (old, FRAME_ROOT_WINDOW (XFRAME (o->frame)))) |
769 | 645 FRAME_ROOT_WINDOW (XFRAME (o->frame)) = replacement; |
265 | 646 |
647 p->left = o->left; | |
648 p->top = o->top; | |
649 p->width = o->width; | |
650 p->height = o->height; | |
651 | |
652 p->next = tem = o->next; | |
485 | 653 if (!NILP (tem)) |
265 | 654 XWINDOW (tem)->prev = replacement; |
655 | |
656 p->prev = tem = o->prev; | |
485 | 657 if (!NILP (tem)) |
265 | 658 XWINDOW (tem)->next = replacement; |
659 | |
660 p->parent = tem = o->parent; | |
485 | 661 if (!NILP (tem)) |
265 | 662 { |
663 if (EQ (XWINDOW (tem)->vchild, old)) | |
664 XWINDOW (tem)->vchild = replacement; | |
665 if (EQ (XWINDOW (tem)->hchild, old)) | |
666 XWINDOW (tem)->hchild = replacement; | |
667 } | |
668 | |
669 /*** Here, if replacement is a vertical combination | |
670 and so is its new parent, we should make replacement's | |
671 children be children of that parent instead. ***/ | |
672 } | |
673 | |
674 DEFUN ("delete-window", Fdelete_window, Sdelete_window, 0, 1, "", | |
675 "Remove WINDOW from the display. Default is selected window.") | |
676 (window) | |
677 register Lisp_Object window; | |
678 { | |
679 register Lisp_Object tem, parent, sib; | |
680 register struct window *p; | |
681 register struct window *par; | |
682 | |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
683 /* Because this function is called by other C code on non-leaf |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
684 windows, the CHECK_LIVE_WINDOW macro would choke inappropriately, |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
685 so we can't decode_window here. */ |
485 | 686 if (NILP (window)) |
265 | 687 window = selected_window; |
688 else | |
689 CHECK_WINDOW (window, 0); | |
690 p = XWINDOW (window); | |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
691 |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
692 /* It's okay to delete an already-deleted window. */ |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
693 if (NILP (p->buffer) |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
694 && NILP (p->hchild) |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
695 && NILP (p->vchild)) |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
696 return Qnil; |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
697 |
265 | 698 parent = p->parent; |
485 | 699 if (NILP (parent)) |
265 | 700 error ("Attempt to delete minibuffer or sole ordinary window"); |
701 par = XWINDOW (parent); | |
702 | |
703 windows_or_buffers_changed++; | |
704 | |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
705 /* Are we trying to delete any frame's selected window? */ |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
706 { |
3723
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
707 Lisp_Object frame, pwindow; |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
708 |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
709 /* See if the frame's selected window is either WINDOW |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
710 or any subwindow of it, by finding all that window's parents |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
711 and comparing each one with WINDOW. */ |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
712 frame = WINDOW_FRAME (XWINDOW (window)); |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
713 pwindow = FRAME_SELECTED_WINDOW (XFRAME (frame)); |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
714 |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
715 while (!NILP (pwindow)) |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
716 { |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
717 if (EQ (window, pwindow)) |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
718 break; |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
719 pwindow = XWINDOW (pwindow)->parent; |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
720 } |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
721 |
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
722 if (EQ (window, pwindow)) |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
723 { |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
724 Lisp_Object alternative = Fnext_window (window, Qlambda, Qnil); |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
725 |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
726 /* If we're about to delete the selected window on the |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
727 selected frame, then we should use Fselect_window to select |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
728 the new window. On the other hand, if we're about to |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
729 delete the selected window on any other frame, we shouldn't do |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
730 anything but set the frame's selected_window slot. */ |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
731 if (EQ (window, selected_window)) |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
732 Fselect_window (alternative); |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
733 else |
3723
ccb9c93aac80
(Fdelete_window): Handle deleting a parent of the selected window.
Richard M. Stallman <rms@gnu.org>
parents:
3688
diff
changeset
|
734 FRAME_SELECTED_WINDOW (XFRAME (frame)) = alternative; |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
735 } |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
736 } |
265 | 737 |
738 tem = p->buffer; | |
739 /* tem is null for dummy parent windows | |
740 (which have inferiors but not any contents themselves) */ | |
485 | 741 if (!NILP (tem)) |
265 | 742 { |
743 unshow_buffer (p); | |
744 unchain_marker (p->pointm); | |
745 unchain_marker (p->start); | |
746 } | |
747 | |
748 tem = p->next; | |
485 | 749 if (!NILP (tem)) |
265 | 750 XWINDOW (tem)->prev = p->prev; |
751 | |
752 tem = p->prev; | |
485 | 753 if (!NILP (tem)) |
265 | 754 XWINDOW (tem)->next = p->next; |
755 | |
756 if (EQ (window, par->hchild)) | |
757 par->hchild = p->next; | |
758 if (EQ (window, par->vchild)) | |
759 par->vchild = p->next; | |
760 | |
761 /* Find one of our siblings to give our space to. */ | |
762 sib = p->prev; | |
485 | 763 if (NILP (sib)) |
265 | 764 { |
765 /* If p gives its space to its next sibling, that sibling needs | |
766 to have its top/left side pulled back to where p's is. | |
767 set_window_{height,width} will re-position the sibling's | |
768 children. */ | |
769 sib = p->next; | |
1525
f79a22ad87d0
* window.c (Fwindow_width, Fset_window_hscroll): Use accessors on
Jim Blandy <jimb@redhat.com>
parents:
1444
diff
changeset
|
770 XWINDOW (sib)->top = p->top; |
f79a22ad87d0
* window.c (Fwindow_width, Fset_window_hscroll): Use accessors on
Jim Blandy <jimb@redhat.com>
parents:
1444
diff
changeset
|
771 XWINDOW (sib)->left = p->left; |
265 | 772 } |
773 | |
774 /* Stretch that sibling. */ | |
485 | 775 if (!NILP (par->vchild)) |
265 | 776 set_window_height (sib, |
777 XFASTINT (XWINDOW (sib)->height) + XFASTINT (p->height), | |
778 1); | |
485 | 779 if (!NILP (par->hchild)) |
265 | 780 set_window_width (sib, |
781 XFASTINT (XWINDOW (sib)->width) + XFASTINT (p->width), | |
782 1); | |
783 | |
784 /* If parent now has only one child, | |
785 put the child into the parent's place. */ | |
786 tem = par->hchild; | |
485 | 787 if (NILP (tem)) |
265 | 788 tem = par->vchild; |
485 | 789 if (NILP (XWINDOW (tem)->next)) |
265 | 790 replace_window (parent, tem); |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
791 |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
792 /* Since we may be deleting combination windows, we must make sure that |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
793 not only p but all its children have been marked as deleted. */ |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
794 if (! NILP (p->hchild)) |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
795 delete_all_subwindows (XWINDOW (p->hchild)); |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
796 else if (! NILP (p->vchild)) |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
797 delete_all_subwindows (XWINDOW (p->vchild)); |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
798 |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
799 /* Mark this window as deleted. */ |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
800 p->buffer = p->hchild = p->vchild = Qnil; |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
801 |
265 | 802 return Qnil; |
803 } | |
804 | |
432 | 805 |
769 | 806 extern Lisp_Object next_frame (), prev_frame (); |
432 | 807 |
4145
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
808 /* This comment supplies the doc string for `next-window', |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
809 for make-docfile to see. We cannot put this in the real DEFUN |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
810 due to limits in the Unix cpp. |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
811 |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
812 DEFUN ("next-window", Ffoo, Sfoo, 0, 3, 0, |
432 | 813 "Return next window after WINDOW in canonical ordering of windows.\n\ |
814 If omitted, WINDOW defaults to the selected window.\n\ | |
815 \n\ | |
816 Optional second arg MINIBUF t means count the minibuffer window even\n\ | |
817 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\ | |
818 it is active. MINIBUF neither t nor nil means not to count the\n\ | |
819 minibuffer even if it is active.\n\ | |
820 \n\ | |
769 | 821 Several frames may share a single minibuffer; if the minibuffer\n\ |
822 counts, all windows on all frames that share that minibuffer count\n\ | |
432 | 823 too. This means that next-window may be used to iterate through the\n\ |
769 | 824 set of windows even when the minibuffer is on another frame. If the\n\ |
825 minibuffer does not count, only windows from WINDOW's frame count.\n\ | |
432 | 826 \n\ |
769 | 827 Optional third arg ALL-FRAMES t means include windows on all frames.\n\ |
828 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\ | |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
829 above. If neither nil nor t, restrict to WINDOW's frame.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
830 \n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
831 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
832 `next-window' to iterate through the entire cycle of acceptable\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
833 windows, eventually ending up back at the window you started with.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
834 `previous-window' traverses the same cycle, in the reverse order.") |
4145
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
835 (window, minibuf, all_frames) */ |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
836 |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
837 DEFUN ("next-window", Fnext_window, Snext_window, 0, 3, 0, |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
838 0) |
769 | 839 (window, minibuf, all_frames) |
840 register Lisp_Object window, minibuf, all_frames; | |
265 | 841 { |
432 | 842 register Lisp_Object tem; |
843 Lisp_Object start_window; | |
265 | 844 |
485 | 845 if (NILP (window)) |
432 | 846 window = selected_window; |
847 else | |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
848 CHECK_LIVE_WINDOW (window, 0); |
432 | 849 |
850 start_window = window; | |
851 | |
852 /* minibuf == nil may or may not include minibuffers. | |
853 Decide if it does. */ | |
485 | 854 if (NILP (minibuf)) |
432 | 855 minibuf = (minibuf_level ? Qt : Qlambda); |
856 | |
769 | 857 /* all_frames == nil doesn't specify which frames to include. |
858 Decide which frames it includes. */ | |
859 if (NILP (all_frames)) | |
860 all_frames = (EQ (minibuf, Qt) | |
861 ? (FRAME_MINIBUF_WINDOW | |
862 (XFRAME | |
863 (WINDOW_FRAME | |
432 | 864 (XWINDOW (window))))) |
865 : Qnil); | |
769 | 866 else if (! EQ (all_frames, Qt)) |
867 all_frames = Qnil; | |
3621
0576930165ed
(Fscroll_left): Make argument optional.
Richard M. Stallman <rms@gnu.org>
parents:
3535
diff
changeset
|
868 /* Now all_frames is t meaning search all frames, |
0576930165ed
(Fscroll_left): Make argument optional.
Richard M. Stallman <rms@gnu.org>
parents:
3535
diff
changeset
|
869 nil meaning search just current frame, |
0576930165ed
(Fscroll_left): Make argument optional.
Richard M. Stallman <rms@gnu.org>
parents:
3535
diff
changeset
|
870 or a window, meaning search the frame that window belongs to. */ |
432 | 871 |
265 | 872 /* Do this loop at least once, to get the next window, and perhaps |
873 again, if we hit the minibuffer and that is not acceptable. */ | |
874 do | |
875 { | |
876 /* Find a window that actually has a next one. This loop | |
877 climbs up the tree. */ | |
485 | 878 while (tem = XWINDOW (window)->next, NILP (tem)) |
879 if (tem = XWINDOW (window)->parent, !NILP (tem)) | |
265 | 880 window = tem; |
432 | 881 else |
265 | 882 { |
769 | 883 /* We've reached the end of this frame. |
884 Which other frames are acceptable? */ | |
885 tem = WINDOW_FRAME (XWINDOW (window)); | |
886 #ifdef MULTI_FRAME | |
887 if (! NILP (all_frames)) | |
888 tem = next_frame (tem, all_frames); | |
432 | 889 #endif |
769 | 890 tem = FRAME_ROOT_WINDOW (XFRAME (tem)); |
432 | 891 |
265 | 892 break; |
893 } | |
894 | |
895 window = tem; | |
432 | 896 |
265 | 897 /* If we're in a combination window, find its first child and |
898 recurse on that. Otherwise, we've found the window we want. */ | |
899 while (1) | |
900 { | |
485 | 901 if (!NILP (XWINDOW (window)->hchild)) |
265 | 902 window = XWINDOW (window)->hchild; |
485 | 903 else if (!NILP (XWINDOW (window)->vchild)) |
265 | 904 window = XWINDOW (window)->vchild; |
905 else break; | |
906 } | |
907 } | |
432 | 908 /* Which windows are acceptible? |
909 Exit the loop and accept this window if | |
265 | 910 this isn't a minibuffer window, or |
432 | 911 we're accepting minibuffer windows, or |
912 we've come all the way around and we're back at the original window. */ | |
265 | 913 while (MINI_WINDOW_P (XWINDOW (window)) |
432 | 914 && ! EQ (minibuf, Qt) |
1525
f79a22ad87d0
* window.c (Fwindow_width, Fset_window_hscroll): Use accessors on
Jim Blandy <jimb@redhat.com>
parents:
1444
diff
changeset
|
915 && ! EQ (window, start_window)); |
265 | 916 |
917 return window; | |
918 } | |
919 | |
4145
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
920 /* This comment supplies the doc string for `previous-window', |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
921 for make-docfile to see. We cannot put this in the real DEFUN |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
922 due to limits in the Unix cpp. |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
923 |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
924 DEFUN ("previous-window", Ffoo, Sfoo, 0, 3, 0, |
432 | 925 "Return the window preceeding WINDOW in canonical ordering of windows.\n\ |
926 If omitted, WINDOW defaults to the selected window.\n\ | |
927 \n\ | |
928 Optional second arg MINIBUF t means count the minibuffer window even\n\ | |
929 if not active. MINIBUF nil or omitted means count the minibuffer iff\n\ | |
930 it is active. MINIBUF neither t nor nil means not to count the\n\ | |
931 minibuffer even if it is active.\n\ | |
932 \n\ | |
769 | 933 Several frames may share a single minibuffer; if the minibuffer\n\ |
934 counts, all windows on all frames that share that minibuffer count\n\ | |
432 | 935 too. This means that previous-window may be used to iterate through\n\ |
769 | 936 the set of windows even when the minibuffer is on another frame. If\n\ |
937 the minibuffer does not count, only windows from WINDOW's frame\n\ | |
432 | 938 count.\n\ |
939 \n\ | |
769 | 940 Optional third arg ALL-FRAMES t means include windows on all frames.\n\ |
941 ALL-FRAMES nil or omitted means cycle within the frames as specified\n\ | |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
942 above. If neither nil nor t, restrict to WINDOW's frame.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
943 \n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
944 If you use consistent values for MINIBUF and ALL-FRAMES, you can use\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
945 `previous-window' to iterate through the entire cycle of acceptable\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
946 windows, eventually ending up back at the window you started with.\n\ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
947 `next-window' traverses the same cycle, in the reverse order.") |
4145
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
948 (window, minibuf, all_frames) */ |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
949 |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
950 |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
951 DEFUN ("previous-window", Fprevious_window, Sprevious_window, 0, 3, 0, |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
952 0) |
769 | 953 (window, minibuf, all_frames) |
954 register Lisp_Object window, minibuf, all_frames; | |
265 | 955 { |
956 register Lisp_Object tem; | |
432 | 957 Lisp_Object start_window; |
265 | 958 |
485 | 959 if (NILP (window)) |
265 | 960 window = selected_window; |
961 else | |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
962 CHECK_LIVE_WINDOW (window, 0); |
265 | 963 |
432 | 964 start_window = window; |
265 | 965 |
432 | 966 /* minibuf == nil may or may not include minibuffers. |
967 Decide if it does. */ | |
485 | 968 if (NILP (minibuf)) |
432 | 969 minibuf = (minibuf_level ? Qt : Qlambda); |
265 | 970 |
769 | 971 /* all_frames == nil doesn't specify which frames to include. |
972 Decide which frames it includes. */ | |
973 if (NILP (all_frames)) | |
974 all_frames = (EQ (minibuf, Qt) | |
975 ? (FRAME_MINIBUF_WINDOW | |
976 (XFRAME | |
977 (WINDOW_FRAME | |
432 | 978 (XWINDOW (window))))) |
979 : Qnil); | |
769 | 980 else if (! EQ (all_frames, Qt)) |
981 all_frames = Qnil; | |
3621
0576930165ed
(Fscroll_left): Make argument optional.
Richard M. Stallman <rms@gnu.org>
parents:
3535
diff
changeset
|
982 /* Now all_frames is t meaning search all frames, |
0576930165ed
(Fscroll_left): Make argument optional.
Richard M. Stallman <rms@gnu.org>
parents:
3535
diff
changeset
|
983 nil meaning search just current frame, |
0576930165ed
(Fscroll_left): Make argument optional.
Richard M. Stallman <rms@gnu.org>
parents:
3535
diff
changeset
|
984 or a window, meaning search the frame that window belongs to. */ |
265 | 985 |
986 /* Do this loop at least once, to get the previous window, and perhaps | |
987 again, if we hit the minibuffer and that is not acceptable. */ | |
988 do | |
989 { | |
990 /* Find a window that actually has a previous one. This loop | |
991 climbs up the tree. */ | |
485 | 992 while (tem = XWINDOW (window)->prev, NILP (tem)) |
993 if (tem = XWINDOW (window)->parent, !NILP (tem)) | |
265 | 994 window = tem; |
432 | 995 else |
265 | 996 { |
769 | 997 /* We have found the top window on the frame. |
998 Which frames are acceptable? */ | |
999 tem = WINDOW_FRAME (XWINDOW (window)); | |
1000 #ifdef MULTI_FRAME | |
1001 if (! NILP (all_frames)) | |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
1002 /* It's actually important that we use prev_frame here, |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
1003 rather than next_frame. All the windows acceptable |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
1004 according to the given parameters should form a ring; |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
1005 Fnext_window and Fprevious_window should go back and |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
1006 forth around the ring. If we use next_frame here, |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
1007 then Fnext_window and Fprevious_window take different |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
1008 paths through the set of acceptable windows. |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
1009 window_loop assumes that these `ring' requirement are |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
1010 met. */ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
1011 tem = prev_frame (tem, all_frames); |
265 | 1012 #endif |
3621
0576930165ed
(Fscroll_left): Make argument optional.
Richard M. Stallman <rms@gnu.org>
parents:
3535
diff
changeset
|
1013 /* If this frame has a minibuffer, find that window first, |
0576930165ed
(Fscroll_left): Make argument optional.
Richard M. Stallman <rms@gnu.org>
parents:
3535
diff
changeset
|
1014 because it is conceptually the last window in that frame. */ |
3678
01941fa99c91
* window.c (Fprevious_window): Use FRAME_HAS_MINIBUF_P to decide
Jim Blandy <jimb@redhat.com>
parents:
3645
diff
changeset
|
1015 if (FRAME_HAS_MINIBUF_P (XFRAME (tem))) |
01941fa99c91
* window.c (Fprevious_window): Use FRAME_HAS_MINIBUF_P to decide
Jim Blandy <jimb@redhat.com>
parents:
3645
diff
changeset
|
1016 tem = FRAME_MINIBUF_WINDOW (XFRAME (tem)); |
01941fa99c91
* window.c (Fprevious_window): Use FRAME_HAS_MINIBUF_P to decide
Jim Blandy <jimb@redhat.com>
parents:
3645
diff
changeset
|
1017 else |
3621
0576930165ed
(Fscroll_left): Make argument optional.
Richard M. Stallman <rms@gnu.org>
parents:
3535
diff
changeset
|
1018 tem = FRAME_ROOT_WINDOW (XFRAME (tem)); |
432 | 1019 |
265 | 1020 break; |
1021 } | |
1022 | |
1023 window = tem; | |
1024 /* If we're in a combination window, find its last child and | |
1025 recurse on that. Otherwise, we've found the window we want. */ | |
1026 while (1) | |
1027 { | |
485 | 1028 if (!NILP (XWINDOW (window)->hchild)) |
265 | 1029 window = XWINDOW (window)->hchild; |
485 | 1030 else if (!NILP (XWINDOW (window)->vchild)) |
265 | 1031 window = XWINDOW (window)->vchild; |
1032 else break; | |
485 | 1033 while (tem = XWINDOW (window)->next, !NILP (tem)) |
265 | 1034 window = tem; |
1035 } | |
1036 } | |
432 | 1037 /* Which windows are acceptable? |
1038 Exit the loop and accept this window if | |
265 | 1039 this isn't a minibuffer window, or |
432 | 1040 we're accepting minibuffer windows, or |
1041 we've come all the way around and we're back at the original window. */ | |
265 | 1042 while (MINI_WINDOW_P (XWINDOW (window)) |
432 | 1043 && !EQ (minibuf, Qt) |
1525
f79a22ad87d0
* window.c (Fwindow_width, Fset_window_hscroll): Use accessors on
Jim Blandy <jimb@redhat.com>
parents:
1444
diff
changeset
|
1044 && !EQ (window, start_window)); |
265 | 1045 |
1046 return window; | |
1047 } | |
1048 | |
338 | 1049 DEFUN ("other-window", Fother_window, Sother_window, 1, 2, "p", |
769 | 1050 "Select the ARG'th different window on this frame.\n\ |
1051 All windows on current frame are arranged in a cyclic order.\n\ | |
265 | 1052 This command selects the window ARG steps away in that order.\n\ |
1053 A negative ARG moves in the opposite order. If the optional second\n\ | |
769 | 1054 argument ALL_FRAMES is non-nil, cycle through all frames.") |
1055 (n, all_frames) | |
1056 register Lisp_Object n, all_frames; | |
265 | 1057 { |
1058 register int i; | |
1059 register Lisp_Object w; | |
1060 | |
1061 CHECK_NUMBER (n, 0); | |
1062 w = selected_window; | |
1063 i = XINT (n); | |
1064 | |
1065 while (i > 0) | |
1066 { | |
769 | 1067 w = Fnext_window (w, Qnil, all_frames); |
265 | 1068 i--; |
1069 } | |
1070 while (i < 0) | |
1071 { | |
769 | 1072 w = Fprevious_window (w, Qnil, all_frames); |
265 | 1073 i++; |
1074 } | |
1075 Fselect_window (w); | |
1076 return Qnil; | |
1077 } | |
1078 | |
1079 /* Look at all windows, performing an operation specified by TYPE | |
1080 with argument OBJ. | |
3785
3455cbb3339d
Don't let the 'B' interactive spec default to buffers viewed in
Jim Blandy <jimb@redhat.com>
parents:
3765
diff
changeset
|
1081 If FRAMES is Qt, look at all frames; |
3455cbb3339d
Don't let the 'B' interactive spec default to buffers viewed in
Jim Blandy <jimb@redhat.com>
parents:
3765
diff
changeset
|
1082 Qnil, look at just the selected frame; |
3455cbb3339d
Don't let the 'B' interactive spec default to buffers viewed in
Jim Blandy <jimb@redhat.com>
parents:
3765
diff
changeset
|
1083 a frame, just look at windows on that frame. |
265 | 1084 If MINI is non-zero, perform the operation on minibuffer windows too. |
1085 */ | |
1086 | |
1087 enum window_loop | |
1088 { | |
1089 WINDOW_LOOP_UNUSED, | |
1090 GET_BUFFER_WINDOW, /* Arg is buffer */ | |
1091 GET_LRU_WINDOW, /* Arg is t for full-width windows only */ | |
1092 DELETE_OTHER_WINDOWS, /* Arg is window not to delete */ | |
1093 DELETE_BUFFER_WINDOWS, /* Arg is buffer */ | |
1094 GET_LARGEST_WINDOW, | |
1095 UNSHOW_BUFFER, /* Arg is buffer */ | |
1096 }; | |
1097 | |
1098 static Lisp_Object | |
769 | 1099 window_loop (type, obj, mini, frames) |
265 | 1100 enum window_loop type; |
769 | 1101 register Lisp_Object obj, frames; |
265 | 1102 int mini; |
1103 { | |
1104 register Lisp_Object w; | |
1105 register Lisp_Object best_window; | |
1106 register Lisp_Object next_window; | |
983
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1107 register Lisp_Object last_window; |
769 | 1108 FRAME_PTR frame; |
265 | 1109 |
983
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1110 #ifdef MULTI_FRAME |
769 | 1111 /* If we're only looping through windows on a particular frame, |
1112 frame points to that frame. If we're looping through windows | |
1113 on all frames, frame is 0. */ | |
1114 if (FRAMEP (frames)) | |
1115 frame = XFRAME (frames); | |
1116 else if (NILP (frames)) | |
1117 frame = selected_frame; | |
265 | 1118 else |
769 | 1119 frame = 0; |
983
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1120 #else |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1121 frame = 0; |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1122 #endif |
265 | 1123 |
1124 /* Pick a window to start with. */ | |
1125 if (XTYPE (obj) == Lisp_Window) | |
983
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1126 w = obj; |
769 | 1127 else if (frame) |
983
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1128 w = FRAME_SELECTED_WINDOW (frame); |
265 | 1129 else |
983
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1130 w = FRAME_SELECTED_WINDOW (selected_frame); |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1131 |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1132 /* Figure out the last window we're going to mess with. Since |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1133 Fnext_window, given the same options, is guaranteed to go in a |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1134 ring, we can just use Fprevious_window to find the last one. |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1135 |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1136 We can't just wait until we hit the first window again, because |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1137 it might be deleted. */ |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1138 |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1139 #ifdef MULTI_FRAME |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1140 if (frame) |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1141 last_window = Fprevious_window (w, (mini ? Qt : Qnil), Qlambda); |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1142 else |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1143 #endif /* MULTI_FRAME */ |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1144 /* We know frame is 0, so we're looping through all frames. |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1145 Or we know this isn't a MULTI_FRAME Emacs, so who cares? */ |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1146 last_window = Fprevious_window (w, mini ? Qt : Qnil, Qt); |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1147 |
265 | 1148 best_window = Qnil; |
983
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1149 for (;;) |
265 | 1150 { |
3785
3455cbb3339d
Don't let the 'B' interactive spec default to buffers viewed in
Jim Blandy <jimb@redhat.com>
parents:
3765
diff
changeset
|
1151 FRAME_PTR w_frame = XFRAME (WINDOW_FRAME (XWINDOW (w))); |
3455cbb3339d
Don't let the 'B' interactive spec default to buffers viewed in
Jim Blandy <jimb@redhat.com>
parents:
3765
diff
changeset
|
1152 |
265 | 1153 /* Pick the next window now, since some operations will delete |
1154 the current window. */ | |
769 | 1155 #ifdef MULTI_FRAME |
1156 if (frame) | |
432 | 1157 next_window = Fnext_window (w, (mini ? Qt : Qnil), Qlambda); |
265 | 1158 else |
983
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1159 #endif /* MULTI_FRAME */ |
769 | 1160 /* We know frame is 0, so we're looping through all frames. |
1161 Or we know this isn't a MULTI_FRAME Emacs, so who cares? */ | |
265 | 1162 next_window = Fnext_window (w, mini ? Qt : Qnil, Qt); |
1163 | |
3785
3455cbb3339d
Don't let the 'B' interactive spec default to buffers viewed in
Jim Blandy <jimb@redhat.com>
parents:
3765
diff
changeset
|
1164 if (! MINI_WINDOW_P (XWINDOW (w)) |
265 | 1165 || (mini && minibuf_level > 0)) |
1166 switch (type) | |
1167 { | |
1168 case GET_BUFFER_WINDOW: | |
3803
c267c2431d92
Don't let the 'B' interactive spec default to buffers viewed in
Jim Blandy <jimb@redhat.com>
parents:
3785
diff
changeset
|
1169 /* Ignore invisible and iconified frames. */ |
c267c2431d92
Don't let the 'B' interactive spec default to buffers viewed in
Jim Blandy <jimb@redhat.com>
parents:
3785
diff
changeset
|
1170 if (! FRAME_VISIBLE_P (w_frame) |
c267c2431d92
Don't let the 'B' interactive spec default to buffers viewed in
Jim Blandy <jimb@redhat.com>
parents:
3785
diff
changeset
|
1171 || FRAME_ICONIFIED_P (w_frame)) |
265 | 1172 break; |
1173 if (XBUFFER (XWINDOW (w)->buffer) == XBUFFER (obj)) | |
1174 return w; | |
1175 break; | |
1176 | |
1177 case GET_LRU_WINDOW: | |
1178 /* t as arg means consider only full-width windows */ | |
732 | 1179 if (!NILP (obj) && XFASTINT (XWINDOW (w)->width) |
3164
40590cba332a
(window_loop, case GET_LRU_WINDOW): Get frame's width properly.
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
1180 != FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (w))))) |
265 | 1181 break; |
1182 #if 0 | |
769 | 1183 /* Ignore invisible and iconified frames. */ |
1184 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w)))) | |
1185 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w))))) | |
265 | 1186 break; |
1187 #endif | |
1188 /* Ignore dedicated windows and minibuffers. */ | |
1189 if (MINI_WINDOW_P (XWINDOW (w)) | |
485 | 1190 || !NILP (XWINDOW (w)->dedicated)) |
265 | 1191 break; |
485 | 1192 if (NILP (best_window) |
265 | 1193 || (XFASTINT (XWINDOW (best_window)->use_time) |
1194 > XFASTINT (XWINDOW (w)->use_time))) | |
1195 best_window = w; | |
1196 break; | |
1197 | |
1198 case DELETE_OTHER_WINDOWS: | |
1199 if (XWINDOW (w) != XWINDOW (obj)) | |
1200 Fdelete_window (w); | |
1201 break; | |
1202 | |
1203 case DELETE_BUFFER_WINDOWS: | |
1204 if (EQ (XWINDOW (w)->buffer, obj)) | |
1205 { | |
1206 /* If we're deleting the buffer displayed in the only window | |
769 | 1207 on the frame, find a new buffer to display there. */ |
485 | 1208 if (NILP (XWINDOW (w)->parent)) |
265 | 1209 { |
1345
9596a1866aee
(window_loop): Pass 2nd arg to Fother_buffer.
Richard M. Stallman <rms@gnu.org>
parents:
1339
diff
changeset
|
1210 Lisp_Object new_buffer = Fother_buffer (obj, Qnil); |
485 | 1211 if (NILP (new_buffer)) |
265 | 1212 new_buffer |
1213 = Fget_buffer_create (build_string ("*scratch*")); | |
1214 Fset_window_buffer (w, new_buffer); | |
1215 Fset_buffer (XWINDOW (w)->buffer); | |
1216 } | |
1217 else | |
1218 Fdelete_window (w); | |
1219 } | |
1220 break; | |
1221 | |
1222 case GET_LARGEST_WINDOW: | |
1223 #if 0 | |
769 | 1224 /* Ignore invisible and iconified frames. */ |
1225 if (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (w)))) | |
1226 || FRAME_ICONIFIED_P (XFRAME (WINDOW_FRAME (XWINDOW (w))))) | |
265 | 1227 break; |
1228 #endif | |
1229 /* Ignore dedicated windows and minibuffers. */ | |
1230 if (MINI_WINDOW_P (XWINDOW (w)) | |
485 | 1231 || !NILP (XWINDOW (w)->dedicated)) |
265 | 1232 break; |
1233 { | |
1234 struct window *best_window_ptr = XWINDOW (best_window); | |
1235 struct window *w_ptr = XWINDOW (w); | |
485 | 1236 if (NILP (best_window) || |
265 | 1237 (XFASTINT (w_ptr->height) * XFASTINT (w_ptr->width)) |
1238 > (XFASTINT (best_window_ptr->height) | |
1239 * XFASTINT (best_window_ptr->width))) | |
1240 best_window = w; | |
1241 } | |
1242 break; | |
1243 | |
1244 case UNSHOW_BUFFER: | |
1245 if (EQ (XWINDOW (w)->buffer, obj)) | |
1246 { | |
1247 /* Find another buffer to show in this window. */ | |
1345
9596a1866aee
(window_loop): Pass 2nd arg to Fother_buffer.
Richard M. Stallman <rms@gnu.org>
parents:
1339
diff
changeset
|
1248 Lisp_Object another_buffer = Fother_buffer (obj, Qnil); |
485 | 1249 if (NILP (another_buffer)) |
265 | 1250 another_buffer |
1251 = Fget_buffer_create (build_string ("*scratch*")); | |
1252 Fset_window_buffer (w, another_buffer); | |
1253 if (EQ (w, selected_window)) | |
1254 Fset_buffer (XWINDOW (w)->buffer); | |
1255 } | |
1256 break; | |
1257 } | |
983
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1258 |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1259 if (EQ (w, last_window)) |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1260 break; |
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
1261 |
265 | 1262 w = next_window; |
1263 } | |
1264 | |
1265 return best_window; | |
1266 } | |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
1267 |
265 | 1268 DEFUN ("get-lru-window", Fget_lru_window, Sget_lru_window, 0, 1, 0, |
1269 "Return the window least recently selected or used for display.\n\ | |
769 | 1270 If optional argument FRAMES is t, search all frames. If FRAME is a\n\ |
1271 frame, search only that frame.\n") | |
1272 (frames) | |
1273 Lisp_Object frames; | |
265 | 1274 { |
1275 register Lisp_Object w; | |
1276 /* First try for a window that is full-width */ | |
769 | 1277 w = window_loop (GET_LRU_WINDOW, Qt, 0, frames); |
485 | 1278 if (!NILP (w) && !EQ (w, selected_window)) |
265 | 1279 return w; |
1280 /* If none of them, try the rest */ | |
769 | 1281 return window_loop (GET_LRU_WINDOW, Qnil, 0, frames); |
265 | 1282 } |
1283 | |
1284 DEFUN ("get-largest-window", Fget_largest_window, Sget_largest_window, 0, 1, 0, | |
1285 "Return the largest window in area.\n\ | |
769 | 1286 If optional argument FRAMES is t, search all frames. If FRAME is a\n\ |
1287 frame, search only that frame.\n") | |
1288 (frame) | |
1289 Lisp_Object frame; | |
265 | 1290 { |
1291 return window_loop (GET_LARGEST_WINDOW, Qnil, 0, | |
769 | 1292 frame); |
265 | 1293 } |
1294 | |
1295 DEFUN ("get-buffer-window", Fget_buffer_window, Sget_buffer_window, 1, 2, 0, | |
1296 "Return a window currently displaying BUFFER, or nil if none.\n\ | |
3803
c267c2431d92
Don't let the 'B' interactive spec default to buffers viewed in
Jim Blandy <jimb@redhat.com>
parents:
3785
diff
changeset
|
1297 If optional argument FRAME is t, search all visible frames.\n\ |
c267c2431d92
Don't let the 'B' interactive spec default to buffers viewed in
Jim Blandy <jimb@redhat.com>
parents:
3785
diff
changeset
|
1298 If FRAME is nil, search only the selected frame.\n\ |
3785
3455cbb3339d
Don't let the 'B' interactive spec default to buffers viewed in
Jim Blandy <jimb@redhat.com>
parents:
3765
diff
changeset
|
1299 If FRAME is a frame, search only that frame.\n") |
769 | 1300 (buffer, frame) |
1301 Lisp_Object buffer, frame; | |
265 | 1302 { |
1303 buffer = Fget_buffer (buffer); | |
1304 if (XTYPE (buffer) == Lisp_Buffer) | |
769 | 1305 return window_loop (GET_BUFFER_WINDOW, buffer, 1, frame); |
265 | 1306 else |
1307 return Qnil; | |
1308 } | |
1309 | |
1310 DEFUN ("delete-other-windows", Fdelete_other_windows, Sdelete_other_windows, | |
1311 0, 1, "", | |
769 | 1312 "Make WINDOW (or the selected window) fill its frame.\n\ |
1313 Only the frame WINDOW is on is affected.") | |
265 | 1314 (window) |
1315 Lisp_Object window; | |
1316 { | |
1317 struct window *w; | |
1318 int opoint = point; | |
1319 struct buffer *obuf = current_buffer; | |
1320 int top; | |
1321 | |
485 | 1322 if (NILP (window)) |
265 | 1323 window = selected_window; |
1324 else | |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
1325 CHECK_LIVE_WINDOW (window, 0); |
265 | 1326 |
1327 w = XWINDOW (window); | |
1328 top = XFASTINT (w->top); | |
1329 | |
2190
482c7827b968
(Fdelete_other_windows): Handle FRAME_MENU_BAR_LINES.
Richard M. Stallman <rms@gnu.org>
parents:
1994
diff
changeset
|
1330 window_loop (DELETE_OTHER_WINDOWS, window, 0, WINDOW_FRAME (w)); |
265 | 1331 |
1332 Fset_buffer (w->buffer); | |
1333 SET_PT (marker_position (w->start)); | |
2190
482c7827b968
(Fdelete_other_windows): Handle FRAME_MENU_BAR_LINES.
Richard M. Stallman <rms@gnu.org>
parents:
1994
diff
changeset
|
1334 Frecenter (make_number (top - FRAME_MENU_BAR_LINES (XFRAME (WINDOW_FRAME (w))))); |
265 | 1335 |
1336 set_buffer_internal (obuf); | |
1337 SET_PT (opoint); | |
1338 return Qnil; | |
1339 } | |
1340 | |
1341 DEFUN ("delete-windows-on", Fdelete_windows_on, Sdelete_windows_on, | |
1342 1, 1, "bDelete windows on (buffer): ", | |
4145
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1343 "Delete all windows showing BUFFER.\n\ |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1344 Optional second argument FRAME controls which frames are affected.\n\ |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1345 If nil or omitted, delete all windows showing BUFFER in any frame.\n\ |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1346 If t, delete only windows showing BUFFER in the selected frame.\n\ |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1347 If a frame, delete only windows showing BUFFER in that frame.") |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1348 (buffer, frame) |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1349 Lisp_Object buffer, frame; |
265 | 1350 { |
4145
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1351 #ifdef MULTI_FRAME |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1352 /* FRAME uses t and nil to mean the opposite of what window_loop |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1353 expects. */ |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1354 if (! FRAMEP (frame)) |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1355 frame = NILP (frame) ? Qt : Qnil; |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1356 #else |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1357 frame = Qt; |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1358 #endif |
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1359 |
485 | 1360 if (!NILP (buffer)) |
265 | 1361 { |
1362 buffer = Fget_buffer (buffer); | |
1363 CHECK_BUFFER (buffer, 0); | |
4145
a0b726903a1f
* window.c [not MULTI_FRAME] (Fdelete_windows_on): Set FRAME
Jim Blandy <jimb@redhat.com>
parents:
3803
diff
changeset
|
1364 window_loop (DELETE_BUFFER_WINDOWS, buffer, 0, frame); |
265 | 1365 } |
1366 return Qnil; | |
1367 } | |
1368 | |
1369 DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows, | |
1370 Sreplace_buffer_in_windows, | |
1371 1, 1, "bReplace buffer in windows: ", | |
1372 "Replace BUFFER with some other buffer in all windows showing it.") | |
1373 (buffer) | |
1374 Lisp_Object buffer; | |
1375 { | |
485 | 1376 if (!NILP (buffer)) |
265 | 1377 { |
1378 buffer = Fget_buffer (buffer); | |
1379 CHECK_BUFFER (buffer, 0); | |
1380 window_loop (UNSHOW_BUFFER, buffer, 0, Qt); | |
1381 } | |
1382 return Qnil; | |
1383 } | |
1384 | |
1385 /* Set the height of WINDOW and all its inferiors. */ | |
972
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1386 |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1387 /* The smallest acceptable dimensions for a window. Anything smaller |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1388 might crash Emacs. */ |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1389 #define MIN_SAFE_WINDOW_WIDTH (2) |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1390 #define MIN_SAFE_WINDOW_HEIGHT (2) |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1391 |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1392 /* Make sure that window_min_height and window_min_width are |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1393 not too small; if they are, set them to safe minima. */ |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1394 |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1395 static void |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1396 check_min_window_sizes () |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1397 { |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1398 /* Smaller values might permit a crash. */ |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1399 if (window_min_width < MIN_SAFE_WINDOW_WIDTH) |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1400 window_min_width = MIN_SAFE_WINDOW_WIDTH; |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1401 if (window_min_height < MIN_SAFE_WINDOW_HEIGHT) |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1402 window_min_height = MIN_SAFE_WINDOW_HEIGHT; |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1403 } |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1404 |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1405 /* If *ROWS or *COLS are too small a size for FRAME, set them to the |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1406 minimum allowable size. */ |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
1407 void |
972
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1408 check_frame_size (frame, rows, cols) |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
1409 FRAME_PTR frame; |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
1410 int *rows, *cols; |
972
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1411 { |
4347
d6b289b1a6dc
* window.c (check_frame_size): Include the menu bar height in the
Jim Blandy <jimb@redhat.com>
parents:
4292
diff
changeset
|
1412 /* For height, we have to see: |
d6b289b1a6dc
* window.c (check_frame_size): Include the menu bar height in the
Jim Blandy <jimb@redhat.com>
parents:
4292
diff
changeset
|
1413 whether the frame has a minibuffer, |
d6b289b1a6dc
* window.c (check_frame_size): Include the menu bar height in the
Jim Blandy <jimb@redhat.com>
parents:
4292
diff
changeset
|
1414 whether it wants a mode line, and |
d6b289b1a6dc
* window.c (check_frame_size): Include the menu bar height in the
Jim Blandy <jimb@redhat.com>
parents:
4292
diff
changeset
|
1415 whether it has a menu bar. */ |
972
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1416 int min_height = |
3765
bde2da377085
* window.c (check_frame_size): Allow minibuffer-only frames to be
Jim Blandy <jimb@redhat.com>
parents:
3723
diff
changeset
|
1417 (FRAME_MINIBUF_ONLY_P (frame) ? MIN_SAFE_WINDOW_HEIGHT - 1 |
bde2da377085
* window.c (check_frame_size): Allow minibuffer-only frames to be
Jim Blandy <jimb@redhat.com>
parents:
3723
diff
changeset
|
1418 : (! FRAME_HAS_MINIBUF_P (frame)) ? MIN_SAFE_WINDOW_HEIGHT |
972
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1419 : 2 * MIN_SAFE_WINDOW_HEIGHT - 1); |
4347
d6b289b1a6dc
* window.c (check_frame_size): Include the menu bar height in the
Jim Blandy <jimb@redhat.com>
parents:
4292
diff
changeset
|
1420 if (FRAME_MENU_BAR_LINES (frame) > 0) |
d6b289b1a6dc
* window.c (check_frame_size): Include the menu bar height in the
Jim Blandy <jimb@redhat.com>
parents:
4292
diff
changeset
|
1421 min_height += FRAME_MENU_BAR_LINES (frame); |
972
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1422 |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1423 if (*rows < min_height) |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1424 *rows = min_height; |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1425 if (*cols < MIN_SAFE_WINDOW_WIDTH) |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1426 *cols = MIN_SAFE_WINDOW_WIDTH; |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1427 } |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1428 |
265 | 1429 /* Normally the window is deleted if it gets too small. |
1430 nodelete nonzero means do not do this. | |
1431 (The caller should check later and do so if appropriate) */ | |
1432 | |
1433 set_window_height (window, height, nodelete) | |
1434 Lisp_Object window; | |
1435 int height; | |
1436 int nodelete; | |
1437 { | |
1438 register struct window *w = XWINDOW (window); | |
1439 register struct window *c; | |
1440 int oheight = XFASTINT (w->height); | |
1441 int top, pos, lastbot, opos, lastobot; | |
1442 Lisp_Object child; | |
1443 | |
972
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1444 check_min_window_sizes (); |
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1445 |
265 | 1446 if (!nodelete |
485 | 1447 && ! NILP (w->parent) |
265 | 1448 && height < window_min_height) |
1449 { | |
1450 Fdelete_window (window); | |
1451 return; | |
1452 } | |
1453 | |
1454 XFASTINT (w->last_modified) = 0; | |
1455 windows_or_buffers_changed++; | |
1456 XFASTINT (w->height) = height; | |
485 | 1457 if (!NILP (w->hchild)) |
265 | 1458 { |
485 | 1459 for (child = w->hchild; !NILP (child); child = XWINDOW (child)->next) |
265 | 1460 { |
1461 XWINDOW (child)->top = w->top; | |
1462 set_window_height (child, height, nodelete); | |
1463 } | |
1464 } | |
485 | 1465 else if (!NILP (w->vchild)) |
265 | 1466 { |
1467 lastbot = top = XFASTINT (w->top); | |
1468 lastobot = 0; | |
485 | 1469 for (child = w->vchild; !NILP (child); child = c->next) |
265 | 1470 { |
1471 c = XWINDOW (child); | |
1472 | |
1473 opos = lastobot + XFASTINT (c->height); | |
1474 | |
1475 XFASTINT (c->top) = lastbot; | |
1476 | |
1477 pos = (((opos * height) << 1) + oheight) / (oheight << 1); | |
1478 | |
1479 /* Avoid confusion: inhibit deletion of child if becomes too small */ | |
1480 set_window_height (child, pos + top - lastbot, 1); | |
1481 | |
1482 /* Now advance child to next window, | |
1483 and set lastbot if child was not just deleted. */ | |
1484 lastbot = pos + top; | |
1485 lastobot = opos; | |
1486 } | |
1487 /* Now delete any children that became too small. */ | |
1488 if (!nodelete) | |
485 | 1489 for (child = w->vchild; !NILP (child); child = XWINDOW (child)->next) |
265 | 1490 { |
1491 set_window_height (child, XINT (XWINDOW (child)->height), 0); | |
1492 } | |
1493 } | |
1494 } | |
1495 | |
1496 /* Recursively set width of WINDOW and its inferiors. */ | |
1497 | |
1498 set_window_width (window, width, nodelete) | |
1499 Lisp_Object window; | |
1500 int width; | |
1501 int nodelete; | |
1502 { | |
1503 register struct window *w = XWINDOW (window); | |
1504 register struct window *c; | |
1505 int owidth = XFASTINT (w->width); | |
1506 int left, pos, lastright, opos, lastoright; | |
1507 Lisp_Object child; | |
1508 | |
1509 if (!nodelete && width < window_min_width) | |
1510 { | |
1511 Fdelete_window (window); | |
1512 return; | |
1513 } | |
1514 | |
1515 XFASTINT (w->last_modified) = 0; | |
1516 windows_or_buffers_changed++; | |
1517 XFASTINT (w->width) = width; | |
485 | 1518 if (!NILP (w->vchild)) |
265 | 1519 { |
485 | 1520 for (child = w->vchild; !NILP (child); child = XWINDOW (child)->next) |
265 | 1521 { |
1522 XWINDOW (child)->left = w->left; | |
1523 set_window_width (child, width, nodelete); | |
1524 } | |
1525 } | |
485 | 1526 else if (!NILP (w->hchild)) |
265 | 1527 { |
1528 lastright = left = XFASTINT (w->left); | |
1529 lastoright = 0; | |
485 | 1530 for (child = w->hchild; !NILP (child); child = c->next) |
265 | 1531 { |
1532 c = XWINDOW (child); | |
1533 | |
1534 opos = lastoright + XFASTINT (c->width); | |
1535 | |
1536 XFASTINT (c->left) = lastright; | |
1537 | |
1538 pos = (((opos * width) << 1) + owidth) / (owidth << 1); | |
1539 | |
1540 /* Inhibit deletion for becoming too small */ | |
1541 set_window_width (child, pos + left - lastright, 1); | |
1542 | |
1543 /* Now advance child to next window, | |
1544 and set lastright if child was not just deleted. */ | |
1545 lastright = pos + left, lastoright = opos; | |
1546 } | |
1547 /* Delete children that became too small */ | |
1548 if (!nodelete) | |
485 | 1549 for (child = w->hchild; !NILP (child); child = XWINDOW (child)->next) |
265 | 1550 { |
1551 set_window_width (child, XINT (XWINDOW (child)->width), 0); | |
1552 } | |
1553 } | |
1554 } | |
1555 | |
362 | 1556 int window_select_count; |
265 | 1557 |
1558 DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 2, 0, | |
1559 "Make WINDOW display BUFFER as its contents.\n\ | |
1560 BUFFER can be a buffer or buffer name.") | |
1561 (window, buffer) | |
1562 register Lisp_Object window, buffer; | |
1563 { | |
1564 register Lisp_Object tem; | |
1565 register struct window *w = decode_window (window); | |
1566 | |
1567 buffer = Fget_buffer (buffer); | |
1568 CHECK_BUFFER (buffer, 1); | |
1569 | |
485 | 1570 if (NILP (XBUFFER (buffer)->name)) |
265 | 1571 error ("Attempt to display deleted buffer"); |
1572 | |
1573 tem = w->buffer; | |
485 | 1574 if (NILP (tem)) |
265 | 1575 error ("Window is deleted"); |
1576 else if (! EQ (tem, Qt)) /* w->buffer is t when the window | |
1577 is first being set up. */ | |
1578 { | |
485 | 1579 if (!NILP (w->dedicated) && !EQ (tem, buffer)) |
265 | 1580 error ("Window is dedicated to %s\n", tem); |
1581 | |
1582 unshow_buffer (w); | |
1583 } | |
1584 | |
1585 w->buffer = buffer; | |
4292
990f6ee7f527
(Fset_window_buffer): Clear window_end_{pos,valid}.
Richard M. Stallman <rms@gnu.org>
parents:
4145
diff
changeset
|
1586 w->window_end_pos = 0; |
990f6ee7f527
(Fset_window_buffer): Clear window_end_{pos,valid}.
Richard M. Stallman <rms@gnu.org>
parents:
4145
diff
changeset
|
1587 w->window_end_valid = Qnil; |
2579
5d55e3b47227
(Fset-window-buffer): Set horizontal-scrolling on a window to zero when
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
2297
diff
changeset
|
1588 w->hscroll = 0; |
265 | 1589 Fset_marker (w->pointm, |
1590 make_number (BUF_PT (XBUFFER (buffer))), | |
1591 buffer); | |
1592 set_marker_restricted (w->start, | |
1593 make_number (XBUFFER (buffer)->last_window_start), | |
1594 buffer); | |
1595 w->start_at_line_beg = Qnil; | |
3354
0b71a5329961
(Fset_window_buffer): Set window's force_start to Qnil.
Richard M. Stallman <rms@gnu.org>
parents:
3164
diff
changeset
|
1596 w->force_start = Qnil; |
265 | 1597 XFASTINT (w->last_modified) = 0; |
1598 windows_or_buffers_changed++; | |
1599 if (EQ (window, selected_window)) | |
1600 Fset_buffer (buffer); | |
1601 | |
1602 return Qnil; | |
1603 } | |
1604 | |
1605 DEFUN ("select-window", Fselect_window, Sselect_window, 1, 1, 0, | |
1606 "Select WINDOW. Most editing will apply to WINDOW's buffer.\n\ | |
1607 The main editor command loop selects the buffer of the selected window\n\ | |
1608 before each command.") | |
1609 (window) | |
1610 register Lisp_Object window; | |
1611 { | |
1612 register struct window *w; | |
1613 register struct window *ow = XWINDOW (selected_window); | |
1614 | |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
1615 CHECK_LIVE_WINDOW (window, 0); |
265 | 1616 |
1617 w = XWINDOW (window); | |
1618 | |
485 | 1619 if (NILP (w->buffer)) |
265 | 1620 error ("Trying to select deleted window or non-leaf window"); |
1621 | |
1622 XFASTINT (w->use_time) = ++window_select_count; | |
1623 if (EQ (window, selected_window)) | |
1624 return window; | |
1625 | |
1626 Fset_marker (ow->pointm, make_number (BUF_PT (XBUFFER (ow->buffer))), | |
1627 ow->buffer); | |
1628 | |
1629 selected_window = window; | |
769 | 1630 #ifdef MULTI_FRAME |
1631 if (XFRAME (WINDOW_FRAME (w)) != selected_frame) | |
265 | 1632 { |
769 | 1633 XFRAME (WINDOW_FRAME (w))->selected_window = window; |
2297
bb88d48c290f
(Fselect_window): Use Fhandle_switch_frame.
Richard M. Stallman <rms@gnu.org>
parents:
2210
diff
changeset
|
1634 Fhandle_switch_frame (WINDOW_FRAME (w), Qnil); |
265 | 1635 } |
1636 else | |
769 | 1637 selected_frame->selected_window = window; |
265 | 1638 #endif |
1639 | |
1640 record_buffer (w->buffer); | |
1641 Fset_buffer (w->buffer); | |
1642 | |
1643 /* Go to the point recorded in the window. | |
1644 This is important when the buffer is in more | |
1645 than one window. It also matters when | |
1646 redisplay_window has altered point after scrolling, | |
1647 because it makes the change only in the window. */ | |
1648 { | |
1649 register int new_point = marker_position (w->pointm); | |
1650 if (new_point < BEGV) | |
1651 SET_PT (BEGV); | |
1652 if (new_point > ZV) | |
1653 SET_PT (ZV); | |
1654 else | |
1655 SET_PT (new_point); | |
1656 } | |
1657 | |
1658 windows_or_buffers_changed++; | |
1659 return window; | |
1660 } | |
1661 | |
735 | 1662 DEFUN ("display-buffer", Fdisplay_buffer, Sdisplay_buffer, 1, 2, |
2668
33761a44c172
(Fdisplay_buffer): Add space to prompt.
Richard M. Stallman <rms@gnu.org>
parents:
2579
diff
changeset
|
1663 "BDisplay buffer: \nP", |
265 | 1664 "Make BUFFER appear in some window but don't select it.\n\ |
1665 BUFFER can be a buffer or a buffer name.\n\ | |
1666 If BUFFER is shown already in some window, just use that one,\n\ | |
1667 unless the window is the selected window and the optional second\n\ | |
1805
7ba5cfe280eb
(Fdisplay_buffer): Doc fix.
Roland McGrath <roland@gnu.org>
parents:
1798
diff
changeset
|
1668 argument NOT-THIS-WINDOW is non-nil (interactively, with prefix arg).\n\ |
265 | 1669 Returns the window displaying BUFFER.") |
1670 (buffer, not_this_window) | |
1671 register Lisp_Object buffer, not_this_window; | |
1672 { | |
1673 register Lisp_Object window; | |
1674 | |
1675 buffer = Fget_buffer (buffer); | |
1676 CHECK_BUFFER (buffer, 0); | |
1677 | |
485 | 1678 if (!NILP (Vdisplay_buffer_function)) |
265 | 1679 return call2 (Vdisplay_buffer_function, buffer, not_this_window); |
1680 | |
485 | 1681 if (NILP (not_this_window) |
265 | 1682 && XBUFFER (XWINDOW (selected_window)->buffer) == XBUFFER (buffer)) |
1683 return selected_window; | |
1684 | |
1685 window = Fget_buffer_window (buffer, Qnil); | |
485 | 1686 if (!NILP (window) |
1687 && (NILP (not_this_window) || !EQ (window, selected_window))) | |
265 | 1688 return window; |
1689 | |
769 | 1690 #ifdef MULTI_FRAME |
1691 /* If there are no frames open that have more than a minibuffer, | |
1692 we need to create a new frame. */ | |
1693 if (pop_up_frames || last_nonminibuf_frame == 0) | |
265 | 1694 { |
1695 window | |
769 | 1696 = Fframe_selected_window (call0 (Vpop_up_frame_function)); |
265 | 1697 Fset_window_buffer (window, buffer); |
1698 #if 0 | |
2297
bb88d48c290f
(Fselect_window): Use Fhandle_switch_frame.
Richard M. Stallman <rms@gnu.org>
parents:
2210
diff
changeset
|
1699 Fhandle_switch_frame (XWINDOW (window)->frame, Qnil); |
265 | 1700 #endif |
1701 return window; | |
1702 } | |
769 | 1703 #endif /* MULTI_FRAME */ |
265 | 1704 |
358 | 1705 if (pop_up_windows |
769 | 1706 #ifdef MULTI_FRAME |
1707 || FRAME_MINIBUF_ONLY_P (selected_frame) | |
358 | 1708 #endif |
1709 ) | |
1710 { | |
769 | 1711 Lisp_Object frames = Qnil; |
358 | 1712 |
769 | 1713 #ifdef MULTI_FRAME |
1714 if (FRAME_MINIBUF_ONLY_P (selected_frame)) | |
1715 XSET (frames, Lisp_Frame, last_nonminibuf_frame); | |
265 | 1716 #endif |
1717 /* Don't try to create a window if would get an error */ | |
1718 if (split_height_threshold < window_min_height << 1) | |
1719 split_height_threshold = window_min_height << 1; | |
1720 | |
769 | 1721 window = Fget_largest_window (frames); |
265 | 1722 |
485 | 1723 if (!NILP (window) |
265 | 1724 && window_height (window) >= split_height_threshold |
1783
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
1725 && (XFASTINT (XWINDOW (window)->width) |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
1726 == FRAME_WIDTH (XFRAME (WINDOW_FRAME (XWINDOW (window)))))) |
265 | 1727 window = Fsplit_window (window, Qnil, Qnil); |
1728 else | |
1729 { | |
769 | 1730 window = Fget_lru_window (frames); |
265 | 1731 if ((EQ (window, selected_window) |
1732 || EQ (XWINDOW (window)->parent, Qnil)) | |
1733 && window_height (window) >= window_min_height << 1) | |
1734 window = Fsplit_window (window, Qnil, Qnil); | |
1735 } | |
1736 } | |
1737 else | |
1738 window = Fget_lru_window (Qnil); | |
1739 | |
1740 Fset_window_buffer (window, buffer); | |
1741 return window; | |
1742 } | |
1743 | |
1744 void | |
1745 temp_output_buffer_show (buf) | |
1746 register Lisp_Object buf; | |
1747 { | |
1748 register struct buffer *old = current_buffer; | |
1749 register Lisp_Object window; | |
1750 register struct window *w; | |
1751 | |
1752 Fset_buffer (buf); | |
1753 XBUFFER (buf)->save_modified = MODIFF; | |
1754 BEGV = BEG; | |
1755 ZV = Z; | |
1756 SET_PT (BEG); | |
1757 clip_changed = 1; | |
1758 set_buffer_internal (old); | |
1759 | |
1760 if (!EQ (Vtemp_buffer_show_function, Qnil)) | |
1761 call1 (Vtemp_buffer_show_function, buf); | |
1762 else | |
1763 { | |
1764 window = Fdisplay_buffer (buf, Qnil); | |
1765 | |
769 | 1766 #ifdef MULTI_FRAME |
1767 if (XFRAME (XWINDOW (window)->frame) != selected_frame) | |
1768 Fmake_frame_visible (WINDOW_FRAME (XWINDOW (window))); | |
1769 #endif /* MULTI_FRAME */ | |
265 | 1770 Vminibuf_scroll_window = window; |
1771 w = XWINDOW (window); | |
1772 XFASTINT (w->hscroll) = 0; | |
1773 set_marker_restricted (w->start, make_number (1), buf); | |
1774 set_marker_restricted (w->pointm, make_number (1), buf); | |
1775 } | |
1776 } | |
1777 | |
1778 static | |
1779 make_dummy_parent (window) | |
1780 Lisp_Object window; | |
1781 { | |
1782 register Lisp_Object old, new; | |
1783 register struct window *o, *p; | |
1784 | |
1785 old = window; | |
1786 XSETTYPE (old, Lisp_Vector); | |
1787 new = Fcopy_sequence (old); | |
1788 XSETTYPE (new, Lisp_Window); | |
1789 | |
1790 o = XWINDOW (old); | |
1791 p = XWINDOW (new); | |
1792 XFASTINT (p->sequence_number) = ++sequence_number; | |
1793 | |
1794 /* Put new into window structure in place of window */ | |
1795 replace_window (window, new); | |
1796 | |
1797 o->next = Qnil; | |
1798 o->prev = Qnil; | |
1799 o->vchild = Qnil; | |
1800 o->hchild = Qnil; | |
1801 o->parent = new; | |
1802 | |
1803 p->start = Qnil; | |
1804 p->pointm = Qnil; | |
1805 p->buffer = Qnil; | |
1806 } | |
1807 | |
1808 DEFUN ("split-window", Fsplit_window, Ssplit_window, 0, 3, "", | |
1809 "Split WINDOW, putting SIZE lines in the first of the pair.\n\ | |
1810 WINDOW defaults to selected one and SIZE to half its size.\n\ | |
1811 If optional third arg HOR-FLAG is non-nil, split side by side\n\ | |
1812 and put SIZE columns in the first of the pair.") | |
1813 (window, chsize, horflag) | |
1814 Lisp_Object window, chsize, horflag; | |
1815 { | |
1816 register Lisp_Object new; | |
1817 register struct window *o, *p; | |
1818 register int size; | |
1819 | |
485 | 1820 if (NILP (window)) |
265 | 1821 window = selected_window; |
1822 else | |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
1823 CHECK_LIVE_WINDOW (window, 0); |
265 | 1824 |
1825 o = XWINDOW (window); | |
1826 | |
485 | 1827 if (NILP (chsize)) |
265 | 1828 { |
485 | 1829 if (!NILP (horflag)) |
265 | 1830 /* Round odd size up, since this is for the left-hand window, |
1831 and it will lose a column for the separators. */ | |
1832 size = ((XFASTINT (o->width) + 1) & -2) >> 1; | |
1833 else | |
1834 size = XFASTINT (o->height) >> 1; | |
1835 } | |
1836 else | |
1837 { | |
1838 CHECK_NUMBER (chsize, 1); | |
1839 size = XINT (chsize); | |
1840 } | |
1841 | |
1842 if (MINI_WINDOW_P (o)) | |
1843 error ("Attempt to split minibuffer window"); | |
769 | 1844 else if (FRAME_NO_SPLIT_P (XFRAME (WINDOW_FRAME (o)))) |
1845 error ("Attempt to split unsplittable frame"); | |
265 | 1846 |
972
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1847 check_min_window_sizes (); |
265 | 1848 |
485 | 1849 if (NILP (horflag)) |
265 | 1850 { |
1851 if (size < window_min_height | |
1852 || size + window_min_height > XFASTINT (o->height)) | |
1853 args_out_of_range_3 (window, chsize, horflag); | |
485 | 1854 if (NILP (o->parent) |
1855 || NILP (XWINDOW (o->parent)->vchild)) | |
265 | 1856 { |
1857 make_dummy_parent (window); | |
1858 new = o->parent; | |
1859 XWINDOW (new)->vchild = window; | |
1860 } | |
1861 } | |
1862 else | |
1863 { | |
1864 if (size < window_min_width | |
1865 || size + window_min_width > XFASTINT (o->width)) | |
1866 args_out_of_range_3 (window, chsize, horflag); | |
485 | 1867 if (NILP (o->parent) |
1868 || NILP (XWINDOW (o->parent)->hchild)) | |
265 | 1869 { |
1870 make_dummy_parent (window); | |
1871 new = o->parent; | |
1872 XWINDOW (new)->hchild = window; | |
1873 } | |
1874 } | |
1875 | |
1876 /* Now we know that window's parent is a vertical combination | |
1877 if we are dividing vertically, or a horizontal combination | |
1878 if we are making side-by-side windows */ | |
1879 | |
1880 windows_or_buffers_changed++; | |
1881 new = make_window (); | |
1882 p = XWINDOW (new); | |
1883 | |
769 | 1884 p->frame = o->frame; |
265 | 1885 p->next = o->next; |
485 | 1886 if (!NILP (p->next)) |
265 | 1887 XWINDOW (p->next)->prev = new; |
1888 p->prev = window; | |
1889 o->next = new; | |
1890 p->parent = o->parent; | |
1891 p->buffer = Qt; | |
1892 | |
1893 Fset_window_buffer (new, o->buffer); | |
1894 | |
769 | 1895 /* Apportion the available frame space among the two new windows */ |
265 | 1896 |
485 | 1897 if (!NILP (horflag)) |
265 | 1898 { |
1899 p->height = o->height; | |
1900 p->top = o->top; | |
1901 XFASTINT (p->width) = XFASTINT (o->width) - size; | |
1902 XFASTINT (o->width) = size; | |
1903 XFASTINT (p->left) = XFASTINT (o->left) + size; | |
1904 } | |
1905 else | |
1906 { | |
1907 p->left = o->left; | |
1908 p->width = o->width; | |
1909 XFASTINT (p->height) = XFASTINT (o->height) - size; | |
1910 XFASTINT (o->height) = size; | |
1911 XFASTINT (p->top) = XFASTINT (o->top) + size; | |
1912 } | |
1913 | |
1914 return new; | |
1915 } | |
1916 | |
1917 DEFUN ("enlarge-window", Fenlarge_window, Senlarge_window, 1, 2, "p", | |
1918 "Make current window ARG lines bigger.\n\ | |
1919 From program, optional second arg non-nil means grow sideways ARG columns.") | |
1920 (n, side) | |
1921 register Lisp_Object n, side; | |
1922 { | |
1923 CHECK_NUMBER (n, 0); | |
485 | 1924 change_window_height (XINT (n), !NILP (side)); |
265 | 1925 return Qnil; |
1926 } | |
1927 | |
1928 DEFUN ("shrink-window", Fshrink_window, Sshrink_window, 1, 2, "p", | |
1929 "Make current window ARG lines smaller.\n\ | |
1930 From program, optional second arg non-nil means shrink sideways ARG columns.") | |
1931 (n, side) | |
1932 register Lisp_Object n, side; | |
1933 { | |
1934 CHECK_NUMBER (n, 0); | |
485 | 1935 change_window_height (-XINT (n), !NILP (side)); |
265 | 1936 return Qnil; |
1937 } | |
1938 | |
1939 int | |
1940 window_height (window) | |
1941 Lisp_Object window; | |
1942 { | |
1943 register struct window *p = XWINDOW (window); | |
1944 return XFASTINT (p->height); | |
1945 } | |
1946 | |
1947 int | |
1948 window_width (window) | |
1949 Lisp_Object window; | |
1950 { | |
1951 register struct window *p = XWINDOW (window); | |
1952 return XFASTINT (p->width); | |
1953 } | |
1954 | |
1049
25046e48ce9a
* window.c (coordinates_in_window): Do not assume that all
Jim Blandy <jimb@redhat.com>
parents:
1016
diff
changeset
|
1955 #define MINSIZE(w) \ |
25046e48ce9a
* window.c (coordinates_in_window): Do not assume that all
Jim Blandy <jimb@redhat.com>
parents:
1016
diff
changeset
|
1956 (widthflag \ |
25046e48ce9a
* window.c (coordinates_in_window): Do not assume that all
Jim Blandy <jimb@redhat.com>
parents:
1016
diff
changeset
|
1957 ? window_min_width \ |
25046e48ce9a
* window.c (coordinates_in_window): Do not assume that all
Jim Blandy <jimb@redhat.com>
parents:
1016
diff
changeset
|
1958 : (MINI_WINDOW_P (XWINDOW (w)) ? 1 : window_min_height)) |
265 | 1959 |
1960 #define CURBEG(w) \ | |
1049
25046e48ce9a
* window.c (coordinates_in_window): Do not assume that all
Jim Blandy <jimb@redhat.com>
parents:
1016
diff
changeset
|
1961 *(widthflag ? (int *) &(XWINDOW (w)->left) : (int *) &(XWINDOW (w)->top)) |
265 | 1962 |
1963 #define CURSIZE(w) \ | |
1049
25046e48ce9a
* window.c (coordinates_in_window): Do not assume that all
Jim Blandy <jimb@redhat.com>
parents:
1016
diff
changeset
|
1964 *(widthflag ? (int *) &(XWINDOW (w)->width) : (int *) &(XWINDOW (w)->height)) |
265 | 1965 |
1966 /* Unlike set_window_height, this function | |
1967 also changes the heights of the siblings so as to | |
1968 keep everything consistent. */ | |
1969 | |
1970 change_window_height (delta, widthflag) | |
1971 register int delta; | |
1972 int widthflag; | |
1973 { | |
1974 register Lisp_Object parent; | |
1975 Lisp_Object window; | |
1976 register struct window *p; | |
1977 int *sizep; | |
1978 int (*sizefun) () = widthflag ? window_width : window_height; | |
1979 register int (*setsizefun) () = (widthflag | |
1980 ? set_window_width | |
1981 : set_window_height); | |
1982 | |
972
f47d221cbfe6
* window.c (MIN_SAFE_WINDOW_HEIGHT, MIN_SAFE_WINDOW_WIDTH): Macros
Jim Blandy <jimb@redhat.com>
parents:
780
diff
changeset
|
1983 check_min_window_sizes (); |
265 | 1984 |
1985 window = selected_window; | |
1986 while (1) | |
1987 { | |
1988 p = XWINDOW (window); | |
1989 parent = p->parent; | |
485 | 1990 if (NILP (parent)) |
265 | 1991 { |
1992 if (widthflag) | |
1993 error ("No other window to side of this one"); | |
1994 break; | |
1995 } | |
485 | 1996 if (widthflag ? !NILP (XWINDOW (parent)->hchild) |
1997 : !NILP (XWINDOW (parent)->vchild)) | |
265 | 1998 break; |
1999 window = parent; | |
2000 } | |
2001 | |
1049
25046e48ce9a
* window.c (coordinates_in_window): Do not assume that all
Jim Blandy <jimb@redhat.com>
parents:
1016
diff
changeset
|
2002 sizep = &CURSIZE (window); |
25046e48ce9a
* window.c (coordinates_in_window): Do not assume that all
Jim Blandy <jimb@redhat.com>
parents:
1016
diff
changeset
|
2003 |
25046e48ce9a
* window.c (coordinates_in_window): Do not assume that all
Jim Blandy <jimb@redhat.com>
parents:
1016
diff
changeset
|
2004 if (*sizep + delta < MINSIZE (window)) |
265 | 2005 { |
2006 Fdelete_window (window); | |
2007 return; | |
2008 } | |
2009 | |
2010 { | |
2011 register int maxdelta; | |
2012 | |
485 | 2013 maxdelta = (!NILP (parent) ? (*sizefun) (parent) - *sizep |
2014 : !NILP (p->next) ? (*sizefun) (p->next) - MINSIZE (p->next) | |
2015 : !NILP (p->prev) ? (*sizefun) (p->prev) - MINSIZE (p->prev) | |
769 | 2016 /* This is a frame with only one window, a minibuffer-only |
2017 or a minibufferless frame. */ | |
432 | 2018 : (delta = 0)); |
265 | 2019 |
2020 if (delta > maxdelta) | |
2021 /* This case traps trying to make the minibuffer | |
769 | 2022 the full frame, or make the only window aside from the |
2023 minibuffer the full frame. */ | |
265 | 2024 delta = maxdelta; |
432 | 2025 |
2026 if (delta == 0) | |
2027 return; | |
265 | 2028 } |
2029 | |
485 | 2030 if (!NILP (p->next) && |
265 | 2031 (*sizefun) (p->next) - delta >= MINSIZE (p->next)) |
2032 { | |
2033 (*setsizefun) (p->next, (*sizefun) (p->next) - delta, 0); | |
2034 (*setsizefun) (window, *sizep + delta, 0); | |
1049
25046e48ce9a
* window.c (coordinates_in_window): Do not assume that all
Jim Blandy <jimb@redhat.com>
parents:
1016
diff
changeset
|
2035 CURBEG (p->next) += delta; |
265 | 2036 /* This does not change size of p->next, |
2037 but it propagates the new top edge to its children */ | |
2038 (*setsizefun) (p->next, (*sizefun) (p->next), 0); | |
2039 } | |
485 | 2040 else if (!NILP (p->prev) && |
265 | 2041 (*sizefun) (p->prev) - delta >= MINSIZE (p->prev)) |
2042 { | |
2043 (*setsizefun) (p->prev, (*sizefun) (p->prev) - delta, 0); | |
1049
25046e48ce9a
* window.c (coordinates_in_window): Do not assume that all
Jim Blandy <jimb@redhat.com>
parents:
1016
diff
changeset
|
2044 CURBEG (window) -= delta; |
265 | 2045 (*setsizefun) (window, *sizep + delta, 0); |
2046 } | |
2047 else | |
2048 { | |
2049 register int delta1; | |
2050 register int opht = (*sizefun) (parent); | |
2051 | |
2052 /* If trying to grow this window to or beyond size of the parent, | |
2053 make delta1 so big that, on shrinking back down, | |
2054 all the siblings end up with less than one line and are deleted. */ | |
2055 if (opht <= *sizep + delta) | |
2056 delta1 = opht * opht * 2; | |
2057 /* Otherwise, make delta1 just right so that if we add delta1 | |
2058 lines to this window and to the parent, and then shrink | |
2059 the parent back to its original size, the new proportional | |
2060 size of this window will increase by delta. */ | |
2061 else | |
2062 delta1 = (delta * opht * 100) / ((opht - *sizep - delta) * 100); | |
2063 | |
2064 /* Add delta1 lines or columns to this window, and to the parent, | |
2065 keeping things consistent while not affecting siblings. */ | |
1049
25046e48ce9a
* window.c (coordinates_in_window): Do not assume that all
Jim Blandy <jimb@redhat.com>
parents:
1016
diff
changeset
|
2066 CURSIZE (parent) = opht + delta1; |
265 | 2067 (*setsizefun) (window, *sizep + delta1, 0); |
2068 | |
2069 /* Squeeze out delta1 lines or columns from our parent, | |
2070 shriking this window and siblings proportionately. | |
2071 This brings parent back to correct size. | |
2072 Delta1 was calculated so this makes this window the desired size, | |
2073 taking it all out of the siblings. */ | |
2074 (*setsizefun) (parent, opht, 0); | |
2075 } | |
2076 | |
2077 XFASTINT (p->last_modified) = 0; | |
2078 } | |
2079 #undef MINSIZE | |
2080 #undef CURBEG | |
2081 #undef CURSIZE | |
2082 | |
2083 | |
2084 /* Return number of lines of text (not counting mode line) in W. */ | |
2085 | |
2086 int | |
2087 window_internal_height (w) | |
2088 struct window *w; | |
2089 { | |
2090 int ht = XFASTINT (w->height); | |
2091 | |
2092 if (MINI_WINDOW_P (w)) | |
2093 return ht; | |
2094 | |
485 | 2095 if (!NILP (w->parent) || !NILP (w->vchild) || !NILP (w->hchild) |
2096 || !NILP (w->next) || !NILP (w->prev) | |
769 | 2097 || FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (w)))) |
265 | 2098 return ht - 1; |
2099 | |
2100 return ht; | |
2101 } | |
2102 | |
1783
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2103 |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2104 /* Return the number of columns in W. |
1994
73ce9dd21093
Use the term `scroll bar', instead of `scrollbar'.
Jim Blandy <jimb@redhat.com>
parents:
1931
diff
changeset
|
2105 Don't count columns occupied by scroll bars or the vertical bar |
1783
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2106 separating W from the sibling to its right. */ |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2107 int |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2108 window_internal_width (w) |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2109 struct window *w; |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2110 { |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2111 FRAME_PTR f = XFRAME (WINDOW_FRAME (w)); |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2112 int left = XINT (w->left); |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2113 int width = XINT (w->width); |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2114 |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2115 /* If this window is flush against the right edge of the frame, its |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2116 internal width is its full width. */ |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2117 if (left + width >= FRAME_WIDTH (f)) |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2118 return width; |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2119 |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2120 /* If we are not flush right, then our rightmost columns are |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2121 occupied by some sort of separator. */ |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2122 |
1994
73ce9dd21093
Use the term `scroll bar', instead of `scrollbar'.
Jim Blandy <jimb@redhat.com>
parents:
1931
diff
changeset
|
2123 /* Scroll bars occupy a few columns. */ |
73ce9dd21093
Use the term `scroll bar', instead of `scrollbar'.
Jim Blandy <jimb@redhat.com>
parents:
1931
diff
changeset
|
2124 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f)) |
73ce9dd21093
Use the term `scroll bar', instead of `scrollbar'.
Jim Blandy <jimb@redhat.com>
parents:
1931
diff
changeset
|
2125 return width - VERTICAL_SCROLL_BAR_WIDTH; |
1783
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2126 |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2127 /* The column of `|' characters separating side-by-side windows |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2128 occupies one column only. */ |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2129 return width - 1; |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2130 } |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2131 |
8e7932110418
* window.c (window_internal_width): New function, which accounts
Jim Blandy <jimb@redhat.com>
parents:
1716
diff
changeset
|
2132 |
265 | 2133 /* Scroll contents of window WINDOW up N lines. */ |
2134 | |
2135 void | |
522 | 2136 window_scroll (window, n, noerror) |
265 | 2137 Lisp_Object window; |
2138 int n; | |
522 | 2139 int noerror; |
265 | 2140 { |
2141 register struct window *w = XWINDOW (window); | |
2142 register int opoint = point; | |
2143 register int pos; | |
2144 register int ht = window_internal_height (w); | |
2145 register Lisp_Object tem; | |
2146 int lose; | |
2147 Lisp_Object bolp, nmoved; | |
2148 | |
2149 XFASTINT (tem) = point; | |
2150 tem = Fpos_visible_in_window_p (tem, window); | |
2151 | |
485 | 2152 if (NILP (tem)) |
265 | 2153 { |
2154 Fvertical_motion (make_number (- ht / 2)); | |
2155 XFASTINT (tem) = point; | |
2156 Fset_marker (w->start, tem, w->buffer); | |
2157 w->force_start = Qt; | |
2158 } | |
2159 | |
2160 SET_PT (marker_position (w->start)); | |
2161 lose = n < 0 && point == BEGV; | |
2162 Fvertical_motion (make_number (n)); | |
2163 pos = point; | |
2164 bolp = Fbolp (); | |
2165 SET_PT (opoint); | |
2166 | |
2167 if (lose) | |
522 | 2168 { |
2169 if (noerror) | |
2170 return; | |
2171 else | |
2172 Fsignal (Qbeginning_of_buffer, Qnil); | |
2173 } | |
265 | 2174 |
2175 if (pos < ZV) | |
2176 { | |
2177 set_marker_restricted (w->start, make_number (pos), w->buffer); | |
2178 w->start_at_line_beg = bolp; | |
2179 w->update_mode_line = Qt; | |
2180 XFASTINT (w->last_modified) = 0; | |
2181 if (pos > opoint) | |
2182 SET_PT (pos); | |
2183 if (n < 0) | |
2184 { | |
2185 SET_PT (pos); | |
2186 tem = Fvertical_motion (make_number (ht)); | |
2187 if (point > opoint || XFASTINT (tem) < ht) | |
2188 SET_PT (opoint); | |
2189 else | |
2190 Fvertical_motion (make_number (-1)); | |
2191 } | |
2192 } | |
2193 else | |
522 | 2194 { |
2195 if (noerror) | |
2196 return; | |
2197 else | |
2198 Fsignal (Qend_of_buffer, Qnil); | |
2199 } | |
265 | 2200 } |
2201 | |
2202 /* This is the guts of Fscroll_up and Fscroll_down. */ | |
2203 | |
2204 static void | |
2205 scroll_command (n, direction) | |
2206 register Lisp_Object n; | |
2207 int direction; | |
2208 { | |
2209 register int defalt; | |
2210 int count = specpdl_ptr - specpdl; | |
2211 | |
548 | 2212 /* If selected window's buffer isn't current, make it current for the moment. |
2213 But don't screw up if window_scroll gets an error. */ | |
265 | 2214 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer) |
548 | 2215 { |
2216 record_unwind_protect (save_excursion_restore, save_excursion_save ()); | |
2217 Fset_buffer (XWINDOW (selected_window)->buffer); | |
2218 } | |
265 | 2219 |
2220 defalt = (window_internal_height (XWINDOW (selected_window)) | |
2221 - next_screen_context_lines); | |
2222 defalt = direction * (defalt < 1 ? 1 : defalt); | |
2223 | |
485 | 2224 if (NILP (n)) |
522 | 2225 window_scroll (selected_window, defalt, 0); |
265 | 2226 else if (EQ (n, Qminus)) |
522 | 2227 window_scroll (selected_window, - defalt, 0); |
265 | 2228 else |
2229 { | |
2230 n = Fprefix_numeric_value (n); | |
522 | 2231 window_scroll (selected_window, XINT (n) * direction, 0); |
265 | 2232 } |
548 | 2233 |
2234 unbind_to (count, Qnil); | |
265 | 2235 } |
2236 | |
2237 DEFUN ("scroll-up", Fscroll_up, Sscroll_up, 0, 1, "P", | |
2238 "Scroll text of current window upward ARG lines; or near full screen if no ARG.\n\ | |
2239 A near full screen is `next-screen-context-lines' less than a full screen.\n\ | |
2240 When calling from a program, supply a number as argument or nil.") | |
2241 (n) | |
2242 Lisp_Object n; | |
2243 { | |
2244 scroll_command (n, 1); | |
2245 return Qnil; | |
2246 } | |
2247 | |
2248 DEFUN ("scroll-down", Fscroll_down, Sscroll_down, 0, 1, "P", | |
2249 "Scroll text of current window downward ARG lines; or near full screen if no ARG.\n\ | |
2250 A near full screen is `next-screen-context-lines' less than a full screen.\n\ | |
2251 When calling from a program, supply a number as argument or nil.") | |
2252 (n) | |
2253 Lisp_Object n; | |
2254 { | |
2255 scroll_command (n, -1); | |
2256 return Qnil; | |
2257 } | |
2258 | |
2259 DEFUN ("scroll-other-window", Fscroll_other_window, Sscroll_other_window, 0, 1, "P", | |
1339 | 2260 "Scroll next window upward ARG lines; or near full screen if no ARG.\n\ |
265 | 2261 The next window is the one below the current one; or the one at the top\n\ |
2262 if the current one is at the bottom.\n\ | |
2263 When calling from a program, supply a number as argument or nil.\n\ | |
2264 \n\ | |
2265 If in the minibuffer, `minibuf-scroll-window' if non-nil\n\ | |
2266 specifies the window to scroll.\n\ | |
2267 If `other-window-scroll-buffer' is non-nil, scroll the window\n\ | |
2268 showing that buffer, popping the buffer up if necessary.") | |
2269 (n) | |
2270 register Lisp_Object n; | |
2271 { | |
2272 register Lisp_Object window; | |
2273 register int ht; | |
2274 register struct window *w; | |
2275 register int count = specpdl_ptr - specpdl; | |
2276 | |
2277 if (MINI_WINDOW_P (XWINDOW (selected_window)) | |
485 | 2278 && !NILP (Vminibuf_scroll_window)) |
265 | 2279 window = Vminibuf_scroll_window; |
2280 /* If buffer is specified, scroll that buffer. */ | |
485 | 2281 else if (!NILP (Vother_window_scroll_buffer)) |
265 | 2282 { |
2283 window = Fget_buffer_window (Vother_window_scroll_buffer, Qnil); | |
485 | 2284 if (NILP (window)) |
265 | 2285 window = Fdisplay_buffer (Vother_window_scroll_buffer, Qt); |
2286 } | |
2287 else | |
1821
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2288 { |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2289 /* Nothing specified; look for a neighboring window on the same |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2290 frame. */ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2291 window = Fnext_window (selected_window, Qnil, Qnil); |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2292 |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2293 if (EQ (window, selected_window)) |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2294 /* That didn't get us anywhere; look for a window on another |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2295 visible frame. */ |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2296 do |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2297 window = Fnext_window (window, Qnil, Qt); |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2298 while (! FRAME_VISIBLE_P (XFRAME (WINDOW_FRAME (XWINDOW (window)))) |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2299 && ! EQ (window, selected_window)); |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2300 } |
04fb1d3d6992
JimB's changes since January 18th
Jim Blandy <jimb@redhat.com>
parents:
1805
diff
changeset
|
2301 |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
2302 CHECK_LIVE_WINDOW (window, 0); |
265 | 2303 |
2304 if (EQ (window, selected_window)) | |
2305 error ("There is no other window"); | |
2306 | |
2307 w = XWINDOW (window); | |
2308 ht = window_internal_height (w); | |
2309 | |
2310 /* Don't screw up if window_scroll gets an error. */ | |
2311 record_unwind_protect (save_excursion_restore, save_excursion_save ()); | |
2312 | |
2313 Fset_buffer (w->buffer); | |
2314 SET_PT (marker_position (w->pointm)); | |
2315 | |
485 | 2316 if (NILP (n)) |
522 | 2317 window_scroll (window, ht - next_screen_context_lines, 1); |
265 | 2318 else if (EQ (n, Qminus)) |
522 | 2319 window_scroll (window, next_screen_context_lines - ht, 1); |
265 | 2320 else |
2321 { | |
2322 if (XTYPE (n) == Lisp_Cons) | |
2323 n = Fcar (n); | |
2324 CHECK_NUMBER (n, 0); | |
522 | 2325 window_scroll (window, XINT (n), 1); |
265 | 2326 } |
2327 | |
2328 Fset_marker (w->pointm, make_number (point), Qnil); | |
1931
129d8225f748
* keyboard.c (recursive_edit_1, command_loop_1): Pass the proper
Jim Blandy <jimb@redhat.com>
parents:
1829
diff
changeset
|
2329 unbind_to (count, Qnil); |
265 | 2330 |
2331 return Qnil; | |
2332 } | |
2333 | |
3621
0576930165ed
(Fscroll_left): Make argument optional.
Richard M. Stallman <rms@gnu.org>
parents:
3535
diff
changeset
|
2334 DEFUN ("scroll-left", Fscroll_left, Sscroll_left, 0, 1, "P", |
265 | 2335 "Scroll selected window display ARG columns left.\n\ |
2336 Default for ARG is window width minus 2.") | |
2337 (arg) | |
2338 register Lisp_Object arg; | |
2339 { | |
2340 | |
485 | 2341 if (NILP (arg)) |
1829
514384c3689d
* window.c (Fscroll_left, Fscroll_right): Don't forget to apply
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
2342 XFASTINT (arg) = window_internal_width (XWINDOW (selected_window)) - 2; |
265 | 2343 else |
2344 arg = Fprefix_numeric_value (arg); | |
2345 | |
2346 return | |
2347 Fset_window_hscroll (selected_window, | |
2348 make_number (XINT (XWINDOW (selected_window)->hscroll) | |
2349 + XINT (arg))); | |
2350 } | |
2351 | |
3621
0576930165ed
(Fscroll_left): Make argument optional.
Richard M. Stallman <rms@gnu.org>
parents:
3535
diff
changeset
|
2352 DEFUN ("scroll-right", Fscroll_right, Sscroll_right, 0, 1, "P", |
265 | 2353 "Scroll selected window display ARG columns right.\n\ |
2354 Default for ARG is window width minus 2.") | |
2355 (arg) | |
2356 register Lisp_Object arg; | |
2357 { | |
485 | 2358 if (NILP (arg)) |
1829
514384c3689d
* window.c (Fscroll_left, Fscroll_right): Don't forget to apply
Jim Blandy <jimb@redhat.com>
parents:
1821
diff
changeset
|
2359 XFASTINT (arg) = window_internal_width (XWINDOW (selected_window)) - 2; |
265 | 2360 else |
2361 arg = Fprefix_numeric_value (arg); | |
2362 | |
2363 return | |
2364 Fset_window_hscroll (selected_window, | |
2365 make_number (XINT (XWINDOW (selected_window)->hscroll) | |
2366 - XINT (arg))); | |
2367 } | |
2368 | |
2369 DEFUN ("recenter", Frecenter, Srecenter, 0, 1, "P", | |
769 | 2370 "Center point in window and redisplay frame. With ARG, put point on line ARG.\n\ |
265 | 2371 The desired position of point is always relative to the current window.\n\ |
769 | 2372 Just C-u as prefix means put point in the center of the window.\n\ |
2373 No arg (i.e., it is nil) erases the entire frame and then\n\ | |
2374 redraws with point in the center of the current window.") | |
265 | 2375 (n) |
2376 register Lisp_Object n; | |
2377 { | |
2378 register struct window *w = XWINDOW (selected_window); | |
2379 register int ht = window_internal_height (w); | |
2380 register int opoint = point; | |
2381 | |
485 | 2382 if (NILP (n)) |
265 | 2383 { |
769 | 2384 extern int frame_garbaged; |
265 | 2385 |
769 | 2386 SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w))); |
265 | 2387 XFASTINT (n) = ht / 2; |
2388 } | |
2389 else if (XTYPE (n) == Lisp_Cons) /* Just C-u. */ | |
2390 { | |
2391 XFASTINT (n) = ht / 2; | |
2392 } | |
2393 else | |
2394 { | |
2395 n = Fprefix_numeric_value (n); | |
2396 CHECK_NUMBER (n, 0); | |
2397 } | |
2398 | |
2399 if (XINT (n) < 0) | |
2400 XSETINT (n, XINT (n) + ht); | |
2401 | |
2402 XSETINT (n, - XINT (n)); | |
2403 | |
2404 Fvertical_motion (n); | |
2405 Fset_marker (w->start, make_number (point), w->buffer); | |
2406 w->start_at_line_beg = Fbolp (); | |
2407 | |
2408 SET_PT (opoint); | |
2409 w->force_start = Qt; | |
2410 | |
2411 return Qnil; | |
2412 } | |
2413 | |
2414 DEFUN ("move-to-window-line", Fmove_to_window_line, Smove_to_window_line, | |
2415 1, 1, "P", | |
2416 "Position point relative to window.\n\ | |
2417 With no argument, position text at center of window.\n\ | |
769 | 2418 An argument specifies frame line; zero means top of window,\n\ |
265 | 2419 negative means relative to bottom of window.") |
2420 (arg) | |
2421 register Lisp_Object arg; | |
2422 { | |
2423 register struct window *w = XWINDOW (selected_window); | |
2424 register int height = window_internal_height (w); | |
2425 register int start; | |
2426 | |
485 | 2427 if (NILP (arg)) |
265 | 2428 XFASTINT (arg) = height / 2; |
2429 else | |
2430 { | |
2431 arg = Fprefix_numeric_value (arg); | |
2432 if (XINT (arg) < 0) | |
2433 XSETINT (arg, XINT (arg) + height); | |
2434 } | |
2435 | |
2436 start = marker_position (w->start); | |
2437 if (start < BEGV || start > ZV) | |
2438 { | |
2439 Fvertical_motion (make_number (- height / 2)); | |
2440 Fset_marker (w->start, make_number (point), w->buffer); | |
2441 w->start_at_line_beg = Fbolp (); | |
2442 w->force_start = Qt; | |
2443 } | |
2444 else | |
2445 SET_PT (start); | |
2446 | |
2447 return Fvertical_motion (arg); | |
2448 } | |
2449 | |
2450 struct save_window_data | |
2451 { | |
2452 int size_from_Lisp_Vector_struct; | |
2453 struct Lisp_Vector *next_from_Lisp_Vector_struct; | |
769 | 2454 Lisp_Object frame_width, frame_height; |
1325
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2455 Lisp_Object selected_frame; |
265 | 2456 Lisp_Object current_window; |
2457 Lisp_Object current_buffer; | |
2458 Lisp_Object minibuf_scroll_window; | |
2459 Lisp_Object root_window; | |
1325
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2460 Lisp_Object focus_frame; |
265 | 2461 /* A vector, interpreted as a struct saved_window */ |
2462 Lisp_Object saved_windows; | |
2463 }; | |
1326
709532b86646
* window.c (SAVE_WINDOW_DATA_SIZE): Define this using sizeof,
Jim Blandy <jimb@redhat.com>
parents:
1325
diff
changeset
|
2464 |
709532b86646
* window.c (SAVE_WINDOW_DATA_SIZE): Define this using sizeof,
Jim Blandy <jimb@redhat.com>
parents:
1325
diff
changeset
|
2465 /* Arg to Fmake_vector */ |
709532b86646
* window.c (SAVE_WINDOW_DATA_SIZE): Define this using sizeof,
Jim Blandy <jimb@redhat.com>
parents:
1325
diff
changeset
|
2466 #define SAVE_WINDOW_DATA_SIZE \ |
709532b86646
* window.c (SAVE_WINDOW_DATA_SIZE): Define this using sizeof,
Jim Blandy <jimb@redhat.com>
parents:
1325
diff
changeset
|
2467 ((sizeof (struct save_window_data) \ |
709532b86646
* window.c (SAVE_WINDOW_DATA_SIZE): Define this using sizeof,
Jim Blandy <jimb@redhat.com>
parents:
1325
diff
changeset
|
2468 - (sizeof (struct Lisp_Vector) \ |
709532b86646
* window.c (SAVE_WINDOW_DATA_SIZE): Define this using sizeof,
Jim Blandy <jimb@redhat.com>
parents:
1325
diff
changeset
|
2469 /* Don't count the contents member of the struct Lisp_Vector */ \ |
709532b86646
* window.c (SAVE_WINDOW_DATA_SIZE): Define this using sizeof,
Jim Blandy <jimb@redhat.com>
parents:
1325
diff
changeset
|
2470 - sizeof (Lisp_Object))) \ |
709532b86646
* window.c (SAVE_WINDOW_DATA_SIZE): Define this using sizeof,
Jim Blandy <jimb@redhat.com>
parents:
1325
diff
changeset
|
2471 / sizeof (Lisp_Object)) |
265 | 2472 |
2473 /* This is saved as a Lisp_Vector */ | |
2474 struct saved_window | |
2475 { | |
2476 /* these first two must agree with struct Lisp_Vector in lisp.h */ | |
2477 int size_from_Lisp_Vector_struct; | |
2478 struct Lisp_Vector *next_from_Lisp_Vector_struct; | |
2479 | |
2480 Lisp_Object window; | |
2481 Lisp_Object buffer, start, pointm, mark; | |
2482 Lisp_Object left, top, width, height, hscroll; | |
2483 Lisp_Object parent, prev; | |
2484 Lisp_Object start_at_line_beg; | |
2485 Lisp_Object display_table; | |
2486 }; | |
2487 #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */ | |
2488 | |
2489 #define SAVED_WINDOW_N(swv,n) \ | |
2490 ((struct saved_window *) (XVECTOR ((swv)->contents[(n)]))) | |
2491 | |
2492 DEFUN ("window-configuration-p", Fwindow_configuration_p, Swindow_configuration_p, 1, 1, 0, | |
2493 "T if OBJECT is a window-configration object.") | |
2494 (obj) | |
2495 Lisp_Object obj; | |
2496 { | |
2497 if (XTYPE (obj) == Lisp_Window_Configuration) | |
2498 return Qt; | |
2499 return Qnil; | |
2500 } | |
2501 | |
2502 | |
2297
bb88d48c290f
(Fselect_window): Use Fhandle_switch_frame.
Richard M. Stallman <rms@gnu.org>
parents:
2210
diff
changeset
|
2503 DEFUN ("set-window-configuration", Fset_window_configuration, |
bb88d48c290f
(Fselect_window): Use Fhandle_switch_frame.
Richard M. Stallman <rms@gnu.org>
parents:
2210
diff
changeset
|
2504 Sset_window_configuration, 1, 1, 0, |
265 | 2505 "Set the configuration of windows and buffers as specified by CONFIGURATION.\n\ |
2506 CONFIGURATION must be a value previously returned\n\ | |
2507 by `current-window-configuration' (which see).") | |
1016
817b0ce337d7
* window.c (Fset_window_configuration): Removed #if 0'd code which
Jim Blandy <jimb@redhat.com>
parents:
983
diff
changeset
|
2508 (configuration) |
817b0ce337d7
* window.c (Fset_window_configuration): Removed #if 0'd code which
Jim Blandy <jimb@redhat.com>
parents:
983
diff
changeset
|
2509 Lisp_Object configuration; |
265 | 2510 { |
2511 register struct save_window_data *data; | |
2512 struct Lisp_Vector *saved_windows; | |
2513 Lisp_Object new_current_buffer; | |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2514 Lisp_Object frame; |
769 | 2515 FRAME_PTR f; |
265 | 2516 |
1016
817b0ce337d7
* window.c (Fset_window_configuration): Removed #if 0'd code which
Jim Blandy <jimb@redhat.com>
parents:
983
diff
changeset
|
2517 while (XTYPE (configuration) != Lisp_Window_Configuration) |
265 | 2518 { |
1016
817b0ce337d7
* window.c (Fset_window_configuration): Removed #if 0'd code which
Jim Blandy <jimb@redhat.com>
parents:
983
diff
changeset
|
2519 configuration = wrong_type_argument (intern ("window-configuration-p"), |
817b0ce337d7
* window.c (Fset_window_configuration): Removed #if 0'd code which
Jim Blandy <jimb@redhat.com>
parents:
983
diff
changeset
|
2520 configuration); |
265 | 2521 } |
2522 | |
1016
817b0ce337d7
* window.c (Fset_window_configuration): Removed #if 0'd code which
Jim Blandy <jimb@redhat.com>
parents:
983
diff
changeset
|
2523 data = (struct save_window_data *) XVECTOR (configuration); |
265 | 2524 saved_windows = XVECTOR (data->saved_windows); |
2525 | |
2526 new_current_buffer = data->current_buffer; | |
485 | 2527 if (NILP (XBUFFER (new_current_buffer)->name)) |
265 | 2528 new_current_buffer = Qnil; |
2529 | |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2530 frame = XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2531 f = XFRAME (frame); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2532 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2533 /* If f is a dead frame, don't bother rebuilding its window tree. |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2534 However, there is other stuff we should still try to do below. */ |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2535 if (FRAME_LIVE_P (f)) |
265 | 2536 { |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2537 register struct window *w; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2538 register struct saved_window *p; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2539 int k; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2540 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2541 /* If the frame has been resized since this window configuration was |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2542 made, we change the frame to the size specified in the |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2543 configuration, restore the configuration, and then resize it |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2544 back. We keep track of the prevailing height in these variables. */ |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2545 int previous_frame_height = FRAME_HEIGHT (f); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2546 int previous_frame_width = FRAME_WIDTH (f); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2547 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2548 if (XFASTINT (data->frame_height) != previous_frame_height |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2549 || XFASTINT (data->frame_width) != previous_frame_width) |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2550 change_frame_size (f, data->frame_height, data->frame_width, 0, 0); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2551 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2552 windows_or_buffers_changed++; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2553 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2554 /* Kludge Alert! |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2555 Mark all windows now on frame as "deleted". |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2556 Restoring the new configuration "undeletes" any that are in it. |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2557 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2558 Save their current buffers in their height fields, since we may |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2559 need it later, if a buffer saved in the configuration is now |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2560 dead. */ |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2561 delete_all_subwindows (XWINDOW (FRAME_ROOT_WINDOW (f))); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2562 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2563 for (k = 0; k < saved_windows->size; k++) |
265 | 2564 { |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2565 p = SAVED_WINDOW_N (saved_windows, k); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2566 w = XWINDOW (p->window); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2567 w->next = Qnil; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2568 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2569 if (!NILP (p->parent)) |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2570 w->parent = SAVED_WINDOW_N (saved_windows, |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2571 XFASTINT (p->parent))->window; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2572 else |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2573 w->parent = Qnil; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2574 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2575 if (!NILP (p->prev)) |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2576 { |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2577 w->prev = SAVED_WINDOW_N (saved_windows, |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2578 XFASTINT (p->prev))->window; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2579 XWINDOW (w->prev)->next = p->window; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2580 } |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2581 else |
265 | 2582 { |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2583 w->prev = Qnil; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2584 if (!NILP (w->parent)) |
265 | 2585 { |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2586 if (EQ (p->width, XWINDOW (w->parent)->width)) |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2587 { |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2588 XWINDOW (w->parent)->vchild = p->window; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2589 XWINDOW (w->parent)->hchild = Qnil; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2590 } |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2591 else |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2592 { |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2593 XWINDOW (w->parent)->hchild = p->window; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2594 XWINDOW (w->parent)->vchild = Qnil; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2595 } |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2596 } |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2597 } |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2598 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2599 /* If we squirreled away the buffer in the window's height, |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2600 restore it now. */ |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2601 if (XTYPE (w->height) == Lisp_Buffer) |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2602 w->buffer = w->height; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2603 w->left = p->left; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2604 w->top = p->top; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2605 w->width = p->width; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2606 w->height = p->height; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2607 w->hscroll = p->hscroll; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2608 w->display_table = p->display_table; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2609 XFASTINT (w->last_modified) = 0; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2610 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2611 /* Reinstall the saved buffer and pointers into it. */ |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2612 if (NILP (p->buffer)) |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2613 w->buffer = p->buffer; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2614 else |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2615 { |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2616 if (!NILP (XBUFFER (p->buffer)->name)) |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2617 /* If saved buffer is alive, install it. */ |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2618 { |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2619 w->buffer = p->buffer; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2620 w->start_at_line_beg = p->start_at_line_beg; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2621 set_marker_restricted (w->start, |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2622 Fmarker_position (p->start), |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2623 w->buffer); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2624 set_marker_restricted (w->pointm, |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2625 Fmarker_position (p->pointm), |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2626 w->buffer); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2627 Fset_marker (XBUFFER (w->buffer)->mark, |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2628 Fmarker_position (p->mark), w->buffer); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2629 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2630 /* As documented in Fcurrent_window_configuration, don't |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2631 save the location of point in the buffer which was current |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2632 when the window configuration was recorded. */ |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2633 if (!EQ (p->buffer, new_current_buffer) && |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2634 XBUFFER (p->buffer) == current_buffer) |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2635 Fgoto_char (w->pointm); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2636 } |
3535
581c09f72dbd
(Fset_window_configuration): If a window is supposed
Richard M. Stallman <rms@gnu.org>
parents:
3354
diff
changeset
|
2637 else if (NILP (w->buffer) || NILP (XBUFFER (w->buffer)->name)) |
581c09f72dbd
(Fset_window_configuration): If a window is supposed
Richard M. Stallman <rms@gnu.org>
parents:
3354
diff
changeset
|
2638 /* Else unless window has a live buffer, get one. */ |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2639 { |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2640 w->buffer = Fcdr (Fcar (Vbuffer_alist)); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2641 /* This will set the markers to beginning of visible |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2642 range. */ |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2643 set_marker_restricted (w->start, make_number (0), w->buffer); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2644 set_marker_restricted (w->pointm, make_number (0),w->buffer); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2645 w->start_at_line_beg = Qt; |
265 | 2646 } |
2647 else | |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2648 /* Keeping window's old buffer; make sure the markers |
3535
581c09f72dbd
(Fset_window_configuration): If a window is supposed
Richard M. Stallman <rms@gnu.org>
parents:
3354
diff
changeset
|
2649 are real. */ |
265 | 2650 { |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2651 /* Set window markers at start of visible range. */ |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2652 if (XMARKER (w->start)->buffer == 0) |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2653 set_marker_restricted (w->start, make_number (0), |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2654 w->buffer); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2655 if (XMARKER (w->pointm)->buffer == 0) |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2656 set_marker_restricted (w->pointm, |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2657 (make_number |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2658 (BUF_PT (XBUFFER (w->buffer)))), |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2659 w->buffer); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2660 w->start_at_line_beg = Qt; |
265 | 2661 } |
2662 } | |
2663 } | |
1237
3929b2135e58
* window.c (delete_all_subwindows): Save the window's buffer in
Jim Blandy <jimb@redhat.com>
parents:
1123
diff
changeset
|
2664 |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2665 FRAME_ROOT_WINDOW (f) = data->root_window; |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2666 Fselect_window (data->current_window); |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2667 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2668 #ifdef MULTI_FRAME |
1716
95db936d47c0
* keyboard.c (Qscrollbar_movement, Qvertical_scrollbar,
Jim Blandy <jimb@redhat.com>
parents:
1685
diff
changeset
|
2669 if (NILP (data->focus_frame) |
95db936d47c0
* keyboard.c (Qscrollbar_movement, Qvertical_scrollbar,
Jim Blandy <jimb@redhat.com>
parents:
1685
diff
changeset
|
2670 || (XTYPE (data->focus_frame) == Lisp_Frame |
95db936d47c0
* keyboard.c (Qscrollbar_movement, Qvertical_scrollbar,
Jim Blandy <jimb@redhat.com>
parents:
1685
diff
changeset
|
2671 && FRAME_LIVE_P (XFRAME (data->focus_frame)))) |
95db936d47c0
* keyboard.c (Qscrollbar_movement, Qvertical_scrollbar,
Jim Blandy <jimb@redhat.com>
parents:
1685
diff
changeset
|
2672 Fredirect_frame_focus (frame, data->focus_frame); |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2673 #endif |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2674 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2675 #if 0 /* I don't understand why this is needed, and it causes problems |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2676 when the frame's old selected window has been deleted. */ |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2677 #ifdef MULTI_FRAME |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2678 if (f != selected_frame && ! FRAME_TERMCAP_P (f)) |
2297
bb88d48c290f
(Fselect_window): Use Fhandle_switch_frame.
Richard M. Stallman <rms@gnu.org>
parents:
2210
diff
changeset
|
2679 Fhandle_switch_frame (WINDOW_FRAME (XWINDOW (data->root_window)), Qnil); |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2680 #endif |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2681 #endif |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2682 |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2683 /* Set the screen height to the value it had before this function. */ |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2684 if (previous_frame_height != FRAME_HEIGHT (f) |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2685 || previous_frame_width != FRAME_WIDTH (f)) |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2686 change_frame_size (f, previous_frame_height, previous_frame_width, |
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2687 0, 0); |
265 | 2688 } |
2689 | |
1572
04c1b4719e60
* window.c (Fset_window_configuration): Protect call to
Jim Blandy <jimb@redhat.com>
parents:
1525
diff
changeset
|
2690 #ifdef MULTI_FRAME |
1325
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2691 /* Fselect_window will have made f the selected frame, so we |
2297
bb88d48c290f
(Fselect_window): Use Fhandle_switch_frame.
Richard M. Stallman <rms@gnu.org>
parents:
2210
diff
changeset
|
2692 reselect the proper frame here. Fhandle_switch_frame will change the |
1325
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2693 selected window too, but that doesn't make the call to |
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2694 Fselect_window above totally superfluous; it still sets f's |
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2695 selected window. */ |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2696 if (FRAME_LIVE_P (XFRAME (data->selected_frame))) |
2297
bb88d48c290f
(Fselect_window): Use Fhandle_switch_frame.
Richard M. Stallman <rms@gnu.org>
parents:
2210
diff
changeset
|
2697 Fhandle_switch_frame (data->selected_frame, Qnil); |
1572
04c1b4719e60
* window.c (Fset_window_configuration): Protect call to
Jim Blandy <jimb@redhat.com>
parents:
1525
diff
changeset
|
2698 #endif |
1325
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2699 |
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2700 if (!NILP (new_current_buffer)) |
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2701 Fset_buffer (new_current_buffer); |
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2702 |
265 | 2703 Vminibuf_scroll_window = data->minibuf_scroll_window; |
2704 return (Qnil); | |
2705 } | |
2706 | |
769 | 2707 /* Mark all windows now on frame as deleted |
265 | 2708 by setting their buffers to nil. */ |
2709 | |
1685
8d7fc70d3103
* window.c (Fset_window_configuration): If we're restoring the
Jim Blandy <jimb@redhat.com>
parents:
1572
diff
changeset
|
2710 void |
265 | 2711 delete_all_subwindows (w) |
2712 register struct window *w; | |
2713 { | |
485 | 2714 if (!NILP (w->next)) |
265 | 2715 delete_all_subwindows (XWINDOW (w->next)); |
485 | 2716 if (!NILP (w->vchild)) |
265 | 2717 delete_all_subwindows (XWINDOW (w->vchild)); |
485 | 2718 if (!NILP (w->hchild)) |
265 | 2719 delete_all_subwindows (XWINDOW (w->hchild)); |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
2720 |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
2721 w->height = w->buffer; /* See Fset_window_configuration for excuse. */ |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
2722 |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
2723 /* We set all three of these fields to nil, to make sure that we can |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
2724 distinguish this dead window from any live window. Live leaf |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
2725 windows will have buffer set, and combination windows will have |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
2726 vchild or hchild set. */ |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
2727 w->buffer = Qnil; |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
2728 w->vchild = Qnil; |
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
2729 w->hchild = Qnil; |
265 | 2730 } |
2731 | |
2732 static int | |
2733 count_windows (window) | |
2734 register struct window *window; | |
2735 { | |
2736 register int count = 1; | |
485 | 2737 if (!NILP (window->next)) |
265 | 2738 count += count_windows (XWINDOW (window->next)); |
485 | 2739 if (!NILP (window->vchild)) |
265 | 2740 count += count_windows (XWINDOW (window->vchild)); |
485 | 2741 if (!NILP (window->hchild)) |
265 | 2742 count += count_windows (XWINDOW (window->hchild)); |
2743 return count; | |
2744 } | |
2745 | |
2746 static int | |
2747 save_window_save (window, vector, i) | |
2748 Lisp_Object window; | |
2749 struct Lisp_Vector *vector; | |
2750 int i; | |
2751 { | |
2752 register struct saved_window *p; | |
2753 register struct window *w; | |
2754 register Lisp_Object tem; | |
2755 | |
485 | 2756 for (;!NILP (window); window = w->next) |
265 | 2757 { |
2758 p = SAVED_WINDOW_N (vector, i); | |
2759 w = XWINDOW (window); | |
2760 | |
2761 XFASTINT (w->temslot) = i++; | |
2762 p->window = window; | |
2763 p->buffer = w->buffer; | |
2764 p->left = w->left; | |
2765 p->top = w->top; | |
2766 p->width = w->width; | |
2767 p->height = w->height; | |
2768 p->hscroll = w->hscroll; | |
2769 p->display_table = w->display_table; | |
485 | 2770 if (!NILP (w->buffer)) |
265 | 2771 { |
2772 /* Save w's value of point in the window configuration. | |
2773 If w is the selected window, then get the value of point | |
2774 from the buffer; pointm is garbage in the selected window. */ | |
2775 if (EQ (window, selected_window)) | |
2776 { | |
2777 p->pointm = Fmake_marker (); | |
2778 Fset_marker (p->pointm, BUF_PT (XBUFFER (w->buffer)), | |
2779 w->buffer); | |
2780 } | |
2781 else | |
2782 p->pointm = Fcopy_marker (w->pointm); | |
2783 | |
2784 p->start = Fcopy_marker (w->start); | |
2785 p->start_at_line_beg = w->start_at_line_beg; | |
2786 | |
2787 tem = XBUFFER (w->buffer)->mark; | |
2788 p->mark = Fcopy_marker (tem); | |
2789 } | |
2790 else | |
2791 { | |
2792 p->pointm = Qnil; | |
2793 p->start = Qnil; | |
2794 p->mark = Qnil; | |
2795 p->start_at_line_beg = Qnil; | |
2796 } | |
2797 | |
485 | 2798 if (NILP (w->parent)) |
265 | 2799 p->parent = Qnil; |
2800 else | |
2801 p->parent = XWINDOW (w->parent)->temslot; | |
2802 | |
485 | 2803 if (NILP (w->prev)) |
265 | 2804 p->prev = Qnil; |
2805 else | |
2806 p->prev = XWINDOW (w->prev)->temslot; | |
2807 | |
485 | 2808 if (!NILP (w->vchild)) |
265 | 2809 i = save_window_save (w->vchild, vector, i); |
485 | 2810 if (!NILP (w->hchild)) |
265 | 2811 i = save_window_save (w->hchild, vector, i); |
2812 } | |
2813 | |
2814 return i; | |
2815 } | |
2816 | |
2817 DEFUN ("current-window-configuration", | |
358 | 2818 Fcurrent_window_configuration, Scurrent_window_configuration, 0, 1, 0, |
769 | 2819 "Return an object representing the current window configuration of FRAME.\n\ |
2820 If FRAME is nil or omitted, use the selected frame.\n\ | |
265 | 2821 This describes the number of windows, their sizes and current buffers,\n\ |
2822 and for each displayed buffer, where display starts, and the positions of\n\ | |
2823 point and mark. An exception is made for point in the current buffer:\n\ | |
1325
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2824 its value is -not- saved.\n\ |
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2825 This also records the currently selected frame, and FRAME's focus\n\ |
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2826 redirection (see `redirect-frame-focus').") |
769 | 2827 (frame) |
2828 Lisp_Object frame; | |
265 | 2829 { |
2830 register Lisp_Object tem; | |
2831 register int n_windows; | |
2832 register struct save_window_data *data; | |
2833 register int i; | |
769 | 2834 FRAME_PTR f; |
265 | 2835 |
769 | 2836 if (NILP (frame)) |
2837 f = selected_frame; | |
358 | 2838 else |
2839 { | |
769 | 2840 CHECK_LIVE_FRAME (frame, 0); |
2841 f = XFRAME (frame); | |
358 | 2842 } |
2843 | |
769 | 2844 n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f))); |
265 | 2845 data = (struct save_window_data *) |
2846 XVECTOR (Fmake_vector (make_number (SAVE_WINDOW_DATA_SIZE), | |
2847 Qnil)); | |
769 | 2848 XFASTINT (data->frame_width) = FRAME_WIDTH (f); |
2849 XFASTINT (data->frame_height) = FRAME_HEIGHT (f); | |
1572
04c1b4719e60
* window.c (Fset_window_configuration): Protect call to
Jim Blandy <jimb@redhat.com>
parents:
1525
diff
changeset
|
2850 #ifdef MULTI_FRAME |
1325
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2851 XSET (data->selected_frame, Lisp_Frame, selected_frame); |
1572
04c1b4719e60
* window.c (Fset_window_configuration): Protect call to
Jim Blandy <jimb@redhat.com>
parents:
1525
diff
changeset
|
2852 #endif |
769 | 2853 data->current_window = FRAME_SELECTED_WINDOW (f); |
265 | 2854 XSET (data->current_buffer, Lisp_Buffer, current_buffer); |
2855 data->minibuf_scroll_window = Vminibuf_scroll_window; | |
769 | 2856 data->root_window = FRAME_ROOT_WINDOW (f); |
1325
f03e559aac3e
* window.c (struct save_window_data): Save the currently selected
Jim Blandy <jimb@redhat.com>
parents:
1280
diff
changeset
|
2857 data->focus_frame = FRAME_FOCUS_FRAME (f); |
265 | 2858 tem = Fmake_vector (make_number (n_windows), Qnil); |
2859 data->saved_windows = tem; | |
2860 for (i = 0; i < n_windows; i++) | |
2861 XVECTOR (tem)->contents[i] | |
2862 = Fmake_vector (make_number (SAVED_WINDOW_VECTOR_SIZE), Qnil); | |
769 | 2863 save_window_save (FRAME_ROOT_WINDOW (f), |
265 | 2864 XVECTOR (tem), 0); |
2865 XSET (tem, Lisp_Window_Configuration, data); | |
2866 return (tem); | |
2867 } | |
2868 | |
2869 DEFUN ("save-window-excursion", Fsave_window_excursion, Ssave_window_excursion, | |
2870 0, UNEVALLED, 0, | |
2871 "Execute body, preserving window sizes and contents.\n\ | |
2872 Restores which buffer appears in which window, where display starts,\n\ | |
2873 as well as the current buffer.\n\ | |
2874 Does not restore the value of point in current buffer.") | |
2875 (args) | |
2876 Lisp_Object args; | |
2877 { | |
2878 register Lisp_Object val; | |
2879 register int count = specpdl_ptr - specpdl; | |
2880 | |
2881 record_unwind_protect (Fset_window_configuration, | |
358 | 2882 Fcurrent_window_configuration (Qnil)); |
265 | 2883 val = Fprogn (args); |
2884 return unbind_to (count, val); | |
2885 } | |
2886 | |
2887 init_window_once () | |
2888 { | |
769 | 2889 #ifdef MULTI_FRAME |
2890 selected_frame = make_terminal_frame (); | |
2891 minibuf_window = selected_frame->minibuffer_window; | |
2892 selected_window = selected_frame->selected_window; | |
2893 last_nonminibuf_frame = selected_frame; | |
2894 #else /* not MULTI_FRAME */ | |
265 | 2895 extern Lisp_Object get_minibuffer (); |
2896 | |
983
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
2897 minibuf_window = make_window (); |
769 | 2898 FRAME_ROOT_WINDOW (selected_frame) = make_window (); |
265 | 2899 |
769 | 2900 XWINDOW (FRAME_ROOT_WINDOW (selected_frame))->next = minibuf_window; |
2901 XWINDOW (minibuf_window)->prev = FRAME_ROOT_WINDOW (selected_frame); | |
983
eb19dfaec9c4
* window.c (window_loop): This used to keep track of the first
Jim Blandy <jimb@redhat.com>
parents:
972
diff
changeset
|
2902 XWINDOW (minibuf_window)->mini_p = Qt; |
265 | 2903 |
2904 /* These values 9 and 10 are arbitrary, | |
2905 just so that there is "something there." | |
2906 Correct values are put in in init_xdisp */ | |
2907 | |
769 | 2908 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame))->width) = 10; |
265 | 2909 XFASTINT (XWINDOW (minibuf_window)->width) = 10; |
2910 | |
769 | 2911 XFASTINT (XWINDOW (FRAME_ROOT_WINDOW (selected_frame))->height) = 9; |
265 | 2912 XFASTINT (XWINDOW (minibuf_window)->top) = 9; |
2913 XFASTINT (XWINDOW (minibuf_window)->height) = 1; | |
2914 | |
2915 /* Prevent error in Fset_window_buffer. */ | |
769 | 2916 XWINDOW (FRAME_ROOT_WINDOW (selected_frame))->buffer = Qt; |
265 | 2917 XWINDOW (minibuf_window)->buffer = Qt; |
2918 | |
2919 /* Now set them up for real. */ | |
769 | 2920 Fset_window_buffer (FRAME_ROOT_WINDOW (selected_frame), |
732 | 2921 Fcurrent_buffer ()); |
265 | 2922 Fset_window_buffer (minibuf_window, get_minibuffer (0)); |
2923 | |
769 | 2924 selected_window = FRAME_ROOT_WINDOW (selected_frame); |
362 | 2925 /* Make sure this window seems more recently used than |
2926 a newly-created, never-selected window. Increment | |
2927 window_select_count so the first selection ever will get | |
2928 something newer than this. */ | |
2929 XFASTINT (XWINDOW (selected_window)->use_time) = ++window_select_count; | |
769 | 2930 #endif /* not MULTI_FRAME */ |
265 | 2931 } |
2932 | |
2933 syms_of_window () | |
2934 { | |
2935 Qwindowp = intern ("windowp"); | |
2936 staticpro (&Qwindowp); | |
2937 | |
2210
22d78dbb3cc7
Rename `live-window-p' to `window-live-p', for consistency with
Jim Blandy <jimb@redhat.com>
parents:
2190
diff
changeset
|
2938 Qwindow_live_p = intern ("window-live-p"); |
22d78dbb3cc7
Rename `live-window-p' to `window-live-p', for consistency with
Jim Blandy <jimb@redhat.com>
parents:
2190
diff
changeset
|
2939 staticpro (&Qwindow_live_p); |
1444
559d2f2119aa
* window.c: Try to deal coherently with deleted windows:
Jim Blandy <jimb@redhat.com>
parents:
1345
diff
changeset
|
2940 |
1016
817b0ce337d7
* window.c (Fset_window_configuration): Removed #if 0'd code which
Jim Blandy <jimb@redhat.com>
parents:
983
diff
changeset
|
2941 #ifndef MULTI_FRAME |
265 | 2942 /* Make sure all windows get marked */ |
2943 staticpro (&minibuf_window); | |
1016
817b0ce337d7
* window.c (Fset_window_configuration): Removed #if 0'd code which
Jim Blandy <jimb@redhat.com>
parents:
983
diff
changeset
|
2944 #endif |
265 | 2945 |
2946 DEFVAR_LISP ("temp-buffer-show-function", &Vtemp_buffer_show_function, | |
2947 "Non-nil means call as function to display a help buffer.\n\ | |
2948 Used by `with-output-to-temp-buffer'."); | |
2949 Vtemp_buffer_show_function = Qnil; | |
2950 | |
2951 DEFVAR_LISP ("display-buffer-function", &Vdisplay_buffer_function, | |
2952 "If non-nil, function to call to handle `display-buffer'.\n\ | |
2953 It will receive two args, the buffer and a flag which if non-nil means\n\ | |
2954 that the currently selected window is not acceptable.\n\ | |
2955 Commands such as `switch-to-buffer-other-window' and `find-file-other-window'\n\ | |
2956 work using this function."); | |
2957 Vdisplay_buffer_function = Qnil; | |
2958 | |
2959 DEFVAR_LISP ("minibuffer-scroll-window", &Vminibuf_scroll_window, | |
2960 "Non-nil means it is the window that C-M-v in minibuffer should scroll."); | |
2961 Vminibuf_scroll_window = Qnil; | |
2962 | |
2963 DEFVAR_LISP ("other-window-scroll-buffer", &Vother_window_scroll_buffer, | |
2964 "If non-nil, this is a buffer and \\[scroll-other-window] should scroll its window."); | |
2965 Vother_window_scroll_buffer = Qnil; | |
2966 | |
769 | 2967 DEFVAR_BOOL ("pop-up-frames", &pop_up_frames, |
780 | 2968 "*Non-nil means `display-buffer' should make a separate frame."); |
769 | 2969 pop_up_frames = 0; |
265 | 2970 |
769 | 2971 DEFVAR_LISP ("pop-up-frame-function", &Vpop_up_frame_function, |
2972 "*If non-nil, function to call to handle automatic new frame creation.\n\ | |
2973 It is called with no arguments and should return a newly created frame.\n\ | |
265 | 2974 \n\ |
769 | 2975 A typical value might be `(lambda () (new-frame pop-up-frame-alist))'\n\ |
2976 where `pop-up-frame-alist' would hold the default frame parameters."); | |
2977 Vpop_up_frame_function = Qnil; | |
265 | 2978 |
2979 DEFVAR_BOOL ("pop-up-windows", &pop_up_windows, | |
2980 "*Non-nil means display-buffer should make new windows."); | |
2981 pop_up_windows = 1; | |
2982 | |
2983 DEFVAR_INT ("next-screen-context-lines", &next_screen_context_lines, | |
2984 "*Number of lines of continuity when scrolling by screenfuls."); | |
2985 next_screen_context_lines = 2; | |
2986 | |
2987 DEFVAR_INT ("split-height-threshold", &split_height_threshold, | |
2988 "*display-buffer would prefer to split the largest window if this large.\n\ | |
2989 If there is only one window, it is split regardless of this value."); | |
2990 split_height_threshold = 500; | |
2991 | |
2992 DEFVAR_INT ("window-min-height", &window_min_height, | |
2993 "*Delete any window less than this tall (including its mode line)."); | |
2994 window_min_height = 4; | |
2995 | |
2996 DEFVAR_INT ("window-min-width", &window_min_width, | |
2997 "*Delete any window less than this wide."); | |
2998 window_min_width = 10; | |
2999 | |
3000 defsubr (&Sselected_window); | |
3001 defsubr (&Sminibuffer_window); | |
3002 defsubr (&Swindow_minibuffer_p); | |
3003 defsubr (&Swindowp); | |
2210
22d78dbb3cc7
Rename `live-window-p' to `window-live-p', for consistency with
Jim Blandy <jimb@redhat.com>
parents:
2190
diff
changeset
|
3004 defsubr (&Swindow_live_p); |
265 | 3005 defsubr (&Spos_visible_in_window_p); |
3006 defsubr (&Swindow_buffer); | |
3007 defsubr (&Swindow_height); | |
3008 defsubr (&Swindow_width); | |
3009 defsubr (&Swindow_hscroll); | |
3010 defsubr (&Sset_window_hscroll); | |
3011 defsubr (&Swindow_edges); | |
432 | 3012 defsubr (&Scoordinates_in_window_p); |
3013 defsubr (&Swindow_at); | |
265 | 3014 defsubr (&Swindow_point); |
3015 defsubr (&Swindow_start); | |
3016 defsubr (&Swindow_end); | |
3017 defsubr (&Sset_window_point); | |
3018 defsubr (&Sset_window_start); | |
3019 defsubr (&Swindow_dedicated_p); | |
722
0a2391511b46
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
708
diff
changeset
|
3020 defsubr (&Sset_window_dedicated_p); |
265 | 3021 defsubr (&Swindow_display_table); |
3022 defsubr (&Sset_window_display_table); | |
3023 defsubr (&Snext_window); | |
3024 defsubr (&Sprevious_window); | |
3025 defsubr (&Sother_window); | |
3026 defsubr (&Sget_lru_window); | |
3027 defsubr (&Sget_largest_window); | |
3028 defsubr (&Sget_buffer_window); | |
3029 defsubr (&Sdelete_other_windows); | |
3030 defsubr (&Sdelete_windows_on); | |
3031 defsubr (&Sreplace_buffer_in_windows); | |
3032 defsubr (&Sdelete_window); | |
3033 defsubr (&Sset_window_buffer); | |
3034 defsubr (&Sselect_window); | |
3035 defsubr (&Sdisplay_buffer); | |
3036 defsubr (&Ssplit_window); | |
3037 defsubr (&Senlarge_window); | |
3038 defsubr (&Sshrink_window); | |
3039 defsubr (&Sscroll_up); | |
3040 defsubr (&Sscroll_down); | |
3041 defsubr (&Sscroll_left); | |
3042 defsubr (&Sscroll_right); | |
3043 defsubr (&Sscroll_other_window); | |
3044 defsubr (&Srecenter); | |
3045 defsubr (&Smove_to_window_line); | |
3046 defsubr (&Swindow_configuration_p); | |
3047 defsubr (&Sset_window_configuration); | |
3048 defsubr (&Scurrent_window_configuration); | |
3049 defsubr (&Ssave_window_excursion); | |
3050 } | |
3051 | |
3052 keys_of_window () | |
3053 { | |
3054 initial_define_key (control_x_map, '1', "delete-other-windows"); | |
3055 initial_define_key (control_x_map, '2', "split-window"); | |
3056 initial_define_key (control_x_map, '0', "delete-window"); | |
3057 initial_define_key (control_x_map, 'o', "other-window"); | |
3058 initial_define_key (control_x_map, '^', "enlarge-window"); | |
3059 initial_define_key (control_x_map, '<', "scroll-left"); | |
3060 initial_define_key (control_x_map, '>', "scroll-right"); | |
3061 | |
3062 initial_define_key (global_map, Ctl ('V'), "scroll-up"); | |
3063 initial_define_key (meta_map, Ctl ('V'), "scroll-other-window"); | |
3064 initial_define_key (meta_map, 'v', "scroll-down"); | |
3065 | |
3066 initial_define_key (global_map, Ctl('L'), "recenter"); | |
3067 initial_define_key (meta_map, 'r', "move-to-window-line"); | |
3068 } |