1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
19
20 #include <config.h>
21
22 #include <stdio.h>
23 #include <ctype.h>
24 #include <setjmp.h>
25 #include "lisp.h"
26 #include "character.h"
27 #ifdef HAVE_X_WINDOWS
28 #include "xterm.h"
29 #endif
30 #ifdef WINDOWSNT
31 #include "w32term.h"
32 #endif
33 #ifdef HAVE_NS
34 #include "nsterm.h"
35 #endif
36 #include "buffer.h"
37
38 #include "commands.h"
39 #include "keyboard.h"
40 #include "frame.h"
41 #include "blockinput.h"
42 #include "termchar.h"
43 #include "termhooks.h"
44 #include "dispextern.h"
45 #include "window.h"
46 #include "font.h"
47 #ifdef HAVE_WINDOW_SYSTEM
48 #include "fontset.h"
49 #endif
50 #ifdef MSDOS
51 #include "msdos.h"
52 #include "dosfns.h"
53 #endif
54
55
56
57 Lisp_Object Vmake_pointer_invisible;
58
59 #ifdef HAVE_WINDOW_SYSTEM
60
61
62
63 Lisp_Object Vx_resource_name;
64
65 66
67
68 Lisp_Object Vx_resource_class;
69
70
71
72 Lisp_Object Vframe_alpha_lower_limit;
73
74 #endif
75
76 #ifdef HAVE_NS
77 Lisp_Object Qns_parse_geometry;
78 #endif
79
80 Lisp_Object Qframep, Qframe_live_p;
81 Lisp_Object Qicon, Qmodeline;
82 Lisp_Object Qonly;
83 Lisp_Object Qx, Qw32, Qmac, Qpc, Qns;
84 Lisp_Object Qvisible;
85 Lisp_Object Qdisplay_type;
86 Lisp_Object Qbackground_mode;
87 Lisp_Object Qnoelisp;
88
89 Lisp_Object Qx_frame_parameter;
90 Lisp_Object Qx_resource_name;
91 Lisp_Object Qterminal;
92 Lisp_Object Qterminal_live_p;
93
94
95
96 Lisp_Object Qauto_raise, Qauto_lower;
97 Lisp_Object Qborder_color, Qborder_width;
98 Lisp_Object Qcursor_color, Qcursor_type;
99 Lisp_Object Qgeometry;
100 Lisp_Object Qheight, Qwidth;
101 Lisp_Object Qleft, Qright;
102 Lisp_Object Qicon_left, Qicon_top, Qicon_type, Qicon_name;
103 Lisp_Object Qinternal_border_width;
104 Lisp_Object Qmouse_color;
105 Lisp_Object Qminibuffer;
106 Lisp_Object Qscroll_bar_width, Qvertical_scroll_bars;
107 Lisp_Object Qvisibility;
108 Lisp_Object Qscroll_bar_foreground, Qscroll_bar_background;
109 Lisp_Object Qscreen_gamma;
110 Lisp_Object Qline_spacing;
111 Lisp_Object Quser_position, Quser_size;
112 Lisp_Object Qwait_for_wm;
113 Lisp_Object Qwindow_id;
114 #ifdef HAVE_X_WINDOWS
115 Lisp_Object Qouter_window_id;
116 #endif
117 Lisp_Object Qparent_id;
118 Lisp_Object Qtitle, Qname;
119 Lisp_Object Qexplicit_name;
120 Lisp_Object Qunsplittable;
121 Lisp_Object Qmenu_bar_lines, Qtool_bar_lines;
122 Lisp_Object Qleft_fringe, Qright_fringe;
123 Lisp_Object Qbuffer_predicate, Qbuffer_list, Qburied_buffer_list;
124 Lisp_Object Qtty_color_mode;
125 Lisp_Object Qtty, Qtty_type;
126
127 Lisp_Object Qfullscreen, Qfullwidth, Qfullheight, Qfullboth, Qmaximized;
128 Lisp_Object Qsticky;
129 Lisp_Object Qfont_backend;
130 Lisp_Object Qalpha;
131
132 Lisp_Object Qface_set_after_frame_default;
133
134 Lisp_Object Vterminal_frame;
135 Lisp_Object Vdefault_frame_alist;
136 Lisp_Object Vdefault_frame_scroll_bars;
137 Lisp_Object Vmouse_position_function;
138 Lisp_Object Vmouse_highlight;
139 static Lisp_Object Vdelete_frame_functions, Qdelete_frame_functions;
140
141 int focus_follows_mouse;
142
143 static void
144 set_menu_bar_lines_1 (window, n)
145 Lisp_Object window;
146 int n;
147 {
148 struct window *w = XWINDOW (window);
149
150 XSETFASTINT (w->last_modified, 0);
151 XSETFASTINT (w->top_line, XFASTINT (w->top_line) + n);
152 XSETFASTINT (w->total_lines, XFASTINT (w->total_lines) - n);
153
154 if (INTEGERP (w->orig_top_line))
155 XSETFASTINT (w->orig_top_line, XFASTINT (w->orig_top_line) + n);
156 if (INTEGERP (w->orig_total_lines))
157 XSETFASTINT (w->orig_total_lines, XFASTINT (w->orig_total_lines) - n);
158
159
160 if (!NILP (w->vchild))
161 set_menu_bar_lines_1 (w->vchild, n);
162
163
164 for (window = w->hchild; !NILP (window); window = w->next)
165 {
166 w = XWINDOW (window);
167 set_menu_bar_lines_1 (window, n);
168 }
169 }
170
171 void
172 set_menu_bar_lines (f, value, oldval)
173 struct frame *f;
174 Lisp_Object value, oldval;
175 {
176 int nlines;
177 int olines = FRAME_MENU_BAR_LINES (f);
178
179 180 181 182
183 if (FRAME_MINIBUF_ONLY_P (f))
184 return;
185
186 if (INTEGERP (value))
187 nlines = XINT (value);
188 else
189 nlines = 0;
190
191 if (nlines != olines)
192 {
193 windows_or_buffers_changed++;
194 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
195 FRAME_MENU_BAR_LINES (f) = nlines;
196 set_menu_bar_lines_1 (f->root_window, nlines - olines);
197 adjust_glyphs (f);
198 }
199 }
200
201 Lisp_Object Vframe_list;
202
203 extern Lisp_Object Vminibuffer_list;
204 extern Lisp_Object get_minibuffer ();
205 extern Lisp_Object Fhandle_switch_frame ();
206 extern Lisp_Object Fredirect_frame_focus ();
207 extern Lisp_Object x_get_focus_frame ();
208 extern Lisp_Object QCname, Qfont_param;
209
210
211 DEFUN ("framep", Fframep, Sframep, 1, 1, 0,
212 doc: 213 214 215 216 217 218 )
219 (object)
220 Lisp_Object object;
221 {
222 if (!FRAMEP (object))
223 return Qnil;
224 switch (XFRAME (object)->output_method)
225 {
226 case output_initial:
227 case output_termcap:
228 return Qt;
229 case output_x_window:
230 return Qx;
231 case output_w32:
232 return Qw32;
233 case output_msdos_raw:
234 return Qpc;
235 case output_mac:
236 return Qmac;
237 case output_ns:
238 return Qns;
239 default:
240 abort ();
241 }
242 }
243
244 DEFUN ("frame-live-p", Fframe_live_p, Sframe_live_p, 1, 1, 0,
245 doc: 246 247 248 249 )
250 (object)
251 Lisp_Object object;
252 {
253 return ((FRAMEP (object)
254 && FRAME_LIVE_P (XFRAME (object)))
255 ? Fframep (object)
256 : Qnil);
257 }
258
259 DEFUN ("window-system", Fwindow_system, Swindow_system, 0, 1, 0,
260 doc: 261 262 263 264 )
265 (frame)
266 Lisp_Object frame;
267 {
268 Lisp_Object type;
269 if (NILP (frame))
270 frame = selected_frame;
271
272 type = Fframep (frame);
273
274 if (NILP (type))
275 wrong_type_argument (Qframep, frame);
276
277 if (EQ (type, Qt))
278 return Qnil;
279 else
280 return type;
281 }
282
283 struct frame *
284 make_frame (mini_p)
285 int mini_p;
286 {
287 Lisp_Object frame;
288 register struct frame *f;
289 register Lisp_Object root_window;
290 register Lisp_Object mini_window;
291
292 f = allocate_frame ();
293 XSETFRAME (frame, f);
294
295 f->desired_matrix = 0;
296 f->current_matrix = 0;
297 f->desired_pool = 0;
298 f->current_pool = 0;
299 f->glyphs_initialized_p = 0;
300 f->decode_mode_spec_buffer = 0;
301 f->visible = 0;
302 f->async_visible = 0;
303 f->output_data.nothing = 0;
304 f->iconified = 0;
305 f->async_iconified = 0;
306 f->wants_modeline = 1;
307 f->auto_raise = 0;
308 f->auto_lower = 0;
309 f->no_split = 0;
310 f->garbaged = 1;
311 f->has_minibuffer = mini_p;
312 f->focus_frame = Qnil;
313 f->explicit_name = 0;
314 f->can_have_scroll_bars = 0;
315 f->vertical_scroll_bar_type = vertical_scroll_bar_none;
316 f->param_alist = Qnil;
317 f->scroll_bars = Qnil;
318 f->condemned_scroll_bars = Qnil;
319 f->face_alist = Qnil;
320 f->face_cache = NULL;
321 f->menu_bar_items = Qnil;
322 f->menu_bar_vector = Qnil;
323 f->menu_bar_items_used = 0;
324 f->buffer_predicate = Qnil;
325 f->buffer_list = Qnil;
326 f->buried_buffer_list = Qnil;
327 f->namebuf = 0;
328 f->title = Qnil;
329 f->menu_bar_window = Qnil;
330 f->tool_bar_window = Qnil;
331 f->tool_bar_items = Qnil;
332 f->desired_tool_bar_string = f->current_tool_bar_string = Qnil;
333 f->n_tool_bar_items = 0;
334 f->left_fringe_width = f->right_fringe_width = 0;
335 f->fringe_cols = 0;
336 f->scroll_bar_actual_width = 0;
337 f->border_width = 0;
338 f->internal_border_width = 0;
339 f->column_width = 1;
340 f->line_height = 1;
341 f->x_pixels_diff = f->y_pixels_diff = 0;
342 #ifdef HAVE_WINDOW_SYSTEM
343 f->want_fullscreen = FULLSCREEN_NONE;
344 #endif
345 f->size_hint_flags = 0;
346 f->win_gravity = 0;
347 f->font_driver_list = NULL;
348 f->font_data_list = NULL;
349
350 root_window = make_window ();
351 if (mini_p)
352 {
353 mini_window = make_window ();
354 XWINDOW (root_window)->next = mini_window;
355 XWINDOW (mini_window)->prev = root_window;
356 XWINDOW (mini_window)->mini_p = Qt;
357 XWINDOW (mini_window)->frame = frame;
358 f->minibuffer_window = mini_window;
359 }
360 else
361 {
362 mini_window = Qnil;
363 XWINDOW (root_window)->next = Qnil;
364 f->minibuffer_window = Qnil;
365 }
366
367 XWINDOW (root_window)->frame = frame;
368
369 370 371
372
373 SET_FRAME_COLS (f, 10);
374 FRAME_LINES (f) = 10;
375
376 XSETFASTINT (XWINDOW (root_window)->total_cols, 10);
377 XSETFASTINT (XWINDOW (root_window)->total_lines, (mini_p ? 9 : 10));
378
379 if (mini_p)
380 {
381 XSETFASTINT (XWINDOW (mini_window)->total_cols, 10);
382 XSETFASTINT (XWINDOW (mini_window)->top_line, 9);
383 XSETFASTINT (XWINDOW (mini_window)->total_lines, 1);
384 }
385
386
387 {
388 Lisp_Object buf;
389
390 XWINDOW (root_window)->buffer = Qt;
391 buf = Fcurrent_buffer ();
392 393
394 if (SREF (Fbuffer_name (buf), 0) == ' ')
395 buf = Fother_buffer (buf, Qnil, Qnil);
396
397 398 399 400 401 402
403 set_window_buffer (root_window, buf, 0, 0);
404 f->buffer_list = Fcons (buf, Qnil);
405 }
406
407 if (mini_p)
408 {
409 XWINDOW (mini_window)->buffer = Qt;
410 set_window_buffer (mini_window,
411 (NILP (Vminibuffer_list)
412 ? get_minibuffer (0)
413 : Fcar (Vminibuffer_list)),
414 0, 0);
415 }
416
417 f->root_window = root_window;
418 f->selected_window = root_window;
419 420
421 ++window_select_count;
422 XSETFASTINT (XWINDOW (f->selected_window)->use_time, window_select_count);
423
424 f->default_face_done_p = 0;
425
426 return f;
427 }
428
429 #ifdef HAVE_WINDOW_SYSTEM
430 431 432
433
434 struct frame *
435 make_frame_without_minibuffer (mini_window, kb, display)
436 register Lisp_Object mini_window;
437 KBOARD *kb;
438 Lisp_Object display;
439 {
440 register struct frame *f;
441 struct gcpro gcpro1;
442
443 if (!NILP (mini_window))
444 CHECK_LIVE_WINDOW (mini_window);
445
446 if (!NILP (mini_window)
447 && FRAME_KBOARD (XFRAME (XWINDOW (mini_window)->frame)) != kb)
448 error ("Frame and minibuffer must be on the same terminal");
449
450
451 f = make_frame (0);
452
453 if (NILP (mini_window))
454 {
455
456 if (!FRAMEP (kb->Vdefault_minibuffer_frame)
457 || ! FRAME_LIVE_P (XFRAME (kb->Vdefault_minibuffer_frame)))
458 {
459 Lisp_Object frame_dummy;
460
461 XSETFRAME (frame_dummy, f);
462 GCPRO1 (frame_dummy);
463
464 kb->Vdefault_minibuffer_frame =
465 call1 (intern ("make-initial-minibuffer-frame"), display);
466 UNGCPRO;
467 }
468
469 mini_window = XFRAME (kb->Vdefault_minibuffer_frame)->minibuffer_window;
470 }
471
472 f->minibuffer_window = mini_window;
473
474 475
476 if (NILP (Fmemq (XWINDOW (mini_window)->buffer, Vminibuffer_list)))
477 Fset_window_buffer (mini_window,
478 (NILP (Vminibuffer_list)
479 ? get_minibuffer (0)
480 : Fcar (Vminibuffer_list)), Qnil);
481 return f;
482 }
483
484
485
486 struct frame *
487 make_minibuffer_frame ()
488 {
489
490
491 register struct frame *f = make_frame (0);
492 register Lisp_Object mini_window;
493 register Lisp_Object frame;
494
495 XSETFRAME (frame, f);
496
497 f->auto_raise = 0;
498 f->auto_lower = 0;
499 f->no_split = 1;
500 f->wants_modeline = 0;
501 f->has_minibuffer = 1;
502
503 504 505
506
507 mini_window = f->minibuffer_window = f->root_window;
508 XWINDOW (mini_window)->mini_p = Qt;
509 XWINDOW (mini_window)->next = Qnil;
510 XWINDOW (mini_window)->prev = Qnil;
511 XWINDOW (mini_window)->frame = frame;
512
513
514
515 Fset_window_buffer (mini_window,
516 (NILP (Vminibuffer_list)
517 ? get_minibuffer (0)
518 : Fcar (Vminibuffer_list)), Qnil);
519 return f;
520 }
521 #endif
522
523
524
525 static int tty_frame_count;
526
527 struct frame *
528 make_initial_frame (void)
529 {
530 struct frame *f;
531 struct terminal *terminal;
532 Lisp_Object frame;
533
534 eassert (initial_kboard);
535
536
537 if (! (NILP (Vframe_list) || CONSP (Vframe_list)))
538 Vframe_list = Qnil;
539
540 terminal = init_initial_terminal ();
541
542 f = make_frame (1);
543 XSETFRAME (frame, f);
544
545 Vframe_list = Fcons (frame, Vframe_list);
546
547 tty_frame_count = 1;
548 f->name = make_pure_c_string ("F1");
549
550 f->visible = 1;
551 f->async_visible = 1;
552
553 f->output_method = terminal->type;
554 f->terminal = terminal;
555 f->terminal->reference_count++;
556 f->output_data.nothing = 0;
557
558 FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
559 FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
560
561 FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
562 FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
563
564 #ifdef CANNOT_DUMP
565 if (!noninteractive)
566 init_frame_faces (f);
567 #endif
568
569 return f;
570 }
571
572
573 struct frame *
574 make_terminal_frame (struct terminal *terminal)
575 {
576 register struct frame *f;
577 Lisp_Object frame;
578 char name[20];
579
580 if (!terminal->name)
581 error ("Terminal is not live, can't create new frames on it");
582
583 f = make_frame (1);
584
585 XSETFRAME (frame, f);
586 Vframe_list = Fcons (frame, Vframe_list);
587
588 tty_frame_count++;
589 sprintf (name, "F%d", tty_frame_count);
590 f->name = build_string (name);
591
592 f->visible = 1;
593 f->async_visible = 1;
594 f->terminal = terminal;
595 f->terminal->reference_count++;
596 #ifdef MSDOS
597 f->output_data.tty->display_info = &the_only_display_info;
598 if (!inhibit_window_system
599 && (!FRAMEP (selected_frame) || !FRAME_LIVE_P (XFRAME (selected_frame))
600 || XFRAME (selected_frame)->output_method == output_msdos_raw))
601 f->output_method = output_msdos_raw;
602 else
603 f->output_method = output_termcap;
604 #else
605 f->output_method = output_termcap;
606 create_tty_output (f);
607 FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
608 FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
609 #endif
610
611 FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
612 FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
613
614
615 if (FRAMEP (FRAME_TTY (f)->top_frame)
616 && FRAME_LIVE_P (XFRAME (FRAME_TTY (f)->top_frame)))
617 XFRAME (FRAME_TTY (f)->top_frame)->async_visible = 2;
618
619 FRAME_TTY (f)->top_frame = frame;
620
621 if (!noninteractive)
622 init_frame_faces (f);
623
624 return f;
625 }
626
627 628 629 630
631
632 static Lisp_Object
633 get_future_frame_param (Lisp_Object parameter,
634 Lisp_Object supplied_parms,
635 char *current_value)
636 {
637 Lisp_Object result;
638
639 result = Fassq (parameter, supplied_parms);
640 if (NILP (result))
641 result = Fassq (parameter, XFRAME (selected_frame)->param_alist);
642 if (NILP (result) && current_value != NULL)
643 result = build_string (current_value);
644 if (NILP (result))
645 result = Fassq (parameter, Vdefault_frame_alist);
646 if (!NILP (result) && !STRINGP (result))
647 result = XCDR (result);
648 if (NILP (result) || !STRINGP (result))
649 result = Qnil;
650
651 return result;
652 }
653
654 DEFUN ("make-terminal-frame", Fmake_terminal_frame, Smake_terminal_frame,
655 1, 1, 0,
656 doc: 657 658 659 660 661 662 663 664 665 666 667 668 669 670 )
671 (parms)
672 Lisp_Object parms;
673 {
674 struct frame *f;
675 struct terminal *t = NULL;
676 Lisp_Object frame, tem;
677 struct frame *sf = SELECTED_FRAME ();
678
679 #ifdef MSDOS
680 if (sf->output_method != output_msdos_raw
681 && sf->output_method != output_termcap)
682 abort ();
683 #else
684
685 #ifdef WINDOWSNT
686 if (sf->output_method != output_termcap)
687 error ("Not using an ASCII terminal now; cannot make a new ASCII frame");
688 #endif
689 #endif
690
691 {
692 Lisp_Object terminal;
693
694 terminal = Fassq (Qterminal, parms);
695 if (!NILP (terminal))
696 {
697 terminal = XCDR (terminal);
698 t = get_terminal (terminal, 1);
699 }
700 #ifdef MSDOS
701 if (t && t != the_only_display_info.terminal)
702
703 error ("Multiple terminals are not supported on this platform");
704 if (!t)
705 t = the_only_display_info.terminal;
706 #endif
707 }
708
709 if (!t)
710 {
711 char *name = 0, *type = 0;
712 Lisp_Object tty, tty_type;
713
714 tty = get_future_frame_param
715 (Qtty, parms, (FRAME_TERMCAP_P (XFRAME (selected_frame))
716 ? FRAME_TTY (XFRAME (selected_frame))->name
717 : NULL));
718 if (!NILP (tty))
719 {
720 name = (char *) alloca (SBYTES (tty) + 1);
721 strncpy (name, SDATA (tty), SBYTES (tty));
722 name[SBYTES (tty)] = 0;
723 }
724
725 tty_type = get_future_frame_param
726 (Qtty_type, parms, (FRAME_TERMCAP_P (XFRAME (selected_frame))
727 ? FRAME_TTY (XFRAME (selected_frame))->type
728 : NULL));
729 if (!NILP (tty_type))
730 {
731 type = (char *) alloca (SBYTES (tty_type) + 1);
732 strncpy (type, SDATA (tty_type), SBYTES (tty_type));
733 type[SBYTES (tty_type)] = 0;
734 }
735
736 t = init_tty (name, type, 0);
737 }
738
739 f = make_terminal_frame (t);
740
741 {
742 int width, height;
743 get_tty_size (fileno (FRAME_TTY (f)->input), &width, &height);
744 change_frame_size (f, height, width, 0, 0, 0);
745 }
746
747 adjust_glyphs (f);
748 calculate_costs (f);
749 XSETFRAME (frame, f);
750 Fmodify_frame_parameters (frame, Vdefault_frame_alist);
751 Fmodify_frame_parameters (frame, parms);
752 Fmodify_frame_parameters (frame, Fcons (Fcons (Qtty_type,
753 build_string (t->display_info.tty->type)),
754 Qnil));
755 if (t->display_info.tty->name != NULL)
756 Fmodify_frame_parameters (frame, Fcons (Fcons (Qtty,
757 build_string (t->display_info.tty->name)),
758 Qnil));
759 else
760 Fmodify_frame_parameters (frame, Fcons (Fcons (Qtty, Qnil), Qnil));
761
762 763
764 f->face_alist = Fcopy_alist (sf->face_alist);
765 766 767
768 for (tem = f->face_alist; CONSP (tem); tem = XCDR (tem))
769 XSETCDR (XCAR (tem), Fcopy_sequence (XCDR (XCAR (tem))));
770 return frame;
771 }
772
773
774 775 776 777 778 779 780 781 782 783 784 785 786 787
788
789 Lisp_Object
790 do_switch_frame (frame, track, for_deletion, norecord)
791 Lisp_Object frame, norecord;
792 int track, for_deletion;
793 {
794 struct frame *sf = SELECTED_FRAME ();
795
796 797
798 if (CONSP (frame)
799 && EQ (XCAR (frame), Qswitch_frame)
800 && CONSP (XCDR (frame)))
801 frame = XCAR (XCDR (frame));
802
803 804 805
806 CHECK_FRAME (frame);
807 if (! FRAME_LIVE_P (XFRAME (frame)))
808 return Qnil;
809
810 if (sf == XFRAME (frame))
811 return frame;
812
813 814
815 #if 0
816 817 818 819 820 821 822
823 if (track)
824 {
825 Lisp_Object tail;
826
827 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
828 {
829 Lisp_Object focus;
830
831 if (!FRAMEP (XCAR (tail)))
832 abort ();
833
834 focus = FRAME_FOCUS_FRAME (XFRAME (XCAR (tail)));
835
836 if (FRAMEP (focus) && XFRAME (focus) == SELECTED_FRAME ())
837 Fredirect_frame_focus (XCAR (tail), frame);
838 }
839 }
840 #else
841
842 #ifdef HAVE_WINDOW_SYSTEM
843 if (track && FRAME_WINDOW_P (XFRAME (frame)))
844 {
845 Lisp_Object focus, xfocus;
846
847 xfocus = x_get_focus_frame (XFRAME (frame));
848 if (FRAMEP (xfocus))
849 {
850 focus = FRAME_FOCUS_FRAME (XFRAME (xfocus));
851 if (FRAMEP (focus) && XFRAME (focus) == SELECTED_FRAME ())
852 Fredirect_frame_focus (xfocus, frame);
853 }
854 }
855 #endif
856 #endif
857
858 if (!for_deletion && FRAME_HAS_MINIBUF_P (sf))
859 resize_mini_window (XWINDOW (FRAME_MINIBUF_WINDOW (sf)), 1);
860
861 if (FRAME_TERMCAP_P (XFRAME (frame)) || FRAME_MSDOS_P (XFRAME (frame)))
862 {
863 if (FRAMEP (FRAME_TTY (XFRAME (frame))->top_frame))
864
865 XFRAME (FRAME_TTY (XFRAME (frame))->top_frame)->async_visible = 2;
866 XFRAME (frame)->async_visible = 1;
867 FRAME_TTY (XFRAME (frame))->top_frame = frame;
868 }
869
870 selected_frame = frame;
871 if (! FRAME_MINIBUF_ONLY_P (XFRAME (selected_frame)))
872 last_nonminibuf_frame = XFRAME (selected_frame);
873
874 Fselect_window (XFRAME (frame)->selected_window, norecord);
875
876 877 878 879 880 881
882 internal_last_event_frame = Qnil;
883
884 return frame;
885 }
886
887 DEFUN ("select-frame", Fselect_frame, Sselect_frame, 1, 2, "e",
888 doc: 889 890 891 892 893 894 895 896 897 898 899 900 901 )
902 (frame, norecord)
903 Lisp_Object frame, norecord;
904 {
905 return do_switch_frame (frame, 1, 0, norecord);
906 }
907
908
909 DEFUN ("handle-switch-frame", Fhandle_switch_frame, Shandle_switch_frame, 1, 1, "e",
910 doc: 911 912 913 914 915 916 917 )
918 (event)
919 Lisp_Object event;
920 {
921
922 current_kboard->Vprefix_arg = Vcurrent_prefix_arg;
923 call1 (Vrun_hooks, Qmouse_leave_buffer_hook);
924 return do_switch_frame (event, 0, 0, Qnil);
925 }
926
927 DEFUN ("selected-frame", Fselected_frame, Sselected_frame, 0, 0, 0,
928 doc: )
929 ()
930 {
931 return selected_frame;
932 }
933
934 DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 1, 1, 0,
935 doc: )
936 (window)
937 Lisp_Object window;
938 {
939 CHECK_LIVE_WINDOW (window);
940 return XWINDOW (window)->frame;
941 }
942
943 DEFUN ("frame-first-window", Fframe_first_window, Sframe_first_window, 0, 1, 0,
944 doc: 945 )
946 (frame)
947 Lisp_Object frame;
948 {
949 Lisp_Object w;
950
951 if (NILP (frame))
952 w = SELECTED_FRAME ()->root_window;
953 else
954 {
955 CHECK_LIVE_FRAME (frame);
956 w = XFRAME (frame)->root_window;
957 }
958 while (NILP (XWINDOW (w)->buffer))
959 {
960 if (! NILP (XWINDOW (w)->hchild))
961 w = XWINDOW (w)->hchild;
962 else if (! NILP (XWINDOW (w)->vchild))
963 w = XWINDOW (w)->vchild;
964 else
965 abort ();
966 }
967 return w;
968 }
969
970 DEFUN ("active-minibuffer-window", Factive_minibuffer_window,
971 Sactive_minibuffer_window, 0, 0, 0,
972 doc: )
973 ()
974 {
975 return minibuf_level ? minibuf_window : Qnil;
976 }
977
978 DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
979 doc: 980 )
981 (frame)
982 Lisp_Object frame;
983 {
984 Lisp_Object window;
985
986 if (NILP (frame))
987 window = SELECTED_FRAME ()->root_window;
988 else
989 {
990 CHECK_LIVE_FRAME (frame);
991 window = XFRAME (frame)->root_window;
992 }
993
994 return window;
995 }
996
997 DEFUN ("frame-selected-window", Fframe_selected_window,
998 Sframe_selected_window, 0, 1, 0,
999 doc: 1000 )
1001 (frame)
1002 Lisp_Object frame;
1003 {
1004 Lisp_Object window;
1005
1006 if (NILP (frame))
1007 window = SELECTED_FRAME ()->selected_window;
1008 else
1009 {
1010 CHECK_LIVE_FRAME (frame);
1011 window = XFRAME (frame)->selected_window;
1012 }
1013
1014 return window;
1015 }
1016
1017 DEFUN ("set-frame-selected-window", Fset_frame_selected_window,
1018 Sset_frame_selected_window, 2, 3, 0,
1019 doc: 1020 1021 1022 1023 1024 )
1025 (frame, window, norecord)
1026 Lisp_Object frame, window, norecord;
1027 {
1028 if (NILP (frame))
1029 frame = selected_frame;
1030
1031 CHECK_LIVE_FRAME (frame);
1032 CHECK_LIVE_WINDOW (window);
1033
1034 if (! EQ (frame, WINDOW_FRAME (XWINDOW (window))))
1035 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
1036
1037 if (EQ (frame, selected_frame))
1038 return Fselect_window (window, norecord);
1039
1040 return XFRAME (frame)->selected_window = window;
1041 }
1042
1043
1044 DEFUN ("frame-list", Fframe_list, Sframe_list,
1045 0, 0, 0,
1046 doc: )
1047 ()
1048 {
1049 Lisp_Object frames;
1050 frames = Fcopy_sequence (Vframe_list);
1051 #ifdef HAVE_WINDOW_SYSTEM
1052 if (FRAMEP (tip_frame))
1053 frames = Fdelq (tip_frame, frames);
1054 #endif
1055 return frames;
1056 }
1057
1058 1059 1060 1061 1062 1063 1064
1065
1066 static Lisp_Object
1067 next_frame (frame, minibuf)
1068 Lisp_Object frame;
1069 Lisp_Object minibuf;
1070 {
1071 Lisp_Object tail;
1072 int passed = 0;
1073
1074
1075 if (! CONSP (Vframe_list))
1076 abort ();
1077
1078 1079
1080 CHECK_LIVE_FRAME (frame);
1081
1082 while (1)
1083 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
1084 {
1085 Lisp_Object f;
1086
1087 f = XCAR (tail);
1088
1089 if (passed
1090 && ((!FRAME_TERMCAP_P (XFRAME (f)) && !FRAME_TERMCAP_P (XFRAME (frame))
1091 && FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
1092 || (FRAME_TERMCAP_P (XFRAME (f)) && FRAME_TERMCAP_P (XFRAME (frame))
1093 && FRAME_TTY (XFRAME (f)) == FRAME_TTY (XFRAME (frame)))))
1094 {
1095
1096
1097 1098
1099 if (EQ (f, frame))
1100 return f;
1101
1102
1103 if (NILP (minibuf))
1104 {
1105 if (! FRAME_MINIBUF_ONLY_P (XFRAME (f)))
1106 return f;
1107 }
1108 else if (EQ (minibuf, Qvisible))
1109 {
1110 FRAME_SAMPLE_VISIBILITY (XFRAME (f));
1111 if (FRAME_VISIBLE_P (XFRAME (f)))
1112 return f;
1113 }
1114 else if (INTEGERP (minibuf) && XINT (minibuf) == 0)
1115 {
1116 FRAME_SAMPLE_VISIBILITY (XFRAME (f));
1117 if (FRAME_VISIBLE_P (XFRAME (f))
1118 || FRAME_ICONIFIED_P (XFRAME (f)))
1119 return f;
1120 }
1121 else if (WINDOWP (minibuf))
1122 {
1123 if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f)), minibuf)
1124 || EQ (WINDOW_FRAME (XWINDOW (minibuf)), f)
1125 || EQ (WINDOW_FRAME (XWINDOW (minibuf)),
1126 FRAME_FOCUS_FRAME (XFRAME (f))))
1127 return f;
1128 }
1129 else
1130 return f;
1131 }
1132
1133 if (EQ (frame, f))
1134 passed++;
1135 }
1136 }
1137
1138 1139 1140 1141 1142 1143 1144
1145
1146 static Lisp_Object
1147 prev_frame (frame, minibuf)
1148 Lisp_Object frame;
1149 Lisp_Object minibuf;
1150 {
1151 Lisp_Object tail;
1152 Lisp_Object prev;
1153
1154
1155 if (! CONSP (Vframe_list))
1156 abort ();
1157
1158 prev = Qnil;
1159 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
1160 {
1161 Lisp_Object f;
1162
1163 f = XCAR (tail);
1164 if (!FRAMEP (f))
1165 abort ();
1166
1167 if (EQ (frame, f) && !NILP (prev))
1168 return prev;
1169
1170 if ((!FRAME_TERMCAP_P (XFRAME (f)) && !FRAME_TERMCAP_P (XFRAME (frame))
1171 && FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
1172 || (FRAME_TERMCAP_P (XFRAME (f)) && FRAME_TERMCAP_P (XFRAME (frame))
1173 && FRAME_TTY (XFRAME (f)) == FRAME_TTY (XFRAME (frame))))
1174 {
1175 1176
1177 if (NILP (minibuf))
1178 {
1179 if (! FRAME_MINIBUF_ONLY_P (XFRAME (f)))
1180 prev = f;
1181 }
1182 else if (WINDOWP (minibuf))
1183 {
1184 if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f)), minibuf)
1185 || EQ (WINDOW_FRAME (XWINDOW (minibuf)), f)
1186 || EQ (WINDOW_FRAME (XWINDOW (minibuf)),
1187 FRAME_FOCUS_FRAME (XFRAME (f))))
1188 prev = f;
1189 }
1190 else if (EQ (minibuf, Qvisible))
1191 {
1192 FRAME_SAMPLE_VISIBILITY (XFRAME (f));
1193 if (FRAME_VISIBLE_P (XFRAME (f)))
1194 prev = f;
1195 }
1196 else if (XFASTINT (minibuf) == 0)
1197 {
1198 FRAME_SAMPLE_VISIBILITY (XFRAME (f));
1199 if (FRAME_VISIBLE_P (XFRAME (f))
1200 || FRAME_ICONIFIED_P (XFRAME (f)))
1201 prev = f;
1202 }
1203 else
1204 prev = f;
1205 }
1206 }
1207
1208
1209 if (NILP (prev))
1210 1211
1212 return frame;
1213 else
1214 1215 1216
1217 return prev;
1218 }
1219
1220
1221 DEFUN ("next-frame", Fnext_frame, Snext_frame, 0, 2, 0,
1222 doc: 1223 1224 1225 1226 1227 1228 1229 1230 1231 )
1232 (frame, miniframe)
1233 Lisp_Object frame, miniframe;
1234 {
1235 if (NILP (frame))
1236 frame = selected_frame;
1237
1238 CHECK_LIVE_FRAME (frame);
1239 return next_frame (frame, miniframe);
1240 }
1241
1242 DEFUN ("previous-frame", Fprevious_frame, Sprevious_frame, 0, 2, 0,
1243 doc: 1244 1245 1246 1247 1248 1249 1250 1251 1252 )
1253 (frame, miniframe)
1254 Lisp_Object frame, miniframe;
1255 {
1256 if (NILP (frame))
1257 frame = selected_frame;
1258 CHECK_LIVE_FRAME (frame);
1259 return prev_frame (frame, miniframe);
1260 }
1261
1262 1263 1264
1265
1266 int
1267 other_visible_frames (f)
1268 FRAME_PTR f;
1269 {
1270 1271
1272 if (f == SELECTED_FRAME ())
1273 {
1274 Lisp_Object frames;
1275 int count = 0;
1276
1277 for (frames = Vframe_list;
1278 CONSP (frames);
1279 frames = XCDR (frames))
1280 {
1281 Lisp_Object this;
1282
1283 this = XCAR (frames);
1284 1285 1286
1287 #ifdef HAVE_WINDOW_SYSTEM
1288 if (FRAME_WINDOW_P (XFRAME (this)))
1289 {
1290 x_sync (XFRAME (this));
1291 FRAME_SAMPLE_VISIBILITY (XFRAME (this));
1292 }
1293 #endif
1294
1295 if (FRAME_VISIBLE_P (XFRAME (this))
1296 || FRAME_ICONIFIED_P (XFRAME (this))
1297 1298
1299 || (FRAME_WINDOW_P (XFRAME (this)) && !FRAME_WINDOW_P (f)))
1300 count++;
1301 }
1302 return count > 1;
1303 }
1304 return 1;
1305 }
1306
1307
1308 static Lisp_Object
1309 delete_frame_handler (Lisp_Object arg)
1310 {
1311 add_to_log ("Error during `delete-frame': %s", arg, Qnil);
1312 return Qnil;
1313 }
1314
1315 extern Lisp_Object Qrun_hook_with_args;
1316
1317 1318 1319 1320
1321 Lisp_Object
1322 delete_frame (frame, force)
1323 1324 1325
1326 Lisp_Object frame, force;
1327 {
1328 struct frame *f;
1329 struct frame *sf = SELECTED_FRAME ();
1330 struct kboard *kb;
1331
1332 int minibuffer_selected;
1333
1334 if (EQ (frame, Qnil))
1335 {
1336 f = sf;
1337 XSETFRAME (frame, f);
1338 }
1339 else
1340 {
1341 CHECK_FRAME (frame);
1342 f = XFRAME (frame);
1343 }
1344
1345 if (! FRAME_LIVE_P (f))
1346 return Qnil;
1347
1348 if (NILP (force) && !other_visible_frames (f))
1349 error ("Attempt to delete the sole visible or iconified frame");
1350
1351 1352
1353 if (NILP (XCDR (Vframe_list)) && !EQ (force, Qnoelisp))
1354 error ("Attempt to delete the only frame");
1355
1356 1357
1358 if (FRAME_HAS_MINIBUF_P (XFRAME (frame)))
1359 {
1360 Lisp_Object frames;
1361
1362 for (frames = Vframe_list;
1363 CONSP (frames);
1364 frames = XCDR (frames))
1365 {
1366 Lisp_Object this;
1367 this = XCAR (frames);
1368
1369 if (! EQ (this, frame)
1370 && EQ (frame,
1371 WINDOW_FRAME (XWINDOW
1372 (FRAME_MINIBUF_WINDOW (XFRAME (this))))))
1373 {
1374 1375
1376 if (EQ (force, Qnoelisp))
1377 delete_frame (this, Qnoelisp);
1378 else
1379 error ("Attempt to delete a surrogate minibuffer frame");
1380 }
1381 }
1382 }
1383
1384 1385 1386 1387
1388 if (NILP (Vrun_hooks) || !NILP (Fframe_parameter (frame, intern ("tooltip"))))
1389 ;
1390 if (EQ (force, Qnoelisp))
1391 pending_funcalls
1392 = Fcons (list3 (Qrun_hook_with_args, Qdelete_frame_functions, frame),
1393 pending_funcalls);
1394 else
1395 safe_call2 (Qrun_hook_with_args, Qdelete_frame_functions, frame);
1396
1397
1398 if (! FRAME_LIVE_P (f))
1399 return Qnil;
1400
1401 1402
1403
1404 minibuffer_selected = EQ (minibuf_window, selected_window);
1405
1406
1407 if (f == sf)
1408 {
1409 Lisp_Object tail, frame1;
1410
1411
1412 frame1 = next_frame (frame, Qvisible);
1413
1414
1415 if (NILP (frame1) || EQ (frame1, frame))
1416 {
1417 FOR_EACH_FRAME (tail, frame1)
1418 {
1419 if (! EQ (frame, frame1) && FRAME_LIVE_P (XFRAME (frame1)))
1420 break;
1421 }
1422 }
1423 #ifdef NS_IMPL_COCOA
1424 else
1425 1426 1427 1428 1429
1430 Fraise_frame (frame1);
1431 #endif
1432
1433 do_switch_frame (frame1, 0, 1, Qnil);
1434 sf = SELECTED_FRAME ();
1435 }
1436
1437
1438 if (EQ (f->minibuffer_window, minibuf_window))
1439 {
1440 Fset_window_buffer (sf->minibuffer_window,
1441 XWINDOW (minibuf_window)->buffer, Qnil);
1442 minibuf_window = sf->minibuffer_window;
1443
1444 1445
1446 if (minibuffer_selected)
1447 Fselect_window (minibuf_window, Qnil);
1448 }
1449
1450
1451 if (EQ (f->minibuffer_window, echo_area_window))
1452 echo_area_window = sf->minibuffer_window;
1453
1454
1455 #ifdef HAVE_X_WINDOWS
1456 if (FRAME_X_P (f))
1457 x_clear_frame_selections (f);
1458 #endif
1459
1460 1461 1462 1463
1464 free_glyphs (f);
1465
1466 #ifdef HAVE_WINDOW_SYSTEM
1467
1468 font_update_drivers (f, Qnil);
1469 #endif
1470
1471 1472
1473 delete_all_subwindows (XWINDOW (f->root_window));
1474 f->root_window = Qnil;
1475
1476 Vframe_list = Fdelq (frame, Vframe_list);
1477 FRAME_SET_VISIBLE (f, 0);
1478
1479 1480 1481 1482
1483 f->menu_bar_vector = Qnil;
1484
1485 free_font_driver_list (f);
1486 xfree (f->namebuf);
1487 xfree (f->decode_mode_spec_buffer);
1488 xfree (FRAME_INSERT_COST (f));
1489 xfree (FRAME_DELETEN_COST (f));
1490 xfree (FRAME_INSERTN_COST (f));
1491 xfree (FRAME_DELETE_COST (f));
1492 xfree (FRAME_MESSAGE_BUF (f));
1493
1494 1495 1496 1497 1498 1499
1500
1501 if (FRAME_TERMINAL (f)->delete_frame_hook)
1502 (*FRAME_TERMINAL (f)->delete_frame_hook) (f);
1503
1504 {
1505 struct terminal *terminal = FRAME_TERMINAL (f);
1506 f->output_data.nothing = 0;
1507 f->terminal = 0;
1508
1509 1510
1511 terminal->reference_count--;
1512 if (terminal->reference_count == 0)
1513 {
1514 Lisp_Object tmp;
1515 XSETTERMINAL (tmp, terminal);
1516
1517 kb = NULL;
1518 Fdelete_terminal (tmp, NILP (force) ? Qt : force);
1519 }
1520 else
1521 kb = terminal->kboard;
1522 }
1523
1524 1525
1526 if (f == last_nonminibuf_frame)
1527 {
1528 Lisp_Object frames;
1529
1530 last_nonminibuf_frame = 0;
1531
1532 for (frames = Vframe_list;
1533 CONSP (frames);
1534 frames = XCDR (frames))
1535 {
1536 f = XFRAME (XCAR (frames));
1537 if (!FRAME_MINIBUF_ONLY_P (f))
1538 {
1539 last_nonminibuf_frame = f;
1540 break;
1541 }
1542 }
1543 }
1544
1545 1546
1547 if (kb != NULL)
1548 {
1549 Lisp_Object frames;
1550
1551 Lisp_Object frame_on_same_kboard;
1552
1553 frame_on_same_kboard = Qnil;
1554
1555 for (frames = Vframe_list;
1556 CONSP (frames);
1557 frames = XCDR (frames))
1558 {
1559 Lisp_Object this;
1560 struct frame *f1;
1561
1562 this = XCAR (frames);
1563 if (!FRAMEP (this))
1564 abort ();
1565 f1 = XFRAME (this);
1566
1567 if (kb == FRAME_KBOARD (f1))
1568 frame_on_same_kboard = this;
1569 }
1570
1571 if (NILP (frame_on_same_kboard))
1572 not_single_kboard_state (kb);
1573 }
1574
1575
1576 1577 1578
1579 if (kb != NULL && EQ (frame, kb->Vdefault_minibuffer_frame))
1580 {
1581 Lisp_Object frames;
1582
1583
1584 Lisp_Object frame_with_minibuf;
1585
1586 Lisp_Object frame_on_same_kboard;
1587
1588 frame_on_same_kboard = Qnil;
1589 frame_with_minibuf = Qnil;
1590
1591 for (frames = Vframe_list;
1592 CONSP (frames);
1593 frames = XCDR (frames))
1594 {
1595 Lisp_Object this;
1596 struct frame *f1;
1597
1598 this = XCAR (frames);
1599 if (!FRAMEP (this))
1600 abort ();
1601 f1 = XFRAME (this);
1602
1603 1604
1605 if (kb == FRAME_KBOARD (f1)
1606 && FRAME_HAS_MINIBUF_P (f1))
1607 {
1608 frame_with_minibuf = this;
1609 if (FRAME_MINIBUF_ONLY_P (f1))
1610 break;
1611 }
1612
1613 if (kb == FRAME_KBOARD (f1))
1614 frame_on_same_kboard = this;
1615 }
1616
1617 if (!NILP (frame_on_same_kboard))
1618 {
1619 1620 1621 1622 1623 1624
1625 if (NILP (frame_with_minibuf))
1626 abort ();
1627
1628 kb->Vdefault_minibuffer_frame = frame_with_minibuf;
1629 }
1630 else
1631
1632 kb->Vdefault_minibuffer_frame = Qnil;
1633 }
1634
1635
1636 update_mode_lines = 1;
1637
1638 return Qnil;
1639 }
1640
1641 DEFUN ("delete-frame", Fdelete_frame, Sdelete_frame, 0, 2, "",
1642 doc: 1643 1644 1645 1646 1647 1648 1649 1650 1651 )
1652 (frame, force)
1653 Lisp_Object frame, force;
1654 {
1655 return delete_frame (frame, !NILP (force) ? Qt : Qnil);
1656 }
1657
1658
1659
1660
1661 DEFUN ("mouse-position", Fmouse_position, Smouse_position, 0, 0, 0,
1662 doc: 1663 1664 1665 1666 1667 1668 1669 1670 1671 )
1672 ()
1673 {
1674 FRAME_PTR f;
1675 Lisp_Object lispy_dummy;
1676 enum scroll_bar_part party_dummy;
1677 Lisp_Object x, y, retval;
1678 int col, row;
1679 unsigned long long_dummy;
1680 struct gcpro gcpro1;
1681
1682 f = SELECTED_FRAME ();
1683 x = y = Qnil;
1684
1685 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1686
1687 if (FRAME_TERMINAL (f)->mouse_position_hook)
1688 (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, -1,
1689 &lispy_dummy, &party_dummy,
1690 &x, &y,
1691 &long_dummy);
1692 if (! NILP (x))
1693 {
1694 col = XINT (x);
1695 row = XINT (y);
1696 pixel_to_glyph_coords (f, col, row, &col, &row, NULL, 1);
1697 XSETINT (x, col);
1698 XSETINT (y, row);
1699 }
1700 #endif
1701 XSETFRAME (lispy_dummy, f);
1702 retval = Fcons (lispy_dummy, Fcons (x, y));
1703 GCPRO1 (retval);
1704 if (!NILP (Vmouse_position_function))
1705 retval = call1 (Vmouse_position_function, retval);
1706 RETURN_UNGCPRO (retval);
1707 }
1708
1709 DEFUN ("mouse-pixel-position", Fmouse_pixel_position,
1710 Smouse_pixel_position, 0, 0, 0,
1711 doc: 1712 1713 1714 1715 1716 1717 )
1718 ()
1719 {
1720 FRAME_PTR f;
1721 Lisp_Object lispy_dummy;
1722 enum scroll_bar_part party_dummy;
1723 Lisp_Object x, y;
1724 unsigned long long_dummy;
1725
1726 f = SELECTED_FRAME ();
1727 x = y = Qnil;
1728
1729 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1730
1731 if (FRAME_TERMINAL (f)->mouse_position_hook)
1732 (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, -1,
1733 &lispy_dummy, &party_dummy,
1734 &x, &y,
1735 &long_dummy);
1736 #endif
1737 XSETFRAME (lispy_dummy, f);
1738 return Fcons (lispy_dummy, Fcons (x, y));
1739 }
1740
1741 DEFUN ("set-mouse-position", Fset_mouse_position, Sset_mouse_position, 3, 3, 0,
1742 doc: 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 )
1755 (frame, x, y)
1756 Lisp_Object frame, x, y;
1757 {
1758 CHECK_LIVE_FRAME (frame);
1759 CHECK_NUMBER (x);
1760 CHECK_NUMBER (y);
1761
1762
1763 #ifdef HAVE_WINDOW_SYSTEM
1764 if (FRAME_WINDOW_P (XFRAME (frame)))
1765
1766 x_set_mouse_position (XFRAME (frame), XINT (x), XINT (y));
1767 #else
1768 #if defined (MSDOS) && defined (HAVE_MOUSE)
1769 if (FRAME_MSDOS_P (XFRAME (frame)))
1770 {
1771 Fselect_frame (frame, Qnil);
1772 mouse_moveto (XINT (x), XINT (y));
1773 }
1774 #else
1775 #ifdef HAVE_GPM
1776 {
1777 Fselect_frame (frame, Qnil);
1778 term_mouse_moveto (XINT (x), XINT (y));
1779 }
1780 #endif
1781 #endif
1782 #endif
1783
1784 return Qnil;
1785 }
1786
1787 DEFUN ("set-mouse-pixel-position", Fset_mouse_pixel_position,
1788 Sset_mouse_pixel_position, 3, 3, 0,
1789 doc: 1790 1791 1792 1793 1794 1795 1796 )
1797 (frame, x, y)
1798 Lisp_Object frame, x, y;
1799 {
1800 CHECK_LIVE_FRAME (frame);
1801 CHECK_NUMBER (x);
1802 CHECK_NUMBER (y);
1803
1804
1805 #ifdef HAVE_WINDOW_SYSTEM
1806 if (FRAME_WINDOW_P (XFRAME (frame)))
1807
1808 x_set_mouse_pixel_position (XFRAME (frame), XINT (x), XINT (y));
1809 #else
1810 #if defined (MSDOS) && defined (HAVE_MOUSE)
1811 if (FRAME_MSDOS_P (XFRAME (frame)))
1812 {
1813 Fselect_frame (frame, Qnil);
1814 mouse_moveto (XINT (x), XINT (y));
1815 }
1816 #else
1817 #ifdef HAVE_GPM
1818 {
1819 Fselect_frame (frame, Qnil);
1820 term_mouse_moveto (XINT (x), XINT (y));
1821 }
1822 #endif
1823 #endif
1824 #endif
1825
1826 return Qnil;
1827 }
1828
1829 static void make_frame_visible_1 P_ ((Lisp_Object));
1830
1831 DEFUN ("make-frame-visible", Fmake_frame_visible, Smake_frame_visible,
1832 0, 1, "",
1833 doc: 1834 )
1835 (frame)
1836 Lisp_Object frame;
1837 {
1838 if (NILP (frame))
1839 frame = selected_frame;
1840
1841 CHECK_LIVE_FRAME (frame);
1842
1843
1844 #ifdef HAVE_WINDOW_SYSTEM
1845 if (FRAME_WINDOW_P (XFRAME (frame)))
1846 {
1847 FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
1848 x_make_frame_visible (XFRAME (frame));
1849 }
1850 #endif
1851
1852 make_frame_visible_1 (XFRAME (frame)->root_window);
1853
1854
1855 windows_or_buffers_changed++;
1856
1857 return frame;
1858 }
1859
1860 1861
1862
1863 static void
1864 make_frame_visible_1 (window)
1865 Lisp_Object window;
1866 {
1867 struct window *w;
1868
1869 for (;!NILP (window); window = w->next)
1870 {
1871 w = XWINDOW (window);
1872
1873 if (!NILP (w->buffer))
1874 XBUFFER (w->buffer)->display_time = Fcurrent_time ();
1875
1876 if (!NILP (w->vchild))
1877 make_frame_visible_1 (w->vchild);
1878 if (!NILP (w->hchild))
1879 make_frame_visible_1 (w->hchild);
1880 }
1881 }
1882
1883 DEFUN ("make-frame-invisible", Fmake_frame_invisible, Smake_frame_invisible,
1884 0, 2, "",
1885 doc: 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 )
1896 (frame, force)
1897 Lisp_Object frame, force;
1898 {
1899 if (NILP (frame))
1900 frame = selected_frame;
1901
1902 CHECK_LIVE_FRAME (frame);
1903
1904 if (NILP (force) && !other_visible_frames (XFRAME (frame)))
1905 error ("Attempt to make invisible the sole visible or iconified frame");
1906
1907 #if 0
1908
1909 if (EQ (frame, selected_frame))
1910 do_switch_frame (next_frame (frame, Qt), 0, 0, Qnil)
1911 #endif
1912
1913
1914 if (EQ (XFRAME (frame)->minibuffer_window, minibuf_window))
1915 {
1916 struct frame *sf = XFRAME (selected_frame);
1917 Fset_window_buffer (sf->minibuffer_window,
1918 XWINDOW (minibuf_window)->buffer, Qnil);
1919 minibuf_window = sf->minibuffer_window;
1920 }
1921
1922
1923 #ifdef HAVE_WINDOW_SYSTEM
1924 if (FRAME_WINDOW_P (XFRAME (frame)))
1925 x_make_frame_invisible (XFRAME (frame));
1926 #endif
1927
1928
1929 windows_or_buffers_changed++;
1930
1931 return Qnil;
1932 }
1933
1934 DEFUN ("iconify-frame", Ficonify_frame, Siconify_frame,
1935 0, 1, "",
1936 doc: 1937 )
1938 (frame)
1939 Lisp_Object frame;
1940 {
1941 if (NILP (frame))
1942 frame = selected_frame;
1943
1944 CHECK_LIVE_FRAME (frame);
1945
1946 #if 0
1947
1948 if (EQ (frame, selected_frame))
1949 Fhandle_switch_frame (next_frame (frame, Qt));
1950 #endif
1951
1952
1953 if (EQ (XFRAME (frame)->minibuffer_window, minibuf_window))
1954 {
1955 struct frame *sf = XFRAME (selected_frame);
1956 Fset_window_buffer (sf->minibuffer_window,
1957 XWINDOW (minibuf_window)->buffer, Qnil);
1958 minibuf_window = sf->minibuffer_window;
1959 }
1960
1961
1962 #ifdef HAVE_WINDOW_SYSTEM
1963 if (FRAME_WINDOW_P (XFRAME (frame)))
1964 x_iconify_frame (XFRAME (frame));
1965 #endif
1966
1967
1968 windows_or_buffers_changed++;
1969
1970 return Qnil;
1971 }
1972
1973 DEFUN ("frame-visible-p", Fframe_visible_p, Sframe_visible_p,
1974 1, 1, 0,
1975 doc: 1976 1977 1978 1979 1980 1981 1982 1983 )
1984 (frame)
1985 Lisp_Object frame;
1986 {
1987 CHECK_LIVE_FRAME (frame);
1988
1989 FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
1990
1991 if (FRAME_VISIBLE_P (XFRAME (frame)))
1992 return Qt;
1993 if (FRAME_ICONIFIED_P (XFRAME (frame)))
1994 return Qicon;
1995 return Qnil;
1996 }
1997
1998 DEFUN ("visible-frame-list", Fvisible_frame_list, Svisible_frame_list,
1999 0, 0, 0,
2000 doc: )
2001 ()
2002 {
2003 Lisp_Object tail, frame;
2004 struct frame *f;
2005 Lisp_Object value;
2006
2007 value = Qnil;
2008 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
2009 {
2010 frame = XCAR (tail);
2011 if (!FRAMEP (frame))
2012 continue;
2013 f = XFRAME (frame);
2014 if (FRAME_VISIBLE_P (f))
2015 value = Fcons (frame, value);
2016 }
2017 return value;
2018 }
2019
2020
2021 DEFUN ("raise-frame", Fraise_frame, Sraise_frame, 0, 1, "",
2022 doc: 2023 2024 2025 2026 )
2027 (frame)
2028 Lisp_Object frame;
2029 {
2030 struct frame *f;
2031 if (NILP (frame))
2032 frame = selected_frame;
2033
2034 CHECK_LIVE_FRAME (frame);
2035
2036 f = XFRAME (frame);
2037
2038 if (FRAME_TERMCAP_P (f))
2039
2040 Fselect_frame (frame, Qnil);
2041 else
2042
2043 Fmake_frame_visible (frame);
2044
2045 if (FRAME_TERMINAL (f)->frame_raise_lower_hook)
2046 (*FRAME_TERMINAL (f)->frame_raise_lower_hook) (f, 1);
2047
2048 return Qnil;
2049 }
2050
2051
2052 DEFUN ("lower-frame", Flower_frame, Slower_frame, 0, 1, "",
2053 doc: 2054 2055 2056 )
2057 (frame)
2058 Lisp_Object frame;
2059 {
2060 struct frame *f;
2061
2062 if (NILP (frame))
2063 frame = selected_frame;
2064
2065 CHECK_LIVE_FRAME (frame);
2066
2067 f = XFRAME (frame);
2068
2069 if (FRAME_TERMINAL (f)->frame_raise_lower_hook)
2070 (*FRAME_TERMINAL (f)->frame_raise_lower_hook) (f, 0);
2071
2072 return Qnil;
2073 }
2074
2075
2076 DEFUN ("redirect-frame-focus", Fredirect_frame_focus, Sredirect_frame_focus,
2077 1, 2, 0,
2078 doc: 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 )
2101 (frame, focus_frame)
2102 Lisp_Object frame, focus_frame;
2103 {
2104 struct frame *f;
2105
2106 2107 2108
2109 CHECK_FRAME (frame);
2110
2111 if (! NILP (focus_frame))
2112 CHECK_LIVE_FRAME (focus_frame);
2113
2114 f = XFRAME (frame);
2115
2116 f->focus_frame = focus_frame;
2117
2118 if (FRAME_TERMINAL (f)->frame_rehighlight_hook)
2119 (*FRAME_TERMINAL (f)->frame_rehighlight_hook) (f);
2120
2121 return Qnil;
2122 }
2123
2124
2125 DEFUN ("frame-focus", Fframe_focus, Sframe_focus, 1, 1, 0,
2126 doc: 2127 2128 )
2129 (frame)
2130 Lisp_Object frame;
2131 {
2132 CHECK_LIVE_FRAME (frame);
2133
2134 return FRAME_FOCUS_FRAME (XFRAME (frame));
2135 }
2136
2137
2138
2139
2140
2141 Lisp_Object
2142 get_frame_param (frame, prop)
2143 register struct frame *frame;
2144 Lisp_Object prop;
2145 {
2146 register Lisp_Object tem;
2147
2148 tem = Fassq (prop, frame->param_alist);
2149 if (EQ (tem, Qnil))
2150 return tem;
2151 return Fcdr (tem);
2152 }
2153
2154
2155
2156 Lisp_Object
2157 frame_buffer_predicate (frame)
2158 Lisp_Object frame;
2159 {
2160 return XFRAME (frame)->buffer_predicate;
2161 }
2162
2163
2164
2165 Lisp_Object
2166 frame_buffer_list (frame)
2167 Lisp_Object frame;
2168 {
2169 return XFRAME (frame)->buffer_list;
2170 }
2171
2172
2173
2174 void
2175 set_frame_buffer_list (frame, list)
2176 Lisp_Object frame, list;
2177 {
2178 XFRAME (frame)->buffer_list = list;
2179 }
2180
2181
2182
2183 void
2184 frames_discard_buffer (buffer)
2185 Lisp_Object buffer;
2186 {
2187 Lisp_Object frame, tail;
2188
2189 FOR_EACH_FRAME (tail, frame)
2190 {
2191 XFRAME (frame)->buffer_list
2192 = Fdelq (buffer, XFRAME (frame)->buffer_list);
2193 XFRAME (frame)->buried_buffer_list
2194 = Fdelq (buffer, XFRAME (frame)->buried_buffer_list);
2195 }
2196 }
2197
2198 2199
2200
2201 void
2202 store_in_alist (alistptr, prop, val)
2203 Lisp_Object *alistptr, val;
2204 Lisp_Object prop;
2205 {
2206 register Lisp_Object tem;
2207
2208 tem = Fassq (prop, *alistptr);
2209 if (EQ (tem, Qnil))
2210 *alistptr = Fcons (Fcons (prop, val), *alistptr);
2211 else
2212 Fsetcdr (tem, val);
2213 }
2214
2215 static int
2216 frame_name_fnn_p (str, len)
2217 char *str;
2218 EMACS_INT len;
2219 {
2220 if (len > 1 && str[0] == 'F')
2221 {
2222 char *end_ptr;
2223
2224 strtol (str + 1, &end_ptr, 10);
2225
2226 if (end_ptr == str + len)
2227 return 1;
2228 }
2229 return 0;
2230 }
2231
2232 2233
2234
2235 static void
2236 set_term_frame_name (f, name)
2237 struct frame *f;
2238 Lisp_Object name;
2239 {
2240 f->explicit_name = ! NILP (name);
2241
2242
2243 if (NILP (name))
2244 {
2245 char namebuf[20];
2246
2247 2248
2249 if (frame_name_fnn_p (SDATA (f->name),
2250 SBYTES (f->name)))
2251 return;
2252
2253 tty_frame_count++;
2254 sprintf (namebuf, "F%d", tty_frame_count);
2255 name = build_string (namebuf);
2256 }
2257 else
2258 {
2259 CHECK_STRING (name);
2260
2261
2262 if (! NILP (Fstring_equal (name, f->name)))
2263 return;
2264
2265 2266
2267 if (frame_name_fnn_p (SDATA (name), SBYTES (name)))
2268 error ("Frame names of the form F<num> are usurped by Emacs");
2269 }
2270
2271 f->name = name;
2272 update_mode_lines = 1;
2273 }
2274
2275 void
2276 store_frame_param (f, prop, val)
2277 struct frame *f;
2278 Lisp_Object prop, val;
2279 {
2280 register Lisp_Object old_alist_elt;
2281
2282 2283
2284 if (EQ (prop, Qbuffer_list))
2285 {
2286 f->buffer_list = val;
2287 return;
2288 }
2289 if (EQ (prop, Qburied_buffer_list))
2290 {
2291 f->buried_buffer_list = val;
2292 return;
2293 }
2294
2295 2296 2297 2298
2299 if (SYMBOLP (prop))
2300 {
2301 struct Lisp_Symbol *sym = XSYMBOL (prop);
2302 start:
2303 switch (sym->redirect)
2304 {
2305 case SYMBOL_VARALIAS: sym = indirect_variable (sym); goto start;
2306 case SYMBOL_PLAINVAL: case SYMBOL_FORWARDED: break;
2307 case SYMBOL_LOCALIZED:
2308 { struct Lisp_Buffer_Local_Value *blv = sym->val.blv;
2309 if (blv->frame_local && BLV_FOUND (blv) && XFRAME (blv->where) == f)
2310 swap_in_global_binding (sym);
2311 break;
2312 }
2313 default: abort ();
2314 }
2315 }
2316
2317 2318 2319
2320 if (FRAME_TERMCAP_P (f) && EQ (prop, Qtty_color_mode)
2321 && f == FRAME_TTY (f)->previous_frame)
2322
2323 FRAME_TTY (f)->previous_frame = NULL;
2324
2325
2326 old_alist_elt = Fassq (prop, f->param_alist);
2327 if (EQ (old_alist_elt, Qnil))
2328 f->param_alist = Fcons (Fcons (prop, val), f->param_alist);
2329 else
2330 Fsetcdr (old_alist_elt, val);
2331
2332 2333
2334
2335 if (EQ (prop, Qbuffer_predicate))
2336 f->buffer_predicate = val;
2337
2338 if (! FRAME_WINDOW_P (f))
2339 {
2340 if (EQ (prop, Qmenu_bar_lines))
2341 set_menu_bar_lines (f, val, make_number (FRAME_MENU_BAR_LINES (f)));
2342 else if (EQ (prop, Qname))
2343 set_term_frame_name (f, val);
2344 }
2345
2346 if (EQ (prop, Qminibuffer) && WINDOWP (val))
2347 {
2348 if (! MINI_WINDOW_P (XWINDOW (val)))
2349 error ("Surrogate minibuffer windows must be minibuffer windows");
2350
2351 if ((FRAME_HAS_MINIBUF_P (f) || FRAME_MINIBUF_ONLY_P (f))
2352 && !EQ (val, f->minibuffer_window))
2353 error ("Can't change the surrogate minibuffer of a frame with its own minibuffer");
2354
2355
2356 f->minibuffer_window = val;
2357 }
2358 }
2359
2360 DEFUN ("frame-parameters", Fframe_parameters, Sframe_parameters, 0, 1, 0,
2361 doc: 2362 2363 2364 )
2365 (frame)
2366 Lisp_Object frame;
2367 {
2368 Lisp_Object alist;
2369 FRAME_PTR f;
2370 int height, width;
2371 struct gcpro gcpro1;
2372
2373 if (NILP (frame))
2374 frame = selected_frame;
2375
2376 CHECK_FRAME (frame);
2377 f = XFRAME (frame);
2378
2379 if (!FRAME_LIVE_P (f))
2380 return Qnil;
2381
2382 alist = Fcopy_alist (f->param_alist);
2383 GCPRO1 (alist);
2384
2385 if (!FRAME_WINDOW_P (f))
2386 {
2387 int fg = FRAME_FOREGROUND_PIXEL (f);
2388 int bg = FRAME_BACKGROUND_PIXEL (f);
2389 Lisp_Object elt;
2390
2391 2392 2393
2394 elt = Fassq (Qforeground_color, alist);
2395 if (CONSP (elt) && STRINGP (XCDR (elt)))
2396 {
2397 if (strncmp (SDATA (XCDR (elt)),
2398 unspecified_bg,
2399 SCHARS (XCDR (elt))) == 0)
2400 store_in_alist (&alist, Qforeground_color, tty_color_name (f, bg));
2401 else if (strncmp (SDATA (XCDR (elt)),
2402 unspecified_fg,
2403 SCHARS (XCDR (elt))) == 0)
2404 store_in_alist (&alist, Qforeground_color, tty_color_name (f, fg));
2405 }
2406 else
2407 store_in_alist (&alist, Qforeground_color, tty_color_name (f, fg));
2408 elt = Fassq (Qbackground_color, alist);
2409 if (CONSP (elt) && STRINGP (XCDR (elt)))
2410 {
2411 if (strncmp (SDATA (XCDR (elt)),
2412 unspecified_fg,
2413 SCHARS (XCDR (elt))) == 0)
2414 store_in_alist (&alist, Qbackground_color, tty_color_name (f, fg));
2415 else if (strncmp (SDATA (XCDR (elt)),
2416 unspecified_bg,
2417 SCHARS (XCDR (elt))) == 0)
2418 store_in_alist (&alist, Qbackground_color, tty_color_name (f, bg));
2419 }
2420 else
2421 store_in_alist (&alist, Qbackground_color, tty_color_name (f, bg));
2422 store_in_alist (&alist, intern ("font"),
2423 build_string (FRAME_MSDOS_P (f)
2424 ? "ms-dos"
2425 : FRAME_W32_P (f) ? "w32term"
2426 :"tty"));
2427 }
2428 store_in_alist (&alist, Qname, f->name);
2429 height = (f->new_text_lines ? f->new_text_lines : FRAME_LINES (f));
2430 store_in_alist (&alist, Qheight, make_number (height));
2431 width = (f->new_text_cols ? f->new_text_cols : FRAME_COLS (f));
2432 store_in_alist (&alist, Qwidth, make_number (width));
2433 store_in_alist (&alist, Qmodeline, (FRAME_WANTS_MODELINE_P (f) ? Qt : Qnil));
2434 store_in_alist (&alist, Qminibuffer,
2435 (! FRAME_HAS_MINIBUF_P (f) ? Qnil
2436 : FRAME_MINIBUF_ONLY_P (f) ? Qonly
2437 : FRAME_MINIBUF_WINDOW (f)));
2438 store_in_alist (&alist, Qunsplittable, (FRAME_NO_SPLIT_P (f) ? Qt : Qnil));
2439 store_in_alist (&alist, Qbuffer_list, frame_buffer_list (frame));
2440 store_in_alist (&alist, Qburied_buffer_list, XFRAME (frame)->buried_buffer_list);
2441
2442
2443 #ifdef HAVE_WINDOW_SYSTEM
2444 if (FRAME_WINDOW_P (f))
2445 x_report_frame_params (f, &alist);
2446 else
2447 #endif
2448 {
2449
2450 Lisp_Object lines;
2451 XSETFASTINT (lines, FRAME_MENU_BAR_LINES (f));
2452 store_in_alist (&alist, Qmenu_bar_lines, lines);
2453 }
2454
2455 UNGCPRO;
2456 return alist;
2457 }
2458
2459
2460 DEFUN ("frame-parameter", Fframe_parameter, Sframe_parameter, 2, 2, 0,
2461 doc: 2462 )
2463 (frame, parameter)
2464 Lisp_Object frame, parameter;
2465 {
2466 struct frame *f;
2467 Lisp_Object value;
2468
2469 if (NILP (frame))
2470 frame = selected_frame;
2471 else
2472 CHECK_FRAME (frame);
2473 CHECK_SYMBOL (parameter);
2474
2475 f = XFRAME (frame);
2476 value = Qnil;
2477
2478 if (FRAME_LIVE_P (f))
2479 {
2480
2481 if (EQ (parameter, Qname))
2482 value = f->name;
2483 #ifdef HAVE_X_WINDOWS
2484 else if (EQ (parameter, Qdisplay) && FRAME_X_P (f))
2485 value = XCAR (FRAME_X_DISPLAY_INFO (f)->name_list_element);
2486 #endif
2487 else if (EQ (parameter, Qbackground_color)
2488 || EQ (parameter, Qforeground_color))
2489 {
2490 value = Fassq (parameter, f->param_alist);
2491 if (CONSP (value))
2492 {
2493 value = XCDR (value);
2494 2495 2496 2497
2498 if (STRINGP (value) && !FRAME_WINDOW_P (f))
2499 {
2500 const char *color_name;
2501 EMACS_INT csz;
2502
2503 if (EQ (parameter, Qbackground_color))
2504 {
2505 color_name = SDATA (value);
2506 csz = SCHARS (value);
2507 if (strncmp (color_name, unspecified_bg, csz) == 0)
2508 value = tty_color_name (f, FRAME_BACKGROUND_PIXEL (f));
2509 else if (strncmp (color_name, unspecified_fg, csz) == 0)
2510 value = tty_color_name (f, FRAME_FOREGROUND_PIXEL (f));
2511 }
2512 else if (EQ (parameter, Qforeground_color))
2513 {
2514 color_name = SDATA (value);
2515 csz = SCHARS (value);
2516 if (strncmp (color_name, unspecified_fg, csz) == 0)
2517 value = tty_color_name (f, FRAME_FOREGROUND_PIXEL (f));
2518 else if (strncmp (color_name, unspecified_bg, csz) == 0)
2519 value = tty_color_name (f, FRAME_BACKGROUND_PIXEL (f));
2520 }
2521 }
2522 }
2523 else
2524 value = Fcdr (Fassq (parameter, Fframe_parameters (frame)));
2525 }
2526 else if (EQ (parameter, Qdisplay_type)
2527 || EQ (parameter, Qbackground_mode))
2528 value = Fcdr (Fassq (parameter, f->param_alist));
2529 else
2530 2531
2532 value = Fcdr (Fassq (parameter, Fframe_parameters (frame)));
2533 }
2534
2535 return value;
2536 }
2537
2538
2539 DEFUN ("modify-frame-parameters", Fmodify_frame_parameters,
2540 Smodify_frame_parameters, 2, 2, 0,
2541 doc: 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 )
2554 (frame, alist)
2555 Lisp_Object frame, alist;
2556 {
2557 FRAME_PTR f;
2558 register Lisp_Object tail, prop, val;
2559
2560 if (EQ (frame, Qnil))
2561 frame = selected_frame;
2562 CHECK_LIVE_FRAME (frame);
2563 f = XFRAME (frame);
2564
2565
2566 #ifdef HAVE_WINDOW_SYSTEM
2567 if (FRAME_WINDOW_P (f))
2568 x_set_frame_parameters (f, alist);
2569 else
2570 #endif
2571 #ifdef MSDOS
2572 if (FRAME_MSDOS_P (f))
2573 IT_set_frame_parameters (f, alist);
2574 else
2575 #endif
2576
2577 {
2578 int length = XINT (Flength (alist));
2579 int i;
2580 Lisp_Object *parms
2581 = (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
2582 Lisp_Object *values
2583 = (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
2584
2585
2586
2587 i = 0;
2588 for (tail = alist; CONSP (tail); tail = XCDR (tail))
2589 {
2590 Lisp_Object elt;
2591
2592 elt = XCAR (tail);
2593 parms[i] = Fcar (elt);
2594 values[i] = Fcdr (elt);
2595 i++;
2596 }
2597
2598
2599 for (i--; i >= 0; i--)
2600 {
2601 prop = parms[i];
2602 val = values[i];
2603 store_frame_param (f, prop, val);
2604
2605 2606 2607
2608 if (EQ (prop, Qbackground_color))
2609 call1 (Qframe_set_background_mode, frame);
2610 }
2611 }
2612 return Qnil;
2613 }
2614
2615 DEFUN ("frame-char-height", Fframe_char_height, Sframe_char_height,
2616 0, 1, 0,
2617 doc: 2618 2619 )
2620 (frame)
2621 Lisp_Object frame;
2622 {
2623 struct frame *f;
2624
2625 if (NILP (frame))
2626 frame = selected_frame;
2627 CHECK_FRAME (frame);
2628 f = XFRAME (frame);
2629
2630 #ifdef HAVE_WINDOW_SYSTEM
2631 if (FRAME_WINDOW_P (f))
2632 return make_number (x_char_height (f));
2633 else
2634 #endif
2635 return make_number (1);
2636 }
2637
2638
2639 DEFUN ("frame-char-width", Fframe_char_width, Sframe_char_width,
2640 0, 1, 0,
2641 doc: 2642 2643 2644 )
2645 (frame)
2646 Lisp_Object frame;
2647 {
2648 struct frame *f;
2649
2650 if (NILP (frame))
2651 frame = selected_frame;
2652 CHECK_FRAME (frame);
2653 f = XFRAME (frame);
2654
2655 #ifdef HAVE_WINDOW_SYSTEM
2656 if (FRAME_WINDOW_P (f))
2657 return make_number (x_char_width (f));
2658 else
2659 #endif
2660 return make_number (1);
2661 }
2662
2663 DEFUN ("frame-pixel-height", Fframe_pixel_height,
2664 Sframe_pixel_height, 0, 1, 0,
2665 doc: 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 )
2682 (frame)
2683 Lisp_Object frame;
2684 {
2685 struct frame *f;
2686
2687 if (NILP (frame))
2688 frame = selected_frame;
2689 CHECK_FRAME (frame);
2690 f = XFRAME (frame);
2691
2692 #ifdef HAVE_WINDOW_SYSTEM
2693 if (FRAME_WINDOW_P (f))
2694 return make_number (x_pixel_height (f));
2695 else
2696 #endif
2697 return make_number (FRAME_LINES (f));
2698 }
2699
2700 DEFUN ("frame-pixel-width", Fframe_pixel_width,
2701 Sframe_pixel_width, 0, 1, 0,
2702 doc: 2703 2704 )
2705 (frame)
2706 Lisp_Object frame;
2707 {
2708 struct frame *f;
2709
2710 if (NILP (frame))
2711 frame = selected_frame;
2712 CHECK_FRAME (frame);
2713 f = XFRAME (frame);
2714
2715 #ifdef HAVE_WINDOW_SYSTEM
2716 if (FRAME_WINDOW_P (f))
2717 return make_number (x_pixel_width (f));
2718 else
2719 #endif
2720 return make_number (FRAME_COLS (f));
2721 }
2722
2723 DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 3, 0,
2724 doc: 2725 2726 )
2727 (frame, lines, pretend)
2728 Lisp_Object frame, lines, pretend;
2729 {
2730 register struct frame *f;
2731
2732 CHECK_NUMBER (lines);
2733 if (NILP (frame))
2734 frame = selected_frame;
2735 CHECK_LIVE_FRAME (frame);
2736 f = XFRAME (frame);
2737
2738
2739 #ifdef HAVE_WINDOW_SYSTEM
2740 if (FRAME_WINDOW_P (f))
2741 {
2742 if (XINT (lines) != FRAME_LINES (f))
2743 x_set_window_size (f, 1, FRAME_COLS (f), XINT (lines));
2744 do_pending_window_change (0);
2745 }
2746 else
2747 #endif
2748 change_frame_size (f, XINT (lines), 0, !NILP (pretend), 0, 0);
2749 return Qnil;
2750 }
2751
2752 DEFUN ("set-frame-width", Fset_frame_width, Sset_frame_width, 2, 3, 0,
2753 doc: 2754 2755 )
2756 (frame, cols, pretend)
2757 Lisp_Object frame, cols, pretend;
2758 {
2759 register struct frame *f;
2760 CHECK_NUMBER (cols);
2761 if (NILP (frame))
2762 frame = selected_frame;
2763 CHECK_LIVE_FRAME (frame);
2764 f = XFRAME (frame);
2765
2766
2767 #ifdef HAVE_WINDOW_SYSTEM
2768 if (FRAME_WINDOW_P (f))
2769 {
2770 if (XINT (cols) != FRAME_COLS (f))
2771 x_set_window_size (f, 1, XINT (cols), FRAME_LINES (f));
2772 do_pending_window_change (0);
2773 }
2774 else
2775 #endif
2776 change_frame_size (f, 0, XINT (cols), !NILP (pretend), 0, 0);
2777 return Qnil;
2778 }
2779
2780 DEFUN ("set-frame-size", Fset_frame_size, Sset_frame_size, 3, 3, 0,
2781 doc: )
2782 (frame, cols, rows)
2783 Lisp_Object frame, cols, rows;
2784 {
2785 register struct frame *f;
2786
2787 CHECK_LIVE_FRAME (frame);
2788 CHECK_NUMBER (cols);
2789 CHECK_NUMBER (rows);
2790 f = XFRAME (frame);
2791
2792
2793 #ifdef HAVE_WINDOW_SYSTEM
2794 if (FRAME_WINDOW_P (f))
2795 {
2796 if (XINT (rows) != FRAME_LINES (f)
2797 || XINT (cols) != FRAME_COLS (f)
2798 || f->new_text_lines || f->new_text_cols)
2799 x_set_window_size (f, 1, XINT (cols), XINT (rows));
2800 do_pending_window_change (0);
2801 }
2802 else
2803 #endif
2804 change_frame_size (f, XINT (rows), XINT (cols), 0, 0, 0);
2805
2806 return Qnil;
2807 }
2808
2809 DEFUN ("set-frame-position", Fset_frame_position,
2810 Sset_frame_position, 3, 3, 0,
2811 doc: 2812 2813 2814 )
2815 (frame, xoffset, yoffset)
2816 Lisp_Object frame, xoffset, yoffset;
2817 {
2818 register struct frame *f;
2819
2820 CHECK_LIVE_FRAME (frame);
2821 CHECK_NUMBER (xoffset);
2822 CHECK_NUMBER (yoffset);
2823 f = XFRAME (frame);
2824
2825
2826 #ifdef HAVE_WINDOW_SYSTEM
2827 if (FRAME_WINDOW_P (f))
2828 x_set_offset (f, XINT (xoffset), XINT (yoffset), 1);
2829 #endif
2830
2831 return Qt;
2832 }
2833
2834
2835 2836 2837
2838
2839 2840 2841 2842 2843 2844
2845
2846 struct frame_parm_table {
2847 char *name;
2848 Lisp_Object *variable;
2849 };
2850
2851 static struct frame_parm_table frame_parms[] =
2852 {
2853 {"auto-raise", &Qauto_raise},
2854 {"auto-lower", &Qauto_lower},
2855 {"background-color", 0},
2856 {"border-color", &Qborder_color},
2857 {"border-width", &Qborder_width},
2858 {"cursor-color", &Qcursor_color},
2859 {"cursor-type", &Qcursor_type},
2860 {"font", 0},
2861 {"foreground-color", 0},
2862 {"icon-name", &Qicon_name},
2863 {"icon-type", &Qicon_type},
2864 {"internal-border-width", &Qinternal_border_width},
2865 {"menu-bar-lines", &Qmenu_bar_lines},
2866 {"mouse-color", &Qmouse_color},
2867 {"name", &Qname},
2868 {"scroll-bar-width", &Qscroll_bar_width},
2869 {"title", &Qtitle},
2870 {"unsplittable", &Qunsplittable},
2871 {"vertical-scroll-bars", &Qvertical_scroll_bars},
2872 {"visibility", &Qvisibility},
2873 {"tool-bar-lines", &Qtool_bar_lines},
2874 {"scroll-bar-foreground", &Qscroll_bar_foreground},
2875 {"scroll-bar-background", &Qscroll_bar_background},
2876 {"screen-gamma", &Qscreen_gamma},
2877 {"line-spacing", &Qline_spacing},
2878 {"left-fringe", &Qleft_fringe},
2879 {"right-fringe", &Qright_fringe},
2880 {"wait-for-wm", &Qwait_for_wm},
2881 {"fullscreen", &Qfullscreen},
2882 {"font-backend", &Qfont_backend},
2883 {"alpha", &Qalpha},
2884 {"sticky", &Qsticky},
2885 };
2886
2887 #ifdef HAVE_WINDOW_SYSTEM
2888
2889 extern Lisp_Object Qbox;
2890 extern Lisp_Object Qtop;
2891
2892 2893 2894 2895 2896
2897
2898 void
2899 x_fullscreen_adjust (f, width, height, top_pos, left_pos)
2900 struct frame *f;
2901 int *width;
2902 int *height;
2903 int *top_pos;
2904 int *left_pos;
2905 {
2906 int newwidth = FRAME_COLS (f);
2907 int newheight = FRAME_LINES (f);
2908 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2909
2910 *top_pos = f->top_pos;
2911 *left_pos = f->left_pos;
2912
2913 if (f->want_fullscreen & FULLSCREEN_HEIGHT)
2914 {
2915 int ph;
2916
2917 ph = x_display_pixel_height (dpyinfo);
2918 newheight = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, ph);
2919 ph = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, newheight) - f->y_pixels_diff;
2920 newheight = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, ph);
2921 *top_pos = 0;
2922 }
2923
2924 if (f->want_fullscreen & FULLSCREEN_WIDTH)
2925 {
2926 int pw;
2927
2928 pw = x_display_pixel_width (dpyinfo);
2929 newwidth = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pw);
2930 pw = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, newwidth) - f->x_pixels_diff;
2931 newwidth = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pw);
2932 *left_pos = 0;
2933 }
2934
2935 *width = newwidth;
2936 *height = newheight;
2937 }
2938
2939
2940 2941 2942 2943 2944
2945
2946 void
2947 x_set_frame_parameters (f, alist)
2948 FRAME_PTR f;
2949 Lisp_Object alist;
2950 {
2951 Lisp_Object tail;
2952
2953 2954 2955
2956 int width, height;
2957
2958
2959 Lisp_Object left, top;
2960
2961
2962 Lisp_Object icon_left, icon_top;
2963
2964
2965 Lisp_Object *parms;
2966 Lisp_Object *values;
2967 int i, p;
2968 int left_no_change = 0, top_no_change = 0;
2969 int icon_left_no_change = 0, icon_top_no_change = 0;
2970 int size_changed = 0;
2971 struct gcpro gcpro1, gcpro2;
2972
2973 i = 0;
2974 for (tail = alist; CONSP (tail); tail = Fcdr (tail))
2975 i++;
2976
2977 parms = (Lisp_Object *) alloca (i * sizeof (Lisp_Object));
2978 values = (Lisp_Object *) alloca (i * sizeof (Lisp_Object));
2979
2980
2981
2982 i = 0;
2983 for (tail = alist; CONSP (tail); tail = XCDR (tail))
2984 {
2985 Lisp_Object elt;
2986
2987 elt = XCAR (tail);
2988 parms[i] = Fcar (elt);
2989 values[i] = Fcdr (elt);
2990 i++;
2991 }
2992
2993 alist = tail = Qnil;
2994
2995 GCPRO2 (*parms, *values);
2996 gcpro1.nvars = i;
2997 gcpro2.nvars = i;
2998
2999 3000
3001 top = left = Qunbound;
3002 icon_left = icon_top = Qunbound;
3003
3004
3005 width = (f->new_text_cols ? f->new_text_cols : FRAME_COLS (f));
3006 height = (f->new_text_lines ? f->new_text_lines : FRAME_LINES (f));
3007
3008 3009 3010
3011
3012 for (p = 0; p < i; p++)
3013 {
3014 Lisp_Object prop, val;
3015
3016 prop = parms[p];
3017 val = values[p];
3018 if (EQ (prop, Qforeground_color)
3019 || EQ (prop, Qbackground_color)
3020 || EQ (prop, Qfont))
3021 {
3022 register Lisp_Object param_index, old_value;
3023
3024 old_value = get_frame_param (f, prop);
3025 if (NILP (Fequal (val, old_value)))
3026 {
3027 store_frame_param (f, prop, val);
3028
3029 param_index = Fget (prop, Qx_frame_parameter);
3030 if (NATNUMP (param_index)
3031 && (XFASTINT (param_index)
3032 < sizeof (frame_parms)/sizeof (frame_parms[0]))
3033 && FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])
3034 (*(FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
3035 }
3036 }
3037 }
3038
3039
3040 for (i--; i >= 0; i--)
3041 {
3042 Lisp_Object prop, val;
3043
3044 prop = parms[i];
3045 val = values[i];
3046
3047 if (EQ (prop, Qwidth) && NATNUMP (val))
3048 {
3049 size_changed = 1;
3050 width = XFASTINT (val);
3051 }
3052 else if (EQ (prop, Qheight) && NATNUMP (val))
3053 {
3054 size_changed = 1;
3055 height = XFASTINT (val);
3056 }
3057 else if (EQ (prop, Qtop))
3058 top = val;
3059 else if (EQ (prop, Qleft))
3060 left = val;
3061 else if (EQ (prop, Qicon_top))
3062 icon_top = val;
3063 else if (EQ (prop, Qicon_left))
3064 icon_left = val;
3065 else if (EQ (prop, Qforeground_color)
3066 || EQ (prop, Qbackground_color)
3067 || EQ (prop, Qfont))
3068
3069 continue;
3070 else
3071 {
3072 register Lisp_Object param_index, old_value;
3073
3074 old_value = get_frame_param (f, prop);
3075
3076 store_frame_param (f, prop, val);
3077
3078 param_index = Fget (prop, Qx_frame_parameter);
3079 if (NATNUMP (param_index)
3080 && (XFASTINT (param_index)
3081 < sizeof (frame_parms)/sizeof (frame_parms[0]))
3082 && FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])
3083 (*(FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
3084 }
3085 }
3086
3087
3088 if (EQ (left, Qunbound))
3089 {
3090 left_no_change = 1;
3091 if (f->left_pos < 0)
3092 left = Fcons (Qplus, Fcons (make_number (f->left_pos), Qnil));
3093 else
3094 XSETINT (left, f->left_pos);
3095 }
3096 if (EQ (top, Qunbound))
3097 {
3098 top_no_change = 1;
3099 if (f->top_pos < 0)
3100 top = Fcons (Qplus, Fcons (make_number (f->top_pos), Qnil));
3101 else
3102 XSETINT (top, f->top_pos);
3103 }
3104
3105
3106 if (EQ (icon_left, Qunbound) || ! INTEGERP (icon_left))
3107 {
3108 icon_left_no_change = 1;
3109 icon_left = Fcdr (Fassq (Qicon_left, f->param_alist));
3110 if (NILP (icon_left))
3111 XSETINT (icon_left, 0);
3112 }
3113 if (EQ (icon_top, Qunbound) || ! INTEGERP (icon_top))
3114 {
3115 icon_top_no_change = 1;
3116 icon_top = Fcdr (Fassq (Qicon_top, f->param_alist));
3117 if (NILP (icon_top))
3118 XSETINT (icon_top, 0);
3119 }
3120
3121 3122 3123 3124 3125 3126 3127 3128
3129 {
3130 Lisp_Object frame;
3131
3132 check_frame_size (f, &height, &width);
3133
3134 XSETFRAME (frame, f);
3135
3136 if (size_changed
3137 && (width != FRAME_COLS (f)
3138 || height != FRAME_LINES (f)
3139 || f->new_text_lines || f->new_text_cols))
3140 Fset_frame_size (frame, make_number (width), make_number (height));
3141
3142 if ((!NILP (left) || !NILP (top))
3143 && ! (left_no_change && top_no_change)
3144 && ! (NUMBERP (left) && XINT (left) == f->left_pos
3145 && NUMBERP (top) && XINT (top) == f->top_pos))
3146 {
3147 int leftpos = 0;
3148 int toppos = 0;
3149
3150
3151 f->size_hint_flags &= ~ (XNegative | YNegative);
3152 if (EQ (left, Qminus))
3153 f->size_hint_flags |= XNegative;
3154 else if (INTEGERP (left))
3155 {
3156 leftpos = XINT (left);
3157 if (leftpos < 0)
3158 f->size_hint_flags |= XNegative;
3159 }
3160 else if (CONSP (left) && EQ (XCAR (left), Qminus)
3161 && CONSP (XCDR (left))
3162 && INTEGERP (XCAR (XCDR (left))))
3163 {
3164 leftpos = - XINT (XCAR (XCDR (left)));
3165 f->size_hint_flags |= XNegative;
3166 }
3167 else if (CONSP (left) && EQ (XCAR (left), Qplus)
3168 && CONSP (XCDR (left))
3169 && INTEGERP (XCAR (XCDR (left))))
3170 {
3171 leftpos = XINT (XCAR (XCDR (left)));
3172 }
3173
3174 if (EQ (top, Qminus))
3175 f->size_hint_flags |= YNegative;
3176 else if (INTEGERP (top))
3177 {
3178 toppos = XINT (top);
3179 if (toppos < 0)
3180 f->size_hint_flags |= YNegative;
3181 }
3182 else if (CONSP (top) && EQ (XCAR (top), Qminus)
3183 && CONSP (XCDR (top))
3184 && INTEGERP (XCAR (XCDR (top))))
3185 {
3186 toppos = - XINT (XCAR (XCDR (top)));
3187 f->size_hint_flags |= YNegative;
3188 }
3189 else if (CONSP (top) && EQ (XCAR (top), Qplus)
3190 && CONSP (XCDR (top))
3191 && INTEGERP (XCAR (XCDR (top))))
3192 {
3193 toppos = XINT (XCAR (XCDR (top)));
3194 }
3195
3196
3197
3198 f->top_pos = toppos;
3199 f->left_pos = leftpos;
3200
3201 f->win_gravity = NorthWestGravity;
3202
3203
3204 x_set_offset (f, leftpos, toppos, -1);
3205 }
3206
3207 if ((!NILP (icon_left) || !NILP (icon_top))
3208 && ! (icon_left_no_change && icon_top_no_change))
3209 x_wm_set_icon_position (f, XINT (icon_left), XINT (icon_top));
3210 }
3211
3212 UNGCPRO;
3213 }
3214
3215
3216 3217 3218 3219 3220
3221
3222 void
3223 x_report_frame_params (f, alistptr)
3224 struct frame *f;
3225 Lisp_Object *alistptr;
3226 {
3227 char buf[16];
3228 Lisp_Object tem;
3229
3230 3231
3232 XSETINT (tem, f->left_pos);
3233 if (f->left_pos >= 0)
3234 store_in_alist (alistptr, Qleft, tem);
3235 else
3236 store_in_alist (alistptr, Qleft, Fcons (Qplus, Fcons (tem, Qnil)));
3237
3238 XSETINT (tem, f->top_pos);
3239 if (f->top_pos >= 0)
3240 store_in_alist (alistptr, Qtop, tem);
3241 else
3242 store_in_alist (alistptr, Qtop, Fcons (Qplus, Fcons (tem, Qnil)));
3243
3244 store_in_alist (alistptr, Qborder_width,
3245 make_number (f->border_width));
3246 store_in_alist (alistptr, Qinternal_border_width,
3247 make_number (FRAME_INTERNAL_BORDER_WIDTH (f)));
3248 store_in_alist (alistptr, Qleft_fringe,
3249 make_number (FRAME_LEFT_FRINGE_WIDTH (f)));
3250 store_in_alist (alistptr, Qright_fringe,
3251 make_number (FRAME_RIGHT_FRINGE_WIDTH (f)));
3252 store_in_alist (alistptr, Qscroll_bar_width,
3253 (! FRAME_HAS_VERTICAL_SCROLL_BARS (f)
3254 ? make_number (0)
3255 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0
3256 ? make_number (FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
3257 3258 3259
3260 : Qnil));
3261 sprintf (buf, "%ld", (long) FRAME_X_WINDOW (f));
3262 store_in_alist (alistptr, Qwindow_id,
3263 build_string (buf));
3264 #ifdef HAVE_X_WINDOWS
3265 #ifdef USE_X_TOOLKIT
3266
3267 if (FRAME_X_OUTPUT (f)->widget)
3268 #endif
3269 sprintf (buf, "%ld", (long) FRAME_OUTER_WINDOW (f));
3270 store_in_alist (alistptr, Qouter_window_id,
3271 build_string (buf));
3272 #endif
3273 store_in_alist (alistptr, Qicon_name, f->icon_name);
3274 FRAME_SAMPLE_VISIBILITY (f);
3275 store_in_alist (alistptr, Qvisibility,
3276 (FRAME_VISIBLE_P (f) ? Qt
3277 : FRAME_ICONIFIED_P (f) ? Qicon : Qnil));
3278 store_in_alist (alistptr, Qdisplay,
3279 XCAR (FRAME_X_DISPLAY_INFO (f)->name_list_element));
3280
3281 if (FRAME_X_OUTPUT (f)->parent_desc == FRAME_X_DISPLAY_INFO (f)->root_window)
3282 tem = Qnil;
3283 else
3284 XSETFASTINT (tem, FRAME_X_OUTPUT (f)->parent_desc);
3285 store_in_alist (alistptr, Qexplicit_name, (f->explicit_name ? Qt : Qnil));
3286 store_in_alist (alistptr, Qparent_id, tem);
3287 }
3288
3289
3290 3291
3292
3293 void
3294 x_set_fullscreen (f, new_value, old_value)
3295 struct frame *f;
3296 Lisp_Object new_value, old_value;
3297 {
3298 if (NILP (new_value))
3299 f->want_fullscreen = FULLSCREEN_NONE;
3300 else if (EQ (new_value, Qfullboth) || EQ (new_value, Qfullscreen))
3301 f->want_fullscreen = FULLSCREEN_BOTH;
3302 else if (EQ (new_value, Qfullwidth))
3303 f->want_fullscreen = FULLSCREEN_WIDTH;
3304 else if (EQ (new_value, Qfullheight))
3305 f->want_fullscreen = FULLSCREEN_HEIGHT;
3306 else if (EQ (new_value, Qmaximized))
3307 f->want_fullscreen = FULLSCREEN_MAXIMIZED;
3308
3309 if (FRAME_TERMINAL (f)->fullscreen_hook != NULL)
3310 FRAME_TERMINAL (f)->fullscreen_hook (f);
3311 }
3312
3313
3314 3315
3316
3317 void
3318 x_set_line_spacing (f, new_value, old_value)
3319 struct frame *f;
3320 Lisp_Object new_value, old_value;
3321 {
3322 if (NILP (new_value))
3323 f->extra_line_spacing = 0;
3324 else if (NATNUMP (new_value))
3325 f->extra_line_spacing = XFASTINT (new_value);
3326 else
3327 signal_error ("Invalid line-spacing", new_value);
3328 if (FRAME_VISIBLE_P (f))
3329 redraw_frame (f);
3330 }
3331
3332
3333 3334
3335
3336 void
3337 x_set_screen_gamma (f, new_value, old_value)
3338 struct frame *f;
3339 Lisp_Object new_value, old_value;
3340 {
3341 Lisp_Object bgcolor;
3342
3343 if (NILP (new_value))
3344 f->gamma = 0;
3345 else if (NUMBERP (new_value) && XFLOATINT (new_value) > 0)
3346
3347 f->gamma = 1.0 / (0.4545 * XFLOATINT (new_value));
3348 else
3349 signal_error ("Invalid screen-gamma", new_value);
3350
3351
3352 bgcolor = Fassq (Qbackground_color, f->param_alist);
3353 if (CONSP (bgcolor) && (bgcolor = XCDR (bgcolor), STRINGP (bgcolor)))
3354 {
3355 Lisp_Object index = Fget (Qbackground_color, Qx_frame_parameter);
3356 if (NATNUMP (index)
3357 && (XFASTINT (index)
3358 < sizeof (frame_parms)/sizeof (frame_parms[0]))
3359 && FRAME_RIF (f)->frame_parm_handlers[XFASTINT (index)])
3360 (*FRAME_RIF (f)->frame_parm_handlers[XFASTINT (index)])
3361 (f, bgcolor, Qnil);
3362 }
3363
3364 Fclear_face_cache (Qnil);
3365 }
3366
3367
3368 void
3369 x_set_font (f, arg, oldval)
3370 struct frame *f;
3371 Lisp_Object arg, oldval;
3372 {
3373 Lisp_Object frame, font_object, font_param = Qnil;
3374 int fontset = -1;
3375
3376 3377
3378 store_frame_param (f, Qfont, oldval);
3379
3380 3381 3382
3383 if (STRINGP (arg))
3384 {
3385 font_param = arg;
3386 fontset = fs_query_fontset (arg, 0);
3387 if (fontset < 0)
3388 {
3389 font_object = font_open_by_name (f, SDATA (arg));
3390 if (NILP (font_object))
3391 error ("Font `%s' is not defined", SDATA (arg));
3392 arg = AREF (font_object, FONT_NAME_INDEX);
3393 }
3394 else if (fontset > 0)
3395 {
3396 Lisp_Object ascii_font = fontset_ascii (fontset);
3397
3398 font_object = font_open_by_name (f, SDATA (ascii_font));
3399 if (NILP (font_object))
3400 error ("Font `%s' is not defined", SDATA (arg));
3401 arg = AREF (font_object, FONT_NAME_INDEX);
3402 }
3403 else
3404 error ("The default fontset can't be used for a frame font");
3405 }
3406 else if (CONSP (arg) && STRINGP (XCAR (arg)) && FONT_OBJECT_P (XCDR (arg)))
3407 {
3408 3409 3410
3411 fontset = fs_query_fontset (XCAR (arg), 0);
3412 if (fontset < 0)
3413 error ("Unknown fontset: %s", SDATA (XCAR (arg)));
3414 font_object = XCDR (arg);
3415 arg = AREF (font_object, FONT_NAME_INDEX);
3416 font_param = Ffont_get (font_object, QCname);
3417 }
3418 else if (FONT_OBJECT_P (arg))
3419 {
3420 font_object = arg;
3421 font_param = Ffont_get (font_object, QCname);
3422 3423 3424
3425 arg = AREF (font_object, FONT_NAME_INDEX);
3426 fontset = FRAME_FONTSET (f);
3427 3428
3429 if (fontset >= 0)
3430 {
3431 Lisp_Object ascii_font = fontset_ascii (fontset);
3432 Lisp_Object spec = font_spec_from_name (ascii_font);
3433
3434 if (! font_match_p (spec, font_object))
3435 fontset = -1;
3436 }
3437 }
3438 else
3439 signal_error ("Invalid font", arg);
3440
3441 if (! NILP (Fequal (font_object, oldval)))
3442 return;
3443
3444 x_new_font (f, font_object, fontset);
3445 store_frame_param (f, Qfont, arg);
3446 #ifdef HAVE_X_WINDOWS
3447 store_frame_param (f, Qfont_param, font_param);
3448 #endif
3449
3450 f->n_tool_bar_rows = 0;
3451
3452 clear_current_matrices (f);
3453
3454 recompute_basic_faces (f);
3455
3456 do_pending_window_change (0);
3457
3458 3459 3460 3461 3462 3463
3464 }
3465
3466
3467 void
3468 x_set_font_backend (f, new_value, old_value)
3469 struct frame *f;
3470 Lisp_Object new_value, old_value;
3471 {
3472 if (! NILP (new_value)
3473 && !CONSP (new_value))
3474 {
3475 char *p0, *p1;
3476
3477 CHECK_STRING (new_value);
3478 p0 = p1 = SDATA (new_value);
3479 new_value = Qnil;
3480 while (*p0)
3481 {
3482 while (*p1 && ! isspace (*p1) && *p1 != ',') p1++;
3483 if (p0 < p1)
3484 new_value = Fcons (Fintern (make_string (p0, p1 - p0), Qnil),
3485 new_value);
3486 if (*p1)
3487 {
3488 int c;
3489
3490 while ((c = *++p1) && isspace (c));
3491 }
3492 p0 = p1;
3493 }
3494 new_value = Fnreverse (new_value);
3495 }
3496
3497 if (! NILP (old_value) && ! NILP (Fequal (old_value, new_value)))
3498 return;
3499
3500 if (FRAME_FONT (f))
3501 free_all_realized_faces (Qnil);
3502
3503 new_value = font_update_drivers (f, NILP (new_value) ? Qt : new_value);
3504 if (NILP (new_value))
3505 {
3506 if (NILP (old_value))
3507 error ("No font backend available");
3508 font_update_drivers (f, old_value);
3509 error ("None of specified font backends are available");
3510 }
3511 store_frame_param (f, Qfont_backend, new_value);
3512
3513 if (FRAME_FONT (f))
3514 {
3515 Lisp_Object frame;
3516
3517 XSETFRAME (frame, f);
3518 x_set_font (f, Fframe_parameter (frame, Qfont), Qnil);
3519 ++face_change_count;
3520 ++windows_or_buffers_changed;
3521 }
3522 }
3523
3524
3525 void
3526 x_set_fringe_width (f, new_value, old_value)
3527 struct frame *f;
3528 Lisp_Object new_value, old_value;
3529 {
3530 compute_fringe_widths (f, 1);
3531 }
3532
3533 void
3534 x_set_border_width (f, arg, oldval)
3535 struct frame *f;
3536 Lisp_Object arg, oldval;
3537 {
3538 CHECK_NUMBER (arg);
3539
3540 if (XINT (arg) == f->border_width)
3541 return;
3542
3543 if (FRAME_X_WINDOW (f) != 0)
3544 error ("Cannot change the border width of a frame");
3545
3546 f->border_width = XINT (arg);
3547 }
3548
3549 void
3550 x_set_internal_border_width (f, arg, oldval)
3551 struct frame *f;
3552 Lisp_Object arg, oldval;
3553 {
3554 int old = FRAME_INTERNAL_BORDER_WIDTH (f);
3555
3556 CHECK_NUMBER (arg);
3557 FRAME_INTERNAL_BORDER_WIDTH (f) = XINT (arg);
3558 if (FRAME_INTERNAL_BORDER_WIDTH (f) < 0)
3559 FRAME_INTERNAL_BORDER_WIDTH (f) = 0;
3560
3561 #ifdef USE_X_TOOLKIT
3562 if (FRAME_X_OUTPUT (f)->edit_widget)
3563 widget_store_internal_border (FRAME_X_OUTPUT (f)->edit_widget);
3564 #endif
3565
3566 if (FRAME_INTERNAL_BORDER_WIDTH (f) == old)
3567 return;
3568
3569 if (FRAME_X_WINDOW (f) != 0)
3570 {
3571 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
3572 SET_FRAME_GARBAGED (f);
3573 do_pending_window_change (0);
3574 }
3575 else
3576 SET_FRAME_GARBAGED (f);
3577 }
3578
3579 void
3580 x_set_visibility (f, value, oldval)
3581 struct frame *f;
3582 Lisp_Object value, oldval;
3583 {
3584 Lisp_Object frame;
3585 XSETFRAME (frame, f);
3586
3587 if (NILP (value))
3588 Fmake_frame_invisible (frame, Qt);
3589 else if (EQ (value, Qicon))
3590 Ficonify_frame (frame);
3591 else
3592 Fmake_frame_visible (frame);
3593 }
3594
3595 void
3596 x_set_autoraise (f, arg, oldval)
3597 struct frame *f;
3598 Lisp_Object arg, oldval;
3599 {
3600 f->auto_raise = !EQ (Qnil, arg);
3601 }
3602
3603 void
3604 x_set_autolower (f, arg, oldval)
3605 struct frame *f;
3606 Lisp_Object arg, oldval;
3607 {
3608 f->auto_lower = !EQ (Qnil, arg);
3609 }
3610
3611 void
3612 x_set_unsplittable (f, arg, oldval)
3613 struct frame *f;
3614 Lisp_Object arg, oldval;
3615 {
3616 f->no_split = !NILP (arg);
3617 }
3618
3619 void
3620 x_set_vertical_scroll_bars (f, arg, oldval)
3621 struct frame *f;
3622 Lisp_Object arg, oldval;
3623 {
3624 if ((EQ (arg, Qleft) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
3625 || (EQ (arg, Qright) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
3626 || (NILP (arg) && FRAME_HAS_VERTICAL_SCROLL_BARS (f))
3627 || (!NILP (arg) && ! FRAME_HAS_VERTICAL_SCROLL_BARS (f)))
3628 {
3629 FRAME_VERTICAL_SCROLL_BAR_TYPE (f)
3630 = (NILP (arg)
3631 ? vertical_scroll_bar_none
3632 : EQ (Qleft, arg)
3633 ? vertical_scroll_bar_left
3634 : EQ (Qright, arg)
3635 ? vertical_scroll_bar_right
3636 : EQ (Qleft, Vdefault_frame_scroll_bars)
3637 ? vertical_scroll_bar_left
3638 : EQ (Qright, Vdefault_frame_scroll_bars)
3639 ? vertical_scroll_bar_right
3640 : vertical_scroll_bar_none);
3641
3642 3643 3644 3645
3646 if (FRAME_X_WINDOW (f))
3647 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
3648 do_pending_window_change (0);
3649 }
3650 }
3651
3652 void
3653 x_set_scroll_bar_width (f, arg, oldval)
3654 struct frame *f;
3655 Lisp_Object arg, oldval;
3656 {
3657 int wid = FRAME_COLUMN_WIDTH (f);
3658
3659 if (NILP (arg))
3660 {
3661 x_set_scroll_bar_default_width (f);
3662
3663 if (FRAME_X_WINDOW (f))
3664 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
3665 do_pending_window_change (0);
3666 }
3667 else if (INTEGERP (arg) && XINT (arg) > 0
3668 && XFASTINT (arg) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
3669 {
3670 if (XFASTINT (arg) <= 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM)
3671 XSETINT (arg, 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM + 1);
3672
3673 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = XFASTINT (arg);
3674 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (XFASTINT (arg) + wid-1) / wid;
3675 if (FRAME_X_WINDOW (f))
3676 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
3677 do_pending_window_change (0);
3678 }
3679
3680 change_frame_size (f, 0, FRAME_COLS (f), 0, 0, 0);
3681 XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.hpos = 0;
3682 XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.x = 0;
3683 }
3684
3685
3686
3687
3688
3689 Lisp_Object
3690 x_icon_type (f)
3691 FRAME_PTR f;
3692 {
3693 Lisp_Object tem;
3694
3695 tem = assq_no_quit (Qicon_type, f->param_alist);
3696 if (CONSP (tem))
3697 return XCDR (tem);
3698 else
3699 return Qnil;
3700 }
3701
3702 void
3703 x_set_alpha (f, arg, oldval)
3704 struct frame *f;
3705 Lisp_Object arg, oldval;
3706 {
3707 double alpha = 1.0;
3708 double newval[2];
3709 int i, ialpha;
3710 Lisp_Object item;
3711
3712 for (i = 0; i < 2; i++)
3713 {
3714 newval[i] = 1.0;
3715 if (CONSP (arg))
3716 {
3717 item = CAR (arg);
3718 arg = CDR (arg);
3719 }
3720 else
3721 item = arg;
3722
3723 if (NILP (item))
3724 alpha = - 1.0;
3725 else if (FLOATP (item))
3726 {
3727 alpha = XFLOAT_DATA (item);
3728 if (alpha < 0.0 || 1.0 < alpha)
3729 args_out_of_range (make_float (0.0), make_float (1.0));
3730 }
3731 else if (INTEGERP (item))
3732 {
3733 ialpha = XINT (item);
3734 if (ialpha < 0 || 100 < ialpha)
3735 args_out_of_range (make_number (0), make_number (100));
3736 else
3737 alpha = ialpha / 100.0;
3738 }
3739 else
3740 wrong_type_argument (Qnumberp, item);
3741 newval[i] = alpha;
3742 }
3743
3744 for (i = 0; i < 2; i++)
3745 f->alpha[i] = newval[i];
3746
3747 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI) || defined (NS_IMPL_COCOA)
3748 BLOCK_INPUT;
3749 x_set_frame_alpha (f);
3750 UNBLOCK_INPUT;
3751 #endif
3752
3753 return;
3754 }
3755
3756
3757
3758
3759 3760
3761
3762 void
3763 validate_x_resource_name ()
3764 {
3765 int len = 0;
3766
3767 int good_count = 0;
3768
3769 int bad_count = 0;
3770 Lisp_Object new;
3771 int i;
3772
3773 if (!STRINGP (Vx_resource_class))
3774 Vx_resource_class = build_string (EMACS_CLASS);
3775
3776 if (STRINGP (Vx_resource_name))
3777 {
3778 unsigned char *p = SDATA (Vx_resource_name);
3779 int i;
3780
3781 len = SBYTES (Vx_resource_name);
3782
3783 3784
3785 for (i = 0; i < len; i++)
3786 {
3787 int c = p[i];
3788 if (! ((c >= 'a' && c <= 'z')
3789 || (c >= 'A' && c <= 'Z')
3790 || (c >= '0' && c <= '9')
3791 || c == '-' || c == '_'))
3792 bad_count++;
3793 else
3794 good_count++;
3795 }
3796 }
3797 else
3798
3799 bad_count = 5, good_count = 0;
3800
3801
3802 if (bad_count == 0)
3803 return;
3804
3805
3806 if (good_count == 0
3807 || (good_count == 1 && bad_count > 0))
3808 {
3809 Vx_resource_name = build_string ("emacs");
3810 return;
3811 }
3812
3813 3814
3815
3816 Vx_resource_name = new = Fcopy_sequence (Vx_resource_name);
3817
3818 for (i = 0; i < len; i++)
3819 {
3820 int c = SREF (new, i);
3821 if (! ((c >= 'a' && c <= 'z')
3822 || (c >= 'A' && c <= 'Z')
3823 || (c >= '0' && c <= '9')
3824 || c == '-' || c == '_'))
3825 SSET (new, i, '_');
3826 }
3827 }
3828
3829
3830 extern char *x_get_string_resource P_ ((XrmDatabase, char *, char *));
3831 extern Display_Info *check_x_display_info P_ ((Lisp_Object));
3832
3833
3834 3835
3836
3837 static Lisp_Object
3838 xrdb_get_resource (rdb, attribute, class, component, subclass)
3839 XrmDatabase rdb;
3840 Lisp_Object attribute, class, component, subclass;
3841 {
3842 register char *value;
3843 char *name_key;
3844 char *class_key;
3845
3846 CHECK_STRING (attribute);
3847 CHECK_STRING (class);
3848
3849 if (!NILP (component))
3850 CHECK_STRING (component);
3851 if (!NILP (subclass))
3852 CHECK_STRING (subclass);
3853 if (NILP (component) != NILP (subclass))
3854 error ("x-get-resource: must specify both COMPONENT and SUBCLASS or neither");
3855
3856 validate_x_resource_name ();
3857
3858 3859
3860 name_key = (char *) alloca (SBYTES (Vx_resource_name)
3861 + (STRINGP (component)
3862 ? SBYTES (component) : 0)
3863 + SBYTES (attribute)
3864 + 3);
3865
3866 class_key = (char *) alloca (SBYTES (Vx_resource_class)
3867 + SBYTES (class)
3868 + (STRINGP (subclass)
3869 ? SBYTES (subclass) : 0)
3870 + 3);
3871
3872 3873
3874 strcpy (name_key, SDATA (Vx_resource_name));
3875 strcpy (class_key, SDATA (Vx_resource_class));
3876
3877 strcat (class_key, ".");
3878 strcat (class_key, SDATA (class));
3879
3880 if (!NILP (component))
3881 {
3882 strcat (class_key, ".");
3883 strcat (class_key, SDATA (subclass));
3884
3885 strcat (name_key, ".");
3886 strcat (name_key, SDATA (component));
3887 }
3888
3889 strcat (name_key, ".");
3890 strcat (name_key, SDATA (attribute));
3891
3892 value = x_get_string_resource (rdb, name_key, class_key);
3893
3894 if (value != (char *) 0 && *value)
3895 return build_string (value);
3896 else
3897 return Qnil;
3898 }
3899
3900
3901 DEFUN ("x-get-resource", Fx_get_resource, Sx_get_resource, 2, 4, 0,
3902 doc: 3903 3904 3905 3906 3907 3908 3909 3910 )
3911 (attribute, class, component, subclass)
3912 Lisp_Object attribute, class, component, subclass;
3913 {
3914 #ifdef HAVE_X_WINDOWS
3915 check_x ();
3916 #endif
3917
3918 return xrdb_get_resource (check_x_display_info (Qnil)->xrdb,
3919 attribute, class, component, subclass);
3920 }
3921
3922
3923
3924 Lisp_Object
3925 display_x_get_resource (dpyinfo, attribute, class, component, subclass)
3926 Display_Info *dpyinfo;
3927 Lisp_Object attribute, class, component, subclass;
3928 {
3929 return xrdb_get_resource (dpyinfo->xrdb,
3930 attribute, class, component, subclass);
3931 }
3932
3933 #if defined HAVE_X_WINDOWS && !defined USE_X_TOOLKIT
3934
3935
3936 char *
3937 x_get_resource_string (attribute, class)
3938 char *attribute, *class;
3939 {
3940 char *name_key;
3941 char *class_key;
3942 struct frame *sf = SELECTED_FRAME ();
3943
3944 3945
3946 name_key = (char *) alloca (SBYTES (Vinvocation_name)
3947 + strlen (attribute) + 2);
3948 class_key = (char *) alloca ((sizeof (EMACS_CLASS) - 1)
3949 + strlen (class) + 2);
3950
3951 sprintf (name_key, "%s.%s", SDATA (Vinvocation_name), attribute);
3952 sprintf (class_key, "%s.%s", EMACS_CLASS, class);
3953
3954 return x_get_string_resource (FRAME_X_DISPLAY_INFO (sf)->xrdb,
3955 name_key, class_key);
3956 }
3957 #endif
3958
3959 3960 3961 3962 3963 3964 3965 3966 3967 3968
3969
3970 Lisp_Object
3971 x_get_arg (dpyinfo, alist, param, attribute, class, type)
3972 Display_Info *dpyinfo;
3973 Lisp_Object alist, param;
3974 char *attribute;
3975 char *class;
3976 enum resource_types type;
3977 {
3978 register Lisp_Object tem;
3979
3980 tem = Fassq (param, alist);
3981
3982 if (!NILP (tem))
3983 {
3984 3985
3986 Lisp_Object tail;
3987 XSETCAR (tem, Qnil);
3988 3989
3990 for (tail = alist; CONSP (tail); tail = XCDR (tail))
3991 if (CONSP (XCAR (tail))
3992 && EQ (XCAR (XCAR (tail)), param))
3993 XSETCAR (XCAR (tail), Qnil);
3994 }
3995 else
3996 tem = Fassq (param, Vdefault_frame_alist);
3997
3998 3999
4000 if (EQ (tem, Qnil))
4001 {
4002 if (attribute && dpyinfo)
4003 {
4004 tem = display_x_get_resource (dpyinfo,
4005 build_string (attribute),
4006 build_string (class),
4007 Qnil, Qnil);
4008
4009 if (NILP (tem))
4010 return Qunbound;
4011
4012 switch (type)
4013 {
4014 case RES_TYPE_NUMBER:
4015 return make_number (atoi (SDATA (tem)));
4016
4017 case RES_TYPE_BOOLEAN_NUMBER:
4018 if (!strcmp (SDATA (tem), "on")
4019 || !strcmp (SDATA (tem), "true"))
4020 return make_number (1);
4021 return make_number (atoi (SDATA (tem)));
4022 break;
4023
4024 case RES_TYPE_FLOAT:
4025 return make_float (atof (SDATA (tem)));
4026
4027 case RES_TYPE_BOOLEAN:
4028 tem = Fdowncase (tem);
4029 if (!strcmp (SDATA (tem), "on")
4030 #ifdef HAVE_NS
4031 || !strcmp(SDATA(tem), "yes")
4032 #endif
4033 || !strcmp (SDATA (tem), "true"))
4034 return Qt;
4035 else
4036 return Qnil;
4037
4038 case RES_TYPE_STRING:
4039 return tem;
4040
4041 case RES_TYPE_SYMBOL:
4042 4043
4044 {
4045 Lisp_Object lower;
4046 lower = Fdowncase (tem);
4047 if (!strcmp (SDATA (lower), "on")
4048 #ifdef HAVE_NS
4049 || !strcmp(SDATA(lower), "yes")
4050 #endif
4051 || !strcmp (SDATA (lower), "true"))
4052 return Qt;
4053 else if (!strcmp (SDATA (lower), "off")
4054 #ifdef HAVE_NS
4055 || !strcmp(SDATA(lower), "no")
4056 #endif
4057 || !strcmp (SDATA (lower), "false"))
4058 return Qnil;
4059 else
4060 return Fintern (tem, Qnil);
4061 }
4062
4063 default:
4064 abort ();
4065 }
4066 }
4067 else
4068 return Qunbound;
4069 }
4070 return Fcdr (tem);
4071 }
4072
4073 Lisp_Object
4074 x_frame_get_arg (f, alist, param, attribute, class, type)
4075 struct frame *f;
4076 Lisp_Object alist, param;
4077 char *attribute;
4078 char *class;
4079 enum resource_types type;
4080 {
4081 return x_get_arg (FRAME_X_DISPLAY_INFO (f),
4082 alist, param, attribute, class, type);
4083 }
4084
4085
4086
4087 Lisp_Object
4088 x_frame_get_and_record_arg (f, alist, param, attribute, class, type)
4089 struct frame *f;
4090 Lisp_Object alist, param;
4091 char *attribute;
4092 char *class;
4093 enum resource_types type;
4094 {
4095 Lisp_Object value;
4096
4097 value = x_get_arg (FRAME_X_DISPLAY_INFO (f), alist, param,
4098 attribute, class, type);
4099 if (! NILP (value) && ! EQ (value, Qunbound))
4100 store_frame_param (f, param, value);
4101
4102 return value;
4103 }
4104
4105
4106 4107 4108 4109 4110
4111
4112 Lisp_Object
4113 x_default_parameter (f, alist, prop, deflt, xprop, xclass, type)
4114 struct frame *f;
4115 Lisp_Object alist;
4116 Lisp_Object prop;
4117 Lisp_Object deflt;
4118 char *xprop;
4119 char *xclass;
4120 enum resource_types type;
4121 {
4122 Lisp_Object tem;
4123
4124 tem = x_frame_get_arg (f, alist, prop, xprop, xclass, type);
4125 if (EQ (tem, Qunbound))
4126 tem = deflt;
4127 x_set_frame_parameters (f, Fcons (Fcons (prop, tem), Qnil));
4128 return tem;
4129 }
4130
4131
4132
4133
4134 4135 4136 4137 4138 4139 4140 4141
4142 DEFUN ("x-parse-geometry", Fx_parse_geometry, Sx_parse_geometry, 1, 1, 0,
4143 doc: 4144 4145 4146 4147 4148 4149 )
4150 (string)
4151 Lisp_Object string;
4152 {
4153 #ifdef HAVE_NS
4154 call1 (Qns_parse_geometry, string);
4155 #else
4156 int geometry, x, y;
4157 unsigned int width, height;
4158 Lisp_Object result;
4159
4160 CHECK_STRING (string);
4161
4162 geometry = XParseGeometry ((char *) SDATA (string),
4163 &x, &y, &width, &height);
4164 result = Qnil;
4165 if (geometry & XValue)
4166 {
4167 Lisp_Object element;
4168
4169 if (x >= 0 && (geometry & XNegative))
4170 element = Fcons (Qleft, Fcons (Qminus, Fcons (make_number (-x), Qnil)));
4171 else if (x < 0 && ! (geometry & XNegative))
4172 element = Fcons (Qleft, Fcons (Qplus, Fcons (make_number (x), Qnil)));
4173 else
4174 element = Fcons (Qleft, make_number (x));
4175 result = Fcons (element, result);
4176 }
4177
4178 if (geometry & YValue)
4179 {
4180 Lisp_Object element;
4181
4182 if (y >= 0 && (geometry & YNegative))
4183 element = Fcons (Qtop, Fcons (Qminus, Fcons (make_number (-y), Qnil)));
4184 else if (y < 0 && ! (geometry & YNegative))
4185 element = Fcons (Qtop, Fcons (Qplus, Fcons (make_number (y), Qnil)));
4186 else
4187 element = Fcons (Qtop, make_number (y));
4188 result = Fcons (element, result);
4189 }
4190
4191 if (geometry & WidthValue)
4192 result = Fcons (Fcons (Qwidth, make_number (width)), result);
4193 if (geometry & HeightValue)
4194 result = Fcons (Fcons (Qheight, make_number (height)), result);
4195
4196 return result;
4197 #endif
4198 }
4199
4200
4201 4202 4203 4204 4205 4206 4207 4208
4209
4210 #define DEFAULT_ROWS 35
4211 #define DEFAULT_COLS 80
4212
4213 int
4214 x_figure_window_size (f, parms, toolbar_p)
4215 struct frame *f;
4216 Lisp_Object parms;
4217 int toolbar_p;
4218 {
4219 register Lisp_Object tem0, tem1, tem2;
4220 long window_prompting = 0;
4221 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
4222
4223 4224 4225
4226 SET_FRAME_COLS (f, DEFAULT_COLS);
4227 FRAME_LINES (f) = DEFAULT_ROWS;
4228 4229
4230 f->top_pos = 0;
4231 f->left_pos = 0;
4232
4233 4234
4235
4236 f->new_text_cols = f->new_text_lines = 0;
4237
4238 tem0 = x_get_arg (dpyinfo, parms, Qheight, 0, 0, RES_TYPE_NUMBER);
4239 tem1 = x_get_arg (dpyinfo, parms, Qwidth, 0, 0, RES_TYPE_NUMBER);
4240 tem2 = x_get_arg (dpyinfo, parms, Quser_size, 0, 0, RES_TYPE_NUMBER);
4241 if (! EQ (tem0, Qunbound) || ! EQ (tem1, Qunbound))
4242 {
4243 if (!EQ (tem0, Qunbound))
4244 {
4245 CHECK_NUMBER (tem0);
4246 FRAME_LINES (f) = XINT (tem0);
4247 }
4248 if (!EQ (tem1, Qunbound))
4249 {
4250 CHECK_NUMBER (tem1);
4251 SET_FRAME_COLS (f, XINT (tem1));
4252 }
4253 if (!NILP (tem2) && !EQ (tem2, Qunbound))
4254 window_prompting |= USSize;
4255 else
4256 window_prompting |= PSize;
4257 }
4258
4259 f->scroll_bar_actual_width
4260 = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
4261
4262 4263 4264 4265
4266
4267 4268 4269 4270 4271 4272
4273 if (toolbar_p && FRAME_TOOL_BAR_LINES (f))
4274 {
4275 int margin, relief, bar_height;
4276
4277 relief = (tool_bar_button_relief >= 0
4278 ? tool_bar_button_relief
4279 : DEFAULT_TOOL_BAR_BUTTON_RELIEF);
4280
4281 if (INTEGERP (Vtool_bar_button_margin)
4282 && XINT (Vtool_bar_button_margin) > 0)
4283 margin = XFASTINT (Vtool_bar_button_margin);
4284 else if (CONSP (Vtool_bar_button_margin)
4285 && INTEGERP (XCDR (Vtool_bar_button_margin))
4286 && XINT (XCDR (Vtool_bar_button_margin)) > 0)
4287 margin = XFASTINT (XCDR (Vtool_bar_button_margin));
4288 else
4289 margin = 0;
4290
4291 bar_height = DEFAULT_TOOL_BAR_IMAGE_HEIGHT + 2 * margin + 2 * relief;
4292 FRAME_LINES (f) += (bar_height + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
4293 }
4294
4295 compute_fringe_widths (f, 0);
4296
4297 FRAME_PIXEL_WIDTH (f) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, FRAME_COLS (f));
4298 FRAME_PIXEL_HEIGHT (f) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, FRAME_LINES (f));
4299
4300 tem0 = x_get_arg (dpyinfo, parms, Qtop, 0, 0, RES_TYPE_NUMBER);
4301 tem1 = x_get_arg (dpyinfo, parms, Qleft, 0, 0, RES_TYPE_NUMBER);
4302 tem2 = x_get_arg (dpyinfo, parms, Quser_position, 0, 0, RES_TYPE_NUMBER);
4303 if (! EQ (tem0, Qunbound) || ! EQ (tem1, Qunbound))
4304 {
4305 if (EQ (tem0, Qminus))
4306 {
4307 f->top_pos = 0;
4308 window_prompting |= YNegative;
4309 }
4310 else if (CONSP (tem0) && EQ (XCAR (tem0), Qminus)
4311 && CONSP (XCDR (tem0))
4312 && INTEGERP (XCAR (XCDR (tem0))))
4313 {
4314 f->top_pos = - XINT (XCAR (XCDR (tem0)));
4315 window_prompting |= YNegative;
4316 }
4317 else if (CONSP (tem0) && EQ (XCAR (tem0), Qplus)
4318 && CONSP (XCDR (tem0))
4319 && INTEGERP (XCAR (XCDR (tem0))))
4320 {
4321 f->top_pos = XINT (XCAR (XCDR (tem0)));
4322 }
4323 else if (EQ (tem0, Qunbound))
4324 f->top_pos = 0;
4325 else
4326 {
4327 CHECK_NUMBER (tem0);
4328 f->top_pos = XINT (tem0);
4329 if (f->top_pos < 0)
4330 window_prompting |= YNegative;
4331 }
4332
4333 if (EQ (tem1, Qminus))
4334 {
4335 f->left_pos = 0;
4336 window_prompting |= XNegative;
4337 }
4338 else if (CONSP (tem1) && EQ (XCAR (tem1), Qminus)
4339 && CONSP (XCDR (tem1))
4340 && INTEGERP (XCAR (XCDR (tem1))))
4341 {
4342 f->left_pos = - XINT (XCAR (XCDR (tem1)));
4343 window_prompting |= XNegative;
4344 }
4345 else if (CONSP (tem1) && EQ (XCAR (tem1), Qplus)
4346 && CONSP (XCDR (tem1))
4347 && INTEGERP (XCAR (XCDR (tem1))))
4348 {
4349 f->left_pos = XINT (XCAR (XCDR (tem1)));
4350 }
4351 else if (EQ (tem1, Qunbound))
4352 f->left_pos = 0;
4353 else
4354 {
4355 CHECK_NUMBER (tem1);
4356 f->left_pos = XINT (tem1);
4357 if (f->left_pos < 0)
4358 window_prompting |= XNegative;
4359 }
4360
4361 if (!NILP (tem2) && ! EQ (tem2, Qunbound))
4362 window_prompting |= USPosition;
4363 else
4364 window_prompting |= PPosition;
4365 }
4366
4367 if (window_prompting & XNegative)
4368 {
4369 if (window_prompting & YNegative)
4370 f->win_gravity = SouthEastGravity;
4371 else
4372 f->win_gravity = NorthEastGravity;
4373 }
4374 else
4375 {
4376 if (window_prompting & YNegative)
4377 f->win_gravity = SouthWestGravity;
4378 else
4379 f->win_gravity = NorthWestGravity;
4380 }
4381
4382 f->size_hint_flags = window_prompting;
4383
4384 return window_prompting;
4385 }
4386
4387
4388
4389 #endif
4390
4391 void
4392 frame_make_pointer_invisible ()
4393 {
4394 if (! NILP (Vmake_pointer_invisible))
4395 {
4396 struct frame *f;
4397 if (!FRAMEP (selected_frame) || !FRAME_LIVE_P (XFRAME (selected_frame)))
4398 return;
4399
4400 f = SELECTED_FRAME ();
4401 if (f && !f->pointer_invisible
4402 && FRAME_TERMINAL (f)->toggle_invisible_pointer_hook)
4403 {
4404 f->mouse_moved = 0;
4405 FRAME_TERMINAL (f)->toggle_invisible_pointer_hook (f, 1);
4406 f->pointer_invisible = 1;
4407 }
4408 }
4409 }
4410
4411 void
4412 frame_make_pointer_visible ()
4413 {
4414 4415
4416 struct frame *f;
4417
4418 if (!FRAMEP (selected_frame) || !FRAME_LIVE_P (XFRAME (selected_frame)))
4419 return;
4420
4421 f = SELECTED_FRAME ();
4422 if (f && f->pointer_invisible && f->mouse_moved
4423 && FRAME_TERMINAL (f)->toggle_invisible_pointer_hook)
4424 {
4425 FRAME_TERMINAL (f)->toggle_invisible_pointer_hook (f, 0);
4426 f->pointer_invisible = 0;
4427 }
4428 }
4429
4430
4431
4432 4433 4434
4435
4436 void
4437 syms_of_frame ()
4438 {
4439 Qframep = intern_c_string ("framep");
4440 staticpro (&Qframep);
4441 Qframe_live_p = intern_c_string ("frame-live-p");
4442 staticpro (&Qframe_live_p);
4443 Qexplicit_name = intern_c_string ("explicit-name");
4444 staticpro (&Qexplicit_name);
4445 Qheight = intern_c_string ("height");
4446 staticpro (&Qheight);
4447 Qicon = intern_c_string ("icon");
4448 staticpro (&Qicon);
4449 Qminibuffer = intern_c_string ("minibuffer");
4450 staticpro (&Qminibuffer);
4451 Qmodeline = intern_c_string ("modeline");
4452 staticpro (&Qmodeline);
4453 Qonly = intern_c_string ("only");
4454 staticpro (&Qonly);
4455 Qwidth = intern_c_string ("width");
4456 staticpro (&Qwidth);
4457 Qgeometry = intern_c_string ("geometry");
4458 staticpro (&Qgeometry);
4459 Qicon_left = intern_c_string ("icon-left");
4460 staticpro (&Qicon_left);
4461 Qicon_top = intern_c_string ("icon-top");
4462 staticpro (&Qicon_top);
4463 Qleft = intern_c_string ("left");
4464 staticpro (&Qleft);
4465 Qright = intern_c_string ("right");
4466 staticpro (&Qright);
4467 Quser_position = intern_c_string ("user-position");
4468 staticpro (&Quser_position);
4469 Quser_size = intern_c_string ("user-size");
4470 staticpro (&Quser_size);
4471 Qwindow_id = intern_c_string ("window-id");
4472 staticpro (&Qwindow_id);
4473 #ifdef HAVE_X_WINDOWS
4474 Qouter_window_id = intern_c_string ("outer-window-id");
4475 staticpro (&Qouter_window_id);
4476 #endif
4477 Qparent_id = intern_c_string ("parent-id");
4478 staticpro (&Qparent_id);
4479 Qx = intern_c_string ("x");
4480 staticpro (&Qx);
4481 Qw32 = intern_c_string ("w32");
4482 staticpro (&Qw32);
4483 Qpc = intern_c_string ("pc");
4484 staticpro (&Qpc);
4485 Qmac = intern_c_string ("mac");
4486 staticpro (&Qmac);
4487 Qns = intern_c_string ("ns");
4488 staticpro (&Qns);
4489 Qvisible = intern_c_string ("visible");
4490 staticpro (&Qvisible);
4491 Qbuffer_predicate = intern_c_string ("buffer-predicate");
4492 staticpro (&Qbuffer_predicate);
4493 Qbuffer_list = intern_c_string ("buffer-list");
4494 staticpro (&Qbuffer_list);
4495 Qburied_buffer_list = intern_c_string ("buried-buffer-list");
4496 staticpro (&Qburied_buffer_list);
4497 Qdisplay_type = intern_c_string ("display-type");
4498 staticpro (&Qdisplay_type);
4499 Qbackground_mode = intern_c_string ("background-mode");
4500 staticpro (&Qbackground_mode);
4501 Qnoelisp = intern_c_string ("noelisp");
4502 staticpro (&Qnoelisp);
4503 Qtty_color_mode = intern_c_string ("tty-color-mode");
4504 staticpro (&Qtty_color_mode);
4505 Qtty = intern_c_string ("tty");
4506 staticpro (&Qtty);
4507 Qtty_type = intern_c_string ("tty-type");
4508 staticpro (&Qtty_type);
4509
4510 Qface_set_after_frame_default = intern_c_string ("face-set-after-frame-default");
4511 staticpro (&Qface_set_after_frame_default);
4512
4513 Qfullwidth = intern_c_string ("fullwidth");
4514 staticpro (&Qfullwidth);
4515 Qfullheight = intern_c_string ("fullheight");
4516 staticpro (&Qfullheight);
4517 Qfullboth = intern_c_string ("fullboth");
4518 staticpro (&Qfullboth);
4519 Qmaximized = intern_c_string ("maximized");
4520 staticpro (&Qmaximized);
4521 Qx_resource_name = intern_c_string ("x-resource-name");
4522 staticpro (&Qx_resource_name);
4523
4524 Qx_frame_parameter = intern_c_string ("x-frame-parameter");
4525 staticpro (&Qx_frame_parameter);
4526
4527 Qterminal = intern_c_string ("terminal");
4528 staticpro (&Qterminal);
4529 Qterminal_live_p = intern_c_string ("terminal-live-p");
4530 staticpro (&Qterminal_live_p);
4531
4532 #ifdef HAVE_NS
4533 Qns_parse_geometry = intern_c_string ("ns-parse-geometry");
4534 staticpro (&Qns_parse_geometry);
4535 #endif
4536
4537 {
4538 int i;
4539
4540 for (i = 0; i < sizeof (frame_parms) / sizeof (frame_parms[0]); i++)
4541 {
4542 Lisp_Object v = intern_c_string (frame_parms[i].name);
4543 if (frame_parms[i].variable)
4544 {
4545 *frame_parms[i].variable = v;
4546 staticpro (frame_parms[i].variable);
4547 }
4548 Fput (v, Qx_frame_parameter, make_number (i));
4549 }
4550 }
4551
4552 #ifdef HAVE_WINDOW_SYSTEM
4553 DEFVAR_LISP ("x-resource-name", &Vx_resource_name,
4554 doc: 4555 4556 4557 4558 4559 4560 4561 4562 );
4563 Vx_resource_name = Qnil;
4564
4565 DEFVAR_LISP ("x-resource-class", &Vx_resource_class,
4566 doc: 4567 4568 4569 4570 4571 4572 4573 4574 );
4575 Vx_resource_class = build_string (EMACS_CLASS);
4576
4577 DEFVAR_LISP ("frame-alpha-lower-limit", &Vframe_alpha_lower_limit,
4578 doc: 4579 4580 4581 );
4582 Vframe_alpha_lower_limit = make_number (20);
4583 #endif
4584
4585 DEFVAR_LISP ("default-frame-alist", &Vdefault_frame_alist,
4586 doc: 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 );
4598 Vdefault_frame_alist = Qnil;
4599
4600 DEFVAR_LISP ("default-frame-scroll-bars", &Vdefault_frame_scroll_bars,
4601 doc: );
4602 #ifdef HAVE_WINDOW_SYSTEM
4603 #if defined(HAVE_NTGUI) || defined(NS_IMPL_COCOA) || (defined(USE_GTK) && defined(USE_TOOLKIT_SCROLL_BARS))
4604 4605
4606 Vdefault_frame_scroll_bars = Qright;
4607 #else
4608 Vdefault_frame_scroll_bars = Qleft;
4609 #endif
4610 #else
4611 Vdefault_frame_scroll_bars = Qnil;
4612 #endif
4613
4614 DEFVAR_LISP ("terminal-frame", &Vterminal_frame,
4615 doc: );
4616
4617 DEFVAR_LISP ("mouse-position-function", &Vmouse_position_function,
4618 doc: 4619 4620 4621 4622 );
4623 Vmouse_position_function = Qnil;
4624
4625 DEFVAR_LISP ("mouse-highlight", &Vmouse_highlight,
4626 doc: 4627 4628 4629 4630 );
4631 Vmouse_highlight = Qt;
4632
4633 DEFVAR_LISP ("make-pointer-invisible", &Vmake_pointer_invisible,
4634 doc: 4635 );
4636 Vmake_pointer_invisible = Qt;
4637
4638 DEFVAR_LISP ("delete-frame-functions", &Vdelete_frame_functions,
4639 doc: 4640 4641 4642 4643 4644 4645 4646 );
4647 Vdelete_frame_functions = Qnil;
4648 Qdelete_frame_functions = intern_c_string ("delete-frame-functions");
4649 staticpro (&Qdelete_frame_functions);
4650
4651 DEFVAR_KBOARD ("default-minibuffer-frame", Vdefault_minibuffer_frame,
4652 doc: 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 );
4665
4666 DEFVAR_BOOL ("focus-follows-mouse", &focus_follows_mouse,
4667 doc: 4668 4669 4670 );
4671 #ifdef HAVE_WINDOW_SYSTEM
4672 #if defined(HAVE_NTGUI) || defined(HAVE_NS)
4673 focus_follows_mouse = 0;
4674 #else
4675 focus_follows_mouse = 1;
4676 #endif
4677 #else
4678 focus_follows_mouse = 0;
4679 #endif
4680
4681 staticpro (&Vframe_list);
4682
4683 defsubr (&Sactive_minibuffer_window);
4684 defsubr (&Sframep);
4685 defsubr (&Sframe_live_p);
4686 defsubr (&Swindow_system);
4687 defsubr (&Smake_terminal_frame);
4688 defsubr (&Shandle_switch_frame);
4689 defsubr (&Sselect_frame);
4690 defsubr (&Sselected_frame);
4691 defsubr (&Swindow_frame);
4692 defsubr (&Sframe_root_window);
4693 defsubr (&Sframe_first_window);
4694 defsubr (&Sframe_selected_window);
4695 defsubr (&Sset_frame_selected_window);
4696 defsubr (&Sframe_list);
4697 defsubr (&Snext_frame);
4698 defsubr (&Sprevious_frame);
4699 defsubr (&Sdelete_frame);
4700 defsubr (&Smouse_position);
4701 defsubr (&Smouse_pixel_position);
4702 defsubr (&Sset_mouse_position);
4703 defsubr (&Sset_mouse_pixel_position);
4704 #if 0
4705 defsubr (&Sframe_configuration);
4706 defsubr (&Srestore_frame_configuration);
4707 #endif
4708 defsubr (&Smake_frame_visible);
4709 defsubr (&Smake_frame_invisible);
4710 defsubr (&Siconify_frame);
4711 defsubr (&Sframe_visible_p);
4712 defsubr (&Svisible_frame_list);
4713 defsubr (&Sraise_frame);
4714 defsubr (&Slower_frame);
4715 defsubr (&Sredirect_frame_focus);
4716 defsubr (&Sframe_focus);
4717 defsubr (&Sframe_parameters);
4718 defsubr (&Sframe_parameter);
4719 defsubr (&Smodify_frame_parameters);
4720 defsubr (&Sframe_char_height);
4721 defsubr (&Sframe_char_width);
4722 defsubr (&Sframe_pixel_height);
4723 defsubr (&Sframe_pixel_width);
4724 defsubr (&Sset_frame_height);
4725 defsubr (&Sset_frame_width);
4726 defsubr (&Sset_frame_size);
4727 defsubr (&Sset_frame_position);
4728
4729 #ifdef HAVE_WINDOW_SYSTEM
4730 defsubr (&Sx_get_resource);
4731 defsubr (&Sx_parse_geometry);
4732 #endif
4733
4734 }
4735
4736 4737