Mercurial > hg > xemacs-beta

comparison src/device-gtk.c @ 462:0784d089fdc9 r21-2-46

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r21-2-46
author cvs
date Mon, 13 Aug 2007 11:44:37 +0200
parents
children 9a775fb11bb7
comparison
equal deleted inserted replaced
461:120ed4009e51 462:0784d089fdc9
1 /* Device functions for X windows.
2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
3 Copyright (C) 1994, 1995 Free Software Foundation, Inc.
4
5 This file is part of XEmacs.
6
7 XEmacs is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
10 later version.
11
12 XEmacs is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with XEmacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 /* Synched up with: Not in FSF. */
23
24 /* Original authors: Jamie Zawinski and the FSF */
25 /* Rewritten by Ben Wing and Chuck Thompson. */
26 /* Gtk flavor written by William Perry */
27
28 #include <config.h>
29 #include "lisp.h"
30
31 #include "console-gtk.h"
32 #include "gccache-gtk.h"
33 #include "glyphs-gtk.h"
34 #include "objects-gtk.h"
35 #include "gtk-xemacs.h"
36
37 #include "buffer.h"
38 #include "events.h"
39 #include "faces.h"
40 #include "frame.h"
41 #include "redisplay.h"
42 #include "sysdep.h"
43 #include "window.h"
44 #include "elhash.h"
45
46 #include "sysfile.h"
47 #include "systime.h"
48
49 #ifdef HAVE_GNOME
50 #include <libgnomeui/libgnomeui.h>
51 #endif
52
53 #ifdef HAVE_BONOBO
54 #include <bonobo.h>
55 #endif
56
57 Lisp_Object Vdefault_gtk_device;
58
59 /* Qdisplay in general.c */
60 Lisp_Object Qinit_pre_gtk_win, Qinit_post_gtk_win;
61
62 /* The application class of Emacs. */
63 Lisp_Object Vgtk_emacs_application_class;
64
65 Lisp_Object Vgtk_initial_argv_list; /* #### ugh! */
66 Lisp_Object Vgtk_initial_geometry;
67
68 static void gtk_device_init_x_specific_cruft (struct device *d);
69
70
71 /************************************************************************/
72 /* helper functions */
73 /************************************************************************/
74
75 struct device *
76 decode_gtk_device (Lisp_Object device)
77 {
78 XSETDEVICE (device, decode_device (device));
79 CHECK_GTK_DEVICE (device);
80 return XDEVICE (device);
81 }
82
83
84 /************************************************************************/
85 /* initializing a GTK connection */
86 /************************************************************************/
87 extern Lisp_Object
88 xemacs_gtk_convert_color(GdkColor *c, GtkWidget *w);
89
90 extern Lisp_Object __get_gtk_font_truename (GdkFont *gdk_font, int expandp);
91
92 #define convert_font(f) __get_gtk_font_truename (f, 0)
93
94 static void
95 allocate_gtk_device_struct (struct device *d)
96 {
97 d->device_data = xnew_and_zero (struct gtk_device);
98 DEVICE_GTK_DATA (d)->x_keysym_map_hashtable = Qnil;
99 }
100
101 static void
102 gtk_init_device_class (struct device *d)
103 {
104 if (DEVICE_GTK_DEPTH(d) > 2)
105 {
106 switch (DEVICE_GTK_VISUAL(d)->type)
107 {
108 case GDK_VISUAL_STATIC_GRAY:
109 case GDK_VISUAL_GRAYSCALE:
110 DEVICE_CLASS (d) = Qgrayscale;
111 break;
112 default:
113 DEVICE_CLASS (d) = Qcolor;
114 }
115 }
116 else
117 DEVICE_CLASS (d) = Qmono;
118 }
119
120 #ifdef HAVE_GDK_IMLIB_INIT
121 extern void gdk_imlib_init(void);
122 #endif
123
124 extern void emacs_gtk_selection_handle (GtkWidget *,
125 GtkSelectionData *selection_data,
126 guint info,
127 guint time_stamp,
128 gpointer data);
129 extern void emacs_gtk_selection_received (GtkWidget *widget,
130 GtkSelectionData *selection_data,
131 gpointer user_data);
132
133 #ifdef HAVE_BONOBO
134 static CORBA_ORB orb;
135 #endif
136
137 DEFUN ("gtk-init", Fgtk_init, 1, 1, 0, /*
138 Initialize the GTK subsystem.
139 ARGS is a standard list of command-line arguments.
140
141 No effect if called more than once. Called automatically when
142 creating the first GTK device. Must be called manually from batch
143 mode.
144 */
145 (args))
146 {
147 int argc;
148 char **argv;
149 static int done;
150
151 if (done)
152 {
153 return (Qt);
154 }
155
156 make_argc_argv (args, &argc, &argv);
157
158 slow_down_interrupts ();
159 #ifdef HAVE_GNOME
160 #ifdef INFODOCK
161 gnome_init ("InfoDock", EMACS_VERSION, argc, argv);
162 #else
163 gnome_init ("XEmacs", EMACS_VERSION, argc, argv);
164 #endif /* INFODOCK */
165 #else
166 gtk_init (&argc, &argv);
167 #endif
168
169 #ifdef HAVE_BONOBO
170 orb = oaf_init (argc, argv);
171
172 if (bonobo_init (orb, NULL, NULL) == FALSE)
173 {
174 g_warning ("Could not initialize bonobo...");
175 }
176
177 bonobo_activate ();
178 #endif
179
180 speed_up_interrupts ();
181
182 free_argc_argv (argv);
183 return (Qt);
184 }
185
186 static void
187 gtk_init_device (struct device *d, Lisp_Object props)
188 {
189 Lisp_Object device;
190 Lisp_Object display;
191 GtkWidget *app_shell = NULL;
192 GdkVisual *visual = NULL;
193 GdkColormap *cmap = NULL;
194
195 XSETDEVICE (device, d);
196
197 /* gtk_init() and even gtk_check_init() are so brain dead that
198 getting an empty argv array causes them to abort. */
199 if (NILP (Vgtk_initial_argv_list))
200 {
201 signal_simple_error ("gtk-initial-argv-list must be set before creating Gtk devices", Vgtk_initial_argv_list);
202 return;
203 }
204
205 allocate_gtk_device_struct (d);
206 display = DEVICE_CONNECTION (d);
207
208 /* Attempt to load a site-specific gtkrc */
209 {
210 Lisp_Object gtkrc = Fexpand_file_name (build_string ("gtkrc"), Vdata_directory);
211 gchar **default_files = gtk_rc_get_default_files ();
212 gint num_files;
213
214 if (STRINGP (gtkrc))
215 {
216 /* Found one, load it up! */
217 gchar **new_rc_files = NULL;
218 int ctr;
219
220 for (num_files = 0; default_files[num_files]; num_files++);
221
222 new_rc_files = xnew_array_and_zero (gchar *, num_files + 3);
223
224 new_rc_files[0] = XSTRING_DATA (gtkrc);
225 for (ctr = 1; default_files[ctr-1]; ctr++)
226 new_rc_files[ctr] = g_strdup (default_files[ctr-1]);
227
228 gtk_rc_set_default_files (new_rc_files);
229
230 for (ctr = 1; new_rc_files[ctr]; ctr++)
231 free(new_rc_files[ctr]);
232
233 xfree (new_rc_files);
234 }
235 }
236
237 Fgtk_init (Vgtk_initial_argv_list);
238
239 #ifdef __FreeBSD__
240 gdk_set_use_xshm (FALSE);
241 #endif
242
243 /* We attempt to load this file so that the user can set
244 ** gtk-initial-geometry and not need GNOME & session management to
245 ** set their default frame size. It also avoids the flicker
246 ** associated with setting the frame size in your .emacs file.
247 */
248 call4 (Qload, build_string ("~/.xemacs/gtk-options.el"), Qt, Qt, Qt);
249
250 #ifdef HAVE_GDK_IMLIB_INIT
251 /* Some themes in Gtk are so lame (most notably the Pixmap theme)
252 that they rely on gdk_imlib, but don't call its initialization
253 routines. This makes them USELESS for non-gnome applications.
254 So we bend over backwards to try and make them work. Losers. */
255 gdk_imlib_init ();
256 #endif
257
258 if (NILP (DEVICE_NAME (d)))
259 DEVICE_NAME (d) = display;
260
261 /* Always search for the best visual */
262 visual = gdk_visual_get_best();
263 cmap = gdk_colormap_new (visual, TRUE);
264
265 DEVICE_GTK_VISUAL (d) = visual;
266 DEVICE_GTK_COLORMAP (d) = cmap;
267 DEVICE_GTK_DEPTH (d) = visual->depth;
268
269 {
270 GtkWidget *w = gtk_window_new (GTK_WINDOW_TOPLEVEL);
271
272 app_shell = gtk_xemacs_new (NULL);
273 gtk_container_add (GTK_CONTAINER (w), app_shell);
274
275 gtk_widget_realize (w);
276 }
277
278 DEVICE_GTK_APP_SHELL (d) = app_shell;
279
280 /* Realize the app_shell so that its window exists for GC creation
281 purposes */
282 gtk_widget_realize (GTK_WIDGET (app_shell));
283
284 /* Need to set up some selection handlers */
285 gtk_selection_add_target (GTK_WIDGET (app_shell), GDK_SELECTION_PRIMARY,
286 GDK_SELECTION_TYPE_STRING, 0);
287
288 gtk_signal_connect (GTK_OBJECT (app_shell), "selection_get",
289 GTK_SIGNAL_FUNC (emacs_gtk_selection_handle), NULL);
290 gtk_signal_connect (GTK_OBJECT (app_shell), "selection_received",
291 GTK_SIGNAL_FUNC (emacs_gtk_selection_received), NULL);
292
293 DEVICE_GTK_WM_COMMAND_FRAME (d) = Qnil;
294
295 gtk_init_modifier_mapping (d);
296
297 gtk_device_init_x_specific_cruft (d);
298
299 init_baud_rate (d);
300 init_one_device (d);
301
302 DEVICE_GTK_GC_CACHE (d) = make_gc_cache (GTK_WIDGET (app_shell));
303 DEVICE_GTK_GRAY_PIXMAP (d) = NULL;
304
305 gtk_init_device_class (d);
306
307 /* Run the elisp side of the X device initialization. */
308 call0 (Qinit_pre_gtk_win);
309 }
310
311 static void
312 gtk_finish_init_device (struct device *d, Lisp_Object props)
313 {
314 call0 (Qinit_post_gtk_win);
315 }
316
317 static void
318 gtk_mark_device (struct device *d)
319 {
320 mark_object (DEVICE_GTK_WM_COMMAND_FRAME (d));
321 mark_object (DEVICE_GTK_DATA (d)->x_keysym_map_hashtable);
322 }
323
324
325 /************************************************************************/
326 /* closing an X connection */
327 /************************************************************************/
328
329 static void
330 free_gtk_device_struct (struct device *d)
331 {
332 xfree (d->device_data);
333 }
334
335 static void
336 gtk_delete_device (struct device *d)
337 {
338 Lisp_Object device;
339
340 #ifdef FREE_CHECKING
341 extern void (*__free_hook)();
342 int checking_free;
343 #endif
344
345 XSETDEVICE (device, d);
346 if (1)
347 {
348 #ifdef FREE_CHECKING
349 checking_free = (__free_hook != 0);
350
351 /* Disable strict free checking, to avoid bug in X library */
352 if (checking_free)
353 disable_strict_free_check ();
354 #endif
355
356 free_gc_cache (DEVICE_GTK_GC_CACHE (d));
357
358 #ifdef FREE_CHECKING
359 if (checking_free)
360 enable_strict_free_check ();
361 #endif
362 }
363
364 if (EQ (device, Vdefault_gtk_device))
365 {
366 Lisp_Object devcons, concons;
367 /* #### handle deleting last X device */
368 Vdefault_gtk_device = Qnil;
369 DEVICE_LOOP_NO_BREAK (devcons, concons)
370 {
371 if (DEVICE_GTK_P (XDEVICE (XCAR (devcons))) &&
372 !EQ (device, XCAR (devcons)))
373 {
374 Vdefault_gtk_device = XCAR (devcons);
375 goto double_break;
376 }
377 }
378 }
379 double_break:
380 free_gtk_device_struct (d);
381 }
382
383
384 /************************************************************************/
385 /* handle X errors */
386 /************************************************************************/
387
388 const char *
389 gtk_event_name (GdkEventType event_type)
390 {
391 GtkEnumValue *vals = gtk_type_enum_get_values (GTK_TYPE_GDK_EVENT_TYPE);
392
393 while (vals && (vals->value != event_type)) vals++;
394
395 if (vals)
396 return (vals->value_nick);
397
398 return (NULL);
399 }
400
401
402 /************************************************************************/
403 /* display information functions */
404 /************************************************************************/
405
406 DEFUN ("default-gtk-device", Fdefault_gtk_device, 0, 0, 0, /*
407 Return the default GTK device for resourcing.
408 This is the first-created GTK device that still exists.
409 */
410 ())
411 {
412 return Vdefault_gtk_device;
413 }
414
415 DEFUN ("gtk-display-visual-class", Fgtk_display_visual_class, 0, 1, 0, /*
416 Return the visual class of the GTK display DEVICE is using.
417 The returned value will be one of the symbols `static-gray', `gray-scale',
418 `static-color', `pseudo-color', `true-color', or `direct-color'.
419 */
420 (device))
421 {
422 GdkVisual *vis = DEVICE_GTK_VISUAL (decode_gtk_device (device));
423 switch (vis->type)
424 {
425 case GDK_VISUAL_STATIC_GRAY: return intern ("static-gray");
426 case GDK_VISUAL_GRAYSCALE: return intern ("gray-scale");
427 case GDK_VISUAL_STATIC_COLOR: return intern ("static-color");
428 case GDK_VISUAL_PSEUDO_COLOR: return intern ("pseudo-color");
429 case GDK_VISUAL_TRUE_COLOR: return intern ("true-color");
430 case GDK_VISUAL_DIRECT_COLOR: return intern ("direct-color");
431 default:
432 error ("display has an unknown visual class");
433 return Qnil; /* suppress compiler warning */
434 }
435 }
436
437 DEFUN ("gtk-display-visual-depth", Fgtk_display_visual_depth, 0, 1, 0, /*
438 Return the bitplane depth of the visual the GTK display DEVICE is using.
439 */
440 (device))
441 {
442 return make_int (DEVICE_GTK_DEPTH (decode_gtk_device (device)));
443 }
444
445 static Lisp_Object
446 gtk_device_system_metrics (struct device *d,
447 enum device_metrics m)
448 {
449 #if 0
450 GtkStyle *style = gtk_widget_get_style (GTK_WIDGET (DEVICE_GTK_APP_SHELL (d)));
451
452 style = gtk_style_attach (style, w);
453 #endif
454
455 switch (m)
456 {
457 case DM_size_device:
458 return Fcons (make_int (gdk_screen_width ()),
459 make_int (gdk_screen_height ()));
460 case DM_size_device_mm:
461 return Fcons (make_int (gdk_screen_width_mm ()),
462 make_int (gdk_screen_height_mm ()));
463 case DM_num_color_cells:
464 return make_int (gdk_colormap_get_system_size ());
465 case DM_num_bit_planes:
466 return make_int (DEVICE_GTK_DEPTH (d));
467
468 #if 0
469 case DM_color_default:
470 case DM_color_select:
471 case DM_color_balloon:
472 case DM_color_3d_face:
473 case DM_color_3d_light:
474 case DM_color_3d_dark:
475 case DM_color_menu:
476 case DM_color_menu_highlight:
477 case DM_color_menu_button:
478 case DM_color_menu_disabled:
479 case DM_color_toolbar:
480 case DM_color_scrollbar:
481 case DM_color_desktop:
482 case DM_color_workspace:
483 case DM_font_default:
484 case DM_font_menubar:
485 case DM_font_dialog:
486 case DM_size_cursor:
487 case DM_size_scrollbar:
488 case DM_size_menu:
489 case DM_size_toolbar:
490 case DM_size_toolbar_button:
491 case DM_size_toolbar_border:
492 case DM_size_icon:
493 case DM_size_icon_small:
494 case DM_size_workspace:
495 case DM_device_dpi:
496 case DM_mouse_buttons:
497 case DM_swap_buttons:
498 case DM_show_sounds:
499 case DM_slow_device:
500 case DM_security:
501 #endif
502 default: /* No such device metric property for GTK devices */
503 return Qunbound;
504 }
505 }
506
507 DEFUN ("gtk-keysym-on-keyboard-p", Fgtk_keysym_on_keyboard_p, 1, 2, 0, /*
508 Return true if KEYSYM names a key on the keyboard of DEVICE.
509 More precisely, return true if some keystroke (possibly including modifiers)
510 on the keyboard of DEVICE keys generates KEYSYM.
511 Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in
512 /usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system.
513 The keysym name can be provided in two forms:
514 - if keysym is a string, it must be the name as known to X windows.
515 - if keysym is a symbol, it must be the name as known to XEmacs.
516 The two names differ in capitalization and underscoring.
517 */
518 (keysym, device))
519 {
520 struct device *d = decode_device (device);
521
522 if (!DEVICE_GTK_P (d))
523 signal_simple_error ("Not a GTK device", device);
524
525 return (NILP (Fgethash (keysym, DEVICE_GTK_DATA (d)->x_keysym_map_hashtable, Qnil)) ?
526 Qnil : Qt);
527 }
528
529
530 /************************************************************************/
531 /* grabs and ungrabs */
532 /************************************************************************/
533
534 DEFUN ("gtk-grab-pointer", Fgtk_grab_pointer, 0, 3, 0, /*
535 Grab the pointer and restrict it to its current window.
536 If optional DEVICE argument is nil, the default device will be used.
537 If optional CURSOR argument is non-nil, change the pointer shape to that
538 until `gtk-ungrab-pointer' is called (it should be an object returned by the
539 `make-cursor-glyph' function).
540 If the second optional argument IGNORE-KEYBOARD is non-nil, ignore all
541 keyboard events during the grab.
542 Returns t if the grab is successful, nil otherwise.
543 */
544 (device, cursor, ignore_keyboard))
545 {
546 GdkWindow *w;
547 int result;
548 struct device *d = decode_gtk_device (device);
549
550 if (!NILP (cursor))
551 {
552 CHECK_POINTER_GLYPH (cursor);
553 cursor = glyph_image_instance (cursor, device, ERROR_ME, 0);
554 }
555
556 /* We should call gdk_pointer_grab() and (possibly) gdk_keyboard_grab() here instead */
557 w = GET_GTK_WIDGET_WINDOW (FRAME_GTK_TEXT_WIDGET (device_selected_frame (d)));
558
559 result = gdk_pointer_grab (w, FALSE,
560 GDK_POINTER_MOTION_MASK |
561 GDK_POINTER_MOTION_HINT_MASK |
562 GDK_BUTTON1_MOTION_MASK |
563 GDK_BUTTON2_MOTION_MASK |
564 GDK_BUTTON3_MOTION_MASK |
565 GDK_BUTTON_PRESS_MASK |
566 GDK_BUTTON_RELEASE_MASK,
567 w,
568 NULL, /* #### BILL!!! Need to create a GdkCursor * as necessary! */
569 GDK_CURRENT_TIME);
570
571 return (result == 0) ? Qt : Qnil;
572 }
573
574 DEFUN ("gtk-ungrab-pointer", Fgtk_ungrab_pointer, 0, 1, 0, /*
575 Release a pointer grab made with `gtk-grab-pointer'.
576 If optional first arg DEVICE is nil the default device is used.
577 If it is t the pointer will be released on all GTK devices.
578 */
579 (device))
580 {
581 if (!EQ (device, Qt))
582 {
583 gdk_pointer_ungrab (GDK_CURRENT_TIME);
584 }
585 else
586 {
587 Lisp_Object devcons, concons;
588
589 DEVICE_LOOP_NO_BREAK (devcons, concons)
590 {
591 struct device *d = XDEVICE (XCAR (devcons));
592
593 if (DEVICE_GTK_P (d))
594 gdk_pointer_ungrab (GDK_CURRENT_TIME);
595 }
596 }
597 return Qnil;
598 }
599
600 DEFUN ("gtk-grab-keyboard", Fgtk_grab_keyboard, 0, 1, 0, /*
601 Grab the keyboard on the given device (defaulting to the selected one).
602 So long as the keyboard is grabbed, all keyboard events will be delivered
603 to emacs -- it is not possible for other clients to eavesdrop on them.
604 Ungrab the keyboard with `gtk-ungrab-keyboard' (use an unwind-protect).
605 Returns t if the grab is successful, nil otherwise.
606 */
607 (device))
608 {
609 struct device *d = decode_gtk_device (device);
610 GdkWindow *w = GET_GTK_WIDGET_WINDOW (FRAME_GTK_TEXT_WIDGET (device_selected_frame (d)));
611
612 gdk_keyboard_grab (w, FALSE, GDK_CURRENT_TIME );
613
614 return Qt;
615 }
616
617 DEFUN ("gtk-ungrab-keyboard", Fgtk_ungrab_keyboard, 0, 1, 0, /*
618 Release a keyboard grab made with `gtk-grab-keyboard'.
619 */
620 (device))
621 {
622 gdk_keyboard_ungrab (GDK_CURRENT_TIME);
623 return Qnil;
624 }
625
626
627 /************************************************************************/
628 /* Style Info */
629 /************************************************************************/
630 DEFUN ("gtk-style-info", Fgtk_style_info, 0, 1, 0, /*
631 Get the style information for a Gtk device.
632 */
633 (device))
634 {
635 struct device *d = decode_device (device);
636 GtkStyle *style = NULL;
637 Lisp_Object result = Qnil;
638 GtkWidget *app_shell = GTK_WIDGET (DEVICE_GTK_APP_SHELL (d));
639 GdkWindow *w = GET_GTK_WIDGET_WINDOW (app_shell);
640
641 if (!DEVICE_GTK_P (d))
642 return (Qnil);
643
644 style = gtk_widget_get_style (app_shell);
645 style = gtk_style_attach (style, w);
646
647 if (!style) return (Qnil);
648
649 #define FROB_COLOR(slot, name) \
650 result = nconc2 (result, \
651 list2 (intern (name), \
652 list5 (xemacs_gtk_convert_color (&style->slot[GTK_STATE_NORMAL], app_shell),\
653 xemacs_gtk_convert_color (&style->slot[GTK_STATE_ACTIVE], app_shell),\
654 xemacs_gtk_convert_color (&style->slot[GTK_STATE_PRELIGHT], app_shell),\
655 xemacs_gtk_convert_color (&style->slot[GTK_STATE_SELECTED], app_shell),\
656 xemacs_gtk_convert_color (&style->slot[GTK_STATE_INSENSITIVE], app_shell))))
657
658 FROB_COLOR (fg, "foreground");
659 FROB_COLOR (bg, "background");
660 FROB_COLOR (light, "light");
661 FROB_COLOR (dark, "dark");
662 FROB_COLOR (mid, "mid");
663 FROB_COLOR (text, "text");
664 FROB_COLOR (base, "base");
665 #undef FROB_COLOR
666
667 result = nconc2 (result, list2 (Qfont, convert_font (style->font)));
668
669 #define FROB_PIXMAP(state) (style->rc_style->bg_pixmap_name[state] ? build_string (style->rc_style->bg_pixmap_name[state]) : Qnil)
670
671 if (style->rc_style)
672 result = nconc2 (result, list2 (Qbackground,
673 list5 ( FROB_PIXMAP (GTK_STATE_NORMAL),
674 FROB_PIXMAP (GTK_STATE_ACTIVE),
675 FROB_PIXMAP (GTK_STATE_PRELIGHT),
676 FROB_PIXMAP (GTK_STATE_SELECTED),
677 FROB_PIXMAP (GTK_STATE_INSENSITIVE))));
678 #undef FROB_PIXMAP
679
680 return (result);
681 }
682
683 static unsigned int
684 gtk_device_implementation_flags (void)
685 {
686 return 0; /* XDEVIMPF_PIXEL_GEOMETRY; */
687 }
688
689
690 /************************************************************************/
691 /* initialization */
692 /************************************************************************/
693
694 void
695 syms_of_device_gtk (void)
696 {
697 DEFSUBR (Fdefault_gtk_device);
698 DEFSUBR (Fgtk_keysym_on_keyboard_p);
699 DEFSUBR (Fgtk_display_visual_class);
700 DEFSUBR (Fgtk_display_visual_depth);
701 DEFSUBR (Fgtk_style_info);
702 DEFSUBR (Fgtk_grab_pointer);
703 DEFSUBR (Fgtk_ungrab_pointer);
704 DEFSUBR (Fgtk_grab_keyboard);
705 DEFSUBR (Fgtk_ungrab_keyboard);
706 DEFSUBR (Fgtk_init);
707
708 defsymbol (&Qinit_pre_gtk_win, "init-pre-gtk-win");
709 defsymbol (&Qinit_post_gtk_win, "init-post-gtk-win");
710 }
711
712 void
713 console_type_create_device_gtk (void)
714 {
715 CONSOLE_HAS_METHOD (gtk, init_device);
716 CONSOLE_HAS_METHOD (gtk, finish_init_device);
717 CONSOLE_HAS_METHOD (gtk, mark_device);
718 CONSOLE_HAS_METHOD (gtk, delete_device);
719 CONSOLE_HAS_METHOD (gtk, device_system_metrics);
720 CONSOLE_HAS_METHOD (gtk, device_implementation_flags);
721 }
722
723 void
724 vars_of_device_gtk (void)
725 {
726 Fprovide (Qgtk);
727
728 staticpro (&Vdefault_gtk_device);
729
730 DEFVAR_LISP ("gtk-initial-argv-list", &Vgtk_initial_argv_list /*
731 You don't want to know.
732 This is used during startup to communicate the remaining arguments in
733 `command-line-args-left' to the C code, which passes the args to
734 the GTK initialization code, which removes some args, and then the
735 args are placed back into `gtk-initial-arg-list' and thence into
736 `command-line-args-left'. Perhaps `command-line-args-left' should
737 just reside in C.
738 */ );
739
740 DEFVAR_LISP ("gtk-initial-geometry", &Vgtk_initial_geometry /*
741 You don't want to know.
742 This is used during startup to communicate the default geometry to GTK.
743 */ );
744
745 Vdefault_gtk_device = Qnil;
746 Vgtk_initial_geometry = Qnil;
747 Vgtk_initial_argv_list = Qnil;
748 }
749
750 #include <gdk/gdkx.h>
751 static void
752 gtk_device_init_x_specific_cruft (struct device *d)
753 {
754 DEVICE_INFD (d) = DEVICE_OUTFD (d) = ConnectionNumber (GDK_DISPLAY ());
755 }