286
|
1 /* Generic screen functions.
|
|
2 Copyright (C) 1989 Free Software Foundation.
|
|
3
|
|
4 This file is part of GNU Emacs.
|
|
5
|
|
6 GNU Emacs is free software; you can redistribute it and/or modify
|
|
7 it under the terms of the GNU General Public License as published by
|
|
8 the Free Software Foundation; either version 1, or (at your option)
|
|
9 any later version.
|
|
10
|
|
11 GNU Emacs is distributed in the hope that it will be useful,
|
|
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
14 GNU General Public License for more details.
|
|
15
|
|
16 You should have received a copy of the GNU General Public License
|
|
17 along with GNU Emacs; see the file COPYING. If not, write to
|
|
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
19
|
|
20 #include "config.h"
|
|
21 #include "lisp.h"
|
|
22 #include "screen.h"
|
|
23 #include "window.h"
|
|
24
|
|
25 Lisp_Object Vemacs_iconified;
|
|
26 Lisp_Object Qscreenp;
|
|
27 Lisp_Object Vscreen_list;
|
|
28 Lisp_Object Vterminal_screen;
|
|
29 Lisp_Object Vglobal_minibuffer_screen;
|
|
30
|
|
31 extern Lisp_Object Vminibuffer_list;
|
|
32 extern Lisp_Object get_minibuffer ();
|
|
33
|
|
34 DEFUN ("screenp", Fscreenp, Sscreenp, 1, 1, 0,
|
|
35 "Return non-nil if OBJECT is a screen.\n\
|
|
36 Value is t for a termcap screen (a character-only terminal),\n\
|
|
37 `x' for an Emacs screen that is really an X window.")
|
|
38 (screen)
|
|
39 Lisp_Object screen;
|
|
40 {
|
|
41 if (XTYPE (screen) != Lisp_Screen)
|
|
42 return Qnil;
|
|
43 switch (XSCREEN (screen)->output_method)
|
|
44 {
|
|
45 case output_termcap:
|
|
46 return Qt;
|
|
47 case output_x_window:
|
|
48 return intern ("x");
|
|
49 default:
|
|
50 abort ();
|
|
51 }
|
|
52 }
|
|
53
|
|
54 struct screen *
|
|
55 make_screen (mini_p)
|
|
56 int mini_p;
|
|
57 {
|
|
58 Lisp_Object screen;
|
|
59 register struct screen *s;
|
|
60 register Lisp_Object root_window;
|
|
61 register Lisp_Object mini_window;
|
|
62
|
|
63 screen = Fmake_vector (sizeof (struct screen) - sizeof (Lisp_Vector) + 1,
|
|
64 make_number (0));
|
|
65 XSETTYPE (screen, Lisp_Screen);
|
|
66 s = XSCREEN (screen);
|
|
67
|
|
68 s->cursor_x = 0;
|
|
69 s->cursor_y = 0;
|
|
70 s->current_glyphs = 0;
|
|
71 s->desired_glyphs = 0;
|
|
72 s->visible = 0;
|
|
73 s->display.nothing = 0;
|
|
74 s->iconified = 0;
|
|
75 s->wants_modeline = 1;
|
|
76 s->auto_raise = 0;
|
|
77 s->auto_lower = 0;
|
|
78 s->no_split = 0;
|
|
79 s->garbaged = 0;
|
|
80 s->has_minibuffer = mini_p;
|
|
81
|
|
82 s->param_alist = Qnil;
|
|
83
|
|
84 root_window = make_window (0);
|
|
85 if (mini_p)
|
|
86 {
|
|
87 mini_window = make_window (0);
|
|
88 XWINDOW (root_window)->next = mini_window;
|
|
89 XWINDOW (mini_window)->prev = root_window;
|
|
90 XWINDOW (mini_window)->mini_p = Qt;
|
|
91 XWINDOW (mini_window)->screen = screen;
|
|
92 s->minibuffer_window = mini_window;
|
|
93 }
|
|
94 else
|
|
95 {
|
|
96 mini_window = Qnil;
|
|
97 XWINDOW (root_window)->next = Qnil;
|
|
98 s->minibuffer_window = Qnil;
|
|
99 }
|
|
100
|
|
101 XWINDOW (root_window)->screen = screen;
|
|
102
|
|
103 /* 10 is arbitrary,
|
|
104 just so that there is "something there."
|
|
105 Correct size will be set up later with change_screen_size. */
|
|
106
|
|
107 s->width = 10;
|
|
108 s->height = 10;
|
|
109
|
|
110 XFASTINT (XWINDOW (root_window)->width) = 10;
|
|
111 XFASTINT (XWINDOW (root_window)->height) = (mini_p ? 9 : 10);
|
|
112
|
|
113 if (mini_p)
|
|
114 {
|
|
115 XFASTINT (XWINDOW (mini_window)->width) = 10;
|
|
116 XFASTINT (XWINDOW (mini_window)->top) = 9;
|
|
117 XFASTINT (XWINDOW (mini_window)->height) = 1;
|
|
118 }
|
|
119
|
|
120 XWINDOW (root_window)->buffer = Qt;
|
|
121 Fset_window_buffer (root_window, Fcurrent_buffer ());
|
|
122 if (mini_p)
|
|
123 {
|
|
124 XWINDOW (mini_window)->buffer = Qt;
|
|
125 Fset_window_buffer (mini_window,
|
|
126 (NULL (Vminibuffer_list)
|
|
127 ? get_minibuffer (0)
|
|
128 : Fcar (Vminibuffer_list)));
|
|
129 }
|
|
130
|
|
131 s->selected_window = root_window;
|
|
132 s->root_window = root_window;
|
|
133
|
|
134 Vscreen_list = Fcons (screen, Vscreen_list);
|
|
135
|
|
136 return s;
|
|
137 }
|
|
138
|
|
139 /* Make a screen using a separate minibuffer window on another screen.
|
|
140 MINI_WINDOW is the minibuffer window to use. nil means use the
|
|
141 default (the global minibuffer). */
|
|
142
|
|
143 struct screen *
|
|
144 make_screen_without_minibuffer (mini_window)
|
|
145 register Lisp_Object mini_window;
|
|
146 {
|
|
147 register struct screen *s;
|
|
148
|
|
149 /* Choose the minibuffer window to use. */
|
|
150 if (NULL (mini_window))
|
|
151 {
|
|
152 CHECK_SCREEN (Vglobal_minibuffer_screen, 0);
|
|
153 mini_window = XSCREEN (Vglobal_minibuffer_screen)->minibuffer_window;
|
|
154 }
|
|
155 else
|
|
156 {
|
|
157 CHECK_WINDOW (mini_window, 0);
|
|
158 }
|
|
159
|
|
160 /* Make a screen containing just a root window. */
|
|
161 s = make_screen (0);
|
|
162
|
|
163 /* Install the chosen minibuffer window, with proper buffer. */
|
|
164 s->minibuffer_window = mini_window;
|
|
165 Fset_window_buffer (mini_window,
|
|
166 (NULL (Vminibuffer_list)
|
|
167 ? get_minibuffer (0)
|
|
168 : Fcar (Vminibuffer_list)));
|
|
169 return s;
|
|
170 }
|
|
171
|
|
172 /* Make a screen containing only a minibuffer window. */
|
|
173
|
|
174 struct screen *
|
|
175 make_minibuffer_screen ()
|
|
176 {
|
|
177 /* First make a screen containing just a root window, no minibuffer. */
|
|
178
|
|
179 register struct screen *s = make_screen (0);
|
|
180 register Lisp_Object mini_window;
|
|
181 register Lisp_Object screen;
|
|
182
|
|
183 XSET (screen, Lisp_Screen, s);
|
|
184
|
|
185 /* ??? Perhaps leave it to the user program to set auto_raise. */
|
|
186 s->auto_raise = 1;
|
|
187 s->auto_lower = 0;
|
|
188 s->no_split = 1;
|
|
189 s->wants_modeline = 0;
|
|
190 /* Note we leave has_minibuffer as 0. This is a little strange. */
|
|
191
|
|
192 /* Now label the root window as also being the minibuffer.
|
|
193 Avoid infinite looping on the window chain by marking next pointer
|
|
194 as nil. */
|
|
195
|
|
196 mini_window = s->minibuffer_window = s->root_window;
|
|
197 XWINDOW (mini_window)->mini_p = Qt;
|
|
198 XWINDOW (mini_window)->next = Qnil;
|
|
199 XWINDOW (mini_window)->prev = mini_window;
|
|
200 XWINDOW (mini_window)->screen = screen;
|
|
201
|
|
202 /* Put the proper buffer in that window. */
|
|
203
|
|
204 Fset_window_buffer (mini_window,
|
|
205 (NULL (Vminibuffer_list)
|
|
206 ? get_minibuffer (0)
|
|
207 : Fcar (Vminibuffer_list)));
|
|
208 return s;
|
|
209 }
|
|
210
|
|
211 /* Construct a screen that refers to the terminal (stdin and stdout). */
|
|
212
|
|
213 struct screen *
|
|
214 make_terminal_screen ()
|
|
215 {
|
|
216 register struct screen *s;
|
|
217
|
|
218 Vscreen_list = Qnil;
|
|
219 s = make_screen (1);
|
|
220 s->name = build_string ("terminal");
|
|
221 s->visible = 1;
|
|
222 s->display.nothing = 1; /* Nonzero means screen isn't deleted. */
|
|
223 XSET (Vterminal_screen, Lisp_Screen, s);
|
|
224 return s;
|
|
225 }
|
|
226
|
|
227 DEFUN ("select-screen", Fselect_screen, Sselect_screen, 1, 2, 0,
|
|
228 "Select the screen S. S's selected window becomes \"the\"\n\
|
|
229 selected window. If the optional parameter NO-ENTER is non-nil, don't
|
|
230 focus on that screen.")
|
|
231 (screen, no_enter)
|
|
232 Lisp_Object screen, no_enter;
|
|
233 {
|
|
234 CHECK_SCREEN (screen, 0);
|
|
235
|
|
236 if (selected_screen == XSCREEN (screen))
|
|
237 return screen;
|
|
238
|
|
239 selected_screen = XSCREEN (screen);
|
|
240 Fselect_window (XSCREEN (screen)->selected_window);
|
|
241
|
|
242 #ifdef HAVE_X_WINDOWS
|
|
243 #ifdef MULTI_SCREEN
|
|
244 if (XSCREEN (screen)->output_method == output_x_window
|
|
245 && NULL (no_enter))
|
|
246 {
|
|
247 Ffocus_screen (screen);
|
|
248 }
|
|
249 #endif
|
|
250 #endif
|
|
251 choose_minibuf_screen ();
|
|
252
|
|
253 return screen;
|
|
254 }
|
|
255
|
|
256 DEFUN ("selected-screen", Fselected_screen, Sselected_screen, 0, 0, 0,
|
|
257 "Return the screen that is now selected.")
|
|
258 ()
|
|
259 {
|
|
260 Lisp_Object tem;
|
|
261 XSET (tem, Lisp_Screen, selected_screen);
|
|
262 return tem;
|
|
263 }
|
|
264
|
|
265 DEFUN ("window-screen", Fwindow_screen, Swindow_screen, 1, 1, 0,
|
|
266 "Return the screen object that window WINDOW is on.")
|
|
267 (window)
|
|
268 Lisp_Object window;
|
|
269 {
|
|
270 CHECK_WINDOW (window, 0);
|
|
271 return XWINDOW (window)->screen;
|
|
272 }
|
|
273
|
|
274 DEFUN ("screen-root-window", Fscreen_root_window, Sscreen_root_window, 0, 1, 0,
|
|
275 "Returns the root-window of SCREEN.")
|
|
276 (screen)
|
|
277 Lisp_Object screen;
|
|
278 {
|
|
279 if (NULL (screen))
|
|
280 XSET (screen, Lisp_Screen, selected_screen);
|
|
281 CHECK_SCREEN (screen, 0);
|
|
282
|
|
283 return XSCREEN (screen)->root_window;
|
|
284 }
|
|
285
|
|
286 DEFUN ("screen-selected-window", Fscreen_selected_window,
|
|
287 Sscreen_selected_window, 0, 1, 0,
|
|
288 "Return the selected window of screen object SCREEN.")
|
|
289 (screen)
|
|
290 Lisp_Object screen;
|
|
291 {
|
|
292 if (NULL (screen))
|
|
293 XSET (screen, Lisp_Screen, selected_screen);
|
|
294 CHECK_SCREEN (screen, 0);
|
|
295
|
|
296 return XSCREEN (screen)->selected_window;
|
|
297 }
|
|
298
|
|
299 DEFUN ("screen-list", Fscreen_list, Sscreen_list,
|
|
300 0, 0, 0,
|
|
301 "Return a list of all screens.")
|
|
302 ()
|
|
303 {
|
|
304 return Fcopy_sequence (Vscreen_list);
|
|
305 }
|
|
306
|
|
307 #ifdef MULTI_SCREEN
|
|
308 Lisp_Object
|
|
309 next_screen (screen, mini_screen)
|
|
310 Lisp_Object screen;
|
|
311 int mini_screen;
|
|
312 {
|
|
313 Lisp_Object tail;
|
|
314 int passed = 0;
|
|
315
|
|
316 while (1)
|
|
317 for (tail = Vscreen_list; CONSP (tail); tail = XCONS (tail)->cdr)
|
|
318 {
|
|
319 if (passed)
|
335
|
320 if (!mini_screen)
|
|
321 {
|
|
322 SCREEN_PTR s = XSCREEN (XCONS (tail)->car);
|
|
323
|
|
324 if (EQ (XCONS (tail)->car, Vglobal_minibuffer_screen)
|
|
325 && EQ (s->root_window, s->minibuffer_window))
|
|
326 continue;
|
|
327 }
|
286
|
328 else
|
|
329 return XCONS (tail)->car;
|
|
330
|
|
331 if (EQ (screen, XCONS (tail)->car))
|
|
332 passed++;
|
|
333 }
|
|
334 }
|
|
335
|
|
336 Lisp_Object
|
|
337 prev_screen (screen, mini_screen)
|
|
338 Lisp_Object screen;
|
|
339 int mini_screen;
|
|
340 {
|
|
341 Lisp_Object tail;
|
|
342 Lisp_Object prev;
|
|
343
|
|
344 prev = Qnil;
|
|
345 while (1)
|
|
346 for (tail = Vscreen_list; CONSP (tail); tail = XCONS (tail)->cdr)
|
|
347 {
|
|
348 if (EQ (screen, XCONS (tail)->car))
|
|
349 {
|
|
350 if (!NULL (prev) && (mini_screen
|
|
351 || !EQ (XCONS (tail)->car,
|
|
352 Vglobal_minibuffer_screen)))
|
|
353 return prev;
|
|
354 }
|
|
355 prev = XCONS (tail)->car;
|
|
356 }
|
|
357 }
|
|
358
|
|
359 DEFUN ("next-screen", Fnext_screen, Snext_screen,
|
|
360 0, 2, 0,
|
|
361 "Return the next screen in the screen list after SCREEN.\n\
|
335
|
362 If MINISCREEN is non-nil, include screens whose only window is a minibuffer.\n\
|
|
363 If MINISCREEN is nil or omitted, these screens are skipped.")
|
286
|
364 (screen, miniscreen)
|
|
365 Lisp_Object screen, miniscreen;
|
|
366 {
|
|
367 Lisp_Object tail;
|
|
368
|
|
369 if (NULL (screen))
|
|
370 XSET (screen, Lisp_Screen, selected_screen);
|
|
371 CHECK_SCREEN (screen, 0);
|
|
372
|
|
373 return next_screen (screen, (NULL (miniscreen) ? 0 : 1));
|
|
374 }
|
|
375 #endif /* MULTI_SCREEN */
|
|
376
|
|
377 DEFUN ("delete-screen", Fdelete_screen, Sdelete_screen,
|
|
378 0, 1, "",
|
|
379 "Delete SCREEN, permanently eliminating it from use.\n\
|
|
380 Default is current screen.")
|
|
381 (screen)
|
|
382 Lisp_Object screen;
|
|
383 {
|
|
384 struct screen *s;
|
|
385 union display displ;
|
|
386
|
|
387 if (EQ (screen, Qnil))
|
|
388 {
|
|
389 s = selected_screen;
|
|
390 XSET (screen, Lisp_Screen, s);
|
|
391 }
|
|
392 else
|
|
393 {
|
|
394 CHECK_SCREEN (screen, 0);
|
|
395 s = XSCREEN (screen);
|
|
396 }
|
|
397
|
|
398 /* Don't allow deleted screen to remain selected. */
|
|
399 if (s == selected_screen)
|
|
400 {
|
|
401 Lisp_Object next;
|
|
402
|
|
403 next = next_screen (screen, 0);
|
|
404 if (EQ (next, screen))
|
|
405 error ("Attempt to delete the only screen");
|
|
406 Fselect_screen (next, Qnil);
|
|
407 }
|
|
408
|
|
409 /* Don't allow the global minibuffer screen to be deleted */
|
|
410 if (s == XSCREEN (Vglobal_minibuffer_screen))
|
|
411 error ("Attempt to delete the global minibuffer screen");
|
|
412
|
|
413 /* Don't allow minibuf_window to remain on a deleted screen. */
|
|
414 if (EQ (s->minibuffer_window, minibuf_window))
|
|
415 {
|
|
416 Fset_window_buffer (selected_screen->minibuffer_window,
|
|
417 XWINDOW (minibuf_window)->buffer);
|
|
418 minibuf_window = selected_screen->minibuffer_window;
|
|
419 }
|
|
420
|
|
421 Vscreen_list = Fdelq (screen, Vscreen_list);
|
|
422 s->visible = 0;
|
|
423 displ = s->display;
|
|
424 s->display.nothing = 0;
|
|
425
|
|
426 if (s->output_method == output_x_window)
|
|
427 x_destroy_window (s, displ);
|
|
428
|
|
429 return Qnil;
|
|
430 }
|
|
431
|
|
432 /* Return mouse position in character cell units. */
|
|
433
|
|
434 static
|
|
435 read_mouse_position (screen, x, y)
|
|
436 Lisp_Object screen;
|
|
437 int *x, *y;
|
|
438 {
|
|
439 CHECK_SCREEN (screen, 0);
|
|
440
|
|
441 *x = 1;
|
|
442 *y = 1;
|
|
443
|
|
444 #ifdef HAVE_X_WINDOWS
|
|
445 if (XSCREEN (screen)->output_method == output_x_window)
|
|
446 x_read_mouse_position (XSCREEN (screen), x, y);
|
|
447 #endif
|
|
448 }
|
|
449
|
|
450 DEFUN ("read-mouse-position", Fread_mouse_position, Sread_mouse_position, 1, 1, 0,
|
|
451 "Return a cons (x . y) which represents the position of the mouse.")
|
|
452 (screen)
|
|
453 Lisp_Object screen;
|
|
454 {
|
|
455 int x, y;
|
|
456 struct screen *s;
|
|
457
|
|
458 CHECK_SCREEN (screen, 0);
|
|
459
|
|
460 read_mouse_position (screen, &x, &y);
|
|
461 return Fcons (make_number (x), make_number (y));
|
|
462 }
|
|
463
|
|
464 DEFUN ("set-mouse-position", Fset_mouse_position, Sset_mouse_position, 3, 3, 0,
|
|
465 "Move the mouse pointer to the center of cell (X,Y) in SCREEN.\n\
|
|
466 WARNING: If you use this under X, you should do unfocus-screen afterwards.")
|
|
467 (screen, x, y)
|
|
468 Lisp_Object screen, x, y;
|
|
469 {
|
|
470 CHECK_SCREEN (screen, 0);
|
|
471 CHECK_NUMBER (x, 2);
|
|
472 CHECK_NUMBER (y, 1);
|
|
473
|
|
474 #ifdef HAVE_X_WINDOWS
|
|
475 if (XSCREEN (screen)->output_method == output_x_window)
|
|
476 /* Warping the mouse will cause enternotify and focus events. */
|
|
477 x_set_mouse_position (XSCREEN (screen), x, y);
|
|
478 #endif
|
|
479
|
|
480 return Qnil;
|
|
481 }
|
|
482
|
|
483 #if 0
|
|
484 /* ??? Can this be replaced with a Lisp function?
|
|
485 It is used in minibuf.c. Can we get rid of that? */
|
|
486
|
|
487 DEFUN ("screen-configuration", Fscreen_configuration, Sscreen_configuration,
|
|
488 0, 0, 0,
|
|
489 "Return object describing current screen configuration.\n\
|
|
490 The screen configuration is the current mouse position and selected screen.\n\
|
|
491 This object can be given to `restore-screen-configuration'\n\
|
|
492 to restore this screen configuration.")
|
|
493 ()
|
|
494 {
|
|
495 int x, y;
|
|
496 Lisp_Object c, screen;
|
|
497 struct screen *s;
|
|
498
|
|
499 c = Fmake_vector (make_number(3), Qnil);
|
|
500 XVECTOR (c)->contents[0] = screen = Fselected_screen();
|
|
501 read_mouse_position (screen, &x, &y);
|
|
502 XVECTOR (c)->contents[1] = make_number (x);
|
|
503 XVECTOR (c)->contents[2] = make_number (y);
|
|
504
|
|
505 return c;
|
|
506 }
|
|
507
|
|
508 DEFUN ("restore-screen-configuration", Frestore_screen_configuration,
|
|
509 Srestore_screen_configuration,
|
|
510 1, 1, 0,
|
|
511 "Restores screen configuration CONFIGURATION.")
|
|
512 (config)
|
|
513 Lisp_Object config;
|
|
514 {
|
|
515 Lisp_Object x_pos, y_pos, screen;
|
|
516
|
|
517 CHECK_VECTOR (config, 0);
|
|
518 if (XVECTOR (config)->size != 3)
|
|
519 {
|
|
520 error ("Wrong size vector passed to restore-screen-configuration");
|
|
521 }
|
|
522 screen = XVECTOR (config)->contents[0];
|
|
523 CHECK_SCREEN (screen, 0);
|
|
524
|
|
525 Fselect_screen (screen, Qnil);
|
|
526
|
|
527 #if 0
|
|
528 /* This seems to interfere with the screen selection mechanism. jla */
|
|
529 x_pos = XVECTOR (config)->contents[1];
|
|
530 y_pos = XVECTOR (config)->contents[2];
|
|
531 set_mouse_position (screen, XINT (x_pos), XINT (y_pos));
|
|
532 #endif
|
|
533
|
|
534 return screen;
|
|
535 }
|
|
536 #endif
|
|
537
|
|
538 DEFUN ("make-screen-visible", Fmake_screen_visible, Smake_screen_visible,
|
|
539 1, 1, 0,
|
|
540 "Make the screen SCREEN visible (assuming it is an X-window).\n\
|
|
541 Also raises the screen so that nothing obscures it.")
|
|
542 (screen)
|
|
543 Lisp_Object screen;
|
|
544 {
|
|
545 CHECK_SCREEN (screen, 0);
|
|
546
|
|
547 if (XSCREEN (screen)->display.nothing == 0)
|
|
548 error ("Cannot make a dead screen object visible");
|
|
549
|
|
550 if (XSCREEN (screen)->output_method == output_x_window)
|
|
551 x_make_screen_visible (XSCREEN (screen));
|
|
552
|
|
553 return screen;
|
|
554 }
|
|
555
|
|
556 DEFUN ("make-screen-invisible", Fmake_screen_invisible, Smake_screen_invisible,
|
|
557 1, 1, 0,
|
|
558 "Make the screen SCREEN invisible (assuming it is an X-window).")
|
|
559 (screen)
|
|
560 Lisp_Object screen;
|
|
561 {
|
|
562 CHECK_SCREEN (screen, 0);
|
|
563
|
|
564 if (XSCREEN (screen)->output_method == output_x_window)
|
|
565 x_make_screen_invisible (XSCREEN (screen));
|
|
566
|
|
567 return Qnil;
|
|
568 }
|
|
569
|
|
570 DEFUN ("iconify-screen", Ficonify_screen, Siconify_screen,
|
|
571 1, 1, 0,
|
|
572 "Make the screen SCREEN into an icon.")
|
|
573 (screen)
|
|
574 Lisp_Object screen;
|
|
575 {
|
|
576 CHECK_SCREEN (screen, 0);
|
|
577
|
|
578 if (XSCREEN (screen)->display.nothing == 0)
|
|
579 error ("Cannot make a dead screen object iconified.");
|
|
580
|
|
581 if (XSCREEN (screen)->output_method == output_x_window)
|
|
582 x_iconify_screen (XSCREEN (screen));
|
|
583
|
|
584 return Qnil;
|
|
585 }
|
|
586
|
|
587 DEFUN ("deiconify-screen", Fdeiconify_screen, Sdeiconify_screen,
|
|
588 1, 1, 0,
|
|
589 "Open (de-iconify) the iconified screen SCREEN.")
|
|
590 (screen)
|
|
591 Lisp_Object screen;
|
|
592 {
|
|
593 CHECK_SCREEN (screen, 0);
|
|
594
|
|
595 if (XSCREEN (screen)->display.nothing == 0)
|
|
596 error ("Cannot deiconify a dead screen object.");
|
|
597
|
|
598 if (XSCREEN (screen)->output_method == output_x_window)
|
|
599 x_make_screen_visible (XSCREEN (screen));
|
|
600
|
|
601 return screen;
|
|
602 }
|
|
603
|
|
604 DEFUN ("screen-visible-p", Fscreen_visible_p, Sscreen_visible_p,
|
|
605 1, 1, 0,
|
|
606 "Return t if SCREEN is now \"visible\" (actually in use for display).\n\
|
|
607 A screen that is not \"visible\" is not updated and, if it works through\n\
|
|
608 a window system, it may not show at all.\n\
|
|
609 Return the symbol `icon' if window is visible only as an icon.")
|
|
610 (screen)
|
|
611 Lisp_Object screen;
|
|
612 {
|
|
613 CHECK_SCREEN (screen, 0);
|
|
614
|
|
615 if (XSCREEN (screen)->visible)
|
|
616 return Qt;
|
|
617 if (XSCREEN (screen)->iconified)
|
|
618 return intern ("icon");
|
|
619 return Qnil;
|
|
620 }
|
|
621
|
|
622 DEFUN ("visible-screen-list", Fvisible_screen_list, Svisible_screen_list,
|
|
623 0, 0, 0,
|
|
624 "Return a list of all screens now \"visible\" (being updated).")
|
|
625 ()
|
|
626 {
|
|
627 Lisp_Object tail, screen;
|
|
628 struct screen *s;
|
|
629 Lisp_Object value;
|
|
630
|
|
631 value = Qnil;
|
|
632 for (tail = Vscreen_list; CONSP (tail); tail = XCONS (tail)->cdr)
|
|
633 {
|
|
634 screen = XCONS (tail)->car;
|
|
635 if (XTYPE (screen) != Lisp_Screen)
|
|
636 continue;
|
|
637 s = XSCREEN (screen);
|
|
638 if (s->visible)
|
|
639 value = Fcons (screen, value);
|
|
640 }
|
|
641 return value;
|
|
642 }
|
|
643
|
|
644 Lisp_Object
|
|
645 get_screen_param (screen, prop)
|
|
646 register struct screen *screen;
|
|
647 Lisp_Object prop;
|
|
648 {
|
|
649 register Lisp_Object tem;
|
|
650
|
|
651 tem = Fassq (prop, screen->param_alist);
|
|
652 if (EQ (tem, Qnil))
|
|
653 return tem;
|
|
654 return Fcdr (tem);
|
|
655 }
|
|
656
|
|
657 void
|
|
658 store_in_alist (alistptr, propname, val)
|
|
659 Lisp_Object *alistptr, val;
|
|
660 char *propname;
|
|
661 {
|
|
662 register Lisp_Object tem;
|
|
663 register Lisp_Object prop;
|
|
664
|
|
665 prop = intern (propname);
|
|
666 tem = Fassq (prop, *alistptr);
|
|
667 if (EQ (tem, Qnil))
|
|
668 *alistptr = Fcons (Fcons (prop, val), *alistptr);
|
|
669 else
|
|
670 Fsetcdr (tem, val);
|
|
671 }
|
|
672
|
|
673 void
|
|
674 store_screen_param (s, prop, val)
|
|
675 struct screen *s;
|
|
676 Lisp_Object prop, val;
|
|
677 {
|
|
678 register Lisp_Object tem;
|
|
679
|
|
680 tem = Fassq (prop, s->param_alist);
|
|
681 if (EQ (tem, Qnil))
|
|
682 s->param_alist = Fcons (Fcons (prop, val), s->param_alist);
|
|
683 else
|
|
684 Fsetcdr (tem, val);
|
|
685 }
|
|
686
|
|
687 DEFUN ("screen-parameters", Fscreen_parameters, Sscreen_parameters, 0, 1, 0,
|
|
688 "Return the parameters-alist of screen SCREEN.\n\
|
|
689 It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.\n\
|
|
690 The meaningful PARMs depend on the kind of screen.")
|
|
691 (screen)
|
|
692 Lisp_Object screen;
|
|
693 {
|
|
694 Lisp_Object alist;
|
|
695 struct screen *s;
|
|
696
|
|
697 if (EQ (screen, Qnil))
|
|
698 s = selected_screen;
|
|
699 else
|
|
700 {
|
|
701 CHECK_SCREEN (screen, 0);
|
|
702 s = XSCREEN (screen);
|
|
703 }
|
|
704
|
|
705 if (s->display.nothing == 0)
|
|
706 return Qnil;
|
|
707
|
|
708 alist = Fcopy_alist (s->param_alist);
|
|
709 store_in_alist (&alist, "name", s->name);
|
|
710 store_in_alist (&alist, "height", make_number (s->height));
|
|
711 store_in_alist (&alist, "width", make_number (s->width));
|
|
712 store_in_alist (&alist, "modeline", (s->wants_modeline ? Qt : Qnil));
|
|
713 store_in_alist (&alist, "minibuffer", (s->has_minibuffer ? Qt : Qnil));
|
|
714 store_in_alist (&alist, "unsplittable", (s->no_split ? Qt : Qnil));
|
|
715
|
|
716 if (s->output_method == output_x_window)
|
|
717 x_report_screen_params (s, &alist);
|
|
718 return alist;
|
|
719 }
|
|
720
|
|
721 DEFUN ("modify-screen-parameters", Fmodify_screen_parameters,
|
|
722 Smodify_screen_parameters, 2, 2, 0,
|
|
723 "Modify the parameters of screen SCREEN according to ALIST.\n\
|
|
724 ALIST is an alist of parameters to change and their new values.\n\
|
|
725 Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.\n\
|
|
726 The meaningful PARMs depend on the kind of screen; undefined PARMs are ignored.")
|
|
727 (screen, alist)
|
|
728 Lisp_Object screen, alist;
|
|
729 {
|
|
730 register struct screen *s;
|
|
731 register Lisp_Object tail, elt, prop, val;
|
|
732
|
|
733 if (EQ (screen, Qnil))
|
|
734 s = selected_screen;
|
|
735 else
|
|
736 {
|
|
737 CHECK_SCREEN (screen, 0);
|
|
738 s = XSCREEN (screen);
|
|
739 }
|
|
740
|
|
741 if (s->display.nothing == 0)
|
|
742 error ("Cannot modify parameters of a deleted screen");
|
|
743
|
|
744 if (s->output_method == output_x_window)
|
|
745 for (tail = alist; !EQ (tail, Qnil); tail = Fcdr (tail))
|
|
746 {
|
|
747 elt = Fcar (tail);
|
|
748 prop = Fcar (elt);
|
|
749 val = Fcdr (elt);
|
|
750 x_set_screen_param (s, prop, val,
|
|
751 get_screen_param (s, prop));
|
|
752 store_screen_param (s, prop, val);
|
|
753 }
|
|
754
|
|
755 return Qnil;
|
|
756 }
|
|
757
|
|
758
|
|
759 DEFUN ("screen-pixel-size", Fscreen_pixel_size,
|
|
760 Sscreen_pixel_size, 1, 1, 0,
|
|
761 "Return a cons (width . height) of screen SCREEN's dimensions.")
|
|
762 (screen)
|
|
763 Lisp_Object screen;
|
|
764 {
|
|
765 register struct screen *s;
|
|
766 int width, height;
|
|
767
|
|
768 CHECK_SCREEN (screen, 0);
|
|
769 s = XSCREEN (screen);
|
|
770
|
|
771 return Fcons (make_number (x_pixel_width (s)),
|
|
772 make_number (x_pixel_height (s)));
|
|
773 }
|
|
774
|
|
775 DEFUN ("screen-height", Fscreen_height, Sscreen_height, 0, 0, 0,
|
|
776 "Return number of lines available for display on selected screen.")
|
|
777 ()
|
|
778 {
|
|
779 return make_number (SCREEN_HEIGHT (selected_screen));
|
|
780 }
|
|
781
|
|
782 DEFUN ("screen-width", Fscreen_width, Sscreen_width, 0, 0, 0,
|
|
783 "Return number of columns available for display on selected screen.")
|
|
784 ()
|
|
785 {
|
|
786 return make_number (SCREEN_WIDTH (selected_screen));
|
|
787 }
|
|
788
|
|
789 DEFUN ("set-screen-height", Fset_screen_height, Sset_screen_height, 2, 3, 0,
|
|
790 "Specify that the screen SCREEN has LINES lines.\n\
|
|
791 Optional third arg non-nil means that redisplay should use LINES lines\n\
|
|
792 but that the idea of the actual height of the screen should not be changed.")
|
|
793 (screen, rows, pretend)
|
|
794 Lisp_Object rows, pretend;
|
|
795 {
|
|
796 register struct screen *s;
|
|
797
|
|
798 CHECK_NUMBER (rows, 0);
|
|
799 if (NULL (screen))
|
|
800 s = selected_screen;
|
|
801 else
|
|
802 {
|
|
803 CHECK_SCREEN (screen, 0);
|
|
804 s = XSCREEN (screen);
|
|
805 }
|
|
806
|
|
807 if (s->output_method == output_x_window)
|
|
808 {
|
|
809 if (XINT (rows) != s->width)
|
|
810 x_set_window_size (s, s->width, XINT (rows));
|
|
811 }
|
|
812 else
|
|
813 change_screen_size (s, XINT (rows), 0, !NULL (pretend));
|
|
814 return Qnil;
|
|
815 }
|
|
816
|
|
817 DEFUN ("set-screen-width", Fset_screen_width, Sset_screen_width, 2, 3, 0,
|
|
818 "Specify that the screen SCREEN has COLS columns.\n\
|
|
819 Optional third arg non-nil means that redisplay should use COLS columns\n\
|
|
820 but that the idea of the actual width of the screen should not be changed.")
|
|
821 (screen, cols, pretend)
|
|
822 Lisp_Object cols, pretend;
|
|
823 {
|
|
824 register struct screen *s;
|
|
825 CHECK_NUMBER (cols, 0);
|
|
826 if (NULL (screen))
|
|
827 s = selected_screen;
|
|
828 else
|
|
829 {
|
|
830 CHECK_SCREEN (screen, 0);
|
|
831 s = XSCREEN (screen);
|
|
832 }
|
|
833
|
|
834 if (s->output_method == output_x_window)
|
|
835 {
|
|
836 if (XINT (cols) != s->width)
|
|
837 x_set_window_size (s, XINT (cols), s->height);
|
|
838 }
|
|
839 else
|
|
840 change_screen_size (selected_screen, 0, XINT (cols), !NULL (pretend));
|
|
841 return Qnil;
|
|
842 }
|
|
843
|
|
844 DEFUN ("set-screen-size", Fset_screen_size,
|
|
845 Sset_screen_size, 3, 3, 0,
|
|
846 "Sets size of SCREEN to COLS by ROWS, measured in characters.")
|
|
847 (screen, cols, rows)
|
|
848 Lisp_Object screen, cols, rows;
|
|
849 {
|
|
850 register struct screen *s;
|
|
851 int mask;
|
|
852
|
|
853 CHECK_SCREEN (screen, 0);
|
|
854 CHECK_NUMBER (cols, 2);
|
|
855 CHECK_NUMBER (rows, 1);
|
|
856 s = XSCREEN (screen);
|
|
857
|
|
858 if (s->output_method == output_x_window)
|
|
859 {
|
|
860 if (XINT (rows) != s->height || XINT (cols) != s->width)
|
|
861 x_set_window_size (s, XINT (cols), XINT (rows));
|
|
862 }
|
|
863 else
|
|
864 change_screen_size (s, XINT (rows), XINT (cols), 0);
|
|
865
|
|
866 return Qnil;
|
|
867 }
|
|
868
|
|
869 DEFUN ("set-screen-position", Fset_screen_position,
|
|
870 Sset_screen_position, 3, 3, 0,
|
|
871 "Sets size of SCREEN in pixels to XOFFSET by YOFFSET.")
|
|
872 (screen, xoffset, yoffset)
|
|
873 Lisp_Object screen, xoffset, yoffset;
|
|
874 {
|
|
875 register struct screen *s;
|
|
876 int mask;
|
|
877
|
|
878 CHECK_SCREEN (screen, 0);
|
|
879 CHECK_NUMBER (xoffset, 1);
|
|
880 CHECK_NUMBER (yoffset, 2);
|
|
881 s = XSCREEN (screen);
|
|
882
|
|
883 if (s->output_method == output_x_window)
|
|
884 x_set_offset (s, XINT (xoffset), XINT (yoffset));
|
|
885
|
|
886 return Qt;
|
|
887 }
|
|
888
|
|
889 /* Test if column *x, row *y is within window *w. If they are not,
|
|
890 return 0; if they are on the window's modeline, return -1; if
|
|
891 they are in the window's text area (the only other alternative)
|
|
892 set *x and *y to their locations relative to the upper left
|
|
893 corner of the window, and return 1. */
|
|
894 int
|
|
895 coordinates_in_window (w, x, y)
|
|
896 register struct window *w;
|
|
897 register int *x, *y;
|
|
898 {
|
|
899 register int left = XINT (w->left);
|
|
900 register int width = XINT (w->width);
|
|
901 register int window_height = XINT (w->height);
|
|
902 register int top = XFASTINT (w->top);
|
|
903
|
|
904 if (*x < left || *x >= left + width
|
335
|
905 || *y < top || *y > top + window_height - 1)
|
286
|
906 return 0;
|
|
907
|
|
908 if (*y == top + window_height - 1
|
|
909 && window_height > 1) /* 1 line => minibuffer */
|
|
910 /* in modeline */
|
|
911 return -1;
|
|
912
|
|
913 *x -= left;
|
|
914 *y -= top;
|
|
915 return 1;
|
|
916 }
|
|
917
|
|
918 DEFUN ("coordinates-in-window-p", Fcoordinates_in_window_p,
|
|
919 Scoordinates_in_window_p, 2, 2, 0,
|
|
920 "Return non-nil if COORDINATES are in WINDOW.\n\
|
|
921 COORDINATES is a cons of the form (X Y), X and Y being screen-relative.\n\
|
|
922 If COORDINATES are in the text portion of WINDOW, the coordinates relative\n\
|
|
923 to the window are returned. If they are in the modeline of WINDOW, t is\n\
|
|
924 returned.")
|
|
925 (coordinates, window)
|
|
926 register Lisp_Object coordinates, window;
|
|
927 {
|
|
928 int x, y;
|
|
929
|
|
930 CHECK_WINDOW (window, 0);
|
|
931 CHECK_CONS (coordinates, 1);
|
|
932 x = XINT (Fcar (coordinates));
|
|
933 y = XINT (Fcar (Fcdr (coordinates)));
|
|
934
|
|
935 switch (coordinates_in_window (XWINDOW (window), &x, &y))
|
|
936 {
|
|
937 case -1: /* In modeline of window. */
|
|
938 return Qt;
|
|
939
|
|
940 case 0: /* NOT in window at all. */
|
|
941 return Qnil;
|
|
942
|
|
943 case 1: /* In text part of window. */
|
|
944 return Fcons (x, Fcons (y, Qnil));
|
|
945
|
|
946 default:
|
|
947 abort ();
|
|
948 }
|
|
949 }
|
|
950
|
|
951 #ifndef HAVE_X11
|
|
952 DEFUN ("rubber-band-rectangle", Frubber_band_rectangle, Srubber_band_rectangle,
|
|
953 3, 3, "",
|
|
954 "Ask user to specify a window position and size on SCREEN with the mouse.\n\
|
|
955 Arguments are SCREEN, NAME and GEO. NAME is a name to be displayed as\n\
|
|
956 the purpose of this rectangle. GEO is an X-windows size spec that can\n\
|
|
957 specify defaults for some sizes/positions. If GEO specifies everything,\n\
|
|
958 the mouse is not used.\n\
|
|
959 Returns a list of five values: (SCREEN LEFT TOP WIDTH HEIGHT).")
|
|
960 (screen, name, geo)
|
|
961 Lisp_Object screen;
|
|
962 Lisp_Object name;
|
|
963 Lisp_Object geo;
|
|
964 {
|
|
965 int vals[4];
|
|
966 Lisp_Object nums[4];
|
|
967 int i;
|
|
968
|
|
969 CHECK_SCREEN (screen, 0);
|
|
970 CHECK_STRING (name, 1);
|
|
971 CHECK_STRING (geo, 2);
|
|
972
|
|
973 switch (XSCREEN (screen)->output_method)
|
|
974 {
|
|
975 case output_x_window:
|
|
976 x_rubber_band (XSCREEN (screen), &vals[0], &vals[1], &vals[2], &vals[3],
|
|
977 XSTRING (geo)->data, XSTRING (name)->data);
|
|
978 break;
|
|
979
|
|
980 default:
|
|
981 return Qnil;
|
|
982 }
|
|
983
|
|
984 for (i = 0; i < 4; i++)
|
|
985 XFASTINT (nums[i]) = vals[i];
|
|
986 return Fcons (screen, Flist (4, nums));
|
|
987 return Qnil;
|
|
988 }
|
|
989 #endif /* not HAVE_X11 */
|
|
990
|
|
991 choose_minibuf_screen ()
|
|
992 {
|
|
993 /* For lowest-level minibuf, put it on currently selected screen
|
|
994 if screen has a minibuffer. */
|
|
995 if (minibuf_level == 0
|
|
996 && selected_screen != 0
|
|
997 && !EQ (minibuf_window, selected_screen->minibuffer_window)
|
|
998 && !EQ (Qnil, selected_screen->minibuffer_window))
|
|
999 {
|
|
1000 Fset_window_buffer (selected_screen->minibuffer_window,
|
|
1001 XWINDOW (minibuf_window)->buffer);
|
|
1002 minibuf_window = selected_screen->minibuffer_window;
|
|
1003 }
|
|
1004 }
|
|
1005
|
|
1006 syms_of_screen ()
|
|
1007 {
|
|
1008 Qscreenp = intern ("screenp");
|
|
1009
|
|
1010 staticpro (&Vscreen_list);
|
|
1011
|
|
1012 DEFVAR_LISP ("terminal-screen", &Vterminal_screen,
|
|
1013 "The initial screen-object, which represents Emacs's stdout.");
|
|
1014
|
|
1015 DEFVAR_LISP ("emacs-iconified", &Vemacs_iconified,
|
|
1016 "Non-nil if all of emacs is iconified and not screen updates are needed.");
|
|
1017 Vemacs_iconified = Qnil;
|
|
1018
|
|
1019 DEFVAR_LISP ("global-minibuffer-screen", &Vglobal_minibuffer_screen,
|
|
1020 "A screen whose minibuffer is used by minibufferless screens.\n\
|
|
1021 When you create a minibufferless screen, by default it will use the\n\
|
|
1022 minibuffer of this screen. It is up to you to create a suitable screen\n\
|
|
1023 and store it in this variable.");
|
|
1024 Vglobal_minibuffer_screen = Qnil;
|
|
1025
|
|
1026 defsubr (&Sscreenp);
|
|
1027 defsubr (&Sselect_screen);
|
|
1028 defsubr (&Sselected_screen);
|
|
1029 defsubr (&Swindow_screen);
|
|
1030 defsubr (&Sscreen_root_window);
|
|
1031 defsubr (&Sscreen_selected_window);
|
|
1032 defsubr (&Sscreen_list);
|
|
1033 defsubr (&Snext_screen);
|
|
1034 defsubr (&Sdelete_screen);
|
|
1035 defsubr (&Sread_mouse_position);
|
|
1036 defsubr (&Sset_mouse_position);
|
|
1037 #if 0
|
|
1038 defsubr (&Sscreen_configuration);
|
|
1039 defsubr (&Srestore_screen_configuration);
|
|
1040 #endif
|
|
1041 defsubr (&Smake_screen_visible);
|
|
1042 defsubr (&Smake_screen_invisible);
|
|
1043 defsubr (&Siconify_screen);
|
|
1044 defsubr (&Sdeiconify_screen);
|
|
1045 defsubr (&Sscreen_visible_p);
|
|
1046 defsubr (&Svisible_screen_list);
|
|
1047 defsubr (&Sscreen_parameters);
|
|
1048 defsubr (&Smodify_screen_parameters);
|
|
1049 defsubr (&Sscreen_pixel_size);
|
|
1050 defsubr (&Sscreen_height);
|
|
1051 defsubr (&Sscreen_width);
|
|
1052 defsubr (&Sset_screen_height);
|
|
1053 defsubr (&Sset_screen_width);
|
|
1054 defsubr (&Sset_screen_size);
|
|
1055 defsubr (&Sset_screen_position);
|
|
1056 defsubr (&Scoordinates_in_window_p);
|
|
1057 #ifndef HAVE_X11
|
|
1058 defsubr (&Srubber_band_rectangle);
|
|
1059 #endif /* HAVE_X11 */
|
|
1060 }
|