1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <math.h>
24 #include <setjmp.h>
25 #include <ctype.h>
26
27 #ifdef HAVE_UNISTD_H
28 #include <unistd.h>
29 #endif
30
31
32
33 #define XLIB_ILLEGAL_ACCESS
34
35 #include "lisp.h"
36 #include "xterm.h"
37 #include "frame.h"
38 #include "window.h"
39 #include "buffer.h"
40 #include "intervals.h"
41 #include "dispextern.h"
42 #include "keyboard.h"
43 #include "blockinput.h"
44 #include <epaths.h>
45 #include "character.h"
46 #include "charset.h"
47 #include "coding.h"
48 #include "fontset.h"
49 #include "systime.h"
50 #include "termhooks.h"
51 #include "atimer.h"
52 #include "termchar.h"
53 #include "font.h"
54
55 #ifdef HAVE_X_WINDOWS
56
57 #include <ctype.h>
58 #include <sys/types.h>
59 #include <sys/stat.h>
60
61 #if 1
62 #include "bitmaps/gray.xbm"
63 #else
64 #include <X11/bitmaps/gray>
65 #endif
66
67 #include "xsettings.h"
68
69 #ifdef USE_GTK
70 #include "gtkutil.h"
71 #endif
72
73 #ifdef USE_X_TOOLKIT
74 #include <X11/Shell.h>
75
76 #ifndef USE_MOTIF
77 #ifdef HAVE_XAW3D
78 #include <X11/Xaw3d/Paned.h>
79 #include <X11/Xaw3d/Label.h>
80 #else
81 #include <X11/Xaw/Paned.h>
82 #include <X11/Xaw/Label.h>
83 #endif
84 #endif
85
86 #ifdef USG
87 #undef USG
88 #include <X11/Xos.h>
89 #define USG
90 #else
91 #include <X11/Xos.h>
92 #endif
93
94 #include "widget.h"
95
96 #include "../lwlib/lwlib.h"
97
98 #ifdef USE_MOTIF
99 #include <Xm/Xm.h>
100 #include <Xm/DialogS.h>
101 #include <Xm/FileSB.h>
102 #endif
103
104 #if !defined(NO_EDITRES)
105 #define HACK_EDITRES
106 extern void _XEditResCheckMessages ();
107 #endif
108
109
110
111 extern LWLIB_ID widget_id_tick;
112
113 extern void free_frame_menubar ();
114 extern double atof ();
115
116 #ifdef USE_MOTIF
117
118
119
120 static Lisp_Object Vmotif_version_string;
121
122 #endif
123
124 #endif
125
126 #ifdef USE_GTK
127
128
129
130 static Lisp_Object Vgtk_version_string;
131
132 #endif
133
134 #define MAXREQUEST(dpy) (XMaxRequestSize (dpy))
135
136 137 138
139
140 int gray_bitmap_width = gray_width;
141 int gray_bitmap_height = gray_height;
142 char *gray_bitmap_bits = gray_bits;
143
144
145
146 int x_gtk_use_old_file_dialog;
147
148
149
150 int x_gtk_show_hidden_files;
151
152
153
154 int x_gtk_file_dialog_help_text;
155
156
157
158 int x_gtk_whole_detached_tool_bar;
159
160 161
162
163 Lisp_Object Vx_pointer_shape, Vx_nontext_pointer_shape, Vx_mode_pointer_shape;
164 Lisp_Object Vx_hourglass_pointer_shape;
165
166
167
168 Lisp_Object Vx_sensitive_text_pointer_shape;
169
170 171
172
173 Lisp_Object Vx_window_horizontal_drag_shape;
174
175
176
177 Lisp_Object Vx_cursor_fore_pixel;
178
179
180
181 static int x_in_use;
182
183
184
185 Lisp_Object Vx_no_window_manager;
186
187
188
189 Lisp_Object Vx_pixel_size_width_font_regexp;
190
191 Lisp_Object Qnone;
192 Lisp_Object Qsuppress_icon;
193 Lisp_Object Qundefined_color;
194 Lisp_Object Qcompound_text, Qcancel_timer;
195 Lisp_Object Qfont_param;
196
197
198
199 extern Lisp_Object Vwindow_system_version;
200
201
202
203 extern Lisp_Object Vsystem_name;
204
205
206
207 #if GLYPH_DEBUG
208 int image_cache_refcount, dpyinfo_refcount;
209 #endif
210
211 #if defined (USE_GTK) && defined (HAVE_FREETYPE)
212 char *x_last_font_name;
213 #endif
214
215
216
217
218 void
219 check_x ()
220 {
221 if (! x_in_use)
222 error ("X windows are not in use or not initialized");
223 }
224
225 226
227
228 int
229 have_menus_p ()
230 {
231 return x_in_use;
232 }
233
234 235
236
237 FRAME_PTR
238 check_x_frame (frame)
239 Lisp_Object frame;
240 {
241 FRAME_PTR f;
242
243 if (NILP (frame))
244 frame = selected_frame;
245 CHECK_LIVE_FRAME (frame);
246 f = XFRAME (frame);
247 if (! FRAME_X_P (f))
248 error ("Non-X frame used");
249 return f;
250 }
251
252 253 254 255
256
257 struct x_display_info *
258 check_x_display_info (object)
259 Lisp_Object object;
260 {
261 struct x_display_info *dpyinfo = NULL;
262
263 if (NILP (object))
264 {
265 struct frame *sf = XFRAME (selected_frame);
266
267 if (FRAME_X_P (sf) && FRAME_LIVE_P (sf))
268 dpyinfo = FRAME_X_DISPLAY_INFO (sf);
269 else if (x_display_list != 0)
270 dpyinfo = x_display_list;
271 else
272 error ("X windows are not in use or not initialized");
273 }
274 else if (TERMINALP (object))
275 {
276 struct terminal *t = get_terminal (object, 1);
277
278 if (t->type != output_x_window)
279 error ("Terminal %d is not an X display", XINT (object));
280
281 dpyinfo = t->display_info.x;
282 }
283 else if (STRINGP (object))
284 dpyinfo = x_display_info_for_name (object);
285 else
286 {
287 FRAME_PTR f = check_x_frame (object);
288 dpyinfo = FRAME_X_DISPLAY_INFO (f);
289 }
290
291 return dpyinfo;
292 }
293
294
295 296
297
298
299
300 struct frame *
301 x_window_to_frame (dpyinfo, wdesc)
302 struct x_display_info *dpyinfo;
303 int wdesc;
304 {
305 Lisp_Object tail, frame;
306 struct frame *f;
307
308 if (wdesc == None) return 0;
309
310 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
311 {
312 frame = XCAR (tail);
313 if (!FRAMEP (frame))
314 continue;
315 f = XFRAME (frame);
316 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
317 continue;
318 if (f->output_data.x->hourglass_window == wdesc)
319 return f;
320 #ifdef USE_X_TOOLKIT
321 if ((f->output_data.x->edit_widget
322 && XtWindow (f->output_data.x->edit_widget) == wdesc)
323
324 || (!f->output_data.x->edit_widget
325 && FRAME_X_WINDOW (f) == wdesc)
326 || f->output_data.x->icon_desc == wdesc)
327 return f;
328 #else
329 #ifdef USE_GTK
330 if (f->output_data.x->edit_widget)
331 {
332 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
333 struct x_output *x = f->output_data.x;
334 if (gwdesc != 0 && gwdesc == x->edit_widget)
335 return f;
336 }
337 #endif
338 if (FRAME_X_WINDOW (f) == wdesc
339 || f->output_data.x->icon_desc == wdesc)
340 return f;
341 #endif
342 }
343 return 0;
344 }
345
346 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
347 348
349
350 struct frame *
351 x_any_window_to_frame (dpyinfo, wdesc)
352 struct x_display_info *dpyinfo;
353 int wdesc;
354 {
355 Lisp_Object tail, frame;
356 struct frame *f, *found;
357 struct x_output *x;
358
359 if (wdesc == None) return NULL;
360
361 found = NULL;
362 for (tail = Vframe_list; CONSP (tail) && !found; tail = XCDR (tail))
363 {
364 frame = XCAR (tail);
365 if (!FRAMEP (frame))
366 continue;
367
368 f = XFRAME (frame);
369 if (FRAME_X_P (f) && FRAME_X_DISPLAY_INFO (f) == dpyinfo)
370 {
371
372 x = f->output_data.x;
373 if (x->hourglass_window == wdesc)
374 found = f;
375 else if (x->widget)
376 {
377 #ifdef USE_GTK
378 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
379 if (gwdesc != 0
380 && gtk_widget_get_toplevel (gwdesc) == x->widget)
381 found = f;
382 #else
383 if (wdesc == XtWindow (x->widget)
384 || wdesc == XtWindow (x->column_widget)
385 || wdesc == XtWindow (x->edit_widget))
386 found = f;
387
388 else if (lw_window_is_in_menubar (wdesc, x->menubar_widget))
389 found = f;
390 #endif
391 }
392 else if (FRAME_X_WINDOW (f) == wdesc)
393
394 found = f;
395 }
396 }
397
398 return found;
399 }
400
401
402
403 struct frame *
404 x_menubar_window_to_frame (dpyinfo, wdesc)
405 struct x_display_info *dpyinfo;
406 int wdesc;
407 {
408 Lisp_Object tail, frame;
409 struct frame *f;
410 struct x_output *x;
411
412 if (wdesc == None) return 0;
413
414 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
415 {
416 frame = XCAR (tail);
417 if (!FRAMEP (frame))
418 continue;
419 f = XFRAME (frame);
420 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
421 continue;
422 x = f->output_data.x;
423
424 #ifdef USE_GTK
425 if (x->menubar_widget)
426 {
427 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
428
429 430
431 if (gwdesc != 0
432 && (gwdesc == x->menubar_widget
433 || gtk_widget_is_ancestor (x->menubar_widget, gwdesc)
434 || gtk_widget_is_ancestor (gwdesc, x->menubar_widget)))
435 return f;
436 }
437 #else
438 if (x->menubar_widget
439 && lw_window_is_in_menubar (wdesc, x->menubar_widget))
440 return f;
441 #endif
442 }
443 return 0;
444 }
445
446 447
448
449 struct frame *
450 x_top_window_to_frame (dpyinfo, wdesc)
451 struct x_display_info *dpyinfo;
452 int wdesc;
453 {
454 Lisp_Object tail, frame;
455 struct frame *f;
456 struct x_output *x;
457
458 if (wdesc == None) return 0;
459
460 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
461 {
462 frame = XCAR (tail);
463 if (!FRAMEP (frame))
464 continue;
465 f = XFRAME (frame);
466 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
467 continue;
468 x = f->output_data.x;
469
470 if (x->widget)
471 {
472
473 #ifdef USE_GTK
474 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
475 if (gwdesc == x->widget)
476 return f;
477 #else
478 if (wdesc == XtWindow (x->widget))
479 return f;
480 #if 0 481 482
483
484 if (x->menubar_widget
485 && wdesc == XtWindow (x->menubar_widget))
486 return f;
487 #endif
488 #endif
489 }
490 else if (FRAME_X_WINDOW (f) == wdesc)
491
492 return f;
493 }
494 return 0;
495 }
496 #endif
497
498
499
500 static void x_default_font_parameter P_ ((struct frame *, Lisp_Object));
501
502 static Lisp_Object unwind_create_frame P_ ((Lisp_Object));
503 static Lisp_Object unwind_create_tip_frame P_ ((Lisp_Object));
504
505 void x_set_foreground_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
506 static void x_set_wait_for_wm P_ ((struct frame *, Lisp_Object, Lisp_Object));
507 void x_set_background_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
508 void x_set_mouse_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
509 void x_set_cursor_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
510 void x_set_border_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
511 void x_set_cursor_type P_ ((struct frame *, Lisp_Object, Lisp_Object));
512 void x_set_icon_type P_ ((struct frame *, Lisp_Object, Lisp_Object));
513 void x_set_icon_name P_ ((struct frame *, Lisp_Object, Lisp_Object));
514 void x_explicitly_set_name P_ ((struct frame *, Lisp_Object, Lisp_Object));
515 void x_set_menu_bar_lines P_ ((struct frame *, Lisp_Object, Lisp_Object));
516 void x_set_title P_ ((struct frame *, Lisp_Object, Lisp_Object));
517 void x_set_tool_bar_lines P_ ((struct frame *, Lisp_Object, Lisp_Object));
518 void x_set_scroll_bar_foreground P_ ((struct frame *, Lisp_Object,
519 Lisp_Object));
520 void x_set_scroll_bar_background P_ ((struct frame *, Lisp_Object,
521 Lisp_Object));
522 static Lisp_Object x_default_scroll_bar_color_parameter P_ ((struct frame *,
523 Lisp_Object,
524 Lisp_Object,
525 char *, char *,
526 int));
527
528
529 530 531
532
533 void
534 x_real_positions (f, xptr, yptr)
535 FRAME_PTR f;
536 int *xptr, *yptr;
537 {
538 int win_x, win_y, outer_x, outer_y;
539 int real_x = 0, real_y = 0;
540 int had_errors = 0;
541 Window win = f->output_data.x->parent_desc;
542
543 BLOCK_INPUT;
544
545 x_catch_errors (FRAME_X_DISPLAY (f));
546
547 if (win == FRAME_X_DISPLAY_INFO (f)->root_window)
548 win = FRAME_OUTER_WINDOW (f);
549
550 551 552 553
554 for (;;)
555 {
556 Window wm_window, rootw;
557 Window *tmp_children;
558 unsigned int tmp_nchildren;
559 int success;
560
561 success = XQueryTree (FRAME_X_DISPLAY (f), win, &rootw,
562 &wm_window, &tmp_children, &tmp_nchildren);
563
564 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
565
566
567 if (! success)
568 break;
569
570 XFree ((char *) tmp_children);
571
572 if (wm_window == rootw || had_errors)
573 break;
574
575 win = wm_window;
576 }
577
578 if (! had_errors)
579 {
580 unsigned int ign;
581 Window child, rootw;
582
583
584 XGetGeometry (FRAME_X_DISPLAY (f), win,
585 &rootw, &real_x, &real_y, &ign, &ign, &ign, &ign);
586
587 588 589 590 591 592 593 594 595 596
597 XTranslateCoordinates (FRAME_X_DISPLAY (f),
598
599
600 FRAME_X_DISPLAY_INFO (f)->root_window,
601 FRAME_X_WINDOW (f),
602
603
604 real_x, real_y, &win_x, &win_y,
605
606
607 &child);
608
609 if (FRAME_X_WINDOW (f) == FRAME_OUTER_WINDOW (f))
610 {
611 outer_x = win_x;
612 outer_y = win_y;
613 }
614 else
615 {
616 XTranslateCoordinates (FRAME_X_DISPLAY (f),
617
618
619 FRAME_X_DISPLAY_INFO (f)->root_window,
620 FRAME_OUTER_WINDOW (f),
621
622
623 real_x, real_y, &outer_x, &outer_y,
624
625
626 &child);
627 }
628
629 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
630 }
631
632 x_uncatch_errors ();
633
634 UNBLOCK_INPUT;
635
636 if (had_errors) return;
637
638 f->x_pixels_diff = -win_x;
639 f->y_pixels_diff = -win_y;
640
641 FRAME_X_OUTPUT (f)->x_pixels_outer_diff = -outer_x;
642 FRAME_X_OUTPUT (f)->y_pixels_outer_diff = -outer_y;
643
644 *xptr = real_x;
645 *yptr = real_y;
646 }
647
648
649
650
651
652
653 void
654 gamma_correct (f, color)
655 struct frame *f;
656 XColor *color;
657 {
658 if (f->gamma)
659 {
660 color->red = pow (color->red / 65535.0, f->gamma) * 65535.0 + 0.5;
661 color->green = pow (color->green / 65535.0, f->gamma) * 65535.0 + 0.5;
662 color->blue = pow (color->blue / 65535.0, f->gamma) * 65535.0 + 0.5;
663 }
664 }
665
666
667 668 669 670
671
672 int
673 x_defined_color (f, color_name, color, alloc_p)
674 struct frame *f;
675 char *color_name;
676 XColor *color;
677 int alloc_p;
678 {
679 int success_p;
680 Display *dpy = FRAME_X_DISPLAY (f);
681 Colormap cmap = FRAME_X_COLORMAP (f);
682
683 BLOCK_INPUT;
684 success_p = XParseColor (dpy, cmap, color_name, color);
685 if (success_p && alloc_p)
686 success_p = x_alloc_nearest_color (f, cmap, color);
687 UNBLOCK_INPUT;
688
689 return success_p;
690 }
691
692
693 694 695
696
697 int
698 x_decode_color (f, color_name, mono_color)
699 FRAME_PTR f;
700 Lisp_Object color_name;
701 int mono_color;
702 {
703 XColor cdef;
704
705 CHECK_STRING (color_name);
706
707 #if 0 708 709
710 if (strcmp (SDATA (color_name), "black") == 0)
711 return BLACK_PIX_DEFAULT (f);
712 else if (strcmp (SDATA (color_name), "white") == 0)
713 return WHITE_PIX_DEFAULT (f);
714 #endif
715
716
717 if (FRAME_X_DISPLAY_INFO (f)->n_planes == 1)
718 return mono_color;
719
720 721
722 if (x_defined_color (f, SDATA (color_name), &cdef, 1))
723 return cdef.pixel;
724
725 signal_error ("Undefined color", color_name);
726 }
727
728
729
730 731 732
733
734 static void
735 x_set_wait_for_wm (f, new_value, old_value)
736 struct frame *f;
737 Lisp_Object new_value, old_value;
738 {
739 f->output_data.x->wait_for_wm = !NILP (new_value);
740 }
741
742 #ifdef USE_GTK
743
744 745
746
747 int
748 xg_set_icon (f, file)
749 FRAME_PTR f;
750 Lisp_Object file;
751 {
752 int result = 0;
753 Lisp_Object found;
754
755 found = x_find_image_file (file);
756
757 if (! NILP (found))
758 {
759 GdkPixbuf *pixbuf;
760 GError *err = NULL;
761 char *filename = (char *) SDATA (found);
762 BLOCK_INPUT;
763
764 pixbuf = gdk_pixbuf_new_from_file (filename, &err);
765
766 if (pixbuf)
767 {
768 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
769 pixbuf);
770 g_object_unref (pixbuf);
771
772 result = 1;
773 }
774 else
775 g_error_free (err);
776
777 UNBLOCK_INPUT;
778 }
779
780 return result;
781 }
782
783 int
784 xg_set_icon_from_xpm_data (f, data)
785 FRAME_PTR f;
786 char **data;
787 {
788 int result = 0;
789 GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) data);
790
791 if (!pixbuf)
792 return 0;
793
794 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)), pixbuf);
795 g_object_unref (pixbuf);
796 return 1;
797 }
798 #endif
799
800
801 802 803 804 805 806 807
808
809 void
810 x_set_foreground_color (f, arg, oldval)
811 struct frame *f;
812 Lisp_Object arg, oldval;
813 {
814 struct x_output *x = f->output_data.x;
815 unsigned long fg, old_fg;
816
817 fg = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
818 old_fg = FRAME_FOREGROUND_PIXEL (f);
819 FRAME_FOREGROUND_PIXEL (f) = fg;
820
821 if (FRAME_X_WINDOW (f) != 0)
822 {
823 Display *dpy = FRAME_X_DISPLAY (f);
824
825 BLOCK_INPUT;
826 XSetForeground (dpy, x->normal_gc, fg);
827 XSetBackground (dpy, x->reverse_gc, fg);
828
829 if (x->cursor_pixel == old_fg)
830 {
831 unload_color (f, x->cursor_pixel);
832 x->cursor_pixel = x_copy_color (f, fg);
833 XSetBackground (dpy, x->cursor_gc, x->cursor_pixel);
834 }
835
836 UNBLOCK_INPUT;
837
838 update_face_from_frame_parameter (f, Qforeground_color, arg);
839
840 if (FRAME_VISIBLE_P (f))
841 redraw_frame (f);
842 }
843
844 unload_color (f, old_fg);
845 }
846
847 void
848 x_set_background_color (f, arg, oldval)
849 struct frame *f;
850 Lisp_Object arg, oldval;
851 {
852 struct x_output *x = f->output_data.x;
853 unsigned long bg;
854
855 bg = x_decode_color (f, arg, WHITE_PIX_DEFAULT (f));
856 unload_color (f, FRAME_BACKGROUND_PIXEL (f));
857 FRAME_BACKGROUND_PIXEL (f) = bg;
858
859 if (FRAME_X_WINDOW (f) != 0)
860 {
861 Display *dpy = FRAME_X_DISPLAY (f);
862
863 BLOCK_INPUT;
864 XSetBackground (dpy, x->normal_gc, bg);
865 XSetForeground (dpy, x->reverse_gc, bg);
866 XSetWindowBackground (dpy, FRAME_X_WINDOW (f), bg);
867 XSetForeground (dpy, x->cursor_gc, bg);
868
869 #ifdef USE_GTK
870 xg_set_background_color (f, bg);
871 #endif
872
873 #ifndef USE_TOOLKIT_SCROLL_BARS 874
875 {
876 Lisp_Object bar;
877 for (bar = FRAME_SCROLL_BARS (f);
878 !NILP (bar);
879 bar = XSCROLL_BAR (bar)->next)
880 {
881 Window window = XSCROLL_BAR (bar)->x_window;
882 XSetWindowBackground (dpy, window, bg);
883 }
884 }
885 #endif
886
887 UNBLOCK_INPUT;
888 update_face_from_frame_parameter (f, Qbackground_color, arg);
889
890 if (FRAME_VISIBLE_P (f))
891 redraw_frame (f);
892 }
893 }
894
895 static Cursor
896 make_invisible_cursor (f)
897 struct frame *f;
898 {
899 Display *dpy = FRAME_X_DISPLAY (f);
900 static char const no_data[] = { 0 };
901 Pixmap pix;
902 XColor col;
903 Cursor c;
904
905 x_catch_errors (dpy);
906 pix = XCreateBitmapFromData (dpy, FRAME_X_DISPLAY_INFO (f)->root_window,
907 no_data, 1, 1);
908 if (! x_had_errors_p (dpy) && pix != None)
909 {
910 col.pixel = 0;
911 col.red = col.green = col.blue = 0;
912 col.flags = DoRed | DoGreen | DoBlue;
913 c = XCreatePixmapCursor (dpy, pix, pix, &col, &col, 0, 0);
914 if (x_had_errors_p (dpy) || c == None)
915 c = 0;
916 XFreePixmap (dpy, pix);
917 }
918
919 x_uncatch_errors ();
920
921 return c;
922 }
923
924 void
925 x_set_mouse_color (f, arg, oldval)
926 struct frame *f;
927 Lisp_Object arg, oldval;
928 {
929 struct x_output *x = f->output_data.x;
930 Display *dpy = FRAME_X_DISPLAY (f);
931 Cursor cursor, nontext_cursor, mode_cursor, hand_cursor;
932 Cursor hourglass_cursor, horizontal_drag_cursor;
933 unsigned long pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
934 unsigned long mask_color = FRAME_BACKGROUND_PIXEL (f);
935
936
937 if (mask_color == pixel)
938 {
939 x_free_colors (f, &pixel, 1);
940 pixel = x_copy_color (f, FRAME_FOREGROUND_PIXEL (f));
941 }
942
943 unload_color (f, x->mouse_pixel);
944 x->mouse_pixel = pixel;
945
946 BLOCK_INPUT;
947
948
949 x_catch_errors (dpy);
950
951 if (!NILP (Vx_pointer_shape))
952 {
953 CHECK_NUMBER (Vx_pointer_shape);
954 cursor = XCreateFontCursor (dpy, XINT (Vx_pointer_shape));
955 }
956 else
957 cursor = XCreateFontCursor (dpy, XC_xterm);
958 x_check_errors (dpy, "bad text pointer cursor: %s");
959
960 if (!NILP (Vx_nontext_pointer_shape))
961 {
962 CHECK_NUMBER (Vx_nontext_pointer_shape);
963 nontext_cursor
964 = XCreateFontCursor (dpy, XINT (Vx_nontext_pointer_shape));
965 }
966 else
967 nontext_cursor = XCreateFontCursor (dpy, XC_left_ptr);
968 x_check_errors (dpy, "bad nontext pointer cursor: %s");
969
970 if (!NILP (Vx_hourglass_pointer_shape))
971 {
972 CHECK_NUMBER (Vx_hourglass_pointer_shape);
973 hourglass_cursor
974 = XCreateFontCursor (dpy, XINT (Vx_hourglass_pointer_shape));
975 }
976 else
977 hourglass_cursor = XCreateFontCursor (dpy, XC_watch);
978 x_check_errors (dpy, "bad hourglass pointer cursor: %s");
979
980 if (!NILP (Vx_mode_pointer_shape))
981 {
982 CHECK_NUMBER (Vx_mode_pointer_shape);
983 mode_cursor = XCreateFontCursor (dpy, XINT (Vx_mode_pointer_shape));
984 }
985 else
986 mode_cursor = XCreateFontCursor (dpy, XC_xterm);
987 x_check_errors (dpy, "bad modeline pointer cursor: %s");
988
989 if (!NILP (Vx_sensitive_text_pointer_shape))
990 {
991 CHECK_NUMBER (Vx_sensitive_text_pointer_shape);
992 hand_cursor
993 = XCreateFontCursor (dpy, XINT (Vx_sensitive_text_pointer_shape));
994 }
995 else
996 hand_cursor = XCreateFontCursor (dpy, XC_hand2);
997
998 if (!NILP (Vx_window_horizontal_drag_shape))
999 {
1000 CHECK_NUMBER (Vx_window_horizontal_drag_shape);
1001 horizontal_drag_cursor
1002 = XCreateFontCursor (dpy, XINT (Vx_window_horizontal_drag_shape));
1003 }
1004 else
1005 horizontal_drag_cursor
1006 = XCreateFontCursor (dpy, XC_sb_h_double_arrow);
1007
1008
1009 x_check_errors (dpy, "can't set cursor shape: %s");
1010 x_uncatch_errors ();
1011
1012 {
1013 XColor fore_color, back_color;
1014
1015 fore_color.pixel = x->mouse_pixel;
1016 x_query_color (f, &fore_color);
1017 back_color.pixel = mask_color;
1018 x_query_color (f, &back_color);
1019
1020 XRecolorCursor (dpy, cursor, &fore_color, &back_color);
1021 XRecolorCursor (dpy, nontext_cursor, &fore_color, &back_color);
1022 XRecolorCursor (dpy, mode_cursor, &fore_color, &back_color);
1023 XRecolorCursor (dpy, hand_cursor, &fore_color, &back_color);
1024 XRecolorCursor (dpy, hourglass_cursor, &fore_color, &back_color);
1025 XRecolorCursor (dpy, horizontal_drag_cursor, &fore_color, &back_color);
1026 }
1027
1028 if (FRAME_X_WINDOW (f) != 0)
1029 XDefineCursor (dpy, FRAME_X_WINDOW (f),
1030 f->output_data.x->current_cursor = cursor);
1031
1032 if (FRAME_X_DISPLAY_INFO (f)->invisible_cursor == 0)
1033 FRAME_X_DISPLAY_INFO (f)->invisible_cursor = make_invisible_cursor (f);
1034
1035 if (cursor != x->text_cursor
1036 && x->text_cursor != 0)
1037 XFreeCursor (dpy, x->text_cursor);
1038 x->text_cursor = cursor;
1039
1040 if (nontext_cursor != x->nontext_cursor
1041 && x->nontext_cursor != 0)
1042 XFreeCursor (dpy, x->nontext_cursor);
1043 x->nontext_cursor = nontext_cursor;
1044
1045 if (hourglass_cursor != x->hourglass_cursor
1046 && x->hourglass_cursor != 0)
1047 XFreeCursor (dpy, x->hourglass_cursor);
1048 x->hourglass_cursor = hourglass_cursor;
1049
1050 if (mode_cursor != x->modeline_cursor
1051 && x->modeline_cursor != 0)
1052 XFreeCursor (dpy, f->output_data.x->modeline_cursor);
1053 x->modeline_cursor = mode_cursor;
1054
1055 if (hand_cursor != x->hand_cursor
1056 && x->hand_cursor != 0)
1057 XFreeCursor (dpy, x->hand_cursor);
1058 x->hand_cursor = hand_cursor;
1059
1060 if (horizontal_drag_cursor != x->horizontal_drag_cursor
1061 && x->horizontal_drag_cursor != 0)
1062 XFreeCursor (dpy, x->horizontal_drag_cursor);
1063 x->horizontal_drag_cursor = horizontal_drag_cursor;
1064
1065 XFlush (dpy);
1066 UNBLOCK_INPUT;
1067
1068 update_face_from_frame_parameter (f, Qmouse_color, arg);
1069 }
1070
1071 void
1072 x_set_cursor_color (f, arg, oldval)
1073 struct frame *f;
1074 Lisp_Object arg, oldval;
1075 {
1076 unsigned long fore_pixel, pixel;
1077 int fore_pixel_allocated_p = 0, pixel_allocated_p = 0;
1078 struct x_output *x = f->output_data.x;
1079
1080 if (!NILP (Vx_cursor_fore_pixel))
1081 {
1082 fore_pixel = x_decode_color (f, Vx_cursor_fore_pixel,
1083 WHITE_PIX_DEFAULT (f));
1084 fore_pixel_allocated_p = 1;
1085 }
1086 else
1087 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
1088
1089 pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1090 pixel_allocated_p = 1;
1091
1092
1093 if (pixel == FRAME_BACKGROUND_PIXEL (f))
1094 {
1095 if (pixel_allocated_p)
1096 {
1097 x_free_colors (f, &pixel, 1);
1098 pixel_allocated_p = 0;
1099 }
1100
1101 pixel = x->mouse_pixel;
1102 if (pixel == fore_pixel)
1103 {
1104 if (fore_pixel_allocated_p)
1105 {
1106 x_free_colors (f, &fore_pixel, 1);
1107 fore_pixel_allocated_p = 0;
1108 }
1109 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
1110 }
1111 }
1112
1113 unload_color (f, x->cursor_foreground_pixel);
1114 if (!fore_pixel_allocated_p)
1115 fore_pixel = x_copy_color (f, fore_pixel);
1116 x->cursor_foreground_pixel = fore_pixel;
1117
1118 unload_color (f, x->cursor_pixel);
1119 if (!pixel_allocated_p)
1120 pixel = x_copy_color (f, pixel);
1121 x->cursor_pixel = pixel;
1122
1123 if (FRAME_X_WINDOW (f) != 0)
1124 {
1125 BLOCK_INPUT;
1126 XSetBackground (FRAME_X_DISPLAY (f), x->cursor_gc, x->cursor_pixel);
1127 XSetForeground (FRAME_X_DISPLAY (f), x->cursor_gc, fore_pixel);
1128 UNBLOCK_INPUT;
1129
1130 if (FRAME_VISIBLE_P (f))
1131 {
1132 x_update_cursor (f, 0);
1133 x_update_cursor (f, 1);
1134 }
1135 }
1136
1137 update_face_from_frame_parameter (f, Qcursor_color, arg);
1138 }
1139
1140 1141 1142
1143
1144 void
1145 x_set_border_pixel (f, pix)
1146 struct frame *f;
1147 int pix;
1148 {
1149 unload_color (f, f->output_data.x->border_pixel);
1150 f->output_data.x->border_pixel = pix;
1151
1152 if (FRAME_X_WINDOW (f) != 0 && f->border_width > 0)
1153 {
1154 BLOCK_INPUT;
1155 XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1156 (unsigned long)pix);
1157 UNBLOCK_INPUT;
1158
1159 if (FRAME_VISIBLE_P (f))
1160 redraw_frame (f);
1161 }
1162 }
1163
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
1174
1175 void
1176 x_set_border_color (f, arg, oldval)
1177 struct frame *f;
1178 Lisp_Object arg, oldval;
1179 {
1180 int pix;
1181
1182 CHECK_STRING (arg);
1183 pix = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1184 x_set_border_pixel (f, pix);
1185 update_face_from_frame_parameter (f, Qborder_color, arg);
1186 }
1187
1188
1189 void
1190 x_set_cursor_type (f, arg, oldval)
1191 FRAME_PTR f;
1192 Lisp_Object arg, oldval;
1193 {
1194 set_frame_cursor_types (f, arg);
1195
1196
1197 cursor_type_changed = 1;
1198 }
1199
1200 void
1201 x_set_icon_type (f, arg, oldval)
1202 struct frame *f;
1203 Lisp_Object arg, oldval;
1204 {
1205 int result;
1206
1207 if (STRINGP (arg))
1208 {
1209 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1210 return;
1211 }
1212 else if (!STRINGP (oldval) && EQ (oldval, Qnil) == EQ (arg, Qnil))
1213 return;
1214
1215 BLOCK_INPUT;
1216 if (NILP (arg))
1217 result = x_text_icon (f,
1218 (char *) SDATA ((!NILP (f->icon_name)
1219 ? f->icon_name
1220 : f->name)));
1221 else
1222 result = x_bitmap_icon (f, arg);
1223
1224 if (result)
1225 {
1226 UNBLOCK_INPUT;
1227 error ("No icon window available");
1228 }
1229
1230 XFlush (FRAME_X_DISPLAY (f));
1231 UNBLOCK_INPUT;
1232 }
1233
1234 void
1235 x_set_icon_name (f, arg, oldval)
1236 struct frame *f;
1237 Lisp_Object arg, oldval;
1238 {
1239 int result;
1240
1241 if (STRINGP (arg))
1242 {
1243 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1244 return;
1245 }
1246 else if (!NILP (arg) || NILP (oldval))
1247 return;
1248
1249 f->icon_name = arg;
1250
1251 if (f->output_data.x->icon_bitmap != 0)
1252 return;
1253
1254 BLOCK_INPUT;
1255
1256 result = x_text_icon (f,
1257 (char *) SDATA ((!NILP (f->icon_name)
1258 ? f->icon_name
1259 : !NILP (f->title)
1260 ? f->title
1261 : f->name)));
1262
1263 if (result)
1264 {
1265 UNBLOCK_INPUT;
1266 error ("No icon window available");
1267 }
1268
1269 XFlush (FRAME_X_DISPLAY (f));
1270 UNBLOCK_INPUT;
1271 }
1272
1273
1274 void
1275 x_set_menu_bar_lines (f, value, oldval)
1276 struct frame *f;
1277 Lisp_Object value, oldval;
1278 {
1279 int nlines;
1280 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1281 int olines = FRAME_MENU_BAR_LINES (f);
1282 #endif
1283
1284 1285 1286 1287
1288 if (FRAME_MINIBUF_ONLY_P (f))
1289 return;
1290
1291 if (INTEGERP (value))
1292 nlines = XINT (value);
1293 else
1294 nlines = 0;
1295
1296
1297 windows_or_buffers_changed++;
1298
1299 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1300 FRAME_MENU_BAR_LINES (f) = 0;
1301 if (nlines)
1302 {
1303 FRAME_EXTERNAL_MENU_BAR (f) = 1;
1304 if (FRAME_X_P (f) && f->output_data.x->menubar_widget == 0)
1305
1306 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
1307 }
1308 else
1309 {
1310 if (FRAME_EXTERNAL_MENU_BAR (f) == 1)
1311 free_frame_menubar (f);
1312 FRAME_EXTERNAL_MENU_BAR (f) = 0;
1313 if (FRAME_X_P (f))
1314 f->output_data.x->menubar_widget = 0;
1315 }
1316 #else
1317 FRAME_MENU_BAR_LINES (f) = nlines;
1318 change_window_heights (f->root_window, nlines - olines);
1319
1320 1321 1322 1323
1324 if (nlines != olines)
1325 {
1326 int height = FRAME_INTERNAL_BORDER_WIDTH (f);
1327 int width = FRAME_PIXEL_WIDTH (f);
1328 int y;
1329
1330
1331 if (height > 0 && width > 0)
1332 {
1333 y = FRAME_TOP_MARGIN_HEIGHT (f);
1334
1335 BLOCK_INPUT;
1336 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1337 0, y, width, height, False);
1338 UNBLOCK_INPUT;
1339 }
1340
1341 if (nlines > 1 && nlines > olines)
1342 {
1343 y = (olines == 0 ? 1 : olines) * FRAME_LINE_HEIGHT (f);
1344 height = nlines * FRAME_LINE_HEIGHT (f) - y;
1345
1346 BLOCK_INPUT;
1347 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1348 0, y, width, height, False);
1349 UNBLOCK_INPUT;
1350 }
1351
1352 if (nlines == 0 && WINDOWP (f->menu_bar_window))
1353 clear_glyph_matrix (XWINDOW (f->menu_bar_window)->current_matrix);
1354 }
1355 #endif
1356 adjust_glyphs (f);
1357 }
1358
1359
1360 1361 1362 1363 1364
1365
1366 void
1367 x_set_tool_bar_lines (f, value, oldval)
1368 struct frame *f;
1369 Lisp_Object value, oldval;
1370 {
1371 int delta, nlines, root_height;
1372 Lisp_Object root_window;
1373
1374
1375 if (FRAME_MINIBUF_ONLY_P (f))
1376 return;
1377
1378
1379 if (INTEGERP (value) && XINT (value) >= 0)
1380 nlines = XFASTINT (value);
1381 else
1382 nlines = 0;
1383
1384 #ifdef USE_GTK
1385 FRAME_TOOL_BAR_LINES (f) = 0;
1386 if (nlines)
1387 {
1388 FRAME_EXTERNAL_TOOL_BAR (f) = 1;
1389 if (FRAME_X_P (f) && f->output_data.x->toolbar_widget == 0)
1390
1391 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
1392 update_frame_tool_bar (f);
1393 }
1394 else
1395 {
1396 if (FRAME_EXTERNAL_TOOL_BAR (f))
1397 free_frame_tool_bar (f);
1398 FRAME_EXTERNAL_TOOL_BAR (f) = 0;
1399 }
1400
1401 return;
1402 #endif
1403
1404
1405 ++windows_or_buffers_changed;
1406
1407 delta = nlines - FRAME_TOOL_BAR_LINES (f);
1408
1409
1410 root_window = FRAME_ROOT_WINDOW (f);
1411 root_height = WINDOW_TOTAL_LINES (XWINDOW (root_window));
1412 if (root_height - delta < 1)
1413 {
1414 delta = root_height - 1;
1415 nlines = FRAME_TOOL_BAR_LINES (f) + delta;
1416 }
1417
1418 FRAME_TOOL_BAR_LINES (f) = nlines;
1419 change_window_heights (root_window, delta);
1420 adjust_glyphs (f);
1421
1422 1423 1424 1425 1426 1427
1428 if (FRAME_X_WINDOW (f) && FRAME_TOOL_BAR_LINES (f) == 0)
1429 {
1430 clear_frame (f);
1431 clear_current_matrices (f);
1432 }
1433
1434 1435 1436
1437 if (delta < 0)
1438 {
1439 int height = FRAME_INTERNAL_BORDER_WIDTH (f);
1440 int width = FRAME_PIXEL_WIDTH (f);
1441 int y = (FRAME_MENU_BAR_LINES (f) + nlines) * FRAME_LINE_HEIGHT (f);
1442
1443
1444 if (height > 0 && width > 0)
1445 {
1446 BLOCK_INPUT;
1447 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1448 0, y, width, height, False);
1449 UNBLOCK_INPUT;
1450 }
1451
1452 if (WINDOWP (f->tool_bar_window))
1453 clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
1454 }
1455 }
1456
1457
1458 1459 1460 1461
1462
1463 void
1464 x_set_scroll_bar_foreground (f, value, oldval)
1465 struct frame *f;
1466 Lisp_Object value, oldval;
1467 {
1468 unsigned long pixel;
1469
1470 if (STRINGP (value))
1471 pixel = x_decode_color (f, value, BLACK_PIX_DEFAULT (f));
1472 else
1473 pixel = -1;
1474
1475 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
1476 unload_color (f, f->output_data.x->scroll_bar_foreground_pixel);
1477
1478 f->output_data.x->scroll_bar_foreground_pixel = pixel;
1479 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1480 {
1481
1482 if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
1483 (*FRAME_TERMINAL (f)->condemn_scroll_bars_hook) (f);
1484 if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
1485 (*FRAME_TERMINAL (f)->judge_scroll_bars_hook) (f);
1486
1487 update_face_from_frame_parameter (f, Qscroll_bar_foreground, value);
1488 redraw_frame (f);
1489 }
1490 }
1491
1492
1493 1494 1495 1496
1497
1498 void
1499 x_set_scroll_bar_background (f, value, oldval)
1500 struct frame *f;
1501 Lisp_Object value, oldval;
1502 {
1503 unsigned long pixel;
1504
1505 if (STRINGP (value))
1506 pixel = x_decode_color (f, value, WHITE_PIX_DEFAULT (f));
1507 else
1508 pixel = -1;
1509
1510 if (f->output_data.x->scroll_bar_background_pixel != -1)
1511 unload_color (f, f->output_data.x->scroll_bar_background_pixel);
1512
1513 #ifdef USE_TOOLKIT_SCROLL_BARS
1514
1515 if (f->output_data.x->scroll_bar_top_shadow_pixel != -1)
1516 {
1517 unload_color (f, f->output_data.x->scroll_bar_top_shadow_pixel);
1518 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
1519 }
1520 if (f->output_data.x->scroll_bar_bottom_shadow_pixel != -1)
1521 {
1522 unload_color (f, f->output_data.x->scroll_bar_bottom_shadow_pixel);
1523 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
1524 }
1525 #endif
1526
1527 f->output_data.x->scroll_bar_background_pixel = pixel;
1528 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1529 {
1530
1531 if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
1532 (*FRAME_TERMINAL (f)->condemn_scroll_bars_hook) (f);
1533 if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
1534 (*FRAME_TERMINAL (f)->judge_scroll_bars_hook) (f);
1535
1536 update_face_from_frame_parameter (f, Qscroll_bar_background, value);
1537 redraw_frame (f);
1538 }
1539 }
1540
1541
1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561
1562
1563 static unsigned char *
1564 x_encode_text (string, coding_system, selectionp, text_bytes, stringp, freep)
1565 Lisp_Object string, coding_system;
1566 int *text_bytes, *stringp;
1567 int selectionp;
1568 int *freep;
1569 {
1570 int result = string_xstring_p (string);
1571 struct coding_system coding;
1572
1573 if (result == 0)
1574 {
1575
1576 *text_bytes = SBYTES (string);
1577 *stringp = 1;
1578 *freep = 0;
1579 return SDATA (string);
1580 }
1581
1582 setup_coding_system (coding_system, &coding);
1583 coding.mode |= (CODING_MODE_SAFE_ENCODING | CODING_MODE_LAST_BLOCK);
1584
1585 coding.common_flags &= ~CODING_ANNOTATION_MASK;
1586 coding.dst_bytes = SCHARS (string) * 2;
1587 coding.destination = (unsigned char *) xmalloc (coding.dst_bytes);
1588 encode_coding_object (&coding, string, 0, 0,
1589 SCHARS (string), SBYTES (string), Qnil);
1590 *text_bytes = coding.produced;
1591 *stringp = (result == 1 || !EQ (coding_system, Qcompound_text));
1592 *freep = 1;
1593 return coding.destination;
1594 }
1595
1596
1597 1598 1599
1600
1601 static void
1602 x_set_name_internal (f, name)
1603 FRAME_PTR f;
1604 Lisp_Object name;
1605 {
1606 if (FRAME_X_WINDOW (f))
1607 {
1608 BLOCK_INPUT;
1609 {
1610 XTextProperty text, icon;
1611 int bytes, stringp;
1612 int do_free_icon_value = 0, do_free_text_value = 0;
1613 Lisp_Object coding_system;
1614 #ifdef USE_GTK
1615 Lisp_Object encoded_name;
1616 struct gcpro gcpro1;
1617
1618 1619
1620 GCPRO1 (name);
1621 encoded_name = ENCODE_UTF_8 (name);
1622 UNGCPRO;
1623 #endif
1624
1625 coding_system = Qcompound_text;
1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
1640 text.value = x_encode_text (name, coding_system, 0, &bytes, &stringp,
1641 &do_free_text_value);
1642 text.encoding = (stringp ? XA_STRING
1643 : FRAME_X_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1644 text.format = 8;
1645 text.nitems = bytes;
1646
1647 if (!STRINGP (f->icon_name))
1648 {
1649 icon = text;
1650 }
1651 else
1652 {
1653
1654 icon.value = x_encode_text (f->icon_name, coding_system, 0,
1655 &bytes, &stringp, &do_free_icon_value);
1656 icon.encoding = (stringp ? XA_STRING
1657 : FRAME_X_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1658 icon.format = 8;
1659 icon.nitems = bytes;
1660 }
1661
1662 #ifdef USE_GTK
1663 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
1664 (char *) SDATA (encoded_name));
1665 #else
1666 XSetWMName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &text);
1667 #endif
1668
1669 XSetWMIconName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &icon);
1670
1671 if (do_free_icon_value)
1672 xfree (icon.value);
1673 if (do_free_text_value)
1674 xfree (text.value);
1675 }
1676 UNBLOCK_INPUT;
1677 }
1678 }
1679
1680 1681 1682 1683 1684 1685 1686 1687 1688 1689
1690
1691 void
1692 x_set_name (f, name, explicit)
1693 struct frame *f;
1694 Lisp_Object name;
1695 int explicit;
1696 {
1697 1698
1699 if (explicit)
1700 {
1701 1702
1703 if (f->explicit_name && NILP (name))
1704 update_mode_lines = 1;
1705
1706 f->explicit_name = ! NILP (name);
1707 }
1708 else if (f->explicit_name)
1709 return;
1710
1711
1712 if (NILP (name))
1713 {
1714 1715
1716 if (!strcmp (FRAME_X_DISPLAY_INFO (f)->x_id_name,
1717 SDATA (f->name)))
1718 return;
1719 name = build_string (FRAME_X_DISPLAY_INFO (f)->x_id_name);
1720 }
1721 else
1722 CHECK_STRING (name);
1723
1724
1725 if (! NILP (Fstring_equal (name, f->name)))
1726 return;
1727
1728 f->name = name;
1729
1730 1731
1732 if (! NILP (f->title))
1733 name = f->title;
1734
1735 x_set_name_internal (f, name);
1736 }
1737
1738 1739 1740
1741 void
1742 x_explicitly_set_name (f, arg, oldval)
1743 FRAME_PTR f;
1744 Lisp_Object arg, oldval;
1745 {
1746 x_set_name (f, arg, 1);
1747 }
1748
1749 1750 1751
1752 void
1753 x_implicitly_set_name (f, arg, oldval)
1754 FRAME_PTR f;
1755 Lisp_Object arg, oldval;
1756 {
1757 x_set_name (f, arg, 0);
1758 }
1759
1760 1761
1762
1763 void
1764 x_set_title (f, name, old_name)
1765 struct frame *f;
1766 Lisp_Object name, old_name;
1767 {
1768
1769 if (EQ (name, f->title))
1770 return;
1771
1772 update_mode_lines = 1;
1773
1774 f->title = name;
1775
1776 if (NILP (name))
1777 name = f->name;
1778 else
1779 CHECK_STRING (name);
1780
1781 x_set_name_internal (f, name);
1782 }
1783
1784 void
1785 x_set_scroll_bar_default_width (f)
1786 struct frame *f;
1787 {
1788 int wid = FRAME_COLUMN_WIDTH (f);
1789
1790 #ifdef USE_TOOLKIT_SCROLL_BARS
1791
1792 int width = 16 + 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM;
1793 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (width + wid - 1) / wid;
1794 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = width;
1795 #else
1796 1797
1798 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
1799
1800 1801
1802 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = 0;
1803 #endif
1804 }
1805
1806
1807 1808 1809 1810
1811
1812 static Lisp_Object
1813 x_default_scroll_bar_color_parameter (f, alist, prop, xprop, xclass,
1814 foreground_p)
1815 struct frame *f;
1816 Lisp_Object alist;
1817 Lisp_Object prop;
1818 char *xprop;
1819 char *xclass;
1820 int foreground_p;
1821 {
1822 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
1823 Lisp_Object tem;
1824
1825 tem = x_get_arg (dpyinfo, alist, prop, xprop, xclass, RES_TYPE_STRING);
1826 if (EQ (tem, Qunbound))
1827 {
1828 #ifdef USE_TOOLKIT_SCROLL_BARS
1829
1830 1831
1832 tem = display_x_get_resource (dpyinfo,
1833 build_string (foreground_p
1834 ? "foreground"
1835 : "background"),
1836 empty_unibyte_string,
1837 build_string ("verticalScrollBar"),
1838 empty_unibyte_string);
1839 if (!STRINGP (tem))
1840 {
1841 1842 1843 1844 1845
1846 tem = Qnil;
1847 }
1848
1849 #else
1850
1851 tem = Qnil;
1852
1853 #endif
1854 }
1855
1856 x_set_frame_parameters (f, Fcons (Fcons (prop, tem), Qnil));
1857 return tem;
1858 }
1859
1860
1861
1862
1863 #ifdef USE_X_TOOLKIT
1864
1865 1866 1867 1868
1869
1870 static void
1871 hack_wm_protocols (f, widget)
1872 FRAME_PTR f;
1873 Widget widget;
1874 {
1875 Display *dpy = XtDisplay (widget);
1876 Window w = XtWindow (widget);
1877 int need_delete = 1;
1878 int need_focus = 1;
1879 int need_save = 1;
1880
1881 BLOCK_INPUT;
1882 {
1883 Atom type;
1884 unsigned char *catoms;
1885 int format = 0;
1886 unsigned long nitems = 0;
1887 unsigned long bytes_after;
1888
1889 if ((XGetWindowProperty (dpy, w,
1890 FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
1891 (long)0, (long)100, False, XA_ATOM,
1892 &type, &format, &nitems, &bytes_after,
1893 &catoms)
1894 == Success)
1895 && format == 32 && type == XA_ATOM)
1896 {
1897 Atom *atoms = (Atom *) catoms;
1898 while (nitems > 0)
1899 {
1900 nitems--;
1901 if (atoms[nitems]
1902 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window)
1903 need_delete = 0;
1904 else if (atoms[nitems]
1905 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_take_focus)
1906 need_focus = 0;
1907 else if (atoms[nitems]
1908 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself)
1909 need_save = 0;
1910 }
1911 }
1912 if (catoms)
1913 XFree (catoms);
1914 }
1915 {
1916 Atom props [10];
1917 int count = 0;
1918 if (need_delete)
1919 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window;
1920 if (need_focus)
1921 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_take_focus;
1922 if (need_save)
1923 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
1924 if (count)
1925 XChangeProperty (dpy, w, FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
1926 XA_ATOM, 32, PropModeAppend,
1927 (unsigned char *) props, count);
1928 }
1929 UNBLOCK_INPUT;
1930 }
1931 #endif
1932
1933
1934
1935
1936
1937 #ifdef HAVE_X_I18N
1938
1939 static XFontSet xic_create_xfontset P_ ((struct frame *));
1940 static XIMStyle best_xim_style P_ ((XIMStyles *, XIMStyles *));
1941
1942
1943
1944
1945 static XIMStyle supported_xim_styles[] =
1946 {
1947 XIMPreeditPosition | XIMStatusArea,
1948 XIMPreeditPosition | XIMStatusNothing,
1949 XIMPreeditPosition | XIMStatusNone,
1950 XIMPreeditNothing | XIMStatusArea,
1951 XIMPreeditNothing | XIMStatusNothing,
1952 XIMPreeditNothing | XIMStatusNone,
1953 XIMPreeditNone | XIMStatusArea,
1954 XIMPreeditNone | XIMStatusNothing,
1955 XIMPreeditNone | XIMStatusNone,
1956 0,
1957 };
1958
1959
1960
1961
1962 char xic_defaut_fontset[] = "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
1963
1964 1965
1966 char *
1967 xic_create_fontsetname (base_fontname, motif)
1968 char *base_fontname;
1969 Bool motif;
1970 {
1971 const char *sep = motif ? ";" : ",";
1972 char *fontsetname;
1973
1974
1975 if (xic_defaut_fontset == base_fontname)
1976 {
1977 int len = strlen (base_fontname) + 2;
1978 fontsetname = xmalloc (len);
1979 bzero (fontsetname, len);
1980 strcpy (fontsetname, base_fontname);
1981 }
1982 else
1983 {
1984 1985 1986 1987 1988
1989 char *p = base_fontname;
1990 int i;
1991
1992 for (i = 0; *p; p++)
1993 if (*p == '-') i++;
1994 if (i != 14)
1995 { 1996 1997
1998 int len = strlen (base_fontname) + strlen (xic_defaut_fontset) + 3;
1999 fontsetname = xmalloc (len);
2000 bzero (fontsetname, len);
2001 strcpy (fontsetname, base_fontname);
2002 strcat (fontsetname, sep);
2003 strcat (fontsetname, xic_defaut_fontset);
2004 }
2005 else
2006 {
2007 int len;
2008 char *p1 = NULL, *p2 = NULL, *p3 = NULL;
2009 char *font_allcs = NULL;
2010 char *font_allfamilies = NULL;
2011 char *font_all = NULL;
2012 char *allcs = "*-*-*-*-*-*-*";
2013 char *allfamilies = "-*-*-";
2014 char *all = "*-*-*-*-";
2015 char *base;
2016
2017 for (i = 0, p = base_fontname; i < 8; p++)
2018 {
2019 if (*p == '-')
2020 {
2021 i++;
2022 if (i == 3)
2023 p1 = p + 1;
2024 else if (i == 7)
2025 p2 = p + 1;
2026 else if (i == 6)
2027 p3 = p + 1;
2028 }
2029 }
2030 2031
2032 if (*p3 != '*')
2033 {
2034 int diff = (p2 - p3) - 2;
2035
2036 base = alloca (strlen (base_fontname) + 1);
2037 bcopy (base_fontname, base, p3 - base_fontname);
2038 base[p3 - base_fontname] = '*';
2039 base[(p3 - base_fontname) + 1] = '-';
2040 strcpy (base + (p3 - base_fontname) + 2, p2);
2041 p = base + (p - base_fontname) - diff;
2042 p1 = base + (p1 - base_fontname);
2043 p2 = base + (p2 - base_fontname) - diff;
2044 base_fontname = base;
2045 }
2046
2047
2048 len = p - base_fontname + strlen (allcs) + 1;
2049 font_allcs = (char *) alloca (len);
2050 bzero (font_allcs, len);
2051 bcopy (base_fontname, font_allcs, p - base_fontname);
2052 strcat (font_allcs, allcs);
2053
2054 2055
2056 len = p - p1 + strlen (allcs) + strlen (allfamilies) + 1;
2057 font_allfamilies = (char *) alloca (len);
2058 bzero (font_allfamilies, len);
2059 strcpy (font_allfamilies, allfamilies);
2060 bcopy (p1, font_allfamilies + strlen (allfamilies), p - p1);
2061 strcat (font_allfamilies, allcs);
2062
2063
2064 len = p - p2 + strlen (allcs) + strlen (all) + strlen (allfamilies) + 1;
2065 font_all = (char *) alloca (len);
2066 bzero (font_all, len);
2067 strcpy (font_all, allfamilies);
2068 strcat (font_all, all);
2069 bcopy (p2, font_all + strlen (all) + strlen (allfamilies), p - p2);
2070 strcat (font_all, allcs);
2071
2072
2073 len = strlen (base_fontname) + strlen (font_allcs)
2074 + strlen (font_allfamilies) + strlen (font_all) + 5;
2075 fontsetname = xmalloc (len);
2076 bzero (fontsetname, len);
2077 strcpy (fontsetname, base_fontname);
2078 strcat (fontsetname, sep);
2079 strcat (fontsetname, font_allcs);
2080 strcat (fontsetname, sep);
2081 strcat (fontsetname, font_allfamilies);
2082 strcat (fontsetname, sep);
2083 strcat (fontsetname, font_all);
2084 }
2085 }
2086 if (motif)
2087 strcat (fontsetname, ":");
2088 return fontsetname;
2089 }
2090
2091 #ifdef DEBUG_XIC_FONTSET
2092 static void
2093 print_fontset_result (xfs, name, missing_list, missing_count)
2094 XFontSet xfs;
2095 char *name;
2096 char **missing_list;
2097 int missing_count;
2098 {
2099 if (xfs)
2100 fprintf (stderr, "XIC Fontset created: %s\n", name);
2101 else
2102 {
2103 fprintf (stderr, "XIC Fontset failed: %s\n", name);
2104 while (missing_count-- > 0)
2105 {
2106 fprintf (stderr, " missing: %s\n", *missing_list);
2107 missing_list++;
2108 }
2109 }
2110
2111 }
2112 #endif
2113
2114 static XFontSet
2115 xic_create_xfontset (f)
2116 struct frame *f;
2117 {
2118 XFontSet xfs = NULL;
2119 struct font *font = FRAME_FONT (f);
2120 int pixel_size = font->pixel_size;
2121 Lisp_Object rest, frame;
2122
2123
2124 FOR_EACH_FRAME (rest, frame)
2125 {
2126 struct frame *cf = XFRAME (frame);
2127
2128 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
2129 && FRAME_X_DISPLAY_INFO (cf) == FRAME_X_DISPLAY_INFO (f)
2130 && FRAME_FONT (f)
2131 && FRAME_FONT (f)->pixel_size == pixel_size)
2132 {
2133 xfs = FRAME_XIC_FONTSET (cf);
2134 break;
2135 }
2136 }
2137
2138 if (! xfs)
2139 {
2140 char buf[256];
2141 char **missing_list;
2142 int missing_count;
2143 char *def_string;
2144 char *xlfd_format = "-*-*-medium-r-normal--%d-*-*-*-*-*";
2145
2146 sprintf (buf, xlfd_format, pixel_size);
2147 missing_list = NULL;
2148 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), buf,
2149 &missing_list, &missing_count, &def_string);
2150 #ifdef DEBUG_XIC_FONTSET
2151 print_fontset_result (xfs, buf, missing_list, missing_count);
2152 #endif
2153 if (missing_list)
2154 XFreeStringList (missing_list);
2155 if (! xfs)
2156 {
2157 2158
2159 int sizes[] = {0, 8, 10, 11, 12, 14, 17, 18, 20, 24, 26, 34, 0};
2160 int *smaller, *larger;
2161
2162 for (smaller = sizes; smaller[1]; smaller++)
2163 if (smaller[1] >= pixel_size)
2164 break;
2165 larger = smaller + 1;
2166 if (*larger == pixel_size)
2167 larger++;
2168 while (*smaller || *larger)
2169 {
2170 int this_size;
2171
2172 if (! *larger)
2173 this_size = *smaller--;
2174 else if (! *smaller)
2175 this_size = *larger++;
2176 else if (pixel_size - *smaller < *larger - pixel_size)
2177 this_size = *smaller--;
2178 else
2179 this_size = *larger++;
2180 sprintf (buf, xlfd_format, this_size);
2181 missing_list = NULL;
2182 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), buf,
2183 &missing_list, &missing_count, &def_string);
2184 #ifdef DEBUG_XIC_FONTSET
2185 print_fontset_result (xfs, buf, missing_list, missing_count);
2186 #endif
2187 if (missing_list)
2188 XFreeStringList (missing_list);
2189 if (xfs)
2190 break;
2191 }
2192 }
2193 if (! xfs)
2194 {
2195 char *last_resort = "-*-*-*-r-normal--*-*-*-*-*-*";
2196
2197 missing_list = NULL;
2198 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), last_resort,
2199 &missing_list, &missing_count, &def_string);
2200 #ifdef DEBUG_XIC_FONTSET
2201 print_fontset_result (xfs, last_resort, missing_list, missing_count);
2202 #endif
2203 if (missing_list)
2204 XFreeStringList (missing_list);
2205 }
2206
2207 }
2208
2209 return xfs;
2210 }
2211
2212
2213
2214 void
2215 xic_free_xfontset (f)
2216 struct frame *f;
2217 {
2218 Lisp_Object rest, frame;
2219 int shared_p = 0;
2220
2221 if (!FRAME_XIC_FONTSET (f))
2222 return;
2223
2224
2225 FOR_EACH_FRAME (rest, frame)
2226 {
2227 struct frame *cf = XFRAME (frame);
2228 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
2229 && FRAME_X_DISPLAY_INFO (cf) == FRAME_X_DISPLAY_INFO (f)
2230 && FRAME_XIC_FONTSET (cf) == FRAME_XIC_FONTSET (f))
2231 {
2232 shared_p = 1;
2233 break;
2234 }
2235 }
2236
2237 if (!shared_p)
2238
2239 XFreeFontSet (FRAME_X_DISPLAY (f), FRAME_XIC_FONTSET (f));
2240
2241 if (FRAME_XIC_BASE_FONTNAME (f))
2242 xfree (FRAME_XIC_BASE_FONTNAME (f));
2243 FRAME_XIC_BASE_FONTNAME (f) = NULL;
2244 FRAME_XIC_FONTSET (f) = NULL;
2245 }
2246
2247
2248 2249 2250
2251
2252 static XIMStyle
2253 best_xim_style (user, xim)
2254 XIMStyles *user;
2255 XIMStyles *xim;
2256 {
2257 int i, j;
2258
2259 for (i = 0; i < user->count_styles; ++i)
2260 for (j = 0; j < xim->count_styles; ++j)
2261 if (user->supported_styles[i] == xim->supported_styles[j])
2262 return user->supported_styles[i];
2263
2264
2265 return XIMPreeditNothing | XIMStatusNothing;
2266 }
2267
2268
2269
2270 static XIMStyle xic_style;
2271
2272 void
2273 create_frame_xic (f)
2274 struct frame *f;
2275 {
2276 XIM xim;
2277 XIC xic = NULL;
2278 XFontSet xfs = NULL;
2279
2280 if (FRAME_XIC (f))
2281 return;
2282
2283
2284 xfs = xic_create_xfontset (f);
2285 xim = FRAME_X_XIM (f);
2286 if (xim)
2287 {
2288 XRectangle s_area;
2289 XPoint spot;
2290 XVaNestedList preedit_attr;
2291 XVaNestedList status_attr;
2292
2293 s_area.x = 0; s_area.y = 0; s_area.width = 1; s_area.height = 1;
2294 spot.x = 0; spot.y = 1;
2295
2296
2297 if (xic_style == 0)
2298 {
2299 XIMStyles supported_list;
2300 supported_list.count_styles = (sizeof supported_xim_styles
2301 / sizeof supported_xim_styles[0]);
2302 supported_list.supported_styles = supported_xim_styles;
2303 xic_style = best_xim_style (&supported_list,
2304 FRAME_X_XIM_STYLES (f));
2305 }
2306
2307 preedit_attr = XVaCreateNestedList (0,
2308 XNFontSet, xfs,
2309 XNForeground,
2310 FRAME_FOREGROUND_PIXEL (f),
2311 XNBackground,
2312 FRAME_BACKGROUND_PIXEL (f),
2313 (xic_style & XIMPreeditPosition
2314 ? XNSpotLocation
2315 : NULL),
2316 &spot,
2317 NULL);
2318 status_attr = XVaCreateNestedList (0,
2319 XNArea,
2320 &s_area,
2321 XNFontSet,
2322 xfs,
2323 XNForeground,
2324 FRAME_FOREGROUND_PIXEL (f),
2325 XNBackground,
2326 FRAME_BACKGROUND_PIXEL (f),
2327 NULL);
2328
2329 xic = XCreateIC (xim,
2330 XNInputStyle, xic_style,
2331 XNClientWindow, FRAME_X_WINDOW (f),
2332 XNFocusWindow, FRAME_X_WINDOW (f),
2333 XNStatusAttributes, status_attr,
2334 XNPreeditAttributes, preedit_attr,
2335 NULL);
2336 XFree (preedit_attr);
2337 XFree (status_attr);
2338 }
2339
2340 FRAME_XIC (f) = xic;
2341 FRAME_XIC_STYLE (f) = xic_style;
2342 FRAME_XIC_FONTSET (f) = xfs;
2343 }
2344
2345
2346
2347
2348 void
2349 free_frame_xic (f)
2350 struct frame *f;
2351 {
2352 if (FRAME_XIC (f) == NULL)
2353 return;
2354
2355 XDestroyIC (FRAME_XIC (f));
2356 xic_free_xfontset (f);
2357
2358 FRAME_XIC (f) = NULL;
2359 }
2360
2361
2362 2363
2364
2365 void
2366 xic_set_preeditarea (w, x, y)
2367 struct window *w;
2368 int x, y;
2369 {
2370 struct frame *f = XFRAME (w->frame);
2371 XVaNestedList attr;
2372 XPoint spot;
2373
2374 spot.x = WINDOW_TO_FRAME_PIXEL_X (w, x) + WINDOW_LEFT_FRINGE_WIDTH (w);
2375 spot.y = WINDOW_TO_FRAME_PIXEL_Y (w, y) + FONT_BASE (FRAME_FONT (f));
2376 attr = XVaCreateNestedList (0, XNSpotLocation, &spot, NULL);
2377 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2378 XFree (attr);
2379 }
2380
2381
2382
2383
2384 void
2385 xic_set_statusarea (f)
2386 struct frame *f;
2387 {
2388 XIC xic = FRAME_XIC (f);
2389 XVaNestedList attr;
2390 XRectangle area;
2391 XRectangle *needed;
2392
2393 2394
2395 area.x = area.y = area.width = area.height = 0;
2396 attr = XVaCreateNestedList (0, XNAreaNeeded, &area, NULL);
2397 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2398 XFree (attr);
2399
2400 attr = XVaCreateNestedList (0, XNAreaNeeded, &needed, NULL);
2401 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2402 XFree (attr);
2403
2404 if (needed->width == 0)
2405 {
2406 attr = XVaCreateNestedList (0, XNArea, &needed, NULL);
2407 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2408 XFree (attr);
2409 }
2410
2411 area.width = needed->width;
2412 area.height = needed->height;
2413 area.x = FRAME_PIXEL_WIDTH (f) - area.width - FRAME_INTERNAL_BORDER_WIDTH (f);
2414 area.y = (FRAME_PIXEL_HEIGHT (f) - area.height
2415 - FRAME_MENUBAR_HEIGHT (f)
2416 - FRAME_TOOLBAR_HEIGHT (f)
2417 - FRAME_INTERNAL_BORDER_WIDTH (f));
2418 XFree (needed);
2419
2420 attr = XVaCreateNestedList (0, XNArea, &area, NULL);
2421 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2422 XFree (attr);
2423 }
2424
2425
2426 2427
2428
2429 void
2430 xic_set_xfontset (f, base_fontname)
2431 struct frame *f;
2432 char *base_fontname;
2433 {
2434 XVaNestedList attr;
2435 XFontSet xfs;
2436
2437 xic_free_xfontset (f);
2438
2439 xfs = xic_create_xfontset (f);
2440
2441 attr = XVaCreateNestedList (0, XNFontSet, xfs, NULL);
2442 if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
2443 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2444 if (FRAME_XIC_STYLE (f) & XIMStatusArea)
2445 XSetICValues (FRAME_XIC (f), XNStatusAttributes, attr, NULL);
2446 XFree (attr);
2447
2448 FRAME_XIC_FONTSET (f) = xfs;
2449 }
2450
2451 #endif
2452
2453
2454
2455 #ifdef USE_X_TOOLKIT
2456
2457
2458
2459 static void
2460 x_window (f, window_prompting, minibuffer_only)
2461 struct frame *f;
2462 long window_prompting;
2463 int minibuffer_only;
2464 {
2465 XClassHint class_hints;
2466 XSetWindowAttributes attributes;
2467 unsigned long attribute_mask;
2468 Widget shell_widget;
2469 Widget pane_widget;
2470 Widget frame_widget;
2471 Arg al [25];
2472 int ac;
2473
2474 BLOCK_INPUT;
2475
2476 2477 2478 2479 2480
2481
2482 {
2483 char *str = (char *) SDATA (Vx_resource_name);
2484 f->namebuf = (char *) xmalloc (strlen (str) + 1);
2485 strcpy (f->namebuf, str);
2486 }
2487
2488 ac = 0;
2489 XtSetArg (al[ac], XtNallowShellResize, 1); ac++;
2490 XtSetArg (al[ac], XtNinput, 1); ac++;
2491 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2492 XtSetArg (al[ac], XtNborderWidth, f->border_width); ac++;
2493 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2494 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2495 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2496 shell_widget = XtAppCreateShell (f->namebuf, EMACS_CLASS,
2497 applicationShellWidgetClass,
2498 FRAME_X_DISPLAY (f), al, ac);
2499
2500 f->output_data.x->widget = shell_widget;
2501
2502
2503 pane_widget = lw_create_widget ("main", "pane", widget_id_tick++,
2504 (widget_value *) NULL,
2505 shell_widget, False,
2506 (lw_callback) NULL,
2507 (lw_callback) NULL,
2508 (lw_callback) NULL,
2509 (lw_callback) NULL);
2510
2511 ac = 0;
2512 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2513 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2514 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2515 XtSetValues (pane_widget, al, ac);
2516 f->output_data.x->column_widget = pane_widget;
2517
2518 2519
2520
2521 ac = 0;
2522 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2523 XtSetArg (al[ac], XtNshowGrip, 0); ac++;
2524 XtSetArg (al[ac], XtNallowResize, 1); ac++;
2525 XtSetArg (al[ac], XtNresizeToPreferred, 1); ac++;
2526 XtSetArg (al[ac], XtNemacsFrame, f); ac++;
2527 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2528 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2529 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2530 frame_widget = XtCreateWidget (f->namebuf, emacsFrameClass, pane_widget,
2531 al, ac);
2532
2533 f->output_data.x->edit_widget = frame_widget;
2534
2535 XtManageChild (frame_widget);
2536
2537
2538 {
2539 int len;
2540 char *tem, shell_position[32];
2541 Arg al[10];
2542 int ac = 0;
2543 int extra_borders = 0;
2544 int menubar_size
2545 = (f->output_data.x->menubar_widget
2546 ? (f->output_data.x->menubar_widget->core.height
2547 + f->output_data.x->menubar_widget->core.border_width)
2548 : 0);
2549
2550 #if 0 2551
2552 if (FRAME_EXTERNAL_MENU_BAR (f))
2553 {
2554 Dimension ibw = 0;
2555 XtVaGetValues (pane_widget, XtNinternalBorderWidth, &ibw, NULL);
2556 menubar_size += ibw;
2557 }
2558 #endif
2559
2560 f->output_data.x->menubar_height = menubar_size;
2561
2562 #ifndef USE_LUCID
2563 2564 2565
2566 XtVaGetValues (f->output_data.x->edit_widget, XtNinternalBorderWidth,
2567 &extra_borders, NULL);
2568 extra_borders *= 2;
2569 #endif
2570
2571 2572 2573 2574 2575
2576 {
2577 int left = f->left_pos;
2578 int xneg = window_prompting & XNegative;
2579 int top = f->top_pos;
2580 int yneg = window_prompting & YNegative;
2581 if (xneg)
2582 left = -left;
2583 if (yneg)
2584 top = -top;
2585
2586 if (window_prompting & USPosition)
2587 sprintf (shell_position, "=%dx%d%c%d%c%d",
2588 FRAME_PIXEL_WIDTH (f) + extra_borders,
2589 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders,
2590 (xneg ? '-' : '+'), left,
2591 (yneg ? '-' : '+'), top);
2592 else
2593 {
2594 sprintf (shell_position, "=%dx%d",
2595 FRAME_PIXEL_WIDTH (f) + extra_borders,
2596 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders);
2597
2598 2599 2600 2601 2602
2603 XtSetArg (al[ac], XtNx, left); ac++;
2604 XtSetArg (al[ac], XtNy, top); ac++;
2605 }
2606 }
2607
2608 len = strlen (shell_position) + 1;
2609 2610 2611 2612
2613 tem = (char *) xmalloc (len);
2614 strncpy (tem, shell_position, len);
2615 XtSetArg (al[ac], XtNgeometry, tem); ac++;
2616 XtSetValues (shell_widget, al, ac);
2617 }
2618
2619 XtManageChild (pane_widget);
2620 XtRealizeWidget (shell_widget);
2621
2622 if (FRAME_X_EMBEDDED_P (f))
2623 XReparentWindow (FRAME_X_DISPLAY (f), XtWindow (shell_widget),
2624 f->output_data.x->parent_desc, 0, 0);
2625
2626 FRAME_X_WINDOW (f) = XtWindow (frame_widget);
2627
2628 validate_x_resource_name ();
2629
2630 class_hints.res_name = (char *) SDATA (Vx_resource_name);
2631 class_hints.res_class = (char *) SDATA (Vx_resource_class);
2632 XSetClassHint (FRAME_X_DISPLAY (f), XtWindow (shell_widget), &class_hints);
2633
2634 #ifdef HAVE_X_I18N
2635 FRAME_XIC (f) = NULL;
2636 if (use_xim)
2637 create_frame_xic (f);
2638 #endif
2639
2640 f->output_data.x->wm_hints.input = True;
2641 f->output_data.x->wm_hints.flags |= InputHint;
2642 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2643 &f->output_data.x->wm_hints);
2644
2645 hack_wm_protocols (f, shell_widget);
2646
2647 #ifdef HACK_EDITRES
2648 XtAddEventHandler (shell_widget, 0, True, _XEditResCheckMessages, 0);
2649 #endif
2650
2651 2652 2653 2654
2655 XChangeProperty (XtDisplay (frame_widget), XtWindow (frame_widget),
2656 FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
2657 XA_ATOM, 32, PropModeAppend,
2658 (unsigned char*) NULL, 0);
2659
2660
2661 attributes.event_mask = STANDARD_EVENT_SET;
2662
2663 #ifdef HAVE_X_I18N
2664 if (FRAME_XIC (f))
2665 {
2666
2667 unsigned long fevent = NoEventMask;
2668 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2669 attributes.event_mask |= fevent;
2670 }
2671 #endif
2672
2673 attribute_mask = CWEventMask;
2674 XChangeWindowAttributes (XtDisplay (shell_widget), XtWindow (shell_widget),
2675 attribute_mask, &attributes);
2676
2677 XtMapWidget (frame_widget);
2678
2679 2680 2681 2682
2683 {
2684 Lisp_Object name;
2685 int explicit = f->explicit_name;
2686
2687 f->explicit_name = 0;
2688 name = f->name;
2689 f->name = Qnil;
2690 x_set_name (f, name, explicit);
2691 }
2692
2693 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2694 f->output_data.x->current_cursor
2695 = f->output_data.x->text_cursor);
2696
2697 UNBLOCK_INPUT;
2698
2699 2700
2701 lw_set_main_areas (pane_widget, 0, frame_widget);
2702 }
2703
2704 #else
2705 #ifdef USE_GTK
2706 void
2707 x_window (f)
2708 FRAME_PTR f;
2709 {
2710 if (! xg_create_frame_widgets (f))
2711 error ("Unable to create window");
2712
2713 #ifdef HAVE_X_I18N
2714 FRAME_XIC (f) = NULL;
2715 if (use_xim)
2716 {
2717 BLOCK_INPUT;
2718 create_frame_xic (f);
2719 if (FRAME_XIC (f))
2720 {
2721
2722 unsigned long fevent = NoEventMask;
2723 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2724
2725 if (fevent != NoEventMask)
2726 {
2727 XSetWindowAttributes attributes;
2728 XWindowAttributes wattr;
2729 unsigned long attribute_mask;
2730
2731 XGetWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2732 &wattr);
2733 attributes.event_mask = wattr.your_event_mask | fevent;
2734 attribute_mask = CWEventMask;
2735 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2736 attribute_mask, &attributes);
2737 }
2738 }
2739 UNBLOCK_INPUT;
2740 }
2741 #endif
2742 }
2743
2744 #else
2745
2746
2747 void
2748 x_window (f)
2749 struct frame *f;
2750
2751 {
2752 XClassHint class_hints;
2753 XSetWindowAttributes attributes;
2754 unsigned long attribute_mask;
2755
2756 attributes.background_pixel = FRAME_BACKGROUND_PIXEL (f);
2757 attributes.border_pixel = f->output_data.x->border_pixel;
2758 attributes.bit_gravity = StaticGravity;
2759 attributes.backing_store = NotUseful;
2760 attributes.save_under = True;
2761 attributes.event_mask = STANDARD_EVENT_SET;
2762 attributes.colormap = FRAME_X_COLORMAP (f);
2763 attribute_mask = (CWBackPixel | CWBorderPixel | CWBitGravity | CWEventMask
2764 | CWColormap);
2765
2766 BLOCK_INPUT;
2767 FRAME_X_WINDOW (f)
2768 = XCreateWindow (FRAME_X_DISPLAY (f),
2769 f->output_data.x->parent_desc,
2770 f->left_pos,
2771 f->top_pos,
2772 FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
2773 f->border_width,
2774 CopyFromParent,
2775 InputOutput,
2776 FRAME_X_VISUAL (f),
2777 attribute_mask, &attributes);
2778
2779 #ifdef HAVE_X_I18N
2780 if (use_xim)
2781 {
2782 create_frame_xic (f);
2783 if (FRAME_XIC (f))
2784 {
2785
2786 unsigned long fevent = NoEventMask;
2787 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2788 attributes.event_mask |= fevent;
2789 attribute_mask = CWEventMask;
2790 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2791 attribute_mask, &attributes);
2792 }
2793 }
2794 #endif
2795
2796 validate_x_resource_name ();
2797
2798 class_hints.res_name = (char *) SDATA (Vx_resource_name);
2799 class_hints.res_class = (char *) SDATA (Vx_resource_class);
2800 XSetClassHint (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &class_hints);
2801
2802 2803
2804 f->output_data.x->menubar_height = 0;
2805
2806 2807 2808 2809
2810
2811 f->output_data.x->wm_hints.input = True;
2812 f->output_data.x->wm_hints.flags |= InputHint;
2813 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2814 &f->output_data.x->wm_hints);
2815 f->output_data.x->wm_hints.icon_pixmap = None;
2816
2817
2818 {
2819 Atom protocols[2];
2820 protocols[0] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window;
2821 protocols[1] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
2822 XSetWMProtocols (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), protocols, 2);
2823 }
2824
2825 2826 2827 2828
2829 {
2830 Lisp_Object name;
2831 int explicit = f->explicit_name;
2832
2833 f->explicit_name = 0;
2834 name = f->name;
2835 f->name = Qnil;
2836 x_set_name (f, name, explicit);
2837 }
2838
2839 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2840 f->output_data.x->current_cursor
2841 = f->output_data.x->text_cursor);
2842
2843 UNBLOCK_INPUT;
2844
2845 if (FRAME_X_WINDOW (f) == 0)
2846 error ("Unable to create window");
2847 }
2848
2849 #endif
2850 #endif
2851
2852
2853
2854 static void
2855 x_icon_verify (f, parms)
2856 struct frame *f;
2857 Lisp_Object parms;
2858 {
2859 Lisp_Object icon_x, icon_y;
2860
2861 2862
2863 icon_x = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2864 icon_y = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2865 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2866 {
2867 CHECK_NUMBER (icon_x);
2868 CHECK_NUMBER (icon_y);
2869 }
2870 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2871 error ("Both left and top icon corners of icon must be specified");
2872 }
2873
2874 2875 2876
2877
2878 static void
2879 x_icon (f, parms)
2880 struct frame *f;
2881 Lisp_Object parms;
2882 {
2883 Lisp_Object icon_x, icon_y;
2884 #if 0
2885 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2886 #endif
2887
2888 2889
2890 icon_x = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2891 icon_y = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2892 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2893 {
2894 CHECK_NUMBER (icon_x);
2895 CHECK_NUMBER (icon_y);
2896 }
2897 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2898 error ("Both left and top icon corners of icon must be specified");
2899
2900 BLOCK_INPUT;
2901
2902 if (! EQ (icon_x, Qunbound))
2903 x_wm_set_icon_position (f, XINT (icon_x), XINT (icon_y));
2904
2905 #if 0 2906
2907
2908 x_wm_set_window_state
2909 (f, (EQ (x_get_arg (dpyinfo, parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL),
2910 Qicon)
2911 ? IconicState
2912 : NormalState));
2913 #endif
2914
2915 x_text_icon (f, (char *) SDATA ((!NILP (f->icon_name)
2916 ? f->icon_name
2917 : f->name)));
2918
2919 UNBLOCK_INPUT;
2920 }
2921
2922 2923 2924
2925
2926 static void
2927 x_make_gc (f)
2928 struct frame *f;
2929 {
2930 XGCValues gc_values;
2931
2932 BLOCK_INPUT;
2933
2934 2935
2936
2937 gc_values.foreground = FRAME_FOREGROUND_PIXEL (f);
2938 gc_values.background = FRAME_BACKGROUND_PIXEL (f);
2939 gc_values.line_width = 0;
2940 f->output_data.x->normal_gc
2941 = XCreateGC (FRAME_X_DISPLAY (f),
2942 FRAME_X_WINDOW (f),
2943 GCLineWidth | GCForeground | GCBackground,
2944 &gc_values);
2945
2946
2947 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2948 gc_values.background = FRAME_FOREGROUND_PIXEL (f);
2949 f->output_data.x->reverse_gc
2950 = XCreateGC (FRAME_X_DISPLAY (f),
2951 FRAME_X_WINDOW (f),
2952 GCForeground | GCBackground | GCLineWidth,
2953 &gc_values);
2954
2955
2956 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2957 gc_values.background = f->output_data.x->cursor_pixel;
2958 gc_values.fill_style = FillOpaqueStippled;
2959 f->output_data.x->cursor_gc
2960 = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2961 (GCForeground | GCBackground
2962 | GCFillStyle | GCLineWidth),
2963 &gc_values);
2964
2965
2966 f->output_data.x->white_relief.gc = 0;
2967 f->output_data.x->black_relief.gc = 0;
2968
2969 2970 2971
2972 f->output_data.x->border_tile
2973 = (XCreatePixmapFromBitmapData
2974 (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
2975 gray_bits, gray_width, gray_height,
2976 FRAME_FOREGROUND_PIXEL (f),
2977 FRAME_BACKGROUND_PIXEL (f),
2978 DefaultDepth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f))));
2979
2980 UNBLOCK_INPUT;
2981 }
2982
2983
2984
2985
2986 void
2987 x_free_gcs (f)
2988 struct frame *f;
2989 {
2990 Display *dpy = FRAME_X_DISPLAY (f);
2991
2992 BLOCK_INPUT;
2993
2994 if (f->output_data.x->normal_gc)
2995 {
2996 XFreeGC (dpy, f->output_data.x->normal_gc);
2997 f->output_data.x->normal_gc = 0;
2998 }
2999
3000 if (f->output_data.x->reverse_gc)
3001 {
3002 XFreeGC (dpy, f->output_data.x->reverse_gc);
3003 f->output_data.x->reverse_gc = 0;
3004 }
3005
3006 if (f->output_data.x->cursor_gc)
3007 {
3008 XFreeGC (dpy, f->output_data.x->cursor_gc);
3009 f->output_data.x->cursor_gc = 0;
3010 }
3011
3012 if (f->output_data.x->border_tile)
3013 {
3014 XFreePixmap (dpy, f->output_data.x->border_tile);
3015 f->output_data.x->border_tile = 0;
3016 }
3017
3018 UNBLOCK_INPUT;
3019 }
3020
3021
3022 3023 3024
3025
3026 static Lisp_Object
3027 unwind_create_frame (frame)
3028 Lisp_Object frame;
3029 {
3030 struct frame *f = XFRAME (frame);
3031
3032 3033 3034
3035 if (!FRAME_LIVE_P (f))
3036 return Qnil;
3037
3038
3039 if (!CONSP (Vframe_list) || !EQ (XCAR (Vframe_list), frame))
3040 {
3041 #if GLYPH_DEBUG
3042 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
3043 #endif
3044
3045 x_free_frame_resources (f);
3046
3047 #if GLYPH_DEBUG
3048
3049 xassert (dpyinfo->reference_count == dpyinfo_refcount);
3050 xassert (dpyinfo->image_cache->refcount == image_cache_refcount);
3051 #endif
3052 return Qt;
3053 }
3054
3055 return Qnil;
3056 }
3057
3058
3059 static void
3060 x_default_font_parameter (f, parms)
3061 struct frame *f;
3062 Lisp_Object parms;
3063 {
3064 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
3065 Lisp_Object font_param = x_get_arg (dpyinfo, parms, Qfont, NULL, NULL,
3066 RES_TYPE_STRING);
3067 Lisp_Object font;
3068 int got_from_gconf = 0;
3069 if (EQ (font_param, Qunbound))
3070 font_param = Qnil;
3071
3072 if (NILP (font_param))
3073 {
3074 3075 3076
3077 const char *system_font = xsettings_get_system_font ();
3078 if (system_font) font_param = make_string (system_font,
3079 strlen (system_font));
3080 }
3081
3082 font = !NILP (font_param) ? font_param
3083 : x_get_arg (dpyinfo, parms, Qfont, "font", "Font", RES_TYPE_STRING);
3084
3085 if (! STRINGP (font))
3086 {
3087 char *names[]
3088 = {
3089 #ifdef HAVE_XFT
3090
3091 "monospace-10",
3092 #endif
3093 "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1",
3094 "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1",
3095 "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1",
3096 3097
3098 "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1",
3099 3100
3101 "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1",
3102 "fixed",
3103 NULL };
3104 int i;
3105
3106 for (i = 0; names[i]; i++)
3107 {
3108 font = font_open_by_name (f, names[i]);
3109 if (! NILP (font))
3110 break;
3111 }
3112 if (NILP (font))
3113 error ("No suitable font was found");
3114 }
3115 else if (!NILP (font_param))
3116 {
3117 3118
3119 x_set_frame_parameters (f, Fcons (Fcons (Qfont_param, font_param), Qnil));
3120 }
3121
3122 x_default_parameter (f, parms, Qfont, font,
3123 got_from_gconf ? NULL : "font",
3124 got_from_gconf ? NULL : "Font",
3125 RES_TYPE_STRING);
3126 }
3127
3128
3129 DEFUN ("x-wm-set-size-hint", Fx_wm_set_size_hint, Sx_wm_set_size_hint,
3130 0, 1, 0,
3131 doc: 3132 )
3133 (frame)
3134 Lisp_Object frame;
3135 {
3136 struct frame *f;
3137 if (NILP (frame))
3138 frame = selected_frame;
3139 f = XFRAME (frame);
3140 BLOCK_INPUT;
3141 if (FRAME_X_P (f))
3142 x_wm_set_size_hint (f, 0, 0);
3143 UNBLOCK_INPUT;
3144 return Qnil;
3145 }
3146
3147 static void
3148 set_machine_and_pid_properties (struct frame *f)
3149 {
3150
3151 XTextProperty text;
3152 int bytes, stringp;
3153 int do_free_text_value = 0;
3154 long pid = (long) getpid ();
3155
3156 text.value = x_encode_text (Vsystem_name,
3157 Qcompound_text, 0, &bytes, &stringp,
3158 &do_free_text_value);
3159 text.encoding = (stringp ? XA_STRING
3160 : FRAME_X_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
3161 text.format = 8;
3162 text.nitems = bytes;
3163 XSetWMClientMachine (FRAME_X_DISPLAY (f),
3164 FRAME_OUTER_WINDOW (f),
3165 &text);
3166 if (do_free_text_value)
3167 xfree (text.value);
3168
3169 XChangeProperty (FRAME_X_DISPLAY (f),
3170 FRAME_OUTER_WINDOW (f),
3171 XInternAtom (FRAME_X_DISPLAY (f),
3172 "_NET_WM_PID",
3173 False),
3174 XA_CARDINAL, 32, PropModeReplace,
3175 (unsigned char *) &pid, 1);
3176 }
3177
3178 DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
3179 1, 1, 0,
3180 doc: 3181 3182 3183 3184 3185 3186 3187 3188 )
3189 (parms)
3190 Lisp_Object parms;
3191 {
3192 struct frame *f;
3193 Lisp_Object frame, tem;
3194 Lisp_Object name;
3195 int minibuffer_only = 0;
3196 long window_prompting = 0;
3197 int width, height;
3198 int count = SPECPDL_INDEX ();
3199 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
3200 Lisp_Object display;
3201 struct x_display_info *dpyinfo = NULL;
3202 Lisp_Object parent;
3203 struct kboard *kb;
3204
3205 parms = Fcopy_alist (parms);
3206
3207 3208
3209 Vx_resource_name = Vinvocation_name;
3210
3211 display = x_get_arg (dpyinfo, parms, Qterminal, 0, 0, RES_TYPE_NUMBER);
3212 if (EQ (display, Qunbound))
3213 display = x_get_arg (dpyinfo, parms, Qdisplay, 0, 0, RES_TYPE_STRING);
3214 if (EQ (display, Qunbound))
3215 display = Qnil;
3216 dpyinfo = check_x_display_info (display);
3217 kb = dpyinfo->terminal->kboard;
3218
3219 if (!dpyinfo->terminal->name)
3220 error ("Terminal is not live, can't create new frames on it");
3221
3222 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
3223 if (!STRINGP (name)
3224 && ! EQ (name, Qunbound)
3225 && ! NILP (name))
3226 error ("Invalid frame name--not a string or nil");
3227
3228 if (STRINGP (name))
3229 Vx_resource_name = name;
3230
3231
3232 parent = x_get_arg (dpyinfo, parms, Qparent_id, NULL, NULL, RES_TYPE_NUMBER);
3233 if (EQ (parent, Qunbound))
3234 parent = Qnil;
3235 if (! NILP (parent))
3236 CHECK_NUMBER (parent);
3237
3238
3239 3240
3241 frame = Qnil;
3242 GCPRO4 (parms, parent, name, frame);
3243 tem = x_get_arg (dpyinfo, parms, Qminibuffer, "minibuffer", "Minibuffer",
3244 RES_TYPE_SYMBOL);
3245 if (EQ (tem, Qnone) || NILP (tem))
3246 f = make_frame_without_minibuffer (Qnil, kb, display);
3247 else if (EQ (tem, Qonly))
3248 {
3249 f = make_minibuffer_frame ();
3250 minibuffer_only = 1;
3251 }
3252 else if (WINDOWP (tem))
3253 f = make_frame_without_minibuffer (tem, kb, display);
3254 else
3255 f = make_frame (1);
3256
3257 XSETFRAME (frame, f);
3258
3259
3260 FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
3261
3262 f->terminal = dpyinfo->terminal;
3263 f->terminal->reference_count++;
3264
3265 f->output_method = output_x_window;
3266 f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
3267 bzero (f->output_data.x, sizeof (struct x_output));
3268 f->output_data.x->icon_bitmap = -1;
3269 FRAME_FONTSET (f) = -1;
3270 f->output_data.x->scroll_bar_foreground_pixel = -1;
3271 f->output_data.x->scroll_bar_background_pixel = -1;
3272 #ifdef USE_TOOLKIT_SCROLL_BARS
3273 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
3274 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
3275 #endif
3276
3277 f->icon_name
3278 = x_get_arg (dpyinfo, parms, Qicon_name, "iconName", "Title",
3279 RES_TYPE_STRING);
3280 if (! STRINGP (f->icon_name))
3281 f->icon_name = Qnil;
3282
3283 FRAME_X_DISPLAY_INFO (f) = dpyinfo;
3284
3285
3286 record_unwind_protect (unwind_create_frame, frame);
3287 #if GLYPH_DEBUG
3288 image_cache_refcount = FRAME_IMAGE_CACHE (f)->refcount;
3289 dpyinfo_refcount = dpyinfo->reference_count;
3290 #endif
3291
3292 3293
3294 {
3295 Lisp_Object black;
3296 struct gcpro gcpro1;
3297
3298 3299 3300
3301 FRAME_FOREGROUND_PIXEL (f) = -1;
3302 FRAME_BACKGROUND_PIXEL (f) = -1;
3303 f->output_data.x->cursor_pixel = -1;
3304 f->output_data.x->cursor_foreground_pixel = -1;
3305 f->output_data.x->border_pixel = -1;
3306 f->output_data.x->mouse_pixel = -1;
3307
3308 black = build_string ("black");
3309 GCPRO1 (black);
3310 FRAME_FOREGROUND_PIXEL (f)
3311 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3312 FRAME_BACKGROUND_PIXEL (f)
3313 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3314 f->output_data.x->cursor_pixel
3315 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3316 f->output_data.x->cursor_foreground_pixel
3317 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3318 f->output_data.x->border_pixel
3319 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3320 f->output_data.x->mouse_pixel
3321 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3322 UNGCPRO;
3323 }
3324
3325
3326
3327 if (!NILP (parent))
3328 {
3329 f->output_data.x->parent_desc = (Window) XFASTINT (parent);
3330 f->output_data.x->explicit_parent = 1;
3331 }
3332 else
3333 {
3334 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
3335 f->output_data.x->explicit_parent = 0;
3336 }
3337
3338 3339
3340 if (EQ (name, Qunbound) || NILP (name))
3341 {
3342 f->name = build_string (dpyinfo->x_id_name);
3343 f->explicit_name = 0;
3344 }
3345 else
3346 {
3347 f->name = name;
3348 f->explicit_name = 1;
3349
3350 specbind (Qx_resource_name, name);
3351 }
3352
3353 f->resx = dpyinfo->resx;
3354 f->resy = dpyinfo->resy;
3355
3356 #ifdef HAVE_FREETYPE
3357 #ifdef HAVE_XFT
3358 register_font_driver (&xftfont_driver, f);
3359 #else
3360 register_font_driver (&ftxfont_driver, f);
3361 #endif
3362 #endif
3363 register_font_driver (&xfont_driver, f);
3364
3365 x_default_parameter (f, parms, Qfont_backend, Qnil,
3366 "fontBackend", "FontBackend", RES_TYPE_STRING);
3367
3368 3369
3370 x_default_font_parameter (f, parms);
3371 if (!FRAME_FONT (f))
3372 {
3373 delete_frame (frame, Qnoelisp);
3374 error ("Invalid frame font");
3375 }
3376
3377
3378 if (! FRAME_X_EMBEDDED_P (f))
3379 x_default_parameter (f, parms, Qborder_width, make_number (0),
3380 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
3381
3382 3383 3384
3385 if (NILP (Fassq (Qinternal_border_width, parms)))
3386 {
3387 Lisp_Object value;
3388
3389 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
3390 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
3391 if (! EQ (value, Qunbound))
3392 parms = Fcons (Fcons (Qinternal_border_width, value),
3393 parms);
3394 }
3395 x_default_parameter (f, parms, Qinternal_border_width,
3396 #ifdef USE_GTK
3397 make_number (0),
3398 #else
3399 make_number (1),
3400 #endif
3401 "internalBorderWidth", "internalBorderWidth",
3402 RES_TYPE_NUMBER);
3403 x_default_parameter (f, parms, Qvertical_scroll_bars,
3404 #if defined(USE_GTK) && defined(USE_TOOLKIT_SCROLL_BARS)
3405 Qright,
3406 #else
3407 Qleft,
3408 #endif
3409 "verticalScrollBars", "ScrollBars",
3410 RES_TYPE_SYMBOL);
3411
3412
3413 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
3414 "foreground", "Foreground", RES_TYPE_STRING);
3415 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
3416 "background", "Background", RES_TYPE_STRING);
3417 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
3418 "pointerColor", "Foreground", RES_TYPE_STRING);
3419 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
3420 "cursorColor", "Foreground", RES_TYPE_STRING);
3421 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
3422 "borderColor", "BorderColor", RES_TYPE_STRING);
3423 x_default_parameter (f, parms, Qscreen_gamma, Qnil,
3424 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT);
3425 x_default_parameter (f, parms, Qline_spacing, Qnil,
3426 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER);
3427 x_default_parameter (f, parms, Qleft_fringe, Qnil,
3428 "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
3429 x_default_parameter (f, parms, Qright_fringe, Qnil,
3430 "rightFringe", "RightFringe", RES_TYPE_NUMBER);
3431
3432 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_foreground,
3433 "scrollBarForeground",
3434 "ScrollBarForeground", 1);
3435 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_background,
3436 "scrollBarBackground",
3437 "ScrollBarBackground", 0);
3438
3439 3440 3441 3442 3443 3444
3445 init_frame_faces (f);
3446
3447 x_default_parameter (f, parms, Qmenu_bar_lines, make_number (1),
3448 "menuBar", "MenuBar", RES_TYPE_BOOLEAN_NUMBER);
3449 x_default_parameter (f, parms, Qtool_bar_lines, make_number (1),
3450 "toolBar", "ToolBar", RES_TYPE_NUMBER);
3451 x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
3452 "bufferPredicate", "BufferPredicate",
3453 RES_TYPE_SYMBOL);
3454 x_default_parameter (f, parms, Qtitle, Qnil,
3455 "title", "Title", RES_TYPE_STRING);
3456 x_default_parameter (f, parms, Qwait_for_wm, Qt,
3457 "waitForWM", "WaitForWM", RES_TYPE_BOOLEAN);
3458 x_default_parameter (f, parms, Qfullscreen, Qnil,
3459 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
3460
3461
3462 window_prompting = x_figure_window_size (f, parms, 1);
3463
3464 tem = x_get_arg (dpyinfo, parms, Qunsplittable, 0, 0, RES_TYPE_BOOLEAN);
3465 f->no_split = minibuffer_only || EQ (tem, Qt);
3466
3467 x_icon_verify (f, parms);
3468
3469
3470 #ifdef USE_X_TOOLKIT
3471 x_window (f, window_prompting, minibuffer_only);
3472 #else
3473 x_window (f);
3474 #endif
3475
3476 x_icon (f, parms);
3477 x_make_gc (f);
3478
3479
3480 FRAME_X_DISPLAY_INFO (f)->reference_count++;
3481 Vframe_list = Fcons (frame, Vframe_list);
3482
3483 3484
3485 x_default_parameter (f, parms, Qicon_type, Qt,
3486 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL);
3487
3488 x_default_parameter (f, parms, Qauto_raise, Qnil,
3489 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3490 x_default_parameter (f, parms, Qauto_lower, Qnil,
3491 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3492 x_default_parameter (f, parms, Qcursor_type, Qbox,
3493 "cursorType", "CursorType", RES_TYPE_SYMBOL);
3494 x_default_parameter (f, parms, Qscroll_bar_width, Qnil,
3495 "scrollBarWidth", "ScrollBarWidth",
3496 RES_TYPE_NUMBER);
3497 x_default_parameter (f, parms, Qalpha, Qnil,
3498 "alpha", "Alpha", RES_TYPE_NUMBER);
3499
3500 3501 3502
3503 width = FRAME_COLS (f);
3504 height = FRAME_LINES (f);
3505
3506 SET_FRAME_COLS (f, 0);
3507 FRAME_LINES (f) = 0;
3508 change_frame_size (f, height, width, 1, 0, 0);
3509
3510 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3511
3512 if (!minibuffer_only && FRAME_EXTERNAL_MENU_BAR (f))
3513 {
3514 3515
3516 initialize_frame_menubar (f);
3517
3518 #ifndef USE_GTK
3519 3520
3521 lw_set_main_areas (f->output_data.x->column_widget,
3522 f->output_data.x->menubar_widget,
3523 f->output_data.x->edit_widget);
3524 #endif
3525 }
3526 #endif
3527
3528 3529 3530
3531 BLOCK_INPUT;
3532 x_wm_set_size_hint (f, window_prompting, 0);
3533 UNBLOCK_INPUT;
3534
3535 3536 3537
3538 if (! f->output_data.x->explicit_parent)
3539 {
3540 Lisp_Object visibility;
3541
3542 visibility = x_get_arg (dpyinfo, parms, Qvisibility, 0, 0,
3543 RES_TYPE_SYMBOL);
3544 if (EQ (visibility, Qunbound))
3545 visibility = Qt;
3546
3547 if (EQ (visibility, Qicon))
3548 x_iconify_frame (f);
3549 else if (! NILP (visibility))
3550 x_make_frame_visible (f);
3551 else
3552
3553 ;
3554 }
3555
3556 BLOCK_INPUT;
3557
3558
3559 set_machine_and_pid_properties(f);
3560
3561 3562
3563 if (dpyinfo->client_leader_window != 0)
3564 {
3565 XChangeProperty (FRAME_X_DISPLAY (f),
3566 FRAME_OUTER_WINDOW (f),
3567 dpyinfo->Xatom_wm_client_leader,
3568 XA_WINDOW, 32, PropModeReplace,
3569 (unsigned char *) &dpyinfo->client_leader_window, 1);
3570 }
3571
3572 UNBLOCK_INPUT;
3573
3574 3575
3576 if (FRAME_HAS_MINIBUF_P (f)
3577 && (!FRAMEP (kb->Vdefault_minibuffer_frame)
3578 || !FRAME_LIVE_P (XFRAME (kb->Vdefault_minibuffer_frame))))
3579 kb->Vdefault_minibuffer_frame = frame;
3580
3581 3582
3583 for (tem = parms; CONSP (tem); tem = XCDR (tem))
3584 if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
3585 f->param_alist = Fcons (XCAR (tem), f->param_alist);
3586
3587 UNGCPRO;
3588
3589 3590
3591 Vwindow_list = Qnil;
3592
3593 return unbind_to (count, frame);
3594 }
3595
3596
3597 3598 3599
3600
3601 Lisp_Object
3602 x_get_focus_frame (frame)
3603 struct frame *frame;
3604 {
3605 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (frame);
3606 Lisp_Object xfocus;
3607 if (! dpyinfo->x_focus_frame)
3608 return Qnil;
3609
3610 XSETFRAME (xfocus, dpyinfo->x_focus_frame);
3611 return xfocus;
3612 }
3613
3614
3615 3616 3617 3618 3619 3620 3621 3622
3623
3624 DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
3625 doc: 3626 )
3627 (frame)
3628 Lisp_Object frame;
3629 {
3630 struct frame *f = check_x_frame (frame);
3631 Display *dpy = FRAME_X_DISPLAY (f);
3632
3633 BLOCK_INPUT;
3634 x_catch_errors (dpy);
3635 XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3636 RevertToParent, CurrentTime);
3637 x_ewmh_activate_frame (f);
3638 x_uncatch_errors ();
3639 UNBLOCK_INPUT;
3640
3641 return Qnil;
3642 }
3643
3644
3645 DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
3646 doc: )
3647 (color, frame)
3648 Lisp_Object color, frame;
3649 {
3650 XColor foo;
3651 FRAME_PTR f = check_x_frame (frame);
3652
3653 CHECK_STRING (color);
3654
3655 if (x_defined_color (f, SDATA (color), &foo, 0))
3656 return Qt;
3657 else
3658 return Qnil;
3659 }
3660
3661 DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
3662 doc: )
3663 (color, frame)
3664 Lisp_Object color, frame;
3665 {
3666 XColor foo;
3667 FRAME_PTR f = check_x_frame (frame);
3668
3669 CHECK_STRING (color);
3670
3671 if (x_defined_color (f, SDATA (color), &foo, 0))
3672 return list3 (make_number (foo.red),
3673 make_number (foo.green),
3674 make_number (foo.blue));
3675 else
3676 return Qnil;
3677 }
3678
3679 DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
3680 doc: )
3681 (terminal)
3682 Lisp_Object terminal;
3683 {
3684 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3685
3686 if (dpyinfo->n_planes <= 2)
3687 return Qnil;
3688
3689 switch (dpyinfo->visual->class)
3690 {
3691 case StaticColor:
3692 case PseudoColor:
3693 case TrueColor:
3694 case DirectColor:
3695 return Qt;
3696
3697 default:
3698 return Qnil;
3699 }
3700 }
3701
3702 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p, Sx_display_grayscale_p,
3703 0, 1, 0,
3704 doc: 3705 3706 3707 3708 )
3709 (terminal)
3710 Lisp_Object terminal;
3711 {
3712 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3713
3714 if (dpyinfo->n_planes <= 1)
3715 return Qnil;
3716
3717 switch (dpyinfo->visual->class)
3718 {
3719 case StaticColor:
3720 case PseudoColor:
3721 case TrueColor:
3722 case DirectColor:
3723 case StaticGray:
3724 case GrayScale:
3725 return Qt;
3726
3727 default:
3728 return Qnil;
3729 }
3730 }
3731
3732 DEFUN ("x-display-pixel-width", Fx_display_pixel_width, Sx_display_pixel_width,
3733 0, 1, 0,
3734 doc: 3735 3736 3737 )
3738 (terminal)
3739 Lisp_Object terminal;
3740 {
3741 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3742
3743 return make_number (x_display_pixel_width (dpyinfo));
3744 }
3745
3746 DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
3747 Sx_display_pixel_height, 0, 1, 0,
3748 doc: 3749 3750 3751 )
3752 (terminal)
3753 Lisp_Object terminal;
3754 {
3755 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3756
3757 return make_number (x_display_pixel_height (dpyinfo));
3758 }
3759
3760 DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
3761 0, 1, 0,
3762 doc: 3763 3764 3765 )
3766 (terminal)
3767 Lisp_Object terminal;
3768 {
3769 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3770
3771 return make_number (dpyinfo->n_planes);
3772 }
3773
3774 DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
3775 0, 1, 0,
3776 doc: 3777 3778 3779 )
3780 (terminal)
3781 Lisp_Object terminal;
3782 {
3783 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3784
3785 int nr_planes = DisplayPlanes (dpyinfo->display,
3786 XScreenNumberOfScreen (dpyinfo->screen));
3787
3788 3789 3790 3791 3792
3793 if (nr_planes > 24) nr_planes = 24;
3794
3795 return make_number (1 << nr_planes);
3796 }
3797
3798 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
3799 Sx_server_max_request_size,
3800 0, 1, 0,
3801 doc: 3802 3803 3804 )
3805 (terminal)
3806 Lisp_Object terminal;
3807 {
3808 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3809
3810 return make_number (MAXREQUEST (dpyinfo->display));
3811 }
3812
3813 DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
3814 doc: 3815 3816 3817 3818 3819 )
3820 (terminal)
3821 Lisp_Object terminal;
3822 {
3823 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3824 char *vendor = ServerVendor (dpyinfo->display);
3825
3826 if (! vendor) vendor = "";
3827 return build_string (vendor);
3828 }
3829
3830 DEFUN ("x-server-version", Fx_server_version, Sx_server_version, 0, 1, 0,
3831 doc: 3832 3833 3834 3835 3836 3837 3838 )
3839 (terminal)
3840 Lisp_Object terminal;
3841 {
3842 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3843 Display *dpy = dpyinfo->display;
3844
3845 return Fcons (make_number (ProtocolVersion (dpy)),
3846 Fcons (make_number (ProtocolRevision (dpy)),
3847 Fcons (make_number (VendorRelease (dpy)), Qnil)));
3848 }
3849
3850 DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
3851 doc: 3852 3853 3854 )
3855 (terminal)
3856 Lisp_Object terminal;
3857 {
3858 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3859
3860 return make_number (ScreenCount (dpyinfo->display));
3861 }
3862
3863 DEFUN ("x-display-mm-height", Fx_display_mm_height, Sx_display_mm_height, 0, 1, 0,
3864 doc: 3865 3866 3867 )
3868 (terminal)
3869 Lisp_Object terminal;
3870 {
3871 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3872
3873 return make_number (HeightMMOfScreen (dpyinfo->screen));
3874 }
3875
3876 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
3877 doc: 3878 3879 3880 )
3881 (terminal)
3882 Lisp_Object terminal;
3883 {
3884 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3885
3886 return make_number (WidthMMOfScreen (dpyinfo->screen));
3887 }
3888
3889 DEFUN ("x-display-backing-store", Fx_display_backing_store,
3890 Sx_display_backing_store, 0, 1, 0,
3891 doc: 3892 3893 3894 3895 )
3896 (terminal)
3897 Lisp_Object terminal;
3898 {
3899 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3900 Lisp_Object result;
3901
3902 switch (DoesBackingStore (dpyinfo->screen))
3903 {
3904 case Always:
3905 result = intern ("always");
3906 break;
3907
3908 case WhenMapped:
3909 result = intern ("when-mapped");
3910 break;
3911
3912 case NotUseful:
3913 result = intern ("not-useful");
3914 break;
3915
3916 default:
3917 error ("Strange value for BackingStore parameter of screen");
3918 result = Qnil;
3919 }
3920
3921 return result;
3922 }
3923
3924 DEFUN ("x-display-visual-class", Fx_display_visual_class,
3925 Sx_display_visual_class, 0, 1, 0,
3926 doc: 3927 3928 3929 3930 3931 3932 )
3933 (terminal)
3934 Lisp_Object terminal;
3935 {
3936 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3937 Lisp_Object result;
3938
3939 switch (dpyinfo->visual->class)
3940 {
3941 case StaticGray:
3942 result = intern ("static-gray");
3943 break;
3944 case GrayScale:
3945 result = intern ("gray-scale");
3946 break;
3947 case StaticColor:
3948 result = intern ("static-color");
3949 break;
3950 case PseudoColor:
3951 result = intern ("pseudo-color");
3952 break;
3953 case TrueColor:
3954 result = intern ("true-color");
3955 break;
3956 case DirectColor:
3957 result = intern ("direct-color");
3958 break;
3959 default:
3960 error ("Display has an unknown visual class");
3961 result = Qnil;
3962 }
3963
3964 return result;
3965 }
3966
3967 DEFUN ("x-display-save-under", Fx_display_save_under,
3968 Sx_display_save_under, 0, 1, 0,
3969 doc: 3970 3971 3972 )
3973 (terminal)
3974 Lisp_Object terminal;
3975 {
3976 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3977
3978 if (DoesSaveUnders (dpyinfo->screen) == True)
3979 return Qt;
3980 else
3981 return Qnil;
3982 }
3983
3984 int
3985 x_pixel_width (f)
3986 register struct frame *f;
3987 {
3988 return FRAME_PIXEL_WIDTH (f);
3989 }
3990
3991 int
3992 x_pixel_height (f)
3993 register struct frame *f;
3994 {
3995 return FRAME_PIXEL_HEIGHT (f);
3996 }
3997
3998 int
3999 x_char_width (f)
4000 register struct frame *f;
4001 {
4002 return FRAME_COLUMN_WIDTH (f);
4003 }
4004
4005 int
4006 x_char_height (f)
4007 register struct frame *f;
4008 {
4009 return FRAME_LINE_HEIGHT (f);
4010 }
4011
4012 int
4013 x_screen_planes (f)
4014 register struct frame *f;
4015 {
4016 return FRAME_X_DISPLAY_INFO (f)->n_planes;
4017 }
4018
4019
4020
4021 4022 4023
4024
4025
4026
4027
4028 static struct visual_class
4029 {
4030 char *name;
4031 int class;
4032 }
4033 visual_classes[] =
4034 {
4035 {"StaticGray", StaticGray},
4036 {"GrayScale", GrayScale},
4037 {"StaticColor", StaticColor},
4038 {"PseudoColor", PseudoColor},
4039 {"TrueColor", TrueColor},
4040 {"DirectColor", DirectColor},
4041 {NULL, 0}
4042 };
4043
4044
4045 #ifndef HAVE_XSCREENNUMBEROFSCREEN
4046
4047 4048
4049
4050 int
4051 XScreenNumberOfScreen (scr)
4052 register Screen *scr;
4053 {
4054 Display *dpy = scr->display;
4055 int i;
4056
4057 for (i = 0; i < dpy->nscreens; ++i)
4058 if (scr == dpy->screens + i)
4059 break;
4060
4061 return i;
4062 }
4063
4064 #endif
4065
4066
4067 4068
4069
4070 void
4071 select_visual (dpyinfo)
4072 struct x_display_info *dpyinfo;
4073 {
4074 Display *dpy = dpyinfo->display;
4075 Screen *screen = dpyinfo->screen;
4076 Lisp_Object value;
4077
4078
4079 value = display_x_get_resource (dpyinfo,
4080 build_string ("visualClass"),
4081 build_string ("VisualClass"),
4082 Qnil, Qnil);
4083 if (STRINGP (value))
4084 {
4085 4086 4087
4088 char *s = (char *) alloca (SBYTES (value) + 1);
4089 char *dash;
4090 int i, class = -1;
4091 XVisualInfo vinfo;
4092
4093 strcpy (s, SDATA (value));
4094 dash = index (s, '-');
4095 if (dash)
4096 {
4097 dpyinfo->n_planes = atoi (dash + 1);
4098 *dash = '\0';
4099 }
4100 else
4101 4102
4103 dpyinfo->n_planes = 0;
4104
4105
4106 for (i = 0; visual_classes[i].name; ++i)
4107 if (xstrcasecmp (s, visual_classes[i].name) == 0)
4108 {
4109 class = visual_classes[i].class;
4110 break;
4111 }
4112
4113
4114 if (class == -1
4115 || !XMatchVisualInfo (dpy, XScreenNumberOfScreen (screen),
4116 dpyinfo->n_planes, class, &vinfo))
4117 fatal ("Invalid visual specification `%s'", SDATA (value));
4118
4119 dpyinfo->visual = vinfo.visual;
4120 }
4121 else
4122 {
4123 int n_visuals;
4124 XVisualInfo *vinfo, vinfo_template;
4125
4126 dpyinfo->visual = DefaultVisualOfScreen (screen);
4127
4128 vinfo_template.visualid = XVisualIDFromVisual (dpyinfo->visual);
4129 vinfo_template.screen = XScreenNumberOfScreen (screen);
4130 vinfo = XGetVisualInfo (dpy, VisualIDMask | VisualScreenMask,
4131 &vinfo_template, &n_visuals);
4132 if (n_visuals <= 0)
4133 fatal ("Can't get proper X visual info");
4134
4135 dpyinfo->n_planes = vinfo->depth;
4136 XFree ((char *) vinfo);
4137 }
4138 }
4139
4140
4141 4142
4143
4144 struct x_display_info *
4145 x_display_info_for_name (name)
4146 Lisp_Object name;
4147 {
4148 Lisp_Object names;
4149 struct x_display_info *dpyinfo;
4150
4151 CHECK_STRING (name);
4152
4153 #if 0
4154 if (! EQ (Vinitial_window_system, intern ("x")))
4155 error ("Not using X Windows");
4156 #endif
4157
4158 for (dpyinfo = x_display_list, names = x_display_name_list;
4159 dpyinfo;
4160 dpyinfo = dpyinfo->next, names = XCDR (names))
4161 {
4162 Lisp_Object tem;
4163 tem = Fstring_equal (XCAR (XCAR (names)), name);
4164 if (!NILP (tem))
4165 return dpyinfo;
4166 }
4167
4168
4169 Vx_resource_name = Vinvocation_name;
4170
4171 validate_x_resource_name ();
4172
4173 dpyinfo = x_term_init (name, (char *)0,
4174 (char *) SDATA (Vx_resource_name));
4175
4176 if (dpyinfo == 0)
4177 error ("Cannot connect to X server %s", SDATA (name));
4178
4179 x_in_use = 1;
4180 XSETFASTINT (Vwindow_system_version, 11);
4181
4182 return dpyinfo;
4183 }
4184
4185
4186 DEFUN ("x-open-connection", Fx_open_connection, Sx_open_connection,
4187 1, 3, 0,
4188 doc: 4189 4190 4191 4192 )
4193 (display, xrm_string, must_succeed)
4194 Lisp_Object display, xrm_string, must_succeed;
4195 {
4196 unsigned char *xrm_option;
4197 struct x_display_info *dpyinfo;
4198
4199 CHECK_STRING (display);
4200 if (! NILP (xrm_string))
4201 CHECK_STRING (xrm_string);
4202
4203 #if 0
4204 if (! EQ (Vinitial_window_system, intern ("x")))
4205 error ("Not using X Windows");
4206 #endif
4207
4208 if (! NILP (xrm_string))
4209 xrm_option = (unsigned char *) SDATA (xrm_string);
4210 else
4211 xrm_option = (unsigned char *) 0;
4212
4213 validate_x_resource_name ();
4214
4215 4216
4217 dpyinfo = x_term_init (display, xrm_option,
4218 (char *) SDATA (Vx_resource_name));
4219
4220 if (dpyinfo == 0)
4221 {
4222 if (!NILP (must_succeed))
4223 fatal ("Cannot connect to X server %s.\n\
4224 Check the DISPLAY environment variable or use `-d'.\n\
4225 Also use the `xauth' program to verify that you have the proper\n\
4226 authorization information needed to connect the X server.\n\
4227 An insecure way to solve the problem may be to use `xhost'.\n",
4228 SDATA (display));
4229 else
4230 error ("Cannot connect to X server %s", SDATA (display));
4231 }
4232
4233 x_in_use = 1;
4234
4235 XSETFASTINT (Vwindow_system_version, 11);
4236 return Qnil;
4237 }
4238
4239 DEFUN ("x-close-connection", Fx_close_connection,
4240 Sx_close_connection, 1, 1, 0,
4241 doc: 4242 4243 4244 )
4245 (terminal)
4246 Lisp_Object terminal;
4247 {
4248 struct x_display_info *dpyinfo = check_x_display_info (terminal);
4249
4250 if (dpyinfo->reference_count > 0)
4251 error ("Display still has frames on it");
4252
4253 x_delete_terminal (dpyinfo->terminal);
4254
4255 return Qnil;
4256 }
4257
4258 DEFUN ("x-display-list", Fx_display_list, Sx_display_list, 0, 0, 0,
4259 doc: )
4260 ()
4261 {
4262 Lisp_Object tail, result;
4263
4264 result = Qnil;
4265 for (tail = x_display_name_list; CONSP (tail); tail = XCDR (tail))
4266 result = Fcons (XCAR (XCAR (tail)), result);
4267
4268 return result;
4269 }
4270
4271 DEFUN ("x-synchronize", Fx_synchronize, Sx_synchronize, 1, 2, 0,
4272 doc: 4273 4274 4275 4276 4277 4278 4279 )
4280 (on, terminal)
4281 Lisp_Object terminal, on;
4282 {
4283 struct x_display_info *dpyinfo = check_x_display_info (terminal);
4284
4285 XSynchronize (dpyinfo->display, !EQ (on, Qnil));
4286
4287 return Qnil;
4288 }
4289
4290
4291
4292 void
4293 x_sync (f)
4294 FRAME_PTR f;
4295 {
4296 BLOCK_INPUT;
4297 XSync (FRAME_X_DISPLAY (f), False);
4298 UNBLOCK_INPUT;
4299 }
4300
4301
4302 4303 4304
4305
4306 DEFUN ("x-change-window-property", Fx_change_window_property,
4307 Sx_change_window_property, 2, 6, 0,
4308 doc: 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 )
4325 (prop, value, frame, type, format, outer_p)
4326 Lisp_Object prop, value, frame, type, format, outer_p;
4327 {
4328 struct frame *f = check_x_frame (frame);
4329 Atom prop_atom;
4330 Atom target_type = XA_STRING;
4331 int element_format = 8;
4332 unsigned char *data;
4333 int nelements;
4334 Window w;
4335
4336 CHECK_STRING (prop);
4337
4338 if (! NILP (format))
4339 {
4340 CHECK_NUMBER (format);
4341 element_format = XFASTINT (format);
4342
4343 if (element_format != 8 && element_format != 16
4344 && element_format != 32)
4345 error ("FORMAT must be one of 8, 16 or 32");
4346 }
4347
4348 if (CONSP (value))
4349 {
4350 nelements = x_check_property_data (value);
4351 if (nelements == -1)
4352 error ("Bad data in VALUE, must be number, string or cons");
4353
4354 if (element_format == 8)
4355 data = (unsigned char *) xmalloc (nelements);
4356 else if (element_format == 16)
4357 data = (unsigned char *) xmalloc (nelements*2);
4358 else
4359 4360 4361 4362 4363
4364 data = (unsigned char *) xmalloc (nelements * sizeof(long));
4365
4366 x_fill_property_data (FRAME_X_DISPLAY (f), value, data, element_format);
4367 }
4368 else
4369 {
4370 CHECK_STRING (value);
4371 data = SDATA (value);
4372 nelements = SCHARS (value);
4373 }
4374
4375 BLOCK_INPUT;
4376 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SDATA (prop), False);
4377 if (! NILP (type))
4378 {
4379 CHECK_STRING (type);
4380 target_type = XInternAtom (FRAME_X_DISPLAY (f), SDATA (type), False);
4381 }
4382
4383 if (! NILP (outer_p)) w = FRAME_OUTER_WINDOW (f);
4384 else w = FRAME_X_WINDOW (f);
4385
4386 XChangeProperty (FRAME_X_DISPLAY (f), w,
4387 prop_atom, target_type, element_format, PropModeReplace,
4388 data, nelements);
4389
4390 if (CONSP (value)) xfree (data);
4391
4392
4393 XFlush (FRAME_X_DISPLAY (f));
4394 UNBLOCK_INPUT;
4395
4396 return value;
4397 }
4398
4399
4400 DEFUN ("x-delete-window-property", Fx_delete_window_property,
4401 Sx_delete_window_property, 1, 2, 0,
4402 doc: 4403 )
4404 (prop, frame)
4405 Lisp_Object prop, frame;
4406 {
4407 struct frame *f = check_x_frame (frame);
4408 Atom prop_atom;
4409
4410 CHECK_STRING (prop);
4411 BLOCK_INPUT;
4412 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SDATA (prop), False);
4413 XDeleteProperty (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), prop_atom);
4414
4415
4416 XFlush (FRAME_X_DISPLAY (f));
4417 UNBLOCK_INPUT;
4418
4419 return prop;
4420 }
4421
4422
4423 DEFUN ("x-window-property", Fx_window_property, Sx_window_property,
4424 1, 6, 0,
4425 doc: 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 )
4436 (prop, frame, type, source, delete_p, vector_ret_p)
4437 Lisp_Object prop, frame, type, source, delete_p, vector_ret_p;
4438 {
4439 struct frame *f = check_x_frame (frame);
4440 Atom prop_atom;
4441 int rc;
4442 Lisp_Object prop_value = Qnil;
4443 unsigned char *tmp_data = NULL;
4444 Atom actual_type;
4445 Atom target_type = XA_STRING;
4446 int actual_format;
4447 unsigned long actual_size, bytes_remaining;
4448 Window target_window = FRAME_X_WINDOW (f);
4449 struct gcpro gcpro1;
4450
4451 GCPRO1 (prop_value);
4452 CHECK_STRING (prop);
4453
4454 if (! NILP (source))
4455 {
4456 if (NUMBERP (source))
4457 {
4458 if (FLOATP (source))
4459 target_window = (Window) XFLOAT (source);
4460 else
4461 target_window = XFASTINT (source);
4462
4463 if (target_window == 0)
4464 target_window = FRAME_X_DISPLAY_INFO (f)->root_window;
4465 }
4466 else if (CONSP (source))
4467 target_window = cons_to_long (source);
4468 }
4469
4470 BLOCK_INPUT;
4471 if (STRINGP (type))
4472 {
4473 if (strcmp ("AnyPropertyType", SDATA (type)) == 0)
4474 target_type = AnyPropertyType;
4475 else
4476 target_type = XInternAtom (FRAME_X_DISPLAY (f), SDATA (type), False);
4477 }
4478
4479 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SDATA (prop), False);
4480 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4481 prop_atom, 0, 0, False, target_type,
4482 &actual_type, &actual_format, &actual_size,
4483 &bytes_remaining, &tmp_data);
4484 if (rc == Success)
4485 {
4486 int size = bytes_remaining;
4487
4488 XFree (tmp_data);
4489 tmp_data = NULL;
4490
4491 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4492 prop_atom, 0, bytes_remaining,
4493 ! NILP (delete_p), target_type,
4494 &actual_type, &actual_format,
4495 &actual_size, &bytes_remaining,
4496 &tmp_data);
4497 if (rc == Success && tmp_data)
4498 {
4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511
4512
4513 if (actual_format == 32 && actual_format < BITS_PER_LONG)
4514 {
4515 unsigned long i;
4516 int *idata = (int *) tmp_data;
4517 long *ldata = (long *) tmp_data;
4518
4519 for (i = 0; i < actual_size; ++i)
4520 idata[i] = (int) ldata[i];
4521 }
4522
4523 if (NILP (vector_ret_p))
4524 prop_value = make_string (tmp_data, size);
4525 else
4526 prop_value = x_property_data_to_lisp (f,
4527 tmp_data,
4528 actual_type,
4529 actual_format,
4530 actual_size);
4531 }
4532
4533 if (tmp_data) XFree (tmp_data);
4534 }
4535
4536 UNBLOCK_INPUT;
4537 UNGCPRO;
4538 return prop_value;
4539 }
4540
4541
4542
4543 4544 4545
4546
4547 4548 4549 4550 4551 4552 4553
4554
4555 void
4556 show_hourglass (timer)
4557 struct atimer *timer;
4558 {
4559 4560 4561
4562 hourglass_atimer = NULL;
4563
4564 if (!hourglass_shown_p)
4565 {
4566 Lisp_Object rest, frame;
4567
4568 BLOCK_INPUT;
4569
4570 FOR_EACH_FRAME (rest, frame)
4571 {
4572 struct frame *f = XFRAME (frame);
4573
4574 if (FRAME_LIVE_P (f) && FRAME_X_P (f) && FRAME_X_DISPLAY (f))
4575 {
4576 Display *dpy = FRAME_X_DISPLAY (f);
4577
4578 #ifdef USE_X_TOOLKIT
4579 if (f->output_data.x->widget)
4580 #else
4581 if (FRAME_OUTER_WINDOW (f))
4582 #endif
4583 {
4584 f->output_data.x->hourglass_p = 1;
4585
4586 if (!f->output_data.x->hourglass_window)
4587 {
4588 unsigned long mask = CWCursor;
4589 XSetWindowAttributes attrs;
4590 #ifdef USE_GTK
4591 Window parent = FRAME_X_WINDOW (f);
4592 #else
4593 Window parent = FRAME_OUTER_WINDOW (f);
4594 #endif
4595 attrs.cursor = f->output_data.x->hourglass_cursor;
4596
4597 f->output_data.x->hourglass_window
4598 = XCreateWindow (dpy, parent,
4599 0, 0, 32000, 32000, 0, 0,
4600 InputOnly,
4601 CopyFromParent,
4602 mask, &attrs);
4603 }
4604
4605 XMapRaised (dpy, f->output_data.x->hourglass_window);
4606 XFlush (dpy);
4607 }
4608 }
4609 }
4610
4611 hourglass_shown_p = 1;
4612 UNBLOCK_INPUT;
4613 }
4614 }
4615
4616
4617 4618
4619
4620 void
4621 hide_hourglass ()
4622 {
4623 if (hourglass_shown_p)
4624 {
4625 Lisp_Object rest, frame;
4626
4627 BLOCK_INPUT;
4628 FOR_EACH_FRAME (rest, frame)
4629 {
4630 struct frame *f = XFRAME (frame);
4631
4632 if (FRAME_X_P (f)
4633
4634 && f->output_data.x->hourglass_window)
4635 {
4636 XUnmapWindow (FRAME_X_DISPLAY (f),
4637 f->output_data.x->hourglass_window);
4638 4639
4640 XSync (FRAME_X_DISPLAY (f), False);
4641 f->output_data.x->hourglass_p = 0;
4642 }
4643 }
4644
4645 hourglass_shown_p = 0;
4646 UNBLOCK_INPUT;
4647 }
4648 }
4649
4650
4651
4652 4653 4654
4655
4656 static Lisp_Object x_create_tip_frame P_ ((struct x_display_info *,
4657 Lisp_Object, Lisp_Object));
4658 static void compute_tip_xy P_ ((struct frame *, Lisp_Object, Lisp_Object,
4659 Lisp_Object, int, int, int *, int *));
4660
4661
4662
4663 Lisp_Object tip_frame;
4664
4665 4666
4667
4668 Lisp_Object tip_timer;
4669 Window tip_window;
4670
4671 4672
4673
4674 Lisp_Object last_show_tip_args;
4675
4676
4677
4678 Lisp_Object Vx_max_tooltip_size;
4679
4680
4681 static Lisp_Object
4682 unwind_create_tip_frame (frame)
4683 Lisp_Object frame;
4684 {
4685 Lisp_Object deleted;
4686
4687 deleted = unwind_create_frame (frame);
4688 if (EQ (deleted, Qt))
4689 {
4690 tip_window = None;
4691 tip_frame = Qnil;
4692 }
4693
4694 return deleted;
4695 }
4696
4697
4698 4699 4700 4701 4702 4703 4704 4705
4706
4707 static Lisp_Object
4708 x_create_tip_frame (dpyinfo, parms, text)
4709 struct x_display_info *dpyinfo;
4710 Lisp_Object parms, text;
4711 {
4712 struct frame *f;
4713 Lisp_Object frame, tem;
4714 Lisp_Object name;
4715 long window_prompting = 0;
4716 int width, height;
4717 int count = SPECPDL_INDEX ();
4718 struct gcpro gcpro1, gcpro2, gcpro3;
4719 int face_change_count_before = face_change_count;
4720 Lisp_Object buffer;
4721 struct buffer *old_buffer;
4722
4723 check_x ();
4724
4725 if (!dpyinfo->terminal->name)
4726 error ("Terminal is not live, can't create new frames on it");
4727
4728 parms = Fcopy_alist (parms);
4729
4730
4731 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
4732 if (!STRINGP (name)
4733 && !EQ (name, Qunbound)
4734 && !NILP (name))
4735 error ("Invalid frame name--not a string or nil");
4736
4737 frame = Qnil;
4738 GCPRO3 (parms, name, frame);
4739 f = make_frame (1);
4740 XSETFRAME (frame, f);
4741
4742 buffer = Fget_buffer_create (build_string (" *tip*"));
4743 Fset_window_buffer (FRAME_ROOT_WINDOW (f), buffer, Qnil);
4744 old_buffer = current_buffer;
4745 set_buffer_internal_1 (XBUFFER (buffer));
4746 current_buffer->truncate_lines = Qnil;
4747 specbind (Qinhibit_read_only, Qt);
4748 specbind (Qinhibit_modification_hooks, Qt);
4749 Ferase_buffer ();
4750 Finsert (1, &text);
4751 set_buffer_internal_1 (old_buffer);
4752
4753 FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
4754 record_unwind_protect (unwind_create_tip_frame, frame);
4755
4756 f->terminal = dpyinfo->terminal;
4757 f->terminal->reference_count++;
4758
4759 4760 4761 4762
4763 f->output_method = output_x_window;
4764 f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
4765 bzero (f->output_data.x, sizeof (struct x_output));
4766 f->output_data.x->icon_bitmap = -1;
4767 FRAME_FONTSET (f) = -1;
4768 f->output_data.x->scroll_bar_foreground_pixel = -1;
4769 f->output_data.x->scroll_bar_background_pixel = -1;
4770 #ifdef USE_TOOLKIT_SCROLL_BARS
4771 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
4772 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
4773 #endif
4774 f->icon_name = Qnil;
4775 FRAME_X_DISPLAY_INFO (f) = dpyinfo;
4776 #if GLYPH_DEBUG
4777 image_cache_refcount = FRAME_IMAGE_CACHE (f)->refcount;
4778 dpyinfo_refcount = dpyinfo->reference_count;
4779 #endif
4780 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
4781 f->output_data.x->explicit_parent = 0;
4782
4783 4784
4785 {
4786 Lisp_Object black;
4787 struct gcpro gcpro1;
4788
4789 4790 4791
4792 FRAME_FOREGROUND_PIXEL (f) = -1;
4793 FRAME_BACKGROUND_PIXEL (f) = -1;
4794 f->output_data.x->cursor_pixel = -1;
4795 f->output_data.x->cursor_foreground_pixel = -1;
4796 f->output_data.x->border_pixel = -1;
4797 f->output_data.x->mouse_pixel = -1;
4798
4799 black = build_string ("black");
4800 GCPRO1 (black);
4801 FRAME_FOREGROUND_PIXEL (f)
4802 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4803 FRAME_BACKGROUND_PIXEL (f)
4804 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4805 f->output_data.x->cursor_pixel
4806 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4807 f->output_data.x->cursor_foreground_pixel
4808 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4809 f->output_data.x->border_pixel
4810 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4811 f->output_data.x->mouse_pixel
4812 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4813 UNGCPRO;
4814 }
4815
4816 4817
4818 if (EQ (name, Qunbound) || NILP (name))
4819 {
4820 f->name = build_string (dpyinfo->x_id_name);
4821 f->explicit_name = 0;
4822 }
4823 else
4824 {
4825 f->name = name;
4826 f->explicit_name = 1;
4827
4828 specbind (Qx_resource_name, name);
4829 }
4830
4831 f->resx = dpyinfo->resx;
4832 f->resy = dpyinfo->resy;
4833
4834 register_font_driver (&xfont_driver, f);
4835 #ifdef HAVE_FREETYPE
4836 #ifdef HAVE_XFT
4837 register_font_driver (&xftfont_driver, f);
4838 #else
4839 register_font_driver (&ftxfont_driver, f);
4840 #endif
4841 #endif
4842
4843 x_default_parameter (f, parms, Qfont_backend, Qnil,
4844 "fontBackend", "FontBackend", RES_TYPE_STRING);
4845
4846 4847
4848 x_default_font_parameter (f, parms);
4849
4850 x_default_parameter (f, parms, Qborder_width, make_number (0),
4851 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
4852
4853 4854 4855
4856 if (NILP (Fassq (Qinternal_border_width, parms)))
4857 {
4858 Lisp_Object value;
4859
4860 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
4861 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
4862 if (! EQ (value, Qunbound))
4863 parms = Fcons (Fcons (Qinternal_border_width, value),
4864 parms);
4865 }
4866
4867 x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
4868 "internalBorderWidth", "internalBorderWidth",
4869 RES_TYPE_NUMBER);
4870
4871
4872 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
4873 "foreground", "Foreground", RES_TYPE_STRING);
4874 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
4875 "background", "Background", RES_TYPE_STRING);
4876 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
4877 "pointerColor", "Foreground", RES_TYPE_STRING);
4878 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
4879 "cursorColor", "Foreground", RES_TYPE_STRING);
4880 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
4881 "borderColor", "BorderColor", RES_TYPE_STRING);
4882
4883 4884 4885 4886 4887 4888
4889 init_frame_faces (f);
4890
4891 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
4892
4893 window_prompting = x_figure_window_size (f, parms, 0);
4894
4895 {
4896 XSetWindowAttributes attrs;
4897 unsigned long mask;
4898 Atom type = FRAME_X_DISPLAY_INFO (f)->Xatom_net_window_type_tooltip;
4899
4900 BLOCK_INPUT;
4901 mask = CWBackPixel | CWOverrideRedirect | CWEventMask;
4902 if (DoesSaveUnders (dpyinfo->screen))
4903 mask |= CWSaveUnder;
4904
4905 4906 4907
4908 attrs.override_redirect = True;
4909 attrs.save_under = True;
4910 attrs.background_pixel = FRAME_BACKGROUND_PIXEL (f);
4911
4912 attrs.event_mask = StructureNotifyMask;
4913 tip_window
4914 = FRAME_X_WINDOW (f)
4915 = XCreateWindow (FRAME_X_DISPLAY (f),
4916 FRAME_X_DISPLAY_INFO (f)->root_window,
4917
4918 0, 0, 1, 1,
4919
4920 f->border_width,
4921 CopyFromParent, InputOutput, CopyFromParent,
4922 mask, &attrs);
4923 XChangeProperty (FRAME_X_DISPLAY (f), tip_window,
4924 FRAME_X_DISPLAY_INFO (f)->Xatom_net_window_type,
4925 XA_ATOM, 32, PropModeReplace,
4926 (unsigned char *)&type, 1);
4927 UNBLOCK_INPUT;
4928 }
4929
4930 x_make_gc (f);
4931
4932 x_default_parameter (f, parms, Qauto_raise, Qnil,
4933 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4934 x_default_parameter (f, parms, Qauto_lower, Qnil,
4935 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4936 x_default_parameter (f, parms, Qcursor_type, Qbox,
4937 "cursorType", "CursorType", RES_TYPE_SYMBOL);
4938
4939 4940 4941
4942 width = FRAME_COLS (f);
4943 height = FRAME_LINES (f);
4944 SET_FRAME_COLS (f, 0);
4945 FRAME_LINES (f) = 0;
4946 change_frame_size (f, height, width, 1, 0, 0);
4947
4948
4949 if (NILP (Fframe_parameter (frame, intern ("tooltip"))))
4950 Fmodify_frame_parameters (frame, Fcons (Fcons (intern ("tooltip"), Qt),
4951 Qnil));
4952
4953 4954
4955
4956
4957 {
4958 Lisp_Object disptype;
4959
4960 if (FRAME_X_DISPLAY_INFO (f)->n_planes == 1)
4961 disptype = intern ("mono");
4962 else if (FRAME_X_DISPLAY_INFO (f)->visual->class == GrayScale
4963 || FRAME_X_DISPLAY_INFO (f)->visual->class == StaticGray)
4964 disptype = intern ("grayscale");
4965 else
4966 disptype = intern ("color");
4967
4968 if (NILP (Fframe_parameter (frame, Qdisplay_type)))
4969 Fmodify_frame_parameters (frame, Fcons (Fcons (Qdisplay_type, disptype),
4970 Qnil));
4971 }
4972
4973 4974 4975 4976 4977 4978 4979 4980
4981 {
4982 Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
4983
4984
4985 tip_frame = frame;
4986 call2 (Qface_set_after_frame_default, frame, Qnil);
4987
4988 if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
4989 Fmodify_frame_parameters (frame, Fcons (Fcons (Qbackground_color, bg),
4990 Qnil));
4991 }
4992
4993 f->no_split = 1;
4994
4995 UNGCPRO;
4996
4997 4998 4999
5000 Vframe_list = Fcons (frame, Vframe_list);
5001
5002 5003
5004 FRAME_X_DISPLAY_INFO (f)->reference_count++;
5005
5006 5007 5008 5009 5010
5011 face_change_count = face_change_count_before;
5012
5013
5014 return unbind_to (count, frame);
5015 }
5016
5017
5018 5019 5020 5021 5022
5023
5024 static void
5025 compute_tip_xy (f, parms, dx, dy, width, height, root_x, root_y)
5026 struct frame *f;
5027 Lisp_Object parms, dx, dy;
5028 int width, height;
5029 int *root_x, *root_y;
5030 {
5031 Lisp_Object left, top;
5032 int win_x, win_y;
5033 Window root, child;
5034 unsigned pmask;
5035
5036
5037 left = Fcdr (Fassq (Qleft, parms));
5038 top = Fcdr (Fassq (Qtop, parms));
5039
5040 5041
5042 if (!INTEGERP (left) || !INTEGERP (top))
5043 {
5044 BLOCK_INPUT;
5045 XQueryPointer (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
5046 &root, &child, root_x, root_y, &win_x, &win_y, &pmask);
5047 UNBLOCK_INPUT;
5048 }
5049
5050 if (INTEGERP (top))
5051 *root_y = XINT (top);
5052 else if (*root_y + XINT (dy) <= 0)
5053 *root_y = 0;
5054 else if (*root_y + XINT (dy) + height
5055 <= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f)))
5056
5057 *root_y += XINT (dy);
5058 else if (height + XINT (dy) <= *root_y)
5059
5060 *root_y -= height + XINT (dy);
5061 else
5062
5063 *root_y = 0;
5064
5065 if (INTEGERP (left))
5066 *root_x = XINT (left);
5067 else if (*root_x + XINT (dx) <= 0)
5068 *root_x = 0;
5069 else if (*root_x + XINT (dx) + width
5070 <= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f)))
5071
5072 *root_x += XINT (dx);
5073 else if (width + XINT (dx) <= *root_x)
5074
5075 *root_x -= width + XINT (dx);
5076 else
5077
5078 *root_x = 0;
5079 }
5080
5081
5082 DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
5083 doc: 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 )
5106 (string, frame, parms, timeout, dx, dy)
5107 Lisp_Object string, frame, parms, timeout, dx, dy;
5108 {
5109 struct frame *f;
5110 struct window *w;
5111 int root_x, root_y;
5112 struct buffer *old_buffer;
5113 struct text_pos pos;
5114 int i, width, height;
5115 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
5116 int old_windows_or_buffers_changed = windows_or_buffers_changed;
5117 int count = SPECPDL_INDEX ();
5118
5119 specbind (Qinhibit_redisplay, Qt);
5120
5121 GCPRO4 (string, parms, frame, timeout);
5122
5123 CHECK_STRING (string);
5124 if (SCHARS (string) == 0)
5125 string = make_unibyte_string (" ", 1);
5126
5127 f = check_x_frame (frame);
5128 if (NILP (timeout))
5129 timeout = make_number (5);
5130 else
5131 CHECK_NATNUM (timeout);
5132
5133 if (NILP (dx))
5134 dx = make_number (5);
5135 else
5136 CHECK_NUMBER (dx);
5137
5138 if (NILP (dy))
5139 dy = make_number (-10);
5140 else
5141 CHECK_NUMBER (dy);
5142
5143 if (NILP (last_show_tip_args))
5144 last_show_tip_args = Fmake_vector (make_number (3), Qnil);
5145
5146 if (!NILP (tip_frame))
5147 {
5148 Lisp_Object last_string = AREF (last_show_tip_args, 0);
5149 Lisp_Object last_frame = AREF (last_show_tip_args, 1);
5150 Lisp_Object last_parms = AREF (last_show_tip_args, 2);
5151
5152 if (EQ (frame, last_frame)
5153 && !NILP (Fequal (last_string, string))
5154 && !NILP (Fequal (last_parms, parms)))
5155 {
5156 struct frame *f = XFRAME (tip_frame);
5157
5158
5159 if (!NILP (tip_timer))
5160 {
5161 Lisp_Object timer = tip_timer;
5162 tip_timer = Qnil;
5163 call1 (Qcancel_timer, timer);
5164 }
5165
5166 BLOCK_INPUT;
5167 compute_tip_xy (f, parms, dx, dy, FRAME_PIXEL_WIDTH (f),
5168 FRAME_PIXEL_HEIGHT (f), &root_x, &root_y);
5169 XMoveWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5170 root_x, root_y);
5171 UNBLOCK_INPUT;
5172 goto start_timer;
5173 }
5174 }
5175
5176
5177 Fx_hide_tip ();
5178
5179 ASET (last_show_tip_args, 0, string);
5180 ASET (last_show_tip_args, 1, frame);
5181 ASET (last_show_tip_args, 2, parms);
5182
5183
5184 if (NILP (Fassq (Qname, parms)))
5185 parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
5186 if (NILP (Fassq (Qinternal_border_width, parms)))
5187 parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
5188 if (NILP (Fassq (Qborder_width, parms)))
5189 parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
5190 if (NILP (Fassq (Qborder_color, parms)))
5191 parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
5192 if (NILP (Fassq (Qbackground_color, parms)))
5193 parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
5194 parms);
5195
5196 5197
5198 frame = x_create_tip_frame (FRAME_X_DISPLAY_INFO (f), parms, string);
5199 f = XFRAME (frame);
5200
5201
5202 w = XWINDOW (FRAME_ROOT_WINDOW (f));
5203 w->left_col = w->top_line = make_number (0);
5204
5205 if (CONSP (Vx_max_tooltip_size)
5206 && INTEGERP (XCAR (Vx_max_tooltip_size))
5207 && XINT (XCAR (Vx_max_tooltip_size)) > 0
5208 && INTEGERP (XCDR (Vx_max_tooltip_size))
5209 && XINT (XCDR (Vx_max_tooltip_size)) > 0)
5210 {
5211 w->total_cols = XCAR (Vx_max_tooltip_size);
5212 w->total_lines = XCDR (Vx_max_tooltip_size);
5213 }
5214 else
5215 {
5216 w->total_cols = make_number (80);
5217 w->total_lines = make_number (40);
5218 }
5219
5220 FRAME_TOTAL_COLS (f) = XINT (w->total_cols);
5221 adjust_glyphs (f);
5222 w->pseudo_window_p = 1;
5223
5224
5225 old_buffer = current_buffer;
5226 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->buffer));
5227 current_buffer->truncate_lines = Qnil;
5228 clear_glyph_matrix (w->desired_matrix);
5229 clear_glyph_matrix (w->current_matrix);
5230 SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
5231 try_window (FRAME_ROOT_WINDOW (f), pos, TRY_WINDOW_IGNORE_FONTS_CHANGE);
5232
5233
5234 width = height = 0;
5235 for (i = 0; i < w->desired_matrix->nrows; ++i)
5236 {
5237 struct glyph_row *row = &w->desired_matrix->rows[i];
5238 struct glyph *last;
5239 int row_width;
5240
5241
5242 if (!row->enabled_p || !row->displays_text_p)
5243 break;
5244
5245
5246 row->full_width_p = 1;
5247
5248 row_width = row->pixel_width;
5249 5250
5251 if (row->used[TEXT_AREA])
5252 {
5253 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
5254 if (INTEGERP (last->object))
5255 row_width -= last->pixel_width;
5256 }
5257
5258 height += row->height;
5259 width = max (width, row_width);
5260 }
5261
5262 5263
5264 height += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5265 width += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5266
5267 5268
5269 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
5270
5271 BLOCK_INPUT;
5272 XMoveResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5273 root_x, root_y, width, height);
5274 XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
5275 UNBLOCK_INPUT;
5276
5277
5278 w->must_be_updated_p = 1;
5279 update_single_window (w, 1);
5280
5281
5282 set_buffer_internal_1 (old_buffer);
5283 windows_or_buffers_changed = old_windows_or_buffers_changed;
5284
5285 start_timer:
5286
5287 tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
5288 intern ("x-hide-tip"));
5289
5290 UNGCPRO;
5291 return unbind_to (count, Qnil);
5292 }
5293
5294
5295 DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 0, 0,
5296 doc: 5297 )
5298 ()
5299 {
5300 int count;
5301 Lisp_Object deleted, frame, timer;
5302 struct gcpro gcpro1, gcpro2;
5303
5304
5305 if (NILP (tip_timer) && NILP (tip_frame))
5306 return Qnil;
5307
5308 frame = tip_frame;
5309 timer = tip_timer;
5310 GCPRO2 (frame, timer);
5311 tip_frame = tip_timer = deleted = Qnil;
5312
5313 count = SPECPDL_INDEX ();
5314 specbind (Qinhibit_redisplay, Qt);
5315 specbind (Qinhibit_quit, Qt);
5316
5317 if (!NILP (timer))
5318 call1 (Qcancel_timer, timer);
5319
5320 if (FRAMEP (frame))
5321 {
5322 delete_frame (frame, Qnil);
5323 deleted = Qt;
5324
5325 #ifdef USE_LUCID
5326 5327 5328
5329 {
5330 struct frame *f = SELECTED_FRAME ();
5331 Widget w = f->output_data.x->menubar_widget;
5332 extern void xlwmenu_redisplay P_ ((Widget));
5333
5334 if (!DoesSaveUnders (FRAME_X_DISPLAY_INFO (f)->screen)
5335 && w != NULL)
5336 {
5337 BLOCK_INPUT;
5338 xlwmenu_redisplay (w);
5339 UNBLOCK_INPUT;
5340 }
5341 }
5342 #endif
5343 }
5344
5345 UNGCPRO;
5346 return unbind_to (count, deleted);
5347 }
5348
5349
5350
5351 5352 5353
5354
5355 DEFUN ("x-uses-old-gtk-dialog", Fx_uses_old_gtk_dialog,
5356 Sx_uses_old_gtk_dialog,
5357 0, 0, 0,
5358 doc: )
5359 ()
5360 {
5361 #ifdef USE_GTK
5362 extern int use_dialog_box;
5363 extern int use_file_dialog;
5364
5365 if (use_dialog_box
5366 && use_file_dialog
5367 && have_menus_p ()
5368 && xg_uses_old_file_dialog ())
5369 return Qt;
5370 #endif
5371 return Qnil;
5372 }
5373
5374
5375 #ifdef USE_MOTIF
5376
5377
5378 static void
5379 file_dialog_cb (widget, client_data, call_data)
5380 Widget widget;
5381 XtPointer call_data, client_data;
5382 {
5383 int *result = (int *) client_data;
5384 XmAnyCallbackStruct *cb = (XmAnyCallbackStruct *) call_data;
5385 *result = cb->reason;
5386 }
5387
5388
5389 5390 5391 5392
5393
5394 static void
5395 file_dialog_unmap_cb (widget, client_data, call_data)
5396 Widget widget;
5397 XtPointer call_data, client_data;
5398 {
5399 int *result = (int *) client_data;
5400 *result = XmCR_CANCEL;
5401 }
5402
5403 static Lisp_Object
5404 clean_up_file_dialog (arg)
5405 Lisp_Object arg;
5406 {
5407 struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
5408 Widget dialog = (Widget) p->pointer;
5409
5410
5411 BLOCK_INPUT;
5412 XtUnmanageChild (dialog);
5413 XtDestroyWidget (dialog);
5414 x_menu_set_in_use (0);
5415 UNBLOCK_INPUT;
5416
5417 return Qnil;
5418 }
5419
5420
5421 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5422 doc: 5423 5424 5425 )
5426 (prompt, dir, default_filename, mustmatch, only_dir_p)
5427 Lisp_Object prompt, dir, default_filename, mustmatch, only_dir_p;
5428 {
5429 int result;
5430 struct frame *f = SELECTED_FRAME ();
5431 Lisp_Object file = Qnil;
5432 Lisp_Object decoded_file;
5433 Widget dialog, text, help;
5434 Arg al[10];
5435 int ac = 0;
5436 extern XtAppContext Xt_app_con;
5437 XmString dir_xmstring, pattern_xmstring;
5438 int count = SPECPDL_INDEX ();
5439 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
5440
5441 check_x ();
5442
5443 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
5444
5445 if (popup_activated ())
5446 error ("Trying to use a menu from within a menu-entry");
5447
5448 CHECK_STRING (prompt);
5449 CHECK_STRING (dir);
5450
5451
5452 specbind (Qinhibit_redisplay, Qt);
5453
5454 BLOCK_INPUT;
5455
5456 5457
5458 dir = Fexpand_file_name (dir, Qnil);
5459 dir_xmstring = XmStringCreateLocalized (SDATA (dir));
5460 pattern_xmstring = XmStringCreateLocalized ("*");
5461
5462 XtSetArg (al[ac], XmNtitle, SDATA (prompt)); ++ac;
5463 XtSetArg (al[ac], XmNdirectory, dir_xmstring); ++ac;
5464 XtSetArg (al[ac], XmNpattern, pattern_xmstring); ++ac;
5465 XtSetArg (al[ac], XmNresizePolicy, XmRESIZE_GROW); ++ac;
5466 XtSetArg (al[ac], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL); ++ac;
5467 dialog = XmCreateFileSelectionDialog (f->output_data.x->widget,
5468 "fsb", al, ac);
5469 XmStringFree (dir_xmstring);
5470 XmStringFree (pattern_xmstring);
5471
5472
5473 XtAddCallback (dialog, XmNokCallback, file_dialog_cb,
5474 (XtPointer) &result);
5475 XtAddCallback (dialog, XmNcancelCallback, file_dialog_cb,
5476 (XtPointer) &result);
5477 XtAddCallback (dialog, XmNunmapCallback, file_dialog_unmap_cb,
5478 (XtPointer) &result);
5479
5480
5481 help = XmFileSelectionBoxGetChild (dialog, XmDIALOG_HELP_BUTTON);
5482 XtUnmanageChild (help);
5483
5484
5485 XtVaSetValues (XmFileSelectionBoxGetChild (dialog, XmDIALOG_OK_BUTTON),
5486 XmNshowAsDefault, True, NULL);
5487
5488 5489 5490 5491
5492 text = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5493 if (!NILP (mustmatch))
5494 {
5495 Widget label;
5496 label = XmFileSelectionBoxGetChild (dialog, XmDIALOG_SELECTION_LABEL);
5497 XtSetSensitive (text, False);
5498 XtSetSensitive (label, False);
5499 }
5500
5501
5502 XtManageChild (dialog);
5503
5504 if (STRINGP (default_filename))
5505 {
5506 XmString default_xmstring;
5507 Widget wtext = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5508 Widget list = XmFileSelectionBoxGetChild (dialog, XmDIALOG_LIST);
5509
5510 XmTextPosition last_pos = XmTextFieldGetLastPosition (wtext);
5511 XmTextFieldReplace (wtext, 0, last_pos,
5512 (SDATA (Ffile_name_nondirectory (default_filename))));
5513
5514 5515
5516
5517 default_xmstring = XmStringCreateLocalized (SDATA (default_filename));
5518
5519 if (XmListItemExists (list, default_xmstring))
5520 {
5521 int item_pos = XmListItemPos (list, default_xmstring);
5522
5523 XmListSelectPos (list, item_pos, True);
5524 XmListSetPos (list, item_pos);
5525 }
5526
5527 XmStringFree (default_xmstring);
5528 }
5529
5530 record_unwind_protect (clean_up_file_dialog, make_save_value (dialog, 0));
5531
5532
5533 x_menu_set_in_use (1);
5534 result = 0;
5535 while (result == 0)
5536 {
5537 XEvent event;
5538 x_menu_wait_for_event (0);
5539 XtAppNextEvent (Xt_app_con, &event);
5540 if (event.type == KeyPress
5541 && FRAME_X_DISPLAY (f) == event.xkey.display)
5542 {
5543 KeySym keysym = XLookupKeysym (&event.xkey, 0);
5544
5545
5546 if (keysym == XK_g && (event.xkey.state & ControlMask) != 0)
5547 XtUnmanageChild (dialog);
5548 }
5549
5550 (void) x_dispatch_event (&event, FRAME_X_DISPLAY (f));
5551 }
5552
5553
5554 if (result == XmCR_OK)
5555 {
5556 XmString text;
5557 String data;
5558
5559 XtVaGetValues (dialog, XmNtextString, &text, NULL);
5560 XmStringGetLtoR (text, XmFONTLIST_DEFAULT_TAG, &data);
5561 XmStringFree (text);
5562 file = build_string (data);
5563 XtFree (data);
5564 }
5565 else
5566 file = Qnil;
5567
5568 UNBLOCK_INPUT;
5569 UNGCPRO;
5570
5571
5572 if (NILP (file))
5573 Fsignal (Qquit, Qnil);
5574
5575 decoded_file = DECODE_FILE (file);
5576
5577 return unbind_to (count, decoded_file);
5578 }
5579
5580 #endif
5581
5582 #ifdef USE_GTK
5583
5584 static Lisp_Object
5585 clean_up_dialog (arg)
5586 Lisp_Object arg;
5587 {
5588 x_menu_set_in_use (0);
5589
5590 return Qnil;
5591 }
5592
5593 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5594 doc: 5595 5596 5597 5598 )
5599 (prompt, dir, default_filename, mustmatch, only_dir_p)
5600 Lisp_Object prompt, dir, default_filename, mustmatch, only_dir_p;
5601 {
5602 FRAME_PTR f = SELECTED_FRAME ();
5603 char *fn;
5604 Lisp_Object file = Qnil;
5605 Lisp_Object decoded_file;
5606 int count = SPECPDL_INDEX ();
5607 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
5608 char *cdef_file;
5609
5610 check_x ();
5611
5612 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
5613
5614 if (popup_activated ())
5615 error ("Trying to use a menu from within a menu-entry");
5616
5617 CHECK_STRING (prompt);
5618 CHECK_STRING (dir);
5619
5620
5621 specbind (Qinhibit_redisplay, Qt);
5622 record_unwind_protect (clean_up_dialog, Qnil);
5623
5624 BLOCK_INPUT;
5625
5626 if (STRINGP (default_filename))
5627 cdef_file = SDATA (default_filename);
5628 else
5629 cdef_file = SDATA (dir);
5630
5631 fn = xg_get_file_name (f, SDATA (prompt), cdef_file,
5632 ! NILP (mustmatch),
5633 ! NILP (only_dir_p));
5634
5635 if (fn)
5636 {
5637 file = build_string (fn);
5638 xfree (fn);
5639 }
5640
5641 UNBLOCK_INPUT;
5642 UNGCPRO;
5643
5644
5645 if (NILP (file))
5646 Fsignal (Qquit, Qnil);
5647
5648 decoded_file = DECODE_FILE (file);
5649
5650 return unbind_to (count, decoded_file);
5651 }
5652
5653
5654 #ifdef HAVE_FREETYPE
5655
5656 DEFUN ("x-select-font", Fx_select_font, Sx_select_font, 0, 2, 0,
5657 doc: 5658 5659 5660 )
5661 (frame, ignored)
5662 Lisp_Object frame, ignored;
5663 {
5664 FRAME_PTR f = check_x_frame (frame);
5665 char *name;
5666 Lisp_Object font;
5667 Lisp_Object font_param;
5668 char *default_name = NULL;
5669 struct gcpro gcpro1, gcpro2;
5670 int count = SPECPDL_INDEX ();
5671
5672 check_x ();
5673
5674 if (popup_activated ())
5675 error ("Trying to use a menu from within a menu-entry");
5676
5677
5678 specbind (Qinhibit_redisplay, Qt);
5679 record_unwind_protect (clean_up_dialog, Qnil);
5680
5681 BLOCK_INPUT;
5682
5683 GCPRO2(font_param, font);
5684
5685 XSETFONT (font, FRAME_FONT (f));
5686 font_param = Ffont_get (font, intern (":name"));
5687 if (STRINGP (font_param))
5688 default_name = xstrdup (SDATA (font_param));
5689 else
5690 {
5691 font_param = Fframe_parameter (frame, Qfont_param);
5692 if (STRINGP (font_param))
5693 default_name = xstrdup (SDATA (font_param));
5694 }
5695
5696 if (default_name == NULL && x_last_font_name != NULL)
5697 default_name = xstrdup (x_last_font_name);
5698
5699
5700 if (default_name)
5701 {
5702 char *p = strrchr (default_name, '-');
5703 if (p)
5704 {
5705 char *ep = p+1;
5706 while (isdigit (*ep))
5707 ++ep;
5708 if (*ep == '\0') *p = ' ';
5709 }
5710 }
5711
5712 name = xg_get_font_name (f, default_name);
5713 xfree (default_name);
5714
5715 if (name)
5716 {
5717 font = build_string (name);
5718 g_free (x_last_font_name);
5719 x_last_font_name = name;
5720 }
5721
5722 UNBLOCK_INPUT;
5723
5724 if (NILP (font))
5725 Fsignal (Qquit, Qnil);
5726
5727 return unbind_to (count, font);
5728 }
5729 #endif
5730
5731 #endif
5732
5733
5734 5735 5736
5737
5738 #ifdef HAVE_XKBGETKEYBOARD
5739 #include <X11/XKBlib.h>
5740 #include <X11/keysym.h>
5741 #endif
5742
5743 DEFUN ("x-backspace-delete-keys-p", Fx_backspace_delete_keys_p,
5744 Sx_backspace_delete_keys_p, 0, 1, 0,
5745 doc: 5746 5747 5748 5749 )
5750 (frame)
5751 Lisp_Object frame;
5752 {
5753 #ifdef HAVE_XKBGETKEYBOARD
5754 XkbDescPtr kb;
5755 struct frame *f = check_x_frame (frame);
5756 Display *dpy = FRAME_X_DISPLAY (f);
5757 Lisp_Object have_keys;
5758 int major, minor, op, event, error;
5759
5760 BLOCK_INPUT;
5761
5762
5763 major = XkbMajorVersion;
5764 minor = XkbMinorVersion;
5765 if (!XkbLibraryVersion (&major, &minor))
5766 {
5767 UNBLOCK_INPUT;
5768 return Qlambda;
5769 }
5770
5771
5772 major = XkbMajorVersion;
5773 minor = XkbMinorVersion;
5774 if (!XkbQueryExtension (dpy, &op, &event, &error, &major, &minor))
5775 {
5776 UNBLOCK_INPUT;
5777 return Qlambda;
5778 }
5779
5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794
5795
5796 have_keys = Qnil;
5797 kb = XkbGetMap (dpy, XkbAllMapComponentsMask, XkbUseCoreKbd);
5798 if (kb)
5799 {
5800 int delete_keycode = 0, backspace_keycode = 0, i;
5801
5802 if (XkbGetNames (dpy, XkbAllNamesMask, kb) == Success)
5803 {
5804 for (i = kb->min_key_code;
5805 (i < kb->max_key_code
5806 && (delete_keycode == 0 || backspace_keycode == 0));
5807 ++i)
5808 {
5809 5810 5811
5812 if (bcmp ("DELE", kb->names->keys[i].name, 4) == 0)
5813 delete_keycode = i;
5814 else if (bcmp ("BKSP", kb->names->keys[i].name, 4) == 0)
5815 backspace_keycode = i;
5816 }
5817
5818 XkbFreeNames (kb, 0, True);
5819 }
5820
5821 XkbFreeClientMap (kb, 0, True);
5822
5823 if (delete_keycode
5824 && backspace_keycode
5825 && XKeysymToKeycode (dpy, XK_Delete) == delete_keycode
5826 && XKeysymToKeycode (dpy, XK_BackSpace) == backspace_keycode)
5827 have_keys = Qt;
5828 }
5829 UNBLOCK_INPUT;
5830 return have_keys;
5831 #else
5832 return Qlambda;
5833 #endif
5834 }
5835
5836
5837
5838 5839 5840
5841
5842 5843
5844
5845 frame_parm_handler x_frame_parm_handlers[] =
5846 {
5847 x_set_autoraise,
5848 x_set_autolower,
5849 x_set_background_color,
5850 x_set_border_color,
5851 x_set_border_width,
5852 x_set_cursor_color,
5853 x_set_cursor_type,
5854 x_set_font,
5855 x_set_foreground_color,
5856 x_set_icon_name,
5857 x_set_icon_type,
5858 x_set_internal_border_width,
5859 x_set_menu_bar_lines,
5860 x_set_mouse_color,
5861 x_explicitly_set_name,
5862 x_set_scroll_bar_width,
5863 x_set_title,
5864 x_set_unsplittable,
5865 x_set_vertical_scroll_bars,
5866 x_set_visibility,
5867 x_set_tool_bar_lines,
5868 x_set_scroll_bar_foreground,
5869 x_set_scroll_bar_background,
5870 x_set_screen_gamma,
5871 x_set_line_spacing,
5872 x_set_fringe_width,
5873 x_set_fringe_width,
5874 x_set_wait_for_wm,
5875 x_set_fullscreen,
5876 x_set_font_backend,
5877 x_set_alpha,
5878 x_set_sticky,
5879 };
5880
5881 void
5882 syms_of_xfns ()
5883 {
5884
5885 x_in_use = 0;
5886
5887 5888
5889
5890 Qnone = intern_c_string ("none");
5891 staticpro (&Qnone);
5892 Qsuppress_icon = intern_c_string ("suppress-icon");
5893 staticpro (&Qsuppress_icon);
5894 Qundefined_color = intern_c_string ("undefined-color");
5895 staticpro (&Qundefined_color);
5896 Qcompound_text = intern_c_string ("compound-text");
5897 staticpro (&Qcompound_text);
5898 Qcancel_timer = intern_c_string ("cancel-timer");
5899 staticpro (&Qcancel_timer);
5900 Qfont_param = intern_c_string ("font-parameter");
5901 staticpro (&Qfont_param);
5902
5903
5904
5905 Vtext_property_default_nonsticky
5906 = Fcons (Fcons (Qdisplay, Qt), Vtext_property_default_nonsticky);
5907
5908
5909 Fput (Qundefined_color, Qerror_conditions,
5910 pure_cons (Qundefined_color, pure_cons (Qerror, Qnil)));
5911 Fput (Qundefined_color, Qerror_message,
5912 make_pure_c_string ("Undefined color"));
5913
5914 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape,
5915 doc: 5916 5917 );
5918 Vx_pointer_shape = Qnil;
5919
5920 #if 0
5921 DEFVAR_LISP ("x-nontext-pointer-shape", &Vx_nontext_pointer_shape,
5922 doc: 5923 5924 );
5925 #endif
5926 Vx_nontext_pointer_shape = Qnil;
5927
5928 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape,
5929 doc: 5930 5931 );
5932 Vx_hourglass_pointer_shape = Qnil;
5933
5934 #if 0
5935 DEFVAR_LISP ("x-mode-pointer-shape", &Vx_mode_pointer_shape,
5936 doc: 5937 5938 );
5939 #endif
5940 Vx_mode_pointer_shape = Qnil;
5941
5942 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
5943 &Vx_sensitive_text_pointer_shape,
5944 doc: 5945 5946 );
5947 Vx_sensitive_text_pointer_shape = Qnil;
5948
5949 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
5950 &Vx_window_horizontal_drag_shape,
5951 doc: 5952 5953 );
5954 Vx_window_horizontal_drag_shape = Qnil;
5955
5956 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel,
5957 doc: );
5958 Vx_cursor_fore_pixel = Qnil;
5959
5960 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size,
5961 doc: 5962 );
5963 Vx_max_tooltip_size = Fcons (make_number (80), make_number (40));
5964
5965 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager,
5966 doc: 5967 5968 );
5969 5970
5971 Vx_no_window_manager = Qnil;
5972
5973 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
5974 &Vx_pixel_size_width_font_regexp,
5975 doc: 5976 5977 5978 5979 5980 );
5981 Vx_pixel_size_width_font_regexp = Qnil;
5982
5983
5984 DEFVAR_BOOL ("x-gtk-use-old-file-dialog", &x_gtk_use_old_file_dialog,
5985 doc: 5986 5987 5988 );
5989 x_gtk_use_old_file_dialog = 0;
5990
5991 DEFVAR_BOOL ("x-gtk-show-hidden-files", &x_gtk_show_hidden_files,
5992 doc: 5993 5994 );
5995 x_gtk_show_hidden_files = 0;
5996
5997 DEFVAR_BOOL ("x-gtk-file-dialog-help-text", &x_gtk_file_dialog_help_text,
5998 doc: 5999 6000 );
6001 x_gtk_file_dialog_help_text = 1;
6002
6003 DEFVAR_BOOL ("x-gtk-whole-detached-tool-bar", &x_gtk_whole_detached_tool_bar,
6004 doc: 6005 6006 );
6007 x_gtk_whole_detached_tool_bar = 0;
6008
6009 Fprovide (intern_c_string ("x"), Qnil);
6010
6011 #ifdef USE_X_TOOLKIT
6012 Fprovide (intern_c_string ("x-toolkit"), Qnil);
6013 #ifdef USE_MOTIF
6014 Fprovide (intern_c_string ("motif"), Qnil);
6015
6016 DEFVAR_LISP ("motif-version-string", &Vmotif_version_string,
6017 doc: );
6018 Vmotif_version_string = build_string (XmVERSION_STRING);
6019 #endif
6020 #endif
6021
6022 #ifdef USE_GTK
6023 6024 6025 6026
6027 Fprovide (intern_c_string ("x-toolkit"), Qnil);
6028 Fprovide (intern_c_string ("gtk"), Qnil);
6029
6030 DEFVAR_LISP ("gtk-version-string", &Vgtk_version_string,
6031 doc: );
6032 {
6033 char gtk_version[40];
6034 g_snprintf (gtk_version, sizeof (gtk_version), "%u.%u.%u",
6035 GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
6036 Vgtk_version_string = make_pure_string (gtk_version, strlen (gtk_version), strlen (gtk_version), 0);
6037 }
6038 #endif
6039
6040
6041 defsubr (&Sx_change_window_property);
6042 defsubr (&Sx_delete_window_property);
6043 defsubr (&Sx_window_property);
6044
6045 defsubr (&Sxw_display_color_p);
6046 defsubr (&Sx_display_grayscale_p);
6047 defsubr (&Sxw_color_defined_p);
6048 defsubr (&Sxw_color_values);
6049 defsubr (&Sx_server_max_request_size);
6050 defsubr (&Sx_server_vendor);
6051 defsubr (&Sx_server_version);
6052 defsubr (&Sx_display_pixel_width);
6053 defsubr (&Sx_display_pixel_height);
6054 defsubr (&Sx_display_mm_width);
6055 defsubr (&Sx_display_mm_height);
6056 defsubr (&Sx_display_screens);
6057 defsubr (&Sx_display_planes);
6058 defsubr (&Sx_display_color_cells);
6059 defsubr (&Sx_display_visual_class);
6060 defsubr (&Sx_display_backing_store);
6061 defsubr (&Sx_display_save_under);
6062 defsubr (&Sx_wm_set_size_hint);
6063 defsubr (&Sx_create_frame);
6064 defsubr (&Sx_open_connection);
6065 defsubr (&Sx_close_connection);
6066 defsubr (&Sx_display_list);
6067 defsubr (&Sx_synchronize);
6068 defsubr (&Sx_focus_frame);
6069 defsubr (&Sx_backspace_delete_keys_p);
6070
6071
6072 check_window_system_func = check_x;
6073
6074 defsubr (&Sx_show_tip);
6075 defsubr (&Sx_hide_tip);
6076 tip_timer = Qnil;
6077 staticpro (&tip_timer);
6078 tip_frame = Qnil;
6079 staticpro (&tip_frame);
6080
6081 last_show_tip_args = Qnil;
6082 staticpro (&last_show_tip_args);
6083
6084 defsubr (&Sx_uses_old_gtk_dialog);
6085 #if defined (USE_MOTIF) || defined (USE_GTK)
6086 defsubr (&Sx_file_dialog);
6087 #endif
6088
6089 #if defined (USE_GTK) && defined (HAVE_FREETYPE)
6090 defsubr (&Sx_select_font);
6091 x_last_font_name = NULL;
6092 #endif
6093 }
6094
6095 #endif
6096
6097 6098