1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
11 * Porting to GTK+ was done by:
13 * (C) 1998,1999,2000 by Marcin Dalecki <martin@dalecki.de>
15 * With GREAT support and continuous encouragements by Andy Kahn and of
16 * course Bram Moolenaar!
18 * Support for GTK+ 2 was added by:
20 * (C) 2002,2003 Jason Hildebrand <jason@peaceworks.ca>
21 * Daniel Elstner <daniel.elstner@gmx.net>
27 /* Gnome redefines _() and N_(). Grrr... */
37 # ifdef bindtextdomain
38 # undef bindtextdomain
40 # ifdef bind_textdomain_codeset
41 # undef bind_textdomain_codeset
43 # if defined(FEAT_GETTEXT) && !defined(ENABLE_NLS)
44 # define ENABLE_NLS /* so the texts in the dialog boxes are translated */
49 /* missing prototype in bonobo-dock-item.h */
50 extern void bonobo_dock_item_set_behavior(BonoboDockItem
*dock_item
, BonoboDockItemBehavior beh
);
54 #if !defined(FEAT_GUI_GTK) && defined(PROTO)
55 /* When generating prototypes we don't want syntax errors. */
57 # define GdkEventExpose int
58 # define GdkEventFocus int
59 # define GdkEventVisibility int
60 # define GdkEventProperty int
61 # define GtkContainer int
62 # define GtkTargetEntry int
64 # define GtkWidget int
68 # define GdkEventKey int
69 # define GdkEventSelection int
70 # define GtkSelectionData int
71 # define GdkEventMotion int
72 # define GdkEventButton int
73 # define GdkDragContext int
74 # define GdkEventConfigure int
75 # define GdkEventClient int
77 # include <gdk/gdkkeysyms.h>
80 # include <gdk/gdkwin32.h>
82 # include <gdk/gdkx.h>
86 # include "gui_gtk_f.h"
89 #ifdef HAVE_X11_SUNKEYSYM_H
90 # include <X11/Sunkeysym.h>
94 * Easy-to-use macro for multihead support.
96 #ifdef HAVE_GTK_MULTIHEAD
97 # define GET_X_ATOM(atom) gdk_x11_atom_to_xatom_for_display( \
98 gtk_widget_get_display(gui.mainwin), atom)
100 # define GET_X_ATOM(atom) ((Atom)(atom))
103 /* Selection type distinguishers */
109 TARGET_COMPOUND_TEXT
,
112 TARGET_TEXT_URI_LIST
,
119 * Table of selection targets supported by Vim.
120 * Note: Order matters, preferred types should come first.
122 static const GtkTargetEntry selection_targets
[] =
124 {VIMENC_ATOM_NAME
, 0, TARGET_VIMENC
},
125 {VIM_ATOM_NAME
, 0, TARGET_VIM
},
127 {"text/html", 0, TARGET_HTML
},
128 {"UTF8_STRING", 0, TARGET_UTF8_STRING
},
130 {"COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT
},
131 {"TEXT", 0, TARGET_TEXT
},
132 {"STRING", 0, TARGET_STRING
}
134 #define N_SELECTION_TARGETS (sizeof(selection_targets) / sizeof(selection_targets[0]))
138 * Table of DnD targets supported by Vim.
139 * Note: Order matters, preferred types should come first.
141 static const GtkTargetEntry dnd_targets
[] =
143 {"text/uri-list", 0, TARGET_TEXT_URI_LIST
},
145 {"text/html", 0, TARGET_HTML
},
146 {"UTF8_STRING", 0, TARGET_UTF8_STRING
},
148 {"STRING", 0, TARGET_STRING
},
149 {"text/plain", 0, TARGET_TEXT_PLAIN
}
151 # define N_DND_TARGETS (sizeof(dnd_targets) / sizeof(dnd_targets[0]))
157 * "Monospace" is a standard font alias that should be present
158 * on all proper Pango/fontconfig installations.
160 # define DEFAULT_FONT "Monospace 10"
162 #else /* !HAVE_GTK2 */
164 * This is the single only fixed width font in X11, which seems to be present
165 * on all servers and available in all the variants we need.
167 # define DEFAULT_FONT "-adobe-courier-medium-r-normal-*-14-*-*-*-m-*-*-*"
169 #endif /* !HAVE_GTK2 */
171 #if !(defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION))
173 * Atoms used to communicate save-yourself from the X11 session manager. There
174 * is no need to move them into the GUI struct, since they should be constant.
176 static GdkAtom wm_protocols_atom
= GDK_NONE
;
177 static GdkAtom save_yourself_atom
= GDK_NONE
;
181 * Atoms used to control/reference X11 selections.
184 static GdkAtom html_atom
= GDK_NONE
;
185 static GdkAtom utf8_string_atom
= GDK_NONE
;
188 static GdkAtom compound_text_atom
= GDK_NONE
;
189 static GdkAtom text_atom
= GDK_NONE
;
191 static GdkAtom vim_atom
= GDK_NONE
; /* Vim's own special selection format */
193 static GdkAtom vimenc_atom
= GDK_NONE
; /* Vim's extended selection format */
197 * Keycodes recognized by vim.
198 * NOTE: when changing this, the table in gui_x11.c probably needs the same
201 static struct special_key
207 const special_keys
[] =
210 {GDK_Down
, 'k', 'd'},
211 {GDK_Left
, 'k', 'l'},
212 {GDK_Right
, 'k', 'r'},
234 {GDK_Pause
, 'F', 'B'}, /* Pause == F21 according to netbeans.txt */
250 {SunXK_F36
, 'F', 'Q'},
251 {SunXK_F37
, 'F', 'R'},
253 {GDK_Help
, '%', '1'},
254 {GDK_Undo
, '&', '8'},
255 {GDK_BackSpace
, 'k', 'b'},
256 {GDK_Insert
, 'k', 'I'},
257 {GDK_Delete
, 'k', 'D'},
258 {GDK_3270_BackTab
, 'k', 'B'},
259 {GDK_Clear
, 'k', 'C'},
260 {GDK_Home
, 'k', 'h'},
262 {GDK_Prior
, 'k', 'P'},
263 {GDK_Next
, 'k', 'N'},
264 {GDK_Print
, '%', '9'},
266 {GDK_KP_Left
, 'k', 'l'},
267 {GDK_KP_Right
, 'k', 'r'},
268 {GDK_KP_Up
, 'k', 'u'},
269 {GDK_KP_Down
, 'k', 'd'},
270 {GDK_KP_Insert
, KS_EXTRA
, (char_u
)KE_KINS
},
271 {GDK_KP_Delete
, KS_EXTRA
, (char_u
)KE_KDEL
},
272 {GDK_KP_Home
, 'K', '1'},
273 {GDK_KP_End
, 'K', '4'},
274 {GDK_KP_Prior
, 'K', '3'}, /* page up */
275 {GDK_KP_Next
, 'K', '5'}, /* page down */
277 {GDK_KP_Add
, 'K', '6'},
278 {GDK_KP_Subtract
, 'K', '7'},
279 {GDK_KP_Divide
, 'K', '8'},
280 {GDK_KP_Multiply
, 'K', '9'},
281 {GDK_KP_Enter
, 'K', 'A'},
282 {GDK_KP_Decimal
, 'K', 'B'},
284 {GDK_KP_0
, 'K', 'C'},
285 {GDK_KP_1
, 'K', 'D'},
286 {GDK_KP_2
, 'K', 'E'},
287 {GDK_KP_3
, 'K', 'F'},
288 {GDK_KP_4
, 'K', 'G'},
289 {GDK_KP_5
, 'K', 'H'},
290 {GDK_KP_6
, 'K', 'I'},
291 {GDK_KP_7
, 'K', 'J'},
292 {GDK_KP_8
, 'K', 'K'},
293 {GDK_KP_9
, 'K', 'L'},
295 /* End of list marker: */
300 * Flags for command line options table below.
303 #define ARG_GEOMETRY 2
304 #define ARG_REVERSE 3
305 #define ARG_NOREVERSE 4
306 #define ARG_BACKGROUND 5
307 #define ARG_FOREGROUND 6
310 #define ARG_NETBEANS 9
311 #define ARG_XRM 10 /* ignored */
312 #define ARG_MENUFONT 11 /* ignored */
313 #define ARG_INDEX_MASK 0x00ff
314 #define ARG_HAS_VALUE 0x0100 /* a value is expected after the argument */
315 #define ARG_NEEDS_GUI 0x0200 /* need to initialize the GUI for this */
316 #define ARG_FOR_GTK 0x0400 /* argument is handled by GTK+ or GNOME */
317 #define ARG_COMPAT_LONG 0x0800 /* accept -foo but substitute with --foo */
318 #define ARG_KEEP 0x1000 /* don't remove argument from argv[] */
321 * This table holds all the X GUI command line options allowed. This includes
322 * the standard ones so that we can skip them when Vim is started without the
323 * GUI (but the GUI might start up later).
325 * When changing this, also update doc/gui_x11.txt and the usage message!!!
334 static const cmdline_option_T cmdline_options
[] =
336 /* We handle these options ourselves */
337 {"-fn", ARG_FONT
|ARG_HAS_VALUE
},
338 {"-font", ARG_FONT
|ARG_HAS_VALUE
},
339 {"-geom", ARG_GEOMETRY
|ARG_HAS_VALUE
},
340 {"-geometry", ARG_GEOMETRY
|ARG_HAS_VALUE
},
341 {"-rv", ARG_REVERSE
},
342 {"-reverse", ARG_REVERSE
},
343 {"+rv", ARG_NOREVERSE
},
344 {"+reverse", ARG_NOREVERSE
},
345 {"-bg", ARG_BACKGROUND
|ARG_HAS_VALUE
},
346 {"-background", ARG_BACKGROUND
|ARG_HAS_VALUE
},
347 {"-fg", ARG_FOREGROUND
|ARG_HAS_VALUE
},
348 {"-foreground", ARG_FOREGROUND
|ARG_HAS_VALUE
},
349 {"-iconic", ARG_ICONIC
},
351 {"--role", ARG_ROLE
|ARG_HAS_VALUE
},
353 #ifdef FEAT_NETBEANS_INTG
354 {"-nb", ARG_NETBEANS
}, /* non-standard value format */
355 {"-xrm", ARG_XRM
|ARG_HAS_VALUE
}, /* not implemented */
356 {"-mf", ARG_MENUFONT
|ARG_HAS_VALUE
}, /* not implemented */
357 {"-menufont", ARG_MENUFONT
|ARG_HAS_VALUE
}, /* not implemented */
359 #if 0 /* not implemented; these arguments don't make sense for GTK+ */
360 {"-boldfont", ARG_HAS_VALUE
},
361 {"-italicfont", ARG_HAS_VALUE
},
362 {"-bw", ARG_HAS_VALUE
},
363 {"-borderwidth", ARG_HAS_VALUE
},
364 {"-sw", ARG_HAS_VALUE
},
365 {"-scrollbarwidth", ARG_HAS_VALUE
},
367 /* Arguments handled by GTK (and GNOME) internally. */
368 {"--g-fatal-warnings", ARG_FOR_GTK
},
369 {"--gdk-debug", ARG_FOR_GTK
|ARG_HAS_VALUE
},
370 {"--gdk-no-debug", ARG_FOR_GTK
|ARG_HAS_VALUE
},
371 {"--gtk-debug", ARG_FOR_GTK
|ARG_HAS_VALUE
},
372 {"--gtk-no-debug", ARG_FOR_GTK
|ARG_HAS_VALUE
},
373 {"--gtk-module", ARG_FOR_GTK
|ARG_HAS_VALUE
},
374 {"--sync", ARG_FOR_GTK
},
375 {"--display", ARG_FOR_GTK
|ARG_HAS_VALUE
|ARG_COMPAT_LONG
},
376 {"--name", ARG_FOR_GTK
|ARG_HAS_VALUE
|ARG_COMPAT_LONG
},
377 {"--class", ARG_FOR_GTK
|ARG_HAS_VALUE
|ARG_COMPAT_LONG
},
379 {"--screen", ARG_FOR_GTK
|ARG_HAS_VALUE
},
380 {"--gxid-host", ARG_FOR_GTK
|ARG_HAS_VALUE
},
381 {"--gxid-port", ARG_FOR_GTK
|ARG_HAS_VALUE
},
382 #else /* these don't seem to exist anymore */
383 {"--no-xshm", ARG_FOR_GTK
},
384 {"--xim-preedit", ARG_FOR_GTK
|ARG_HAS_VALUE
},
385 {"--xim-status", ARG_FOR_GTK
|ARG_HAS_VALUE
},
386 {"--gxid_host", ARG_FOR_GTK
|ARG_HAS_VALUE
},
387 {"--gxid_port", ARG_FOR_GTK
|ARG_HAS_VALUE
},
389 #ifdef FEAT_GUI_GNOME
390 {"--load-modules", ARG_FOR_GTK
|ARG_HAS_VALUE
},
391 {"--sm-client-id", ARG_FOR_GTK
|ARG_HAS_VALUE
},
392 {"--sm-config-prefix", ARG_FOR_GTK
|ARG_HAS_VALUE
},
393 {"--sm-disable", ARG_FOR_GTK
},
394 {"--oaf-ior-fd", ARG_FOR_GTK
|ARG_HAS_VALUE
},
395 {"--oaf-activate-iid", ARG_FOR_GTK
|ARG_HAS_VALUE
},
396 {"--oaf-private", ARG_FOR_GTK
},
397 {"--enable-sound", ARG_FOR_GTK
},
398 {"--disable-sound", ARG_FOR_GTK
},
399 {"--espeaker", ARG_FOR_GTK
|ARG_HAS_VALUE
},
400 {"-?", ARG_FOR_GTK
|ARG_NEEDS_GUI
},
401 {"--help", ARG_FOR_GTK
|ARG_NEEDS_GUI
|ARG_KEEP
},
402 {"--usage", ARG_FOR_GTK
|ARG_NEEDS_GUI
},
403 # if 0 /* conflicts with Vim's own --version argument */
404 {"--version", ARG_FOR_GTK
|ARG_NEEDS_GUI
},
406 {"--disable-crash-dialog", ARG_FOR_GTK
},
411 static int gui_argc
= 0;
412 static char **gui_argv
= NULL
;
415 static const char *role_argument
= NULL
;
417 #if defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION)
418 static const char *restart_command
= NULL
;
419 static char *abs_restart_command
= NULL
;
421 static int found_iconic_arg
= FALSE
;
423 #ifdef FEAT_GUI_GNOME
425 * Can't use Gnome if --socketid given
427 static int using_gnome
= 0;
429 # define using_gnome 0
433 * Parse the GUI related command-line arguments. Any arguments used are
434 * deleted from argv, and *argc is decremented accordingly. This is called
435 * when vim is started, whether or not the GUI has been started.
438 gui_mch_prepare(int *argc
, char **argv
)
440 const cmdline_option_T
*option
;
444 #if defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION)
446 * Determine the command used to invoke Vim, to be passed as restart
447 * command to the session manager. If argv[0] contains any directory
448 * components try building an absolute path, otherwise leave it as is.
450 restart_command
= argv
[0];
452 if (strchr(argv
[0], G_DIR_SEPARATOR
) != NULL
)
454 char_u buf
[MAXPATHL
];
456 if (mch_FullName((char_u
*)argv
[0], buf
, (int)sizeof(buf
), TRUE
) == OK
)
458 abs_restart_command
= (char *)vim_strsave(buf
);
459 restart_command
= abs_restart_command
;
465 * Move all the entries in argv which are relevant to GTK+ and GNOME
466 * into gui_argv. Freed later in gui_mch_init().
469 gui_argv
= (char **)alloc((unsigned)((*argc
+ 1) * sizeof(char *)));
471 g_return_if_fail(gui_argv
!= NULL
);
473 gui_argv
[gui_argc
++] = argv
[i
++];
477 /* Don't waste CPU cycles on non-option arguments. */
478 if (argv
[i
][0] != '-' && argv
[i
][0] != '+')
484 /* Look for argv[i] in cmdline_options[] table. */
485 for (option
= &cmdline_options
[0]; option
->name
!= NULL
; ++option
)
487 len
= strlen(option
->name
);
489 if (strncmp(argv
[i
], option
->name
, len
) == 0)
491 if (argv
[i
][len
] == '\0')
493 /* allow --foo=bar style */
494 if (argv
[i
][len
] == '=' && (option
->flags
& ARG_HAS_VALUE
))
496 #ifdef FEAT_NETBEANS_INTG
497 /* darn, -nb has non-standard syntax */
498 if (vim_strchr((char_u
*)":=", argv
[i
][len
]) != NULL
499 && (option
->flags
& ARG_INDEX_MASK
) == ARG_NETBEANS
)
503 else if ((option
->flags
& ARG_COMPAT_LONG
)
504 && strcmp(argv
[i
], option
->name
+ 1) == 0)
506 /* Replace the standard X arguments "-name" and "-display"
507 * with their GNU-style long option counterparts. */
508 argv
[i
] = (char *)option
->name
;
512 if (option
->name
== NULL
) /* no match */
518 if (option
->flags
& ARG_FOR_GTK
)
520 /* Move the argument into gui_argv, which
521 * will later be passed to gtk_init_check() */
522 gui_argv
[gui_argc
++] = argv
[i
];
528 /* Extract the option's value if there is one.
529 * Accept both "--foo bar" and "--foo=bar" style. */
530 if (option
->flags
& ARG_HAS_VALUE
)
532 if (argv
[i
][len
] == '=')
533 value
= &argv
[i
][len
+ 1];
534 else if (i
+ 1 < *argc
&& strcmp(argv
[i
+ 1], "--") != 0)
538 /* Check for options handled by Vim itself */
539 switch (option
->flags
& ARG_INDEX_MASK
)
542 found_reverse_arg
= TRUE
;
545 found_reverse_arg
= FALSE
;
548 font_argument
= value
;
552 gui
.geom
= vim_strsave((char_u
*)value
);
555 background_argument
= value
;
558 foreground_argument
= value
;
561 found_iconic_arg
= TRUE
;
565 role_argument
= value
; /* used later in gui_mch_open() */
568 #ifdef FEAT_NETBEANS_INTG
571 gui
.dofork
= FALSE
; /* don't fork() when starting GUI */
572 netbeansArg
= argv
[i
];
580 /* These arguments make gnome_program_init() print a message and exit.
581 * Must start the GUI for this, otherwise ":gui" will exit later! */
582 if (option
->flags
& ARG_NEEDS_GUI
)
585 if (option
->flags
& ARG_KEEP
)
589 /* Remove the flag from the argument vector. */
594 /* Move the argument's value as well, if there is one. */
595 if ((option
->flags
& ARG_HAS_VALUE
)
596 && argv
[i
][len
] != '='
597 && strcmp(argv
[i
+ 1], "--") != 0)
601 if (option
->flags
& ARG_FOR_GTK
)
602 gui_argv
[gui_argc
++] = argv
[i
+ 1];
606 mch_memmove(&argv
[i
], &argv
[i
+ n_strip
],
607 (*argc
- i
) * sizeof(char *));
613 gui_argv
[gui_argc
] = NULL
;
616 #if defined(EXITFREE) || defined(PROTO)
621 #if defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION)
622 vim_free(abs_restart_command
);
628 * This should be maybe completely removed.
629 * Doesn't seem possible, since check_copy_area() relies on
630 * this information. --danielk
633 visibility_event(GtkWidget
*widget UNUSED
,
634 GdkEventVisibility
*event
,
635 gpointer data UNUSED
)
637 gui
.visibility
= event
->state
;
639 * When we do an gdk_window_copy_area(), and the window is partially
640 * obscured, we want to receive an event to tell us whether it worked
643 if (gui
.text_gc
!= NULL
)
644 gdk_gc_set_exposures(gui
.text_gc
,
645 gui
.visibility
!= GDK_VISIBILITY_UNOBSCURED
);
650 * Redraw the corresponding portions of the screen.
653 expose_event(GtkWidget
*widget UNUSED
,
654 GdkEventExpose
*event
,
655 gpointer data UNUSED
)
657 /* Skip this when the GUI isn't set up yet, will redraw later. */
661 out_flush(); /* make sure all output has been processed */
662 gui_redraw(event
->area
.x
, event
->area
.y
,
663 event
->area
.width
, event
->area
.height
);
665 /* Clear the border areas if needed */
666 if (event
->area
.x
< FILL_X(0))
667 gdk_window_clear_area(gui
.drawarea
->window
, 0, 0, FILL_X(0), 0);
668 if (event
->area
.y
< FILL_Y(0))
669 gdk_window_clear_area(gui
.drawarea
->window
, 0, 0, 0, FILL_Y(0));
670 if (event
->area
.x
> FILL_X(Columns
))
671 gdk_window_clear_area(gui
.drawarea
->window
,
672 FILL_X((int)Columns
), 0, 0, 0);
673 if (event
->area
.y
> FILL_Y(Rows
))
674 gdk_window_clear_area(gui
.drawarea
->window
, 0, FILL_Y((int)Rows
), 0, 0);
679 #ifdef FEAT_CLIENTSERVER
681 * Handle changes to the "Comm" property
684 property_event(GtkWidget
*widget
,
685 GdkEventProperty
*event
,
686 gpointer data UNUSED
)
688 if (event
->type
== GDK_PROPERTY_NOTIFY
689 && event
->state
== (int)GDK_PROPERTY_NEW_VALUE
690 && GDK_WINDOW_XWINDOW(event
->window
) == commWindow
691 && GET_X_ATOM(event
->atom
) == commProperty
)
695 /* Translate to XLib */
696 xev
.xproperty
.type
= PropertyNotify
;
697 xev
.xproperty
.atom
= commProperty
;
698 xev
.xproperty
.window
= commWindow
;
699 xev
.xproperty
.state
= PropertyNewValue
;
700 serverEventProc(GDK_WINDOW_XDISPLAY(widget
->window
), &xev
);
702 if (gtk_main_level() > 0)
710 /****************************************************************************
716 * This is a simple state machine:
717 * BLINK_NONE not blinking at all
718 * BLINK_OFF blinking, cursor is not shown
719 * BLINK_ON blinking, cursor is shown
726 static int blink_state
= BLINK_NONE
;
727 static long_u blink_waittime
= 700;
728 static long_u blink_ontime
= 400;
729 static long_u blink_offtime
= 250;
730 static guint blink_timer
= 0;
733 gui_mch_set_blinking(long waittime
, long on
, long off
)
735 blink_waittime
= waittime
;
741 * Stop the cursor blinking. Show the cursor if it wasn't shown.
744 gui_mch_stop_blink(void)
748 gtk_timeout_remove(blink_timer
);
751 if (blink_state
== BLINK_OFF
)
752 gui_update_cursor(TRUE
, FALSE
);
753 blink_state
= BLINK_NONE
;
757 blink_cb(gpointer data UNUSED
)
759 if (blink_state
== BLINK_ON
)
762 blink_state
= BLINK_OFF
;
763 blink_timer
= gtk_timeout_add((guint32
)blink_offtime
,
764 (GtkFunction
) blink_cb
, NULL
);
768 gui_update_cursor(TRUE
, FALSE
);
769 blink_state
= BLINK_ON
;
770 blink_timer
= gtk_timeout_add((guint32
)blink_ontime
,
771 (GtkFunction
) blink_cb
, NULL
);
774 return FALSE
; /* don't happen again */
778 * Start the cursor blinking. If it was already blinking, this restarts the
779 * waiting time and shows the cursor.
782 gui_mch_start_blink(void)
785 gtk_timeout_remove(blink_timer
);
786 /* Only switch blinking on if none of the times is zero */
787 if (blink_waittime
&& blink_ontime
&& blink_offtime
&& gui
.in_focus
)
789 blink_timer
= gtk_timeout_add((guint32
)blink_waittime
,
790 (GtkFunction
) blink_cb
, NULL
);
791 blink_state
= BLINK_ON
;
792 gui_update_cursor(TRUE
, FALSE
);
797 enter_notify_event(GtkWidget
*widget UNUSED
,
798 GdkEventCrossing
*event UNUSED
,
799 gpointer data UNUSED
)
801 if (blink_state
== BLINK_NONE
)
802 gui_mch_start_blink();
804 /* make sure keyboard input goes there */
805 if (gtk_socket_id
== 0 || !GTK_WIDGET_HAS_FOCUS(gui
.drawarea
))
806 gtk_widget_grab_focus(gui
.drawarea
);
812 leave_notify_event(GtkWidget
*widget UNUSED
,
813 GdkEventCrossing
*event UNUSED
,
814 gpointer data UNUSED
)
816 if (blink_state
!= BLINK_NONE
)
817 gui_mch_stop_blink();
823 focus_in_event(GtkWidget
*widget
,
824 GdkEventFocus
*event UNUSED
,
825 gpointer data UNUSED
)
827 gui_focus_change(TRUE
);
829 if (blink_state
== BLINK_NONE
)
830 gui_mch_start_blink();
832 /* make sure keyboard input goes to the draw area (if this is focus for a
834 if (widget
!= gui
.drawarea
)
835 gtk_widget_grab_focus(gui
.drawarea
);
837 /* make sure the input buffer is read */
838 if (gtk_main_level() > 0)
845 focus_out_event(GtkWidget
*widget UNUSED
,
846 GdkEventFocus
*event UNUSED
,
847 gpointer data UNUSED
)
849 gui_focus_change(FALSE
);
851 if (blink_state
!= BLINK_NONE
)
852 gui_mch_stop_blink();
854 /* make sure the input buffer is read */
855 if (gtk_main_level() > 0)
864 * Translate a GDK key value to UTF-8 independently of the current locale.
865 * The output is written to string, which must have room for at least 6 bytes
866 * plus the NUL terminator. Returns the length in bytes.
868 * This function is used in the GTK+ 2 GUI only. The GTK+ 1 code makes use
869 * of GdkEventKey::string instead. But event->string is evil; see here why:
870 * http://developer.gnome.org/doc/API/2.0/gdk/gdk-Event-Structures.html#GdkEventKey
873 keyval_to_string(unsigned int keyval
, unsigned int state
, char_u
*string
)
878 uc
= gdk_keyval_to_unicode(keyval
);
881 /* Check for CTRL-foo */
882 if ((state
& GDK_CONTROL_MASK
) && uc
>= 0x20 && uc
< 0x80)
884 /* These mappings look arbitrary at the first glance, but in fact
885 * resemble quite exactly the behaviour of the GTK+ 1.2 GUI on my
886 * machine. The only difference is BS vs. DEL for CTRL-8 (makes
887 * more sense and is consistent with usual terminal behaviour). */
889 string
[0] = uc
& 0x1F;
892 else if (uc
>= '3' && uc
<= '7')
893 string
[0] = uc
^ 0x28;
904 /* Translate a normal key to UTF-8. This doesn't work for dead
905 * keys of course, you _have_ to use an input method for that. */
906 len
= utf_char2bytes((int)uc
, string
);
911 /* Translate keys which are represented by ASCII control codes in Vim.
912 * There are only a few of those; most control keys are translated to
913 * special terminal-like control sequences. */
917 case GDK_Tab
: case GDK_KP_Tab
: case GDK_ISO_Left_Tab
:
923 case GDK_Return
: case GDK_ISO_Enter
: case GDK_3270_Enter
:
938 #endif /* HAVE_GTK2 */
941 modifiers_gdk2vim(guint state
)
945 if (state
& GDK_SHIFT_MASK
)
946 modifiers
|= MOD_MASK_SHIFT
;
947 if (state
& GDK_CONTROL_MASK
)
948 modifiers
|= MOD_MASK_CTRL
;
949 if (state
& GDK_MOD1_MASK
)
950 modifiers
|= MOD_MASK_ALT
;
951 if (state
& GDK_MOD4_MASK
)
952 modifiers
|= MOD_MASK_META
;
958 modifiers_gdk2mouse(guint state
)
962 if (state
& GDK_SHIFT_MASK
)
963 modifiers
|= MOUSE_SHIFT
;
964 if (state
& GDK_CONTROL_MASK
)
965 modifiers
|= MOUSE_CTRL
;
966 if (state
& GDK_MOD1_MASK
)
967 modifiers
|= MOUSE_ALT
;
973 * Main keyboard handler:
976 key_press_event(GtkWidget
*widget UNUSED
,
978 gpointer data UNUSED
)
981 /* 256 bytes is way over the top, but for safety let's reduce it only
982 * for GTK+ 2 where we know for sure how large the string might get.
983 * (That is, up to 6 bytes + NUL + CSI escapes + safety measure.) */
984 char_u string
[32], string2
[32];
986 char_u string
[256], string2
[256];
996 key_sym
= event
->keyval
;
997 state
= event
->state
;
998 #ifndef HAVE_GTK2 /* deprecated */
1000 g_assert(len
<= sizeof(string
));
1005 * It appears as if we always want to consume a key-press (there currently
1006 * aren't any 'return FALSE's), so we always do this: when running in a
1007 * GtkPlug and not a window, we must prevent emission of the key_press
1008 * EVENT from continuing (which is 'beyond' the level of stopping mere
1009 * signals by returning FALSE), otherwise things like tab/cursor-keys are
1010 * processed by the GtkPlug default handler, which moves input focus away
1012 * Note: This should no longer be necessary with GTK+ 2.
1014 if (gtk_socket_id
!= 0)
1015 gtk_signal_emit_stop_by_name(GTK_OBJECT(widget
), "key_press_event");
1019 if (xim_queue_key_press_event(event
, TRUE
))
1023 #ifdef FEAT_HANGULIN
1024 if (key_sym
== GDK_space
&& (state
& GDK_SHIFT_MASK
))
1026 hangul_input_state_toggle();
1033 * These keys have bogus lookup strings, and trapping them here is
1034 * easier than trying to XRebindKeysym() on them with every possible
1035 * combination of modifiers.
1037 if (key_sym
== SunXK_F36
|| key_sym
== SunXK_F37
)
1043 len
= keyval_to_string(key_sym
, state
, string2
);
1045 /* Careful: convert_input() doesn't handle the NUL character.
1046 * No need to convert pure ASCII anyway, thus the len > 1 check. */
1047 if (len
> 1 && input_conv
.vc_type
!= CONV_NONE
)
1048 len
= convert_input(string2
, len
, sizeof(string2
));
1053 if (input_conv
.vc_type
!= CONV_NONE
)
1055 mch_memmove(string2
, event
->string
, len
);
1056 len
= convert_input(string2
, len
, sizeof(string2
));
1061 s
= (char_u
*)event
->string
;
1065 for (i
= 0; i
< len
; ++i
)
1068 if (d
[-1] == CSI
&& d
+ 2 < string
+ sizeof(string
))
1070 /* Turn CSI into K_CSI. */
1078 /* Shift-Tab results in Left_Tab, but we want <S-Tab> */
1079 if (key_sym
== GDK_ISO_Left_Tab
)
1082 state
|= GDK_SHIFT_MASK
;
1085 #ifndef HAVE_GTK2 /* for GTK+ 2, we handle this in keyval_to_string() */
1086 if ((key_sym
== GDK_2
|| key_sym
== GDK_at
) && (state
& GDK_CONTROL_MASK
))
1088 string
[0] = NUL
; /* CTRL-2 and CTRL-@ is NUL */
1091 else if (len
== 0 && (key_sym
== GDK_space
|| key_sym
== GDK_Tab
))
1093 /* When there are modifiers, these keys get zero length; we need the
1094 * original key here to be able to add a modifier below. */
1095 string
[0] = (key_sym
& 0xff);
1101 /* If there is a menu and 'wak' is "yes", or 'wak' is "menu" and the key
1102 * is a menu shortcut, we ignore everything with the ALT modifier. */
1103 if ((state
& GDK_MOD1_MASK
)
1104 && gui
.menu_is_active
1108 && gui_is_menu_shortcut(string
[0]))))
1110 /* For GTK2 we return false to signify that we haven't handled the
1111 * keypress, so that gtk will handle the mnemonic or accelerator. */
1118 /* Check for Alt/Meta key (Mod1Mask), but not for a BS, DEL or character
1119 * that already has the 8th bit set.
1120 * Don't do this for <S-M-Tab>, that should become K_S_TAB with ALT.
1121 * Don't do this for double-byte encodings, it turns the char into a lead
1124 && (state
& GDK_MOD1_MASK
)
1125 && !(key_sym
== GDK_BackSpace
|| key_sym
== GDK_Delete
)
1126 && (string
[0] & 0x80) == 0
1127 && !(key_sym
== GDK_Tab
&& (state
& GDK_SHIFT_MASK
))
1134 state
&= ~GDK_MOD1_MASK
; /* don't use it again */
1136 if (enc_utf8
) /* convert to utf-8 */
1138 string
[1] = string
[0] & 0xbf;
1139 string
[0] = ((unsigned)string
[0] >> 6) + 0xc0;
1140 if (string
[1] == CSI
)
1142 string
[2] = KS_EXTRA
;
1143 string
[3] = (int)KE_CSI
;
1152 /* Check for special keys. Also do this when len == 1 (key has an ASCII
1153 * value) to detect backspace, delete and keypad keys. */
1154 if (len
== 0 || len
== 1)
1156 for (i
= 0; special_keys
[i
].key_sym
!= 0; i
++)
1158 if (special_keys
[i
].key_sym
== key_sym
)
1161 string
[1] = special_keys
[i
].code0
;
1162 string
[2] = special_keys
[i
].code1
;
1169 if (len
== 0) /* Unrecognized key */
1172 #if defined(FEAT_XIM) && defined(FEAT_GUI_GTK) && !defined(HAVE_GTK2)
1173 /* Cancel or type backspace. For GTK2, im_commit_cb() does the same. */
1174 preedit_start_col
= MAXCOL
;
1175 xim_changed_while_preediting
= TRUE
;
1178 /* Special keys (and a few others) may have modifiers. Also when using a
1179 * double-byte encoding (can't set the 8th bit). */
1180 if (len
== -3 || key_sym
== GDK_space
|| key_sym
== GDK_Tab
1181 || key_sym
== GDK_Return
|| key_sym
== GDK_Linefeed
1182 || key_sym
== GDK_Escape
|| key_sym
== GDK_KP_Tab
1183 || key_sym
== GDK_ISO_Enter
|| key_sym
== GDK_3270_Enter
1185 || (enc_dbcs
&& len
== 1 && (state
& GDK_MOD1_MASK
))
1189 modifiers
= modifiers_gdk2vim(state
);
1192 * For some keys a shift modifier is translated into another key
1196 key
= TO_SPECIAL(string
[1], string
[2]);
1200 key
= simplify_key(key
, &modifiers
);
1203 if (IS_SPECIAL(key
))
1206 string
[1] = K_SECOND(key
);
1207 string
[2] = K_THIRD(key
);
1219 string2
[1] = KS_MODIFIER
;
1220 string2
[2] = modifiers
;
1221 add_to_input_buf(string2
, 3);
1225 if (len
== 1 && ((string
[0] == Ctrl_C
&& ctrl_c_interrupts
)
1226 || (string
[0] == intr_char
&& intr_char
!= Ctrl_C
)))
1232 add_to_input_buf(string
, len
);
1234 /* blank out the pointer if necessary */
1236 gui_mch_mousehide(TRUE
);
1238 if (gtk_main_level() > 0)
1244 #if defined(FEAT_XIM) && defined(HAVE_GTK2)
1246 key_release_event(GtkWidget
*widget UNUSED
,
1248 gpointer data UNUSED
)
1251 * GTK+ 2 input methods may do fancy stuff on key release events too.
1252 * With the default IM for instance, you can enter any UCS code point
1253 * by holding down CTRL-SHIFT and typing hexadecimal digits.
1255 return xim_queue_key_press_event(event
, FALSE
);
1260 /****************************************************************************
1261 * Selection handlers:
1265 selection_clear_event(GtkWidget
*widget UNUSED
,
1266 GdkEventSelection
*event
,
1267 gpointer user_data UNUSED
)
1269 if (event
->selection
== clip_plus
.gtk_sel_atom
)
1270 clip_lose_selection(&clip_plus
);
1272 clip_lose_selection(&clip_star
);
1274 if (gtk_main_level() > 0)
1280 #define RS_NONE 0 /* selection_received_cb() not called yet */
1281 #define RS_OK 1 /* selection_received_cb() called and OK */
1282 #define RS_FAIL 2 /* selection_received_cb() called and failed */
1283 static int received_selection
= RS_NONE
;
1286 selection_received_cb(GtkWidget
*widget UNUSED
,
1287 GtkSelectionData
*data
,
1289 gpointer user_data UNUSED
)
1293 char_u
*tmpbuf
= NULL
;
1295 guchar
*tmpbuf_utf8
= NULL
;
1300 if (data
->selection
== clip_plus
.gtk_sel_atom
)
1305 text
= (char_u
*)data
->data
;
1307 motion_type
= MCHAR
;
1309 if (text
== NULL
|| len
<= 0)
1311 received_selection
= RS_FAIL
;
1312 /* clip_free_selection(cbd); ??? */
1314 if (gtk_main_level() > 0)
1320 if (data
->type
== vim_atom
)
1322 motion_type
= *text
++;
1327 else if (data
->type
== vimenc_atom
)
1332 motion_type
= *text
++;
1336 text
+= STRLEN(text
) + 1;
1339 /* If the encoding of the text is different from 'encoding', attempt
1341 conv
.vc_type
= CONV_NONE
;
1342 convert_setup(&conv
, enc
, p_enc
);
1343 if (conv
.vc_type
!= CONV_NONE
)
1345 tmpbuf
= string_convert(&conv
, text
, &len
);
1348 convert_setup(&conv
, NULL
, NULL
);
1354 /* gtk_selection_data_get_text() handles all the nasty details
1355 * and targets and encodings etc. This rocks so hard. */
1358 tmpbuf_utf8
= gtk_selection_data_get_text(data
);
1359 if (tmpbuf_utf8
!= NULL
)
1361 len
= STRLEN(tmpbuf_utf8
);
1362 if (input_conv
.vc_type
!= CONV_NONE
)
1364 tmpbuf
= string_convert(&input_conv
, tmpbuf_utf8
, &len
);
1371 else if (len
>= 2 && text
[0] == 0xff && text
[1] == 0xfe)
1375 /* UTF-16, we get this for HTML */
1376 conv
.vc_type
= CONV_NONE
;
1377 convert_setup_ext(&conv
, (char_u
*)"utf-16le", FALSE
, p_enc
, TRUE
);
1379 if (conv
.vc_type
!= CONV_NONE
)
1383 tmpbuf
= string_convert(&conv
, text
, &len
);
1384 convert_setup(&conv
, NULL
, NULL
);
1390 #else /* !HAVE_GTK2 */
1392 else if (data
->type
== utf8_string_atom
)
1396 conv
.vc_type
= CONV_NONE
;
1397 convert_setup(&conv
, (char_u
*)"utf-8", p_enc
);
1399 if (conv
.vc_type
!= CONV_NONE
)
1401 tmpbuf
= string_convert(&conv
, text
, &len
);
1402 convert_setup(&conv
, NULL
, NULL
);
1408 else if (data
->type
== compound_text_atom
|| data
->type
== text_atom
)
1413 unsigned tmplen
= 0;
1415 count
= gdk_text_property_to_text_list(data
->type
, data
->format
,
1416 data
->data
, data
->length
,
1418 for (i
= 0; i
< count
; ++i
)
1419 tmplen
+= strlen(list
[i
]);
1421 tmpbuf
= alloc(tmplen
+ 1);
1425 for (i
= 0; i
< count
; ++i
)
1426 STRCAT(tmpbuf
, list
[i
]);
1432 gdk_free_text_list(list
);
1434 #endif /* !HAVE_GTK2 */
1436 /* Chop off any traiing NUL bytes. OpenOffice sends these. */
1437 while (len
> 0 && text
[len
- 1] == NUL
)
1440 clip_yank_selection(motion_type
, text
, (long)len
, cbd
);
1441 received_selection
= RS_OK
;
1444 g_free(tmpbuf_utf8
);
1447 if (gtk_main_level() > 0)
1452 * Prepare our selection data for passing it to the external selection
1456 selection_get_cb(GtkWidget
*widget UNUSED
,
1457 GtkSelectionData
*selection_data
,
1460 gpointer user_data UNUSED
)
1470 if (selection_data
->selection
== clip_plus
.gtk_sel_atom
)
1476 return; /* Shouldn't ever happen */
1478 if (info
!= (guint
)TARGET_STRING
1480 && (!clip_html
|| info
!= (guint
)TARGET_HTML
)
1481 && info
!= (guint
)TARGET_UTF8_STRING
1482 && info
!= (guint
)TARGET_VIMENC
1484 && info
!= (guint
)TARGET_VIM
1485 && info
!= (guint
)TARGET_COMPOUND_TEXT
1486 && info
!= (guint
)TARGET_TEXT
)
1489 /* get the selection from the '*'/'+' register */
1490 clip_get_selection(cbd
);
1492 motion_type
= clip_convert_selection(&string
, &tmplen
, cbd
);
1493 if (motion_type
< 0 || string
== NULL
)
1495 /* Due to int arguments we can't handle more than G_MAXINT. Also
1496 * reserve one extra byte for NUL or the motion type; just in case.
1497 * (Not that pasting 2G of text is ever going to work, but... ;-) */
1498 length
= MIN(tmplen
, (long_u
)(G_MAXINT
- 1));
1500 if (info
== (guint
)TARGET_VIM
)
1502 tmpbuf
= alloc((unsigned)length
+ 1);
1505 tmpbuf
[0] = motion_type
;
1506 mch_memmove(tmpbuf
+ 1, string
, (size_t)length
);
1508 /* For our own format, the first byte contains the motion type */
1516 else if (info
== (guint
)TARGET_HTML
)
1520 /* Since we get utf-16, we probably should set it as well. */
1521 conv
.vc_type
= CONV_NONE
;
1522 convert_setup_ext(&conv
, p_enc
, TRUE
, (char_u
*)"utf-16le", FALSE
);
1523 if (conv
.vc_type
!= CONV_NONE
)
1525 tmpbuf
= string_convert(&conv
, string
, &length
);
1526 convert_setup(&conv
, NULL
, NULL
);
1531 /* Prepend the BOM: "fffe" */
1534 tmpbuf
= alloc(length
+ 2);
1537 mch_memmove(tmpbuf
+ 2, string
, (size_t)length
);
1542 selection_data
->type
= selection_data
->target
;
1543 selection_data
->format
= 16; /* 16 bits per char */
1544 gtk_selection_data_set(selection_data
, html_atom
, 16,
1550 else if (info
== (guint
)TARGET_VIMENC
)
1552 int l
= STRLEN(p_enc
);
1554 /* contents: motion_type 'encoding' NUL text */
1555 tmpbuf
= alloc((unsigned)length
+ l
+ 2);
1558 tmpbuf
[0] = motion_type
;
1559 STRCPY(tmpbuf
+ 1, p_enc
);
1560 mch_memmove(tmpbuf
+ l
+ 2, string
, (size_t)length
);
1570 /* gtk_selection_data_set_text() handles everything for us. This is
1571 * so easy and simple and cool, it'd be insane not to use it. */
1574 if (output_conv
.vc_type
!= CONV_NONE
)
1576 tmpbuf
= string_convert(&output_conv
, string
, &length
);
1582 /* Validate the string to avoid runtime warnings */
1583 if (g_utf8_validate((const char *)string
, (gssize
)length
, NULL
))
1585 gtk_selection_data_set_text(selection_data
,
1586 (const char *)string
, length
);
1591 #else /* !HAVE_GTK2 */
1593 else if (info
== (guint
)TARGET_UTF8_STRING
)
1597 conv
.vc_type
= CONV_NONE
;
1598 convert_setup(&conv
, p_enc
, (char_u
*)"utf-8");
1600 if (conv
.vc_type
!= CONV_NONE
)
1602 tmpbuf
= string_convert(&conv
, string
, &length
);
1603 convert_setup(&conv
, NULL
, NULL
);
1607 type
= utf8_string_atom
;
1610 else if (info
== (guint
)TARGET_COMPOUND_TEXT
1611 || info
== (guint
)TARGET_TEXT
)
1615 /* Copy the string to ensure NUL-termination */
1616 tmpbuf
= vim_strnsave(string
, length
);
1620 gdk_string_to_compound_text((const char *)tmpbuf
,
1621 &type
, &format
, &string
, &length
);
1623 selection_data
->type
= type
;
1624 selection_data
->format
= format
;
1625 gtk_selection_data_set(selection_data
, type
, format
, string
, length
);
1626 gdk_free_compound_text(string
);
1632 type
= GDK_TARGET_STRING
;
1634 #endif /* !HAVE_GTK2 */
1638 selection_data
->type
= selection_data
->target
;
1639 selection_data
->format
= 8; /* 8 bits per char */
1641 gtk_selection_data_set(selection_data
, type
, 8, string
, length
);
1647 * Check if the GUI can be started. Called before gvimrc is sourced.
1648 * Return OK or FAIL.
1651 gui_mch_init_check(void)
1654 /* This is needed to make the locale handling consistent between the GUI
1655 * and the rest of VIM. */
1659 #ifdef FEAT_GUI_GNOME
1660 if (gtk_socket_id
== 0)
1664 /* Don't use gtk_init() or gnome_init(), it exits on failure. */
1665 if (!gtk_init_check(&gui_argc
, &gui_argv
))
1668 EMSG(_((char *)e_opendisp
));
1676 /****************************************************************************
1677 * Mouse handling callbacks
1681 static guint mouse_click_timer
= 0;
1682 static int mouse_timed_out
= TRUE
;
1685 * Timer used to recognize multiple clicks of the mouse button
1688 mouse_click_timer_cb(gpointer data
)
1690 /* we don't use this information currently */
1691 int *timed_out
= (int *) data
;
1694 return FALSE
; /* don't happen again */
1697 static guint motion_repeat_timer
= 0;
1698 static int motion_repeat_offset
= FALSE
;
1699 static gint
motion_repeat_timer_cb(gpointer
);
1702 process_motion_notify(int x
, int y
, GdkModifierType state
)
1705 int_u vim_modifiers
;
1707 button
= (state
& (GDK_BUTTON1_MASK
| GDK_BUTTON2_MASK
|
1708 GDK_BUTTON3_MASK
| GDK_BUTTON4_MASK
|
1712 /* If our pointer is currently hidden, then we should show it. */
1713 gui_mch_mousehide(FALSE
);
1715 /* Just moving the rodent above the drawing area without any button
1717 if (button
!= MOUSE_DRAG
)
1719 gui_mouse_moved(x
, y
);
1723 /* translate modifier coding between the main engine and GTK */
1724 vim_modifiers
= modifiers_gdk2mouse(state
);
1726 /* inform the editor engine about the occurrence of this event */
1727 gui_send_mouse_event(button
, x
, y
, FALSE
, vim_modifiers
);
1729 if (gtk_main_level() > 0)
1733 * Auto repeat timer handling.
1736 || x
>= gui
.drawarea
->allocation
.width
1737 || y
>= gui
.drawarea
->allocation
.height
)
1745 /* Calculate the maximal distance of the cursor from the drawing area.
1746 * (offshoot can't become negative here!).
1748 dx
= x
< 0 ? -x
: x
- gui
.drawarea
->allocation
.width
;
1749 dy
= y
< 0 ? -y
: y
- gui
.drawarea
->allocation
.height
;
1751 offshoot
= dx
> dy
? dx
: dy
;
1753 /* Make a linearly decaying timer delay with a threshold of 5 at a
1754 * distance of 127 pixels from the main window.
1756 * One could think endlessly about the most ergonomic variant here.
1757 * For example it could make sense to calculate the distance from the
1758 * drags start instead...
1760 * Maybe a parabolic interpolation would suite us better here too...
1764 /* 5 appears to be somehow near to my perceptual limits :-). */
1769 delay
= (130 * (127 - offshoot
)) / 127 + 5;
1773 if (!motion_repeat_timer
)
1774 motion_repeat_timer
= gtk_timeout_add((guint32
)delay
,
1775 motion_repeat_timer_cb
, NULL
);
1780 * Timer used to recognize multiple clicks of the mouse button.
1783 motion_repeat_timer_cb(gpointer data UNUSED
)
1787 GdkModifierType state
;
1789 gdk_window_get_pointer(gui
.drawarea
->window
, &x
, &y
, &state
);
1791 if (!(state
& (GDK_BUTTON1_MASK
| GDK_BUTTON2_MASK
|
1792 GDK_BUTTON3_MASK
| GDK_BUTTON4_MASK
|
1795 motion_repeat_timer
= 0;
1799 /* If there already is a mouse click in the input buffer, wait another
1800 * time (otherwise we would create a backlog of clicks) */
1801 if (vim_used_in_input_buf() > 10)
1804 motion_repeat_timer
= 0;
1807 * Fake a motion event.
1808 * Trick: Pretend the mouse moved to the next character on every other
1809 * event, otherwise drag events will be discarded, because they are still
1810 * in the same character.
1812 if (motion_repeat_offset
)
1813 x
+= gui
.char_width
;
1815 motion_repeat_offset
= !motion_repeat_offset
;
1816 process_motion_notify(x
, y
, state
);
1818 /* Don't happen again. We will get reinstalled in the synthetic event
1819 * if needed -- thus repeating should still work. */
1824 motion_notify_event(GtkWidget
*widget
,
1825 GdkEventMotion
*event
,
1826 gpointer data UNUSED
)
1832 GdkModifierType state
;
1834 gdk_window_get_pointer(widget
->window
, &x
, &y
, &state
);
1835 process_motion_notify(x
, y
, state
);
1839 process_motion_notify((int)event
->x
, (int)event
->y
,
1840 (GdkModifierType
)event
->state
);
1843 return TRUE
; /* handled */
1848 * Mouse button handling. Note please that we are capturing multiple click's
1849 * by our own timeout mechanism instead of the one provided by GTK+ itself.
1850 * This is due to the way the generic VIM code is recognizing multiple clicks.
1853 button_press_event(GtkWidget
*widget
,
1854 GdkEventButton
*event
,
1855 gpointer data UNUSED
)
1858 int repeated_click
= FALSE
;
1860 int_u vim_modifiers
;
1862 /* Make sure we have focus now we've been selected */
1863 if (gtk_socket_id
!= 0 && !GTK_WIDGET_HAS_FOCUS(widget
))
1864 gtk_widget_grab_focus(widget
);
1867 * Don't let additional events about multiple clicks send by GTK to us
1868 * after the initial button press event confuse us.
1870 if (event
->type
!= GDK_BUTTON_PRESS
)
1876 /* Handle multiple clicks */
1877 if (!mouse_timed_out
&& mouse_click_timer
)
1879 gtk_timeout_remove(mouse_click_timer
);
1880 mouse_click_timer
= 0;
1881 repeated_click
= TRUE
;
1884 mouse_timed_out
= FALSE
;
1885 mouse_click_timer
= gtk_timeout_add((guint32
)p_mouset
,
1886 mouse_click_timer_cb
, &mouse_timed_out
);
1888 switch (event
->button
)
1891 button
= MOUSE_LEFT
;
1894 button
= MOUSE_MIDDLE
;
1897 button
= MOUSE_RIGHT
;
1908 return FALSE
; /* Unknown button */
1912 /* cancel any preediting */
1913 if (im_is_preediting())
1917 vim_modifiers
= modifiers_gdk2mouse(event
->state
);
1919 gui_send_mouse_event(button
, x
, y
, repeated_click
, vim_modifiers
);
1920 if (gtk_main_level() > 0)
1921 gtk_main_quit(); /* make sure the above will be handled immediately */
1928 * GTK+ 2 doesn't handle mouse buttons 4, 5, 6 and 7 the same way as GTK+ 1.
1929 * Instead, it abstracts scrolling via the new GdkEventScroll.
1932 scroll_event(GtkWidget
*widget
,
1933 GdkEventScroll
*event
,
1934 gpointer data UNUSED
)
1937 int_u vim_modifiers
;
1939 if (gtk_socket_id
!= 0 && !GTK_WIDGET_HAS_FOCUS(widget
))
1940 gtk_widget_grab_focus(widget
);
1942 switch (event
->direction
)
1947 case GDK_SCROLL_DOWN
:
1950 default: /* We don't care about left and right... Yet. */
1955 /* cancel any preediting */
1956 if (im_is_preediting())
1960 vim_modifiers
= modifiers_gdk2mouse(event
->state
);
1962 gui_send_mouse_event(button
, (int)event
->x
, (int)event
->y
,
1963 FALSE
, vim_modifiers
);
1965 if (gtk_main_level() > 0)
1966 gtk_main_quit(); /* make sure the above will be handled immediately */
1970 #endif /* HAVE_GTK2 */
1974 button_release_event(GtkWidget
*widget UNUSED
,
1975 GdkEventButton
*event
,
1976 gpointer data UNUSED
)
1979 int_u vim_modifiers
;
1981 /* Remove any motion "machine gun" timers used for automatic further
1982 extension of allocation areas if outside of the applications window
1984 if (motion_repeat_timer
)
1986 gtk_timeout_remove(motion_repeat_timer
);
1987 motion_repeat_timer
= 0;
1993 vim_modifiers
= modifiers_gdk2mouse(event
->state
);
1995 gui_send_mouse_event(MOUSE_RELEASE
, x
, y
, FALSE
, vim_modifiers
);
1996 if (gtk_main_level() > 0)
1997 gtk_main_quit(); /* make sure it will be handled immediately */
2004 /****************************************************************************
2005 * Drag aNd Drop support handlers.
2009 * Count how many items there may be and separate them with a NUL.
2010 * Apparently the items are separated with \r\n. This is not documented,
2011 * thus be careful not to go past the end. Also allow separation with
2015 count_and_decode_uri_list(char_u
*out
, char_u
*raw
, int len
)
2021 for (i
= 0; i
< len
; ++i
)
2023 if (raw
[i
] == NUL
|| raw
[i
] == '\n' || raw
[i
] == '\r')
2025 if (p
> out
&& p
[-1] != NUL
)
2031 else if (raw
[i
] == '%' && i
+ 2 < len
&& hexhex2nr(raw
+ i
+ 1) > 0)
2033 *p
++ = hexhex2nr(raw
+ i
+ 1);
2039 if (p
> out
&& p
[-1] != NUL
)
2041 *p
= NUL
; /* last item didn't have \r or \n */
2048 * Parse NUL separated "src" strings. Make it an array "outlist" form. On
2049 * this process, URI which protocol is not "file:" are removed. Return
2050 * length of array (less than "max").
2053 filter_uri_list(char_u
**outlist
, int max
, char_u
*src
)
2057 for (i
= j
= 0; i
< max
; ++i
)
2060 if (STRNCMP(src
, "file:", 5) == 0)
2063 if (STRNCMP(src
, "//localhost", 11) == 0)
2065 while (src
[0] == '/' && src
[1] == '/')
2067 outlist
[j
++] = vim_strsave(src
);
2069 src
+= STRLEN(src
) + 1;
2075 parse_uri_list(int *count
, char_u
*data
, int len
)
2079 char_u
**array
= NULL
;;
2081 if (data
!= NULL
&& len
> 0 && (tmp
= (char_u
*)alloc(len
+ 1)) != NULL
)
2083 n
= count_and_decode_uri_list(tmp
, data
, len
);
2084 if (n
> 0 && (array
= (char_u
**)alloc(n
* sizeof(char_u
*))) != NULL
)
2085 n
= filter_uri_list(array
, n
, tmp
);
2093 drag_handle_uri_list(GdkDragContext
*context
,
2094 GtkSelectionData
*data
,
2096 GdkModifierType state
,
2103 fnames
= parse_uri_list(&nfiles
, data
->data
, data
->length
);
2105 if (fnames
!= NULL
&& nfiles
> 0)
2109 gtk_drag_finish(context
, TRUE
, FALSE
, time_
); /* accept */
2111 modifiers
= modifiers_gdk2mouse(state
);
2113 gui_handle_drop(x
, y
, modifiers
, fnames
, nfiles
);
2120 drag_handle_text(GdkDragContext
*context
,
2121 GtkSelectionData
*data
,
2123 GdkModifierType state
)
2125 char_u dropkey
[6] = {CSI
, KS_MODIFIER
, 0, CSI
, KS_EXTRA
, (char_u
)KE_DROP
};
2129 char_u
*tmpbuf
= NULL
;
2136 if (data
->type
== utf8_string_atom
)
2139 if (input_conv
.vc_type
!= CONV_NONE
)
2140 tmpbuf
= string_convert(&input_conv
, text
, &len
);
2144 conv
.vc_type
= CONV_NONE
;
2145 convert_setup(&conv
, (char_u
*)"utf-8", p_enc
);
2147 if (conv
.vc_type
!= CONV_NONE
)
2149 tmpbuf
= string_convert(&conv
, text
, &len
);
2150 convert_setup(&conv
, NULL
, NULL
);
2156 # endif /* FEAT_MBYTE */
2158 dnd_yank_drag_data(text
, (long)len
);
2159 gtk_drag_finish(context
, TRUE
, FALSE
, time_
); /* accept */
2164 dropkey
[2] = modifiers_gdk2vim(state
);
2166 if (dropkey
[2] != 0)
2167 add_to_input_buf(dropkey
, (int)sizeof(dropkey
));
2169 add_to_input_buf(dropkey
+ 3, (int)(sizeof(dropkey
) - 3));
2171 if (gtk_main_level() > 0)
2179 drag_data_received_cb(GtkWidget
*widget
,
2180 GdkDragContext
*context
,
2183 GtkSelectionData
*data
,
2186 gpointer user_data UNUSED
)
2188 GdkModifierType state
;
2190 /* Guard against trash */
2191 if (data
->data
== NULL
2192 || data
->length
<= 0
2193 || data
->format
!= 8
2194 || data
->data
[data
->length
] != '\0')
2196 gtk_drag_finish(context
, FALSE
, FALSE
, time_
);
2200 /* Get the current modifier state for proper distinguishment between
2201 * different operations later. */
2202 gdk_window_get_pointer(widget
->window
, NULL
, NULL
, &state
);
2204 /* Not sure about the role of "text/plain" here... */
2205 if (info
== (guint
)TARGET_TEXT_URI_LIST
)
2206 drag_handle_uri_list(context
, data
, time_
, state
, x
, y
);
2208 drag_handle_text(context
, data
, time_
, state
);
2211 #endif /* FEAT_DND */
2214 #if defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION)
2216 * GnomeClient interact callback. Check for unsaved buffers that cannot
2217 * be abandoned and pop up a dialog asking the user for confirmation if
2221 sm_client_check_changed_any(GnomeClient
*client
,
2223 GnomeDialogType type
,
2226 cmdmod_T save_cmdmod
;
2227 gboolean shutdown_cancelled
;
2229 save_cmdmod
= cmdmod
;
2232 cmdmod
.browse
= TRUE
;
2234 # if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
2235 cmdmod
.confirm
= TRUE
;
2238 * If there are changed buffers, present the user with
2239 * a dialog if possible, otherwise give an error message.
2241 shutdown_cancelled
= check_changed_any(FALSE
);
2244 cmdmod
= save_cmdmod
;
2245 setcursor(); /* position the cursor */
2248 * If the user hit the [Cancel] button the whole shutdown
2249 * will be cancelled. Wow, quite powerful feature (:
2251 gnome_interaction_key_return(key
, shutdown_cancelled
);
2255 * Generate a script that can be used to restore the current editing session.
2256 * Save the value of v:this_session before running :mksession in order to make
2257 * automagic session save fully transparent. Return TRUE on success.
2260 write_session_file(char_u
*filename
)
2262 char_u
*escaped_filename
;
2263 char *mksession_cmdline
;
2264 unsigned int save_ssop_flags
;
2268 * Build an ex command line to create a script that restores the current
2269 * session if executed. Escape the filename to avoid nasty surprises.
2271 escaped_filename
= vim_strsave_escaped(filename
, escape_chars
);
2272 if (escaped_filename
== NULL
)
2274 mksession_cmdline
= g_strconcat("mksession ", (char *)escaped_filename
,
2276 vim_free(escaped_filename
);
2279 * Use a reasonable hardcoded set of 'sessionoptions' flags to avoid
2280 * unpredictable effects when the session is saved automatically. Also,
2281 * we definitely need SSOP_GLOBALS to be able to restore v:this_session.
2282 * Don't use SSOP_BUFFERS to prevent the buffer list from becoming
2283 * enormously large if the GNOME session feature is used regularly.
2285 save_ssop_flags
= ssop_flags
;
2286 ssop_flags
= (SSOP_BLANK
|SSOP_CURDIR
|SSOP_FOLDS
|SSOP_GLOBALS
2287 |SSOP_HELP
|SSOP_OPTIONS
|SSOP_WINSIZE
|SSOP_TABPAGES
);
2289 do_cmdline_cmd((char_u
*)"let Save_VV_this_session = v:this_session");
2290 failed
= (do_cmdline_cmd((char_u
*)mksession_cmdline
) == FAIL
);
2291 do_cmdline_cmd((char_u
*)"let v:this_session = Save_VV_this_session");
2292 do_unlet((char_u
*)"Save_VV_this_session", TRUE
);
2294 ssop_flags
= save_ssop_flags
;
2295 g_free(mksession_cmdline
);
2297 * Reopen the file and append a command to restore v:this_session,
2298 * as if this save never happened. This is to avoid conflicts with
2299 * the user's own sessions. FIXME: It's probably less hackish to add
2300 * a "stealth" flag to 'sessionoptions' -- gotta ask Bram.
2306 fd
= open_exfile(filename
, TRUE
, APPENDBIN
);
2308 failed
= (fd
== NULL
2309 || put_line(fd
, "let v:this_session = Save_VV_this_session") == FAIL
2310 || put_line(fd
, "unlet Save_VV_this_session") == FAIL
);
2312 if (fd
!= NULL
&& fclose(fd
) != 0)
2316 mch_remove(filename
);
2323 * "save_yourself" signal handler. Initiate an interaction to ask the user
2324 * for confirmation if necessary. Save the current editing session and tell
2325 * the session manager how to restart Vim.
2328 sm_client_save_yourself(GnomeClient
*client
,
2330 GnomeSaveStyle save_style
,
2332 GnomeInteractStyle interact_style
,
2336 static const char suffix
[] = "-session.vim";
2341 /* Always request an interaction if possible. check_changed_any()
2342 * won't actually show a dialog unless any buffers have been modified.
2343 * There doesn't seem to be an obvious way to check that without
2344 * automatically firing the dialog. Anyway, it works just fine. */
2345 if (interact_style
== GNOME_INTERACT_ANY
)
2346 gnome_client_request_interaction(client
, GNOME_DIALOG_NORMAL
,
2347 &sm_client_check_changed_any
,
2350 ml_sync_all(FALSE
, FALSE
); /* preserve all swap files */
2352 /* The path is unique for each session save. We do neither know nor care
2353 * which session script will actually be used later. This decision is in
2354 * the domain of the session manager. */
2355 session_file
= gnome_config_get_real_path(
2356 gnome_client_get_config_prefix(client
));
2357 len
= strlen(session_file
);
2359 if (len
> 0 && session_file
[len
-1] == G_DIR_SEPARATOR
)
2360 --len
; /* get rid of the superfluous trailing '/' */
2362 session_file
= g_renew(char, session_file
, len
+ sizeof(suffix
));
2363 memcpy(session_file
+ len
, suffix
, sizeof(suffix
));
2365 success
= write_session_file((char_u
*)session_file
);
2369 const char *argv
[8];
2372 /* Tell the session manager how to wipe out the stored session data.
2373 * This isn't as dangerous as it looks, don't worry :) session_file
2374 * is a unique absolute filename. Usually it'll be something like
2375 * `/home/user/.gnome2/vim-XXXXXX-session.vim'. */
2378 argv
[i
++] = session_file
;
2381 gnome_client_set_discard_command(client
, i
, (char **)argv
);
2383 /* Tell the session manager how to restore the just saved session.
2384 * This is easily done thanks to Vim's -S option. Pass the -f flag
2385 * since there's no need to fork -- it might even cause confusion.
2386 * Also pass the window role to give the WM something to match on.
2387 * The role is set in gui_mch_open(), thus should _never_ be NULL. */
2389 argv
[i
++] = restart_command
;
2393 argv
[i
++] = "--role";
2394 argv
[i
++] = gtk_window_get_role(GTK_WINDOW(gui
.mainwin
));
2397 argv
[i
++] = session_file
;
2400 gnome_client_set_restart_command(client
, i
, (char **)argv
);
2401 gnome_client_set_clone_command(client
, 0, NULL
);
2404 g_free(session_file
);
2410 * Called when the session manager wants us to die. There isn't much to save
2411 * here since "save_yourself" has been emitted before (unless serious trouble
2415 sm_client_die(GnomeClient
*client
, gpointer data
)
2417 /* Don't write messages to the GUI anymore */
2418 full_screen
= FALSE
;
2420 vim_strncpy(IObuff
, (char_u
*)
2421 _("Vim: Received \"die\" request from session manager\n"),
2427 * Connect our signal handlers to be notified on session save and shutdown.
2430 setup_save_yourself(void)
2432 GnomeClient
*client
;
2434 client
= gnome_master_client();
2438 /* Must use the deprecated gtk_signal_connect() for compatibility
2439 * with GNOME 1. Arrgh, zombies! */
2440 gtk_signal_connect(GTK_OBJECT(client
), "save_yourself",
2441 GTK_SIGNAL_FUNC(&sm_client_save_yourself
), NULL
);
2442 gtk_signal_connect(GTK_OBJECT(client
), "die",
2443 GTK_SIGNAL_FUNC(&sm_client_die
), NULL
);
2447 #else /* !(FEAT_GUI_GNOME && FEAT_SESSION) */
2451 * GTK tells us that XSMP needs attention
2454 local_xsmp_handle_requests(source
, condition
, data
)
2455 GIOChannel
*source UNUSED
;
2456 GIOCondition condition
;
2459 if (condition
== G_IO_IN
)
2461 /* Do stuff; maybe close connection */
2462 if (xsmp_handle_requests() == FAIL
)
2463 g_io_channel_unref((GIOChannel
*)data
);
2467 g_io_channel_unref((GIOChannel
*)data
);
2471 # endif /* USE_XSMP */
2474 * Setup the WM_PROTOCOLS to indicate we want the WM_SAVE_YOURSELF event.
2475 * This is an ugly use of X functions. GTK doesn't offer an alternative.
2478 setup_save_yourself(void)
2480 Atom
*existing_atoms
= NULL
;
2484 if (xsmp_icefd
!= -1)
2487 * Use XSMP is preference to legacy WM_SAVE_YOURSELF;
2488 * set up GTK IO monitor
2490 GIOChannel
*g_io
= g_io_channel_unix_new(xsmp_icefd
);
2492 g_io_add_watch(g_io
, G_IO_IN
| G_IO_ERR
| G_IO_HUP
,
2493 local_xsmp_handle_requests
, (gpointer
)g_io
);
2498 /* Fall back to old method */
2500 /* first get the existing value */
2501 if (XGetWMProtocols(GDK_WINDOW_XDISPLAY(gui
.mainwin
->window
),
2502 GDK_WINDOW_XWINDOW(gui
.mainwin
->window
),
2503 &existing_atoms
, &count
))
2506 Atom save_yourself_xatom
;
2509 save_yourself_xatom
= GET_X_ATOM(save_yourself_atom
);
2511 /* check if WM_SAVE_YOURSELF isn't there yet */
2512 for (i
= 0; i
< count
; ++i
)
2513 if (existing_atoms
[i
] == save_yourself_xatom
)
2518 /* allocate an Atoms array which is one item longer */
2519 new_atoms
= (Atom
*)alloc((unsigned)((count
+ 1)
2521 if (new_atoms
!= NULL
)
2523 memcpy(new_atoms
, existing_atoms
, count
* sizeof(Atom
));
2524 new_atoms
[count
] = save_yourself_xatom
;
2525 XSetWMProtocols(GDK_WINDOW_XDISPLAY(gui
.mainwin
->window
),
2526 GDK_WINDOW_XWINDOW(gui
.mainwin
->window
),
2527 new_atoms
, count
+ 1);
2528 vim_free(new_atoms
);
2531 XFree(existing_atoms
);
2538 * Installing a global event filter seems to be the only way to catch
2539 * client messages of type WM_PROTOCOLS without overriding GDK's own
2540 * client message event filter. Well, that's still better than trying
2541 * to guess what the GDK filter had done if it had been invoked instead
2542 * (This is what we did for GTK+ 1.2, see below).
2544 * GTK2_FIXME: This doesn't seem to work. For some reason we never
2545 * receive WM_SAVE_YOURSELF even though everything is set up correctly.
2546 * I have the nasty feeling modern session managers just don't send this
2547 * deprecated message anymore. Addition: confirmed by several people.
2549 * The GNOME session support is much cooler anyway. Unlike this ugly
2550 * WM_SAVE_YOURSELF hack it actually stores the session... And yes,
2551 * it should work with KDE as well.
2553 static GdkFilterReturn
2554 global_event_filter(GdkXEvent
*xev
,
2555 GdkEvent
*event UNUSED
,
2556 gpointer data UNUSED
)
2558 XEvent
*xevent
= (XEvent
*)xev
;
2561 && xevent
->type
== ClientMessage
2562 && xevent
->xclient
.message_type
== GET_X_ATOM(wm_protocols_atom
)
2563 && (long_u
)xevent
->xclient
.data
.l
[0]
2564 == GET_X_ATOM(save_yourself_atom
))
2567 ml_sync_all(FALSE
, FALSE
); /* preserve all swap files */
2569 * Set the window's WM_COMMAND property, to let the window manager
2570 * know we are done saving ourselves. We don't want to be
2571 * restarted, thus set argv to NULL.
2573 XSetCommand(GDK_WINDOW_XDISPLAY(gui
.mainwin
->window
),
2574 GDK_WINDOW_XWINDOW(gui
.mainwin
->window
),
2576 return GDK_FILTER_REMOVE
;
2579 return GDK_FILTER_CONTINUE
;
2582 # else /* !HAVE_GTK2 */
2585 * GDK handler for X ClientMessage events.
2587 static GdkFilterReturn
2588 gdk_wm_protocols_filter(GdkXEvent
*xev
, GdkEvent
*event
, gpointer data
)
2590 /* From example in gdkevents.c/gdk_wm_protocols_filter */
2591 XEvent
*xevent
= (XEvent
*)xev
;
2595 if (xevent
->xclient
.data
.l
[0] == GET_X_ATOM(save_yourself_atom
))
2598 ml_sync_all(FALSE
, FALSE
); /* preserve all swap files */
2600 /* Set the window's WM_COMMAND property, to let the window manager
2601 * know we are done saving ourselves. We don't want to be
2602 * restarted, thus set argv to NULL. */
2603 XSetCommand(GDK_WINDOW_XDISPLAY(gui
.mainwin
->window
),
2604 GDK_WINDOW_XWINDOW(gui
.mainwin
->window
),
2608 * Functionality from gdkevents.c/gdk_wm_protocols_filter;
2609 * Registering this filter apparently overrides the default GDK one,
2610 * so we need to perform its functionality. There seems no way to
2611 * register for WM_PROTOCOLS, and only process the WM_SAVE_YOURSELF
2612 * bit; it's all or nothing. Update: No, there is a way -- but it
2613 * only works with GTK+ 2 apparently. See above.
2615 else if (xevent
->xclient
.data
.l
[0] == GET_X_ATOM(gdk_wm_delete_window
))
2617 event
->any
.type
= GDK_DELETE
;
2618 return GDK_FILTER_TRANSLATE
;
2622 return GDK_FILTER_REMOVE
;
2624 # endif /* !HAVE_GTK2 */
2626 #endif /* !(FEAT_GUI_GNOME && FEAT_SESSION) */
2630 * Setup the window icon & xcmdsrv comm after the main window has been realized.
2633 mainwin_realize(GtkWidget
*widget UNUSED
, gpointer data UNUSED
)
2635 /* If you get an error message here, you still need to unpack the runtime
2641 /* A bit hackish, but avoids casting later and allows optimization */
2642 # define static static const
2644 #define magick vim32x32
2645 #include "../runtime/vim32x32.xpm"
2647 #define magick vim16x16
2648 #include "../runtime/vim16x16.xpm"
2650 #define magick vim48x48
2651 #include "../runtime/vim48x48.xpm"
2657 /* When started with "--echo-wid" argument, write window ID on stdout. */
2660 printf("WID: %ld\n", (long)GDK_WINDOW_XWINDOW(gui
.mainwin
->window
));
2664 if (vim_strchr(p_go
, GO_ICON
) != NULL
)
2667 * Add an icon to the main window. For fun and convenience of the user.
2670 GList
*icons
= NULL
;
2672 icons
= g_list_prepend(icons
, gdk_pixbuf_new_from_xpm_data(vim16x16
));
2673 icons
= g_list_prepend(icons
, gdk_pixbuf_new_from_xpm_data(vim32x32
));
2674 icons
= g_list_prepend(icons
, gdk_pixbuf_new_from_xpm_data(vim48x48
));
2676 gtk_window_set_icon_list(GTK_WINDOW(gui
.mainwin
), icons
);
2678 g_list_foreach(icons
, (GFunc
)&g_object_unref
, NULL
);
2681 #else /* !HAVE_GTK2 */
2684 GdkBitmap
*icon_mask
= NULL
;
2685 char **magick
= vim32x32
;
2691 * Adjust the icon to the preferences of the actual window manager.
2692 * This is once again a workaround for a deficiency in GTK+ 1.2.
2694 xdisplay
= GDK_WINDOW_XDISPLAY(gui
.mainwin
->window
);
2695 root_window
= XRootWindow(xdisplay
, DefaultScreen(xdisplay
));
2696 if (XGetIconSizes(xdisplay
, root_window
, &size
, &number_sizes
))
2698 if (number_sizes
> 0)
2700 if (size
->max_height
>= 48 && size
->max_height
>= 48)
2702 else if (size
->max_height
>= 32 && size
->max_height
>= 32)
2704 else if (size
->max_height
>= 16 && size
->max_height
>= 16)
2709 icon
= gdk_pixmap_create_from_xpm_d(gui
.mainwin
->window
,
2710 &icon_mask
, NULL
, magick
);
2712 /* Note: for some reason gdk_window_set_icon() doesn't acquire
2713 * a reference on the pixmap, thus we _have_ to leak it. */
2714 gdk_window_set_icon(gui
.mainwin
->window
, NULL
, icon
, icon_mask
);
2716 #endif /* !HAVE_GTK2 */
2719 #if !(defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION))
2720 /* Register a handler for WM_SAVE_YOURSELF with GDK's low-level X I/F */
2722 gdk_window_add_filter(NULL
, &global_event_filter
, NULL
);
2724 gdk_add_client_message_filter(wm_protocols_atom
,
2725 &gdk_wm_protocols_filter
, NULL
);
2728 /* Setup to indicate to the window manager that we want to catch the
2729 * WM_SAVE_YOURSELF event. For GNOME, this connects to the session
2730 * manager instead. */
2731 #if defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION)
2734 setup_save_yourself();
2736 #ifdef FEAT_CLIENTSERVER
2737 if (serverName
== NULL
&& serverDelayedStartName
!= NULL
)
2739 /* This is a :gui command in a plain vim with no previous server */
2740 commWindow
= GDK_WINDOW_XWINDOW(gui
.mainwin
->window
);
2742 (void)serverRegisterName(GDK_WINDOW_XDISPLAY(gui
.mainwin
->window
),
2743 serverDelayedStartName
);
2748 * Cannot handle "XLib-only" windows with gtk event routines, we'll
2749 * have to change the "server" registration to that of the main window
2750 * If we have not registered a name yet, remember the window
2752 serverChangeRegisteredWindow(GDK_WINDOW_XDISPLAY(gui
.mainwin
->window
),
2753 GDK_WINDOW_XWINDOW(gui
.mainwin
->window
));
2755 gtk_widget_add_events(gui
.mainwin
, GDK_PROPERTY_CHANGE_MASK
);
2756 gtk_signal_connect(GTK_OBJECT(gui
.mainwin
), "property_notify_event",
2757 GTK_SIGNAL_FUNC(property_event
), NULL
);
2762 create_blank_pointer(void)
2764 GdkWindow
*root_window
= NULL
;
2765 GdkPixmap
*blank_mask
;
2767 GdkColor color
= { 0, 0, 0, 0 };
2768 char blank_data
[] = { 0x0 };
2770 #ifdef HAVE_GTK_MULTIHEAD
2771 root_window
= gtk_widget_get_root_window(gui
.mainwin
);
2774 /* Create a pseudo blank pointer, which is in fact one pixel by one pixel
2776 blank_mask
= gdk_bitmap_create_from_data(root_window
, blank_data
, 1, 1);
2777 cursor
= gdk_cursor_new_from_pixmap(blank_mask
, blank_mask
,
2778 &color
, &color
, 0, 0);
2779 gdk_bitmap_unref(blank_mask
);
2784 #ifdef HAVE_GTK_MULTIHEAD
2786 mainwin_screen_changed_cb(GtkWidget
*widget
,
2787 GdkScreen
*previous_screen UNUSED
,
2788 gpointer data UNUSED
)
2790 if (!gtk_widget_has_screen(widget
))
2794 * Recreate the invisible mouse cursor.
2796 if (gui
.blank_pointer
!= NULL
)
2797 gdk_cursor_unref(gui
.blank_pointer
);
2799 gui
.blank_pointer
= create_blank_pointer();
2801 if (gui
.pointer_hidden
&& gui
.drawarea
->window
!= NULL
)
2802 gdk_window_set_cursor(gui
.drawarea
->window
, gui
.blank_pointer
);
2805 * Create a new PangoContext for this screen, and initialize it
2806 * with the current font if necessary.
2808 if (gui
.text_context
!= NULL
)
2809 g_object_unref(gui
.text_context
);
2811 gui
.text_context
= gtk_widget_create_pango_context(widget
);
2812 pango_context_set_base_dir(gui
.text_context
, PANGO_DIRECTION_LTR
);
2814 if (gui
.norm_font
!= NULL
)
2816 gui_mch_init_font(p_guifont
, FALSE
);
2817 gui_set_shellsize(FALSE
, FALSE
, RESIZE_BOTH
);
2820 #endif /* HAVE_GTK_MULTIHEAD */
2823 * After the drawing area comes up, we calculate all colors and create the
2824 * dummy blank cursor.
2826 * Don't try to set any VIM scrollbar sizes anywhere here. I'm relying on the
2827 * fact that the main VIM engine doesn't take them into account anywhere.
2830 drawarea_realize_cb(GtkWidget
*widget
, gpointer data UNUSED
)
2837 gui_mch_new_colors();
2838 gui
.text_gc
= gdk_gc_new(gui
.drawarea
->window
);
2840 gui
.blank_pointer
= create_blank_pointer();
2841 if (gui
.pointer_hidden
)
2842 gdk_window_set_cursor(widget
->window
, gui
.blank_pointer
);
2844 /* get the actual size of the scrollbars, if they are realized */
2845 sbar
= firstwin
->w_scrollbars
[SBAR_LEFT
].id
;
2846 if (!sbar
|| (!gui
.which_scrollbars
[SBAR_LEFT
]
2847 && firstwin
->w_scrollbars
[SBAR_RIGHT
].id
))
2848 sbar
= firstwin
->w_scrollbars
[SBAR_RIGHT
].id
;
2849 if (sbar
&& GTK_WIDGET_REALIZED(sbar
) && sbar
->allocation
.width
)
2850 gui
.scrollbar_width
= sbar
->allocation
.width
;
2852 sbar
= gui
.bottom_sbar
.id
;
2853 if (sbar
&& GTK_WIDGET_REALIZED(sbar
) && sbar
->allocation
.height
)
2854 gui
.scrollbar_height
= sbar
->allocation
.height
;
2858 * Properly clean up on shutdown.
2861 drawarea_unrealize_cb(GtkWidget
*widget UNUSED
, gpointer data UNUSED
)
2863 /* Don't write messages to the GUI anymore */
2864 full_screen
= FALSE
;
2870 if (gui
.ascii_glyphs
!= NULL
)
2872 pango_glyph_string_free(gui
.ascii_glyphs
);
2873 gui
.ascii_glyphs
= NULL
;
2875 if (gui
.ascii_font
!= NULL
)
2877 g_object_unref(gui
.ascii_font
);
2878 gui
.ascii_font
= NULL
;
2880 g_object_unref(gui
.text_context
);
2881 gui
.text_context
= NULL
;
2883 g_object_unref(gui
.text_gc
);
2886 gdk_cursor_unref(gui
.blank_pointer
);
2887 gui
.blank_pointer
= NULL
;
2889 gdk_gc_unref(gui
.text_gc
);
2892 gdk_cursor_destroy(gui
.blank_pointer
);
2893 gui
.blank_pointer
= NULL
;
2898 drawarea_style_set_cb(GtkWidget
*widget UNUSED
,
2899 GtkStyle
*previous_style UNUSED
,
2900 gpointer data UNUSED
)
2902 gui_mch_new_colors();
2906 * Callback routine for the "delete_event" signal on the toplevel window.
2907 * Tries to vim gracefully, or refuses to exit with changed buffers.
2910 delete_event_cb(GtkWidget
*widget UNUSED
,
2911 GdkEventAny
*event UNUSED
,
2912 gpointer data UNUSED
)
2918 #if defined(FEAT_MENU) || defined(FEAT_TOOLBAR) || defined(FEAT_GUI_TABLINE)
2920 get_item_dimensions(GtkWidget
*widget
, GtkOrientation orientation
)
2922 GtkOrientation item_orientation
= GTK_ORIENTATION_HORIZONTAL
;
2924 #ifdef FEAT_GUI_GNOME
2925 if (using_gnome
&& widget
!= NULL
)
2929 BonoboDockItem
*dockitem
;
2931 parent
= gtk_widget_get_parent(widget
);
2932 if (G_TYPE_FROM_INSTANCE(parent
) == BONOBO_TYPE_DOCK_ITEM
)
2934 /* Only menu & toolbar are dock items. Could tabline be?
2935 * Seem to be only the 2 defined in GNOME */
2937 dockitem
= BONOBO_DOCK_ITEM(widget
);
2939 if (dockitem
== NULL
|| dockitem
->is_floating
)
2941 item_orientation
= bonobo_dock_item_get_orientation(dockitem
);
2944 GnomeDockItem
*dockitem
;
2946 widget
= widget
->parent
;
2947 dockitem
= GNOME_DOCK_ITEM(widget
);
2949 if (dockitem
== NULL
|| dockitem
->is_floating
)
2951 item_orientation
= gnome_dock_item_get_orientation(dockitem
);
2956 && item_orientation
== orientation
2957 && GTK_WIDGET_REALIZED(widget
)
2958 && GTK_WIDGET_VISIBLE(widget
))
2960 if (orientation
== GTK_ORIENTATION_HORIZONTAL
)
2961 return widget
->allocation
.height
;
2963 return widget
->allocation
.width
;
2970 get_menu_tool_width(void)
2974 #ifdef FEAT_GUI_GNOME /* these are never vertical without GNOME */
2976 width
+= get_item_dimensions(gui
.menubar
, GTK_ORIENTATION_VERTICAL
);
2978 # ifdef FEAT_TOOLBAR
2979 width
+= get_item_dimensions(gui
.toolbar
, GTK_ORIENTATION_VERTICAL
);
2981 # ifdef FEAT_GUI_TABLINE
2982 if (gui
.tabline
!= NULL
)
2983 width
+= get_item_dimensions(gui
.tabline
, GTK_ORIENTATION_VERTICAL
);
2991 get_menu_tool_height(void)
2996 height
+= get_item_dimensions(gui
.menubar
, GTK_ORIENTATION_HORIZONTAL
);
2999 height
+= get_item_dimensions(gui
.toolbar
, GTK_ORIENTATION_HORIZONTAL
);
3001 #ifdef FEAT_GUI_TABLINE
3002 if (gui
.tabline
!= NULL
)
3003 height
+= get_item_dimensions(gui
.tabline
, GTK_ORIENTATION_HORIZONTAL
);
3009 /* This controls whether we can set the real window hints at
3010 * start-up when in a GtkPlug.
3011 * 0 = normal processing (default)
3012 * 1 = init. hints set, no-one's tried to reset since last check
3013 * 2 = init. hints set, attempt made to change hints
3015 static int init_window_hints_state
= 0;
3018 update_window_manager_hints(int force_width
, int force_height
)
3020 static int old_width
= 0;
3021 static int old_height
= 0;
3022 static int old_min_width
= 0;
3023 static int old_min_height
= 0;
3024 static int old_char_width
= 0;
3025 static int old_char_height
= 0;
3032 /* At start-up, don't try to set the hints until the initial
3033 * values have been used (those that dictate our initial size)
3034 * Let forced (i.e., correct) values through always.
3036 if (!(force_width
&& force_height
) && init_window_hints_state
> 0)
3039 init_window_hints_state
= 2;
3043 /* This also needs to be done when the main window isn't there yet,
3044 * otherwise the hints don't work. */
3045 width
= gui_get_base_width();
3046 height
= gui_get_base_height();
3048 height
+= tabline_height() * gui
.char_height
;
3051 width
+= get_menu_tool_width();
3052 height
+= get_menu_tool_height();
3055 /* GtkSockets use GtkPlug's [gui,mainwin] min-size hints to determine
3056 * their actual widget size. When we set our size ourselves (e.g.,
3057 * 'set columns=' or init. -geom) we briefly set the min. to the size
3058 * we wish to be instead of the legitimate minimum so that we actually
3061 if (force_width
&& force_height
)
3063 min_width
= force_width
;
3064 min_height
= force_height
;
3068 min_width
= width
+ MIN_COLUMNS
* gui
.char_width
;
3069 min_height
= height
+ MIN_LINES
* gui
.char_height
;
3072 /* Avoid an expose event when the size didn't change. */
3073 if (width
!= old_width
3074 || height
!= old_height
3075 || min_width
!= old_min_width
3076 || min_height
!= old_min_height
3077 || gui
.char_width
!= old_char_width
3078 || gui
.char_height
!= old_char_height
)
3080 GdkGeometry geometry
;
3081 GdkWindowHints geometry_mask
;
3083 geometry
.width_inc
= gui
.char_width
;
3084 geometry
.height_inc
= gui
.char_height
;
3085 geometry
.base_width
= width
;
3086 geometry
.base_height
= height
;
3087 geometry
.min_width
= min_width
;
3088 geometry
.min_height
= min_height
;
3089 geometry_mask
= GDK_HINT_BASE_SIZE
|GDK_HINT_RESIZE_INC
3092 /* Using gui.formwin as geometry widget doesn't work as expected
3093 * with GTK+ 2 -- dunno why. Presumably all the resizing hacks
3094 * in Vim confuse GTK+. */
3095 gtk_window_set_geometry_hints(GTK_WINDOW(gui
.mainwin
), gui
.mainwin
,
3096 &geometry
, geometry_mask
);
3098 gtk_window_set_geometry_hints(GTK_WINDOW(gui
.mainwin
), gui
.formwin
,
3099 &geometry
, geometry_mask
);
3102 old_height
= height
;
3103 old_min_width
= min_width
;
3104 old_min_height
= min_height
;
3105 old_char_width
= gui
.char_width
;
3106 old_char_height
= gui
.char_height
;
3114 * This extra effort wouldn't be necessary if we only used stock icons in the
3115 * toolbar, as we do for all builtin icons. But user-defined toolbar icons
3116 * shouldn't be treated differently, thus we do need this.
3119 icon_size_changed_foreach(GtkWidget
*widget
, gpointer user_data
)
3121 if (GTK_IS_IMAGE(widget
))
3123 GtkImage
*image
= (GtkImage
*)widget
;
3125 /* User-defined icons are stored in a GtkIconSet */
3126 if (gtk_image_get_storage_type(image
) == GTK_IMAGE_ICON_SET
)
3128 GtkIconSet
*icon_set
;
3129 GtkIconSize icon_size
;
3131 gtk_image_get_icon_set(image
, &icon_set
, &icon_size
);
3132 icon_size
= (GtkIconSize
)(long)user_data
;
3134 gtk_icon_set_ref(icon_set
);
3135 gtk_image_set_from_icon_set(image
, icon_set
, icon_size
);
3136 gtk_icon_set_unref(icon_set
);
3139 else if (GTK_IS_CONTAINER(widget
))
3141 gtk_container_foreach((GtkContainer
*)widget
,
3142 &icon_size_changed_foreach
,
3146 # endif /* HAVE_GTK2 */
3149 set_toolbar_style(GtkToolbar
*toolbar
)
3151 GtkToolbarStyle style
;
3154 GtkIconSize oldsize
;
3158 if ((toolbar_flags
& (TOOLBAR_TEXT
| TOOLBAR_ICONS
| TOOLBAR_HORIZ
))
3159 == (TOOLBAR_TEXT
| TOOLBAR_ICONS
| TOOLBAR_HORIZ
))
3160 style
= GTK_TOOLBAR_BOTH_HORIZ
;
3163 if ((toolbar_flags
& (TOOLBAR_TEXT
| TOOLBAR_ICONS
))
3164 == (TOOLBAR_TEXT
| TOOLBAR_ICONS
))
3165 style
= GTK_TOOLBAR_BOTH
;
3166 else if (toolbar_flags
& TOOLBAR_TEXT
)
3167 style
= GTK_TOOLBAR_TEXT
;
3169 style
= GTK_TOOLBAR_ICONS
;
3171 gtk_toolbar_set_style(toolbar
, style
);
3172 gtk_toolbar_set_tooltips(toolbar
, (toolbar_flags
& TOOLBAR_TOOLTIPS
) != 0);
3177 case TBIS_TINY
: size
= GTK_ICON_SIZE_MENU
; break;
3178 case TBIS_SMALL
: size
= GTK_ICON_SIZE_SMALL_TOOLBAR
; break;
3179 case TBIS_MEDIUM
: size
= GTK_ICON_SIZE_BUTTON
; break;
3180 case TBIS_LARGE
: size
= GTK_ICON_SIZE_LARGE_TOOLBAR
; break;
3181 default: size
= GTK_ICON_SIZE_INVALID
; break;
3183 oldsize
= gtk_toolbar_get_icon_size(toolbar
);
3185 if (size
== GTK_ICON_SIZE_INVALID
)
3187 /* Let global user preferences decide the icon size. */
3188 gtk_toolbar_unset_icon_size(toolbar
);
3189 size
= gtk_toolbar_get_icon_size(toolbar
);
3191 if (size
!= oldsize
)
3193 gtk_container_foreach(GTK_CONTAINER(toolbar
),
3194 &icon_size_changed_foreach
,
3195 GINT_TO_POINTER((int)size
));
3197 gtk_toolbar_set_icon_size(toolbar
, size
);
3201 #endif /* FEAT_TOOLBAR */
3203 #if defined(FEAT_GUI_TABLINE) || defined(PROTO)
3204 static int ignore_tabline_evt
= FALSE
;
3205 static GtkWidget
*tabline_menu
;
3206 static GtkTooltips
*tabline_tooltip
;
3207 static int clicked_page
; /* page clicked in tab line */
3210 * Handle selecting an item in the tab line popup menu.
3213 tabline_menu_handler(GtkMenuItem
*item UNUSED
, gpointer user_data
)
3215 /* Add the string cmd into input buffer */
3216 send_tabline_menu_event(clicked_page
, (int)(long)user_data
);
3218 if (gtk_main_level() > 0)
3223 add_tabline_menu_item(GtkWidget
*menu
, char_u
*text
, int resp
)
3228 utf_text
= CONVERT_TO_UTF8(text
);
3229 item
= gtk_menu_item_new_with_label((const char *)utf_text
);
3230 gtk_widget_show(item
);
3231 CONVERT_TO_UTF8_FREE(utf_text
);
3233 gtk_container_add(GTK_CONTAINER(menu
), item
);
3234 gtk_signal_connect(GTK_OBJECT(item
), "activate",
3235 GTK_SIGNAL_FUNC(tabline_menu_handler
),
3236 (gpointer
)(long)resp
);
3240 * Create a menu for the tab line.
3243 create_tabline_menu(void)
3247 menu
= gtk_menu_new();
3248 add_tabline_menu_item(menu
, (char_u
*)_("Close"), TABLINE_MENU_CLOSE
);
3249 add_tabline_menu_item(menu
, (char_u
*)_("New tab"), TABLINE_MENU_NEW
);
3250 add_tabline_menu_item(menu
, (char_u
*)_("Open Tab..."), TABLINE_MENU_OPEN
);
3256 on_tabline_menu(GtkWidget
*widget
, GdkEvent
*event
)
3258 /* Was this button press event ? */
3259 if (event
->type
== GDK_BUTTON_PRESS
)
3261 GdkEventButton
*bevent
= (GdkEventButton
*)event
;
3264 GtkWidget
*tabwidget
;
3267 /* When ignoring events return TRUE so that the selected page doesn't
3276 tabwin
= gdk_window_at_pointer(&x
, &y
);
3277 gdk_window_get_user_data(tabwin
, (gpointer
)&tabwidget
);
3278 clicked_page
= (int)(long)gtk_object_get_user_data(
3279 GTK_OBJECT(tabwidget
));
3281 /* If the event was generated for 3rd button popup the menu. */
3282 if (bevent
->button
== 3)
3284 gtk_menu_popup(GTK_MENU(widget
), NULL
, NULL
, NULL
, NULL
,
3285 bevent
->button
, bevent
->time
);
3286 /* We handled the event. */
3289 else if (bevent
->button
== 1)
3291 if (clicked_page
== 0)
3293 /* Click after all tabs moves to next tab page. When "x" is
3294 * small guess it's the left button. */
3295 if (send_tabline_event(x
< 50 ? -1 : 0) && gtk_main_level() > 0)
3300 gtk_notebook_set_page(GTK_NOTEBOOK(gui
.tabline
),
3306 /* We didn't handle the event. */
3311 * Handle selecting one of the tabs.
3315 GtkNotebook
*notebook UNUSED
,
3316 GtkNotebookPage
*page UNUSED
,
3318 gpointer data UNUSED
)
3320 if (!ignore_tabline_evt
)
3322 if (send_tabline_event(idx
+ 1) && gtk_main_level() > 0)
3328 static int showing_tabline
= 0;
3332 * Show or hide the tabline.
3335 gui_mch_show_tabline(int showit
)
3337 if (gui
.tabline
== NULL
)
3341 /* gtk_notebook_get_show_tabs does not exist in gtk+-1.2.10 */
3342 if (!showit
!= !gtk_notebook_get_show_tabs(GTK_NOTEBOOK(gui
.tabline
)))
3344 if (!showit
!= !showing_tabline
)
3347 /* Note: this may cause a resize event */
3348 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(gui
.tabline
), showit
);
3349 update_window_manager_hints(0, 0);
3351 showing_tabline
= showit
;
3354 GTK_WIDGET_UNSET_FLAGS(GTK_WIDGET(gui
.tabline
), GTK_CAN_FOCUS
);
3361 * Return TRUE when tabline is displayed.
3364 gui_mch_showing_tabline(void)
3366 return gui
.tabline
!= NULL
3368 /* gtk_notebook_get_show_tabs does not exist in gtk+-1.2.10 */
3369 && gtk_notebook_get_show_tabs(GTK_NOTEBOOK(gui
.tabline
))
3377 * Update the labels of the tabline.
3380 gui_mch_update_tabline(void)
3383 GtkWidget
*event_box
;
3391 if (gui
.tabline
== NULL
)
3394 ignore_tabline_evt
= TRUE
;
3396 /* Add a label for each tab page. They all contain the same text area. */
3397 for (tp
= first_tabpage
; tp
!= NULL
; tp
= tp
->tp_next
, ++nr
)
3404 page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(gui
.tabline
), nr
);
3407 /* Add notebook page */
3408 page
= gtk_vbox_new(FALSE
, 0);
3409 gtk_widget_show(page
);
3410 event_box
= gtk_event_box_new();
3411 gtk_widget_show(event_box
);
3412 label
= gtk_label_new("-Empty-");
3413 gtk_misc_set_padding(GTK_MISC(label
), 2, 2);
3414 gtk_container_add(GTK_CONTAINER(event_box
), label
);
3415 gtk_widget_show(label
);
3416 gtk_notebook_insert_page(GTK_NOTEBOOK(gui
.tabline
),
3422 event_box
= gtk_notebook_get_tab_label(GTK_NOTEBOOK(gui
.tabline
), page
);
3423 gtk_object_set_user_data(GTK_OBJECT(event_box
),
3424 (gpointer
)(long)tab_num
);
3425 label
= GTK_BIN(event_box
)->child
;
3426 get_tabline_label(tp
, FALSE
);
3427 labeltext
= CONVERT_TO_UTF8(NameBuff
);
3428 gtk_label_set_text(GTK_LABEL(label
), (const char *)labeltext
);
3429 CONVERT_TO_UTF8_FREE(labeltext
);
3431 get_tabline_label(tp
, TRUE
);
3432 labeltext
= CONVERT_TO_UTF8(NameBuff
);
3433 gtk_tooltips_set_tip(GTK_TOOLTIPS(tabline_tooltip
), event_box
,
3434 (const char *)labeltext
, NULL
);
3435 CONVERT_TO_UTF8_FREE(labeltext
);
3438 /* Remove any old labels. */
3439 while (gtk_notebook_get_nth_page(GTK_NOTEBOOK(gui
.tabline
), nr
) != NULL
)
3440 gtk_notebook_remove_page(GTK_NOTEBOOK(gui
.tabline
), nr
);
3442 if (gtk_notebook_current_page(GTK_NOTEBOOK(gui
.tabline
)) != curtabidx
)
3443 gtk_notebook_set_page(GTK_NOTEBOOK(gui
.tabline
), curtabidx
);
3445 /* Make sure everything is in place before drawing text. */
3448 ignore_tabline_evt
= FALSE
;
3452 * Set the current tab to "nr". First tab is 1.
3455 gui_mch_set_curtab(nr
)
3458 if (gui
.tabline
== NULL
)
3461 ignore_tabline_evt
= TRUE
;
3462 if (gtk_notebook_current_page(GTK_NOTEBOOK(gui
.tabline
)) != nr
- 1)
3463 gtk_notebook_set_page(GTK_NOTEBOOK(gui
.tabline
), nr
- 1);
3464 ignore_tabline_evt
= FALSE
;
3467 #endif /* FEAT_GUI_TABLINE */
3470 * Add selection targets for PRIMARY and CLIPBOARD selections.
3473 gui_gtk_set_selection_targets(void)
3476 int n_targets
= N_SELECTION_TARGETS
;
3477 GtkTargetEntry targets
[N_SELECTION_TARGETS
];
3479 for (i
= 0; i
< (int)N_SELECTION_TARGETS
; ++i
)
3482 /* OpenOffice tries to use TARGET_HTML and fails when it doesn't
3483 * return something, instead of trying another target. Therefore only
3484 * offer TARGET_HTML when it works. */
3485 if (!clip_html
&& selection_targets
[i
].info
== TARGET_HTML
)
3489 targets
[j
++] = selection_targets
[i
];
3492 gtk_selection_clear_targets(gui
.drawarea
, (GdkAtom
)GDK_SELECTION_PRIMARY
);
3493 gtk_selection_clear_targets(gui
.drawarea
, (GdkAtom
)clip_plus
.gtk_sel_atom
);
3494 gtk_selection_add_targets(gui
.drawarea
,
3495 (GdkAtom
)GDK_SELECTION_PRIMARY
,
3496 targets
, n_targets
);
3497 gtk_selection_add_targets(gui
.drawarea
,
3498 (GdkAtom
)clip_plus
.gtk_sel_atom
,
3499 targets
, n_targets
);
3503 * Set up for receiving DND items.
3506 gui_gtk_set_dnd_targets(void)
3509 int n_targets
= N_DND_TARGETS
;
3510 GtkTargetEntry targets
[N_DND_TARGETS
];
3512 for (i
= 0; i
< (int)N_DND_TARGETS
; ++i
)
3515 if (!clip_html
&& selection_targets
[i
].info
== TARGET_HTML
)
3519 targets
[j
++] = dnd_targets
[i
];
3522 gtk_drag_dest_unset(gui
.drawarea
);
3523 gtk_drag_dest_set(gui
.drawarea
,
3524 GTK_DEST_DEFAULT_ALL
,
3530 * Initialize the GUI. Create all the windows, set up all the callbacks etc.
3531 * Returns OK for success, FAIL when the GUI can't be started.
3538 #ifdef FEAT_GUI_GNOME
3539 /* Initialize the GNOME libraries. gnome_program_init()/gnome_init()
3540 * exits on failure, but that's a non-issue because we already called
3541 * gtk_init_check() in gui_mch_init_check(). */
3544 gnome_program_init(VIMPACKAGE
, VIM_VERSION_SHORT
,
3545 LIBGNOMEUI_MODULE
, gui_argc
, gui_argv
, NULL
);
3547 gnome_init(VIMPACKAGE
, VIM_VERSION_SHORT
, gui_argc
, gui_argv
);
3554 # if GLIB_CHECK_VERSION(2,1,3)
3555 /* Set the human-readable application name */
3556 g_set_application_name("Vim");
3559 * Force UTF-8 output no matter what the value of 'encoding' is.
3560 * did_set_string_option() in option.c prohibits changing 'termencoding'
3561 * to something else than UTF-8 if the GUI is in use.
3563 set_option_value((char_u
*)"termencoding", 0L, (char_u
*)"utf-8", 0);
3565 # ifdef FEAT_TOOLBAR
3566 gui_gtk_register_stock_icons();
3568 /* FIXME: Need to install the classic icons and a gtkrc.classic file.
3569 * The hard part is deciding install locations and the Makefile magic. */
3571 gtk_rc_parse("gtkrc");
3575 /* Initialize values */
3576 gui
.border_width
= 2;
3577 gui
.scrollbar_width
= SB_DEFAULT_WIDTH
;
3578 gui
.scrollbar_height
= SB_DEFAULT_WIDTH
;
3579 /* LINTED: avoid warning: conversion to 'unsigned long' */
3580 gui
.fgcolor
= g_new0(GdkColor
, 1);
3581 /* LINTED: avoid warning: conversion to 'unsigned long' */
3582 gui
.bgcolor
= g_new0(GdkColor
, 1);
3583 /* LINTED: avoid warning: conversion to 'unsigned long' */
3584 gui
.spcolor
= g_new0(GdkColor
, 1);
3586 /* Initialise atoms */
3588 html_atom
= gdk_atom_intern("text/html", FALSE
);
3589 utf8_string_atom
= gdk_atom_intern("UTF8_STRING", FALSE
);
3592 compound_text_atom
= gdk_atom_intern("COMPOUND_TEXT", FALSE
);
3593 text_atom
= gdk_atom_intern("TEXT", FALSE
);
3596 /* Set default foreground and background colors. */
3597 gui
.norm_pixel
= gui
.def_norm_pixel
;
3598 gui
.back_pixel
= gui
.def_back_pixel
;
3600 if (gtk_socket_id
!= 0)
3604 /* Use GtkSocket from another app. */
3605 #ifdef HAVE_GTK_MULTIHEAD
3606 plug
= gtk_plug_new_for_display(gdk_display_get_default(),
3609 plug
= gtk_plug_new(gtk_socket_id
);
3611 if (plug
!= NULL
&& GTK_PLUG(plug
)->socket_window
!= NULL
)
3617 g_warning("Connection to GTK+ socket (ID %u) failed",
3618 (unsigned int)gtk_socket_id
);
3619 /* Pretend we never wanted it if it failed (get own window) */
3624 if (gtk_socket_id
== 0)
3626 #ifdef FEAT_GUI_GNOME
3629 gui
.mainwin
= gnome_app_new("Vim", NULL
);
3631 /* Use the GNOME save-yourself functionality now. */
3637 gui
.mainwin
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
3640 gtk_widget_set_name(gui
.mainwin
, "vim-main-window");
3643 /* Create the PangoContext used for drawing all text. */
3644 gui
.text_context
= gtk_widget_create_pango_context(gui
.mainwin
);
3645 pango_context_set_base_dir(gui
.text_context
, PANGO_DIRECTION_LTR
);
3649 gtk_window_set_policy(GTK_WINDOW(gui
.mainwin
), TRUE
, TRUE
, TRUE
);
3651 gtk_container_border_width(GTK_CONTAINER(gui
.mainwin
), 0);
3652 gtk_widget_add_events(gui
.mainwin
, GDK_VISIBILITY_NOTIFY_MASK
);
3654 gtk_signal_connect(GTK_OBJECT(gui
.mainwin
), "delete_event",
3655 GTK_SIGNAL_FUNC(&delete_event_cb
), NULL
);
3657 gtk_signal_connect(GTK_OBJECT(gui
.mainwin
), "realize",
3658 GTK_SIGNAL_FUNC(&mainwin_realize
), NULL
);
3659 #ifdef HAVE_GTK_MULTIHEAD
3660 g_signal_connect(G_OBJECT(gui
.mainwin
), "screen_changed",
3661 G_CALLBACK(&mainwin_screen_changed_cb
), NULL
);
3664 gui
.accel_group
= gtk_accel_group_new();
3665 gtk_window_add_accel_group(GTK_WINDOW(gui
.mainwin
), gui
.accel_group
);
3667 gui
.accel_group
= gtk_accel_group_get_default();
3670 /* A vertical box holds the menubar, toolbar and main text window. */
3671 vbox
= gtk_vbox_new(FALSE
, 0);
3673 #ifdef FEAT_GUI_GNOME
3676 # if defined(HAVE_GTK2) && defined(FEAT_MENU)
3677 /* automagically restore menubar/toolbar placement */
3678 gnome_app_enable_layout_config(GNOME_APP(gui
.mainwin
), TRUE
);
3680 gnome_app_set_contents(GNOME_APP(gui
.mainwin
), vbox
);
3685 gtk_container_add(GTK_CONTAINER(gui
.mainwin
), vbox
);
3686 gtk_widget_show(vbox
);
3691 * Create the menubar and handle
3693 gui
.menubar
= gtk_menu_bar_new();
3694 gtk_widget_set_name(gui
.menubar
, "vim-menubar");
3697 /* Avoid that GTK takes <F10> away from us. */
3699 GtkSettings
*gtk_settings
;
3701 gtk_settings
= gtk_settings_get_for_screen(gdk_screen_get_default());
3702 g_object_set(gtk_settings
, "gtk-menu-bar-accel", NULL
, NULL
);
3707 # ifdef FEAT_GUI_GNOME
3711 BonoboDockItem
*dockitem
;
3713 gnome_app_set_menus(GNOME_APP(gui
.mainwin
), GTK_MENU_BAR(gui
.menubar
));
3714 dockitem
= gnome_app_get_dock_item_by_name(GNOME_APP(gui
.mainwin
),
3715 GNOME_APP_MENUBAR_NAME
);
3716 /* We don't want the menu to float. */
3717 bonobo_dock_item_set_behavior(dockitem
,
3718 bonobo_dock_item_get_behavior(dockitem
)
3719 | BONOBO_DOCK_ITEM_BEH_NEVER_FLOATING
);
3720 gui
.menubar_h
= GTK_WIDGET(dockitem
);
3722 gui
.menubar_h
= gnome_dock_item_new("VimMainMenu",
3723 GNOME_DOCK_ITEM_BEH_EXCLUSIVE
|
3724 GNOME_DOCK_ITEM_BEH_NEVER_VERTICAL
);
3725 gtk_container_add(GTK_CONTAINER(gui
.menubar_h
), gui
.menubar
);
3727 gnome_dock_add_item(GNOME_DOCK(GNOME_APP(gui
.mainwin
)->dock
),
3728 GNOME_DOCK_ITEM(gui
.menubar_h
),
3729 GNOME_DOCK_TOP
, /* placement */
3731 0, /* band_position */
3734 gtk_widget_show(gui
.menubar
);
3738 # endif /* FEAT_GUI_GNOME */
3740 /* Always show the menubar, otherwise <F10> doesn't work. It may be
3741 * disabled in gui_init() later. */
3742 gtk_widget_show(gui
.menubar
);
3743 gtk_box_pack_start(GTK_BOX(vbox
), gui
.menubar
, FALSE
, FALSE
, 0);
3745 #endif /* FEAT_MENU */
3749 * Create the toolbar and handle
3752 /* some aesthetics on the toolbar */
3753 gtk_rc_parse_string(
3754 "style \"vim-toolbar-style\" {\n"
3755 " GtkToolbar::button_relief = GTK_RELIEF_NONE\n"
3757 "widget \"*.vim-toolbar\" style \"vim-toolbar-style\"\n");
3758 gui
.toolbar
= gtk_toolbar_new();
3759 gtk_widget_set_name(gui
.toolbar
, "vim-toolbar");
3761 gui
.toolbar
= gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL
,
3763 gtk_toolbar_set_button_relief(GTK_TOOLBAR(gui
.toolbar
), GTK_RELIEF_NONE
);
3765 set_toolbar_style(GTK_TOOLBAR(gui
.toolbar
));
3767 # ifdef FEAT_GUI_GNOME
3771 BonoboDockItem
*dockitem
;
3773 gnome_app_set_toolbar(GNOME_APP(gui
.mainwin
), GTK_TOOLBAR(gui
.toolbar
));
3774 dockitem
= gnome_app_get_dock_item_by_name(GNOME_APP(gui
.mainwin
),
3775 GNOME_APP_TOOLBAR_NAME
);
3776 gui
.toolbar_h
= GTK_WIDGET(dockitem
);
3777 /* When the toolbar is floating it gets stuck. So long as that isn't
3778 * fixed let's disallow floating. */
3779 bonobo_dock_item_set_behavior(dockitem
,
3780 bonobo_dock_item_get_behavior(dockitem
)
3781 | BONOBO_DOCK_ITEM_BEH_NEVER_FLOATING
);
3782 gtk_container_set_border_width(GTK_CONTAINER(gui
.toolbar
), 0);
3784 GtkWidget
*dockitem
;
3786 dockitem
= gnome_dock_item_new("VimToolBar",
3787 GNOME_DOCK_ITEM_BEH_EXCLUSIVE
);
3788 gtk_container_add(GTK_CONTAINER(dockitem
), GTK_WIDGET(gui
.toolbar
));
3789 gui
.toolbar_h
= dockitem
;
3791 gnome_dock_add_item(GNOME_DOCK(GNOME_APP(gui
.mainwin
)->dock
),
3792 GNOME_DOCK_ITEM(dockitem
),
3793 GNOME_DOCK_TOP
, /* placement */
3795 1, /* band_position */
3798 gtk_container_border_width(GTK_CONTAINER(gui
.toolbar
), 2);
3799 gtk_widget_show(gui
.toolbar
);
3803 # endif /* FEAT_GUI_GNOME */
3806 gtk_container_border_width(GTK_CONTAINER(gui
.toolbar
), 1);
3808 if (vim_strchr(p_go
, GO_TOOLBAR
) != NULL
3809 && (toolbar_flags
& (TOOLBAR_TEXT
| TOOLBAR_ICONS
)))
3810 gtk_widget_show(gui
.toolbar
);
3811 gtk_box_pack_start(GTK_BOX(vbox
), gui
.toolbar
, FALSE
, FALSE
, 0);
3813 #endif /* FEAT_TOOLBAR */
3815 #ifdef FEAT_GUI_TABLINE
3817 * Use a Notebook for the tab pages labels. The labels are hidden by
3820 gui
.tabline
= gtk_notebook_new();
3821 gtk_widget_show(gui
.tabline
);
3822 gtk_box_pack_start(GTK_BOX(vbox
), gui
.tabline
, FALSE
, FALSE
, 0);
3823 gtk_notebook_set_show_border(GTK_NOTEBOOK(gui
.tabline
), FALSE
);
3824 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(gui
.tabline
), FALSE
);
3825 gtk_notebook_set_scrollable(GTK_NOTEBOOK(gui
.tabline
), TRUE
);
3826 gtk_notebook_set_tab_border(GTK_NOTEBOOK(gui
.tabline
), FALSE
);
3828 tabline_tooltip
= gtk_tooltips_new();
3829 gtk_tooltips_enable(GTK_TOOLTIPS(tabline_tooltip
));
3832 GtkWidget
*page
, *label
, *event_box
;
3834 /* Add the first tab. */
3835 page
= gtk_vbox_new(FALSE
, 0);
3836 gtk_widget_show(page
);
3837 gtk_container_add(GTK_CONTAINER(gui
.tabline
), page
);
3838 label
= gtk_label_new("-Empty-");
3839 gtk_widget_show(label
);
3840 event_box
= gtk_event_box_new();
3841 gtk_widget_show(event_box
);
3842 gtk_object_set_user_data(GTK_OBJECT(event_box
), (gpointer
)1L);
3843 gtk_misc_set_padding(GTK_MISC(label
), 2, 2);
3844 gtk_container_add(GTK_CONTAINER(event_box
), label
);
3845 gtk_notebook_set_tab_label(GTK_NOTEBOOK(gui
.tabline
), page
, event_box
);
3848 gtk_signal_connect(GTK_OBJECT(gui
.tabline
), "switch_page",
3849 GTK_SIGNAL_FUNC(on_select_tab
), NULL
);
3851 /* Create a popup menu for the tab line and connect it. */
3852 tabline_menu
= create_tabline_menu();
3853 gtk_signal_connect_object(GTK_OBJECT(gui
.tabline
), "button_press_event",
3854 GTK_SIGNAL_FUNC(on_tabline_menu
), GTK_OBJECT(tabline_menu
));
3857 gui
.formwin
= gtk_form_new();
3858 gtk_container_border_width(GTK_CONTAINER(gui
.formwin
), 0);
3859 gtk_widget_set_events(gui
.formwin
, GDK_EXPOSURE_MASK
);
3861 gui
.drawarea
= gtk_drawing_area_new();
3863 /* Determine which events we will filter. */
3864 gtk_widget_set_events(gui
.drawarea
,
3866 GDK_ENTER_NOTIFY_MASK
|
3867 GDK_LEAVE_NOTIFY_MASK
|
3868 GDK_BUTTON_PRESS_MASK
|
3869 GDK_BUTTON_RELEASE_MASK
|
3873 GDK_KEY_PRESS_MASK
|
3874 GDK_KEY_RELEASE_MASK
|
3875 GDK_POINTER_MOTION_MASK
|
3876 GDK_POINTER_MOTION_HINT_MASK
);
3878 gtk_widget_show(gui
.drawarea
);
3879 gtk_form_put(GTK_FORM(gui
.formwin
), gui
.drawarea
, 0, 0);
3880 gtk_widget_show(gui
.formwin
);
3881 gtk_box_pack_start(GTK_BOX(vbox
), gui
.formwin
, TRUE
, TRUE
, 0);
3883 /* For GtkSockets, key-presses must go to the focus widget (drawarea)
3884 * and not the window. */
3885 gtk_signal_connect((gtk_socket_id
== 0) ? GTK_OBJECT(gui
.mainwin
)
3886 : GTK_OBJECT(gui
.drawarea
),
3888 GTK_SIGNAL_FUNC(key_press_event
), NULL
);
3889 #if defined(FEAT_XIM) && defined(HAVE_GTK2)
3890 /* Also forward key release events for the benefit of GTK+ 2 input
3891 * modules. Try CTRL-SHIFT-xdigits to enter a Unicode code point. */
3892 g_signal_connect((gtk_socket_id
== 0) ? G_OBJECT(gui
.mainwin
)
3893 : G_OBJECT(gui
.drawarea
),
3894 "key_release_event",
3895 G_CALLBACK(&key_release_event
), NULL
);
3897 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "realize",
3898 GTK_SIGNAL_FUNC(drawarea_realize_cb
), NULL
);
3899 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "unrealize",
3900 GTK_SIGNAL_FUNC(drawarea_unrealize_cb
), NULL
);
3902 gtk_signal_connect_after(GTK_OBJECT(gui
.drawarea
), "style_set",
3903 GTK_SIGNAL_FUNC(&drawarea_style_set_cb
), NULL
);
3905 gui
.visibility
= GDK_VISIBILITY_UNOBSCURED
;
3907 #if !(defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION))
3908 wm_protocols_atom
= gdk_atom_intern("WM_PROTOCOLS", FALSE
);
3909 save_yourself_atom
= gdk_atom_intern("WM_SAVE_YOURSELF", FALSE
);
3912 if (gtk_socket_id
!= 0)
3913 /* make sure keyboard input can go to the drawarea */
3914 GTK_WIDGET_SET_FLAGS(gui
.drawarea
, GTK_CAN_FOCUS
);
3917 * Set clipboard specific atoms
3919 vim_atom
= gdk_atom_intern(VIM_ATOM_NAME
, FALSE
);
3921 vimenc_atom
= gdk_atom_intern(VIMENC_ATOM_NAME
, FALSE
);
3923 clip_star
.gtk_sel_atom
= GDK_SELECTION_PRIMARY
;
3924 clip_plus
.gtk_sel_atom
= gdk_atom_intern("CLIPBOARD", FALSE
);
3927 * Start out by adding the configured border width into the border offset.
3929 gui
.border_offset
= gui
.border_width
;
3931 gtk_signal_connect(GTK_OBJECT(gui
.mainwin
), "visibility_notify_event",
3932 GTK_SIGNAL_FUNC(visibility_event
), NULL
);
3933 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "expose_event",
3934 GTK_SIGNAL_FUNC(expose_event
), NULL
);
3937 * Only install these enter/leave callbacks when 'p' in 'guioptions'.
3938 * Only needed for some window managers.
3940 if (vim_strchr(p_go
, GO_POINTER
) != NULL
)
3942 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "leave_notify_event",
3943 GTK_SIGNAL_FUNC(leave_notify_event
), NULL
);
3944 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "enter_notify_event",
3945 GTK_SIGNAL_FUNC(enter_notify_event
), NULL
);
3948 /* Real windows can get focus ... GtkPlug, being a mere container can't,
3949 * only its widgets. Arguably, this could be common code and we not use
3950 * the window focus at all, but let's be safe.
3952 if (gtk_socket_id
== 0)
3954 gtk_signal_connect(GTK_OBJECT(gui
.mainwin
), "focus_out_event",
3955 GTK_SIGNAL_FUNC(focus_out_event
), NULL
);
3956 gtk_signal_connect(GTK_OBJECT(gui
.mainwin
), "focus_in_event",
3957 GTK_SIGNAL_FUNC(focus_in_event
), NULL
);
3961 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "focus_out_event",
3962 GTK_SIGNAL_FUNC(focus_out_event
), NULL
);
3963 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "focus_in_event",
3964 GTK_SIGNAL_FUNC(focus_in_event
), NULL
);
3965 #ifdef FEAT_GUI_TABLINE
3966 gtk_signal_connect(GTK_OBJECT(gui
.tabline
), "focus_out_event",
3967 GTK_SIGNAL_FUNC(focus_out_event
), NULL
);
3968 gtk_signal_connect(GTK_OBJECT(gui
.tabline
), "focus_in_event",
3969 GTK_SIGNAL_FUNC(focus_in_event
), NULL
);
3970 #endif /* FEAT_GUI_TABLINE */
3973 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "motion_notify_event",
3974 GTK_SIGNAL_FUNC(motion_notify_event
), NULL
);
3975 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "button_press_event",
3976 GTK_SIGNAL_FUNC(button_press_event
), NULL
);
3977 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "button_release_event",
3978 GTK_SIGNAL_FUNC(button_release_event
), NULL
);
3980 g_signal_connect(G_OBJECT(gui
.drawarea
), "scroll_event",
3981 G_CALLBACK(&scroll_event
), NULL
);
3985 * Add selection handler functions.
3987 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "selection_clear_event",
3988 GTK_SIGNAL_FUNC(selection_clear_event
), NULL
);
3989 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "selection_received",
3990 GTK_SIGNAL_FUNC(selection_received_cb
), NULL
);
3992 gui_gtk_set_selection_targets();
3994 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "selection_get",
3995 GTK_SIGNAL_FUNC(selection_get_cb
), NULL
);
3997 /* Pretend we don't have input focus, we will get an event if we do. */
3998 gui
.in_focus
= FALSE
;
4003 #if (defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION)) || defined(PROTO)
4005 * This is called from gui_start() after a fork() has been done.
4006 * We have to tell the session manager our new PID.
4009 gui_mch_forked(void)
4013 GnomeClient
*client
;
4015 client
= gnome_master_client();
4018 gnome_client_set_process_id(client
, getpid());
4021 #endif /* FEAT_GUI_GNOME && FEAT_SESSION */
4024 * Called when the foreground or background color has been changed.
4025 * This used to change the graphics contexts directly but we are
4026 * currently manipulating them where desired.
4029 gui_mch_new_colors(void)
4031 if (gui
.drawarea
!= NULL
&& gui
.drawarea
->window
!= NULL
)
4033 GdkColor color
= { 0, 0, 0, 0 };
4035 color
.pixel
= gui
.back_pixel
;
4036 gdk_window_set_background(gui
.drawarea
->window
, &color
);
4041 * This signal informs us about the need to rearrange our sub-widgets.
4044 form_configure_event(GtkWidget
*widget UNUSED
,
4045 GdkEventConfigure
*event
,
4046 gpointer data UNUSED
)
4048 int usable_height
= event
->height
;
4050 /* When in a GtkPlug, we can't guarantee valid heights (as a round
4051 * no. of char-heights), so we have to manually sanitise them.
4052 * Widths seem to sort themselves out, don't ask me why.
4054 if (gtk_socket_id
!= 0)
4055 usable_height
-= (gui
.char_height
- (gui
.char_height
/2)); /* sic. */
4057 gtk_form_freeze(GTK_FORM(gui
.formwin
));
4058 gui_resize_shell(event
->width
, usable_height
);
4059 gtk_form_thaw(GTK_FORM(gui
.formwin
));
4065 * Function called when window already closed.
4066 * We can't do much more here than to trying to preserve what had been done,
4067 * since the window is already inevitably going away.
4070 mainwin_destroy_cb(GtkObject
*object UNUSED
, gpointer data UNUSED
)
4072 /* Don't write messages to the GUI anymore */
4073 full_screen
= FALSE
;
4076 gui
.drawarea
= NULL
;
4078 if (!exiting
) /* only do anything if the destroy was unexpected */
4081 (char_u
*)_("Vim: Main window unexpectedly destroyed\n"),
4089 * Bit of a hack to ensure we start GtkPlug windows with the correct window
4090 * hints (and thus the required size from -geom), but that after that we
4091 * put the hints back to normal (the actual minimum size) so we may
4092 * subsequently be resized smaller. GtkSocket (the parent end) uses the
4093 * plug's window 'min hints to set *it's* minimum size, but that's also the
4094 * only way we have of making ourselves bigger (by set lines/columns).
4095 * Thus set hints at start-up to ensure correct init. size, then a
4096 * second after the final attempt to reset the real minimum hinst (done by
4097 * scrollbar init.), actually do the standard hinst and stop the timer.
4098 * We'll not let the default hints be set while this timer's active.
4101 check_startup_plug_hints(gpointer data UNUSED
)
4103 if (init_window_hints_state
== 1)
4105 /* Safe to use normal hints now */
4106 init_window_hints_state
= 0;
4107 update_window_manager_hints(0, 0);
4108 return FALSE
; /* stop timer */
4111 /* Keep on trying */
4112 init_window_hints_state
= 1;
4117 * Open the GUI window which was created by a call to gui_mch_init().
4122 guicolor_T fg_pixel
= INVALCOLOR
;
4123 guicolor_T bg_pixel
= INVALCOLOR
;
4129 * Allow setting a window role on the command line, or invent one
4130 * if none was specified. This is mainly useful for GNOME session
4131 * support; allowing the WM to restore window placement.
4133 if (role_argument
!= NULL
)
4135 gtk_window_set_role(GTK_WINDOW(gui
.mainwin
), role_argument
);
4141 /* Invent a unique-enough ID string for the role */
4142 role
= g_strdup_printf("vim-%u-%u-%u",
4143 (unsigned)mch_get_pid(),
4144 (unsigned)g_random_int(),
4145 (unsigned)time(NULL
));
4147 gtk_window_set_role(GTK_WINDOW(gui
.mainwin
), role
);
4152 if (gui_win_x
!= -1 && gui_win_y
!= -1)
4154 gtk_window_move(GTK_WINDOW(gui
.mainwin
), gui_win_x
, gui_win_y
);
4156 gtk_widget_set_uposition(gui
.mainwin
, gui_win_x
, gui_win_y
);
4159 /* Determine user specified geometry, if present. */
4160 if (gui
.geom
!= NULL
)
4167 mask
= XParseGeometry((char *)gui
.geom
, &x
, &y
, &w
, &h
);
4169 if (mask
& WidthValue
)
4171 if (mask
& HeightValue
)
4173 if (p_window
> (long)h
- 1 || !option_was_set((char_u
*)"window"))
4178 pixel_width
= (guint
)(gui_get_base_width() + Columns
* gui
.char_width
);
4179 pixel_height
= (guint
)(gui_get_base_height() + Rows
* gui
.char_height
);
4182 pixel_width
+= get_menu_tool_width();
4183 pixel_height
+= get_menu_tool_height();
4186 if (mask
& (XValue
| YValue
))
4189 gui_mch_get_screen_dimensions(&ww
, &hh
);
4190 hh
+= p_ghr
+ get_menu_tool_height();
4191 ww
+= get_menu_tool_width();
4192 if (mask
& XNegative
)
4193 x
+= ww
- pixel_width
;
4194 if (mask
& YNegative
)
4195 y
+= hh
- pixel_height
;
4197 gtk_window_move(GTK_WINDOW(gui
.mainwin
), x
, y
);
4199 gtk_widget_set_uposition(gui
.mainwin
, x
, y
);
4205 /* From now until everyone's stopped trying to set the window hints
4206 * to their correct minimum values, stop them being set as we need
4207 * them to remain at our required size for the parent GtkSocket to
4208 * give us the right initial size.
4210 if (gtk_socket_id
!= 0 && (mask
& WidthValue
|| mask
& HeightValue
))
4212 update_window_manager_hints(pixel_width
, pixel_height
);
4213 init_window_hints_state
= 1;
4214 g_timeout_add(1000, check_startup_plug_hints
, NULL
);
4218 pixel_width
= (guint
)(gui_get_base_width() + Columns
* gui
.char_width
);
4219 pixel_height
= (guint
)(gui_get_base_height() + Rows
* gui
.char_height
);
4221 /* For GTK2 changing the size of the form widget doesn't cause window
4223 if (gtk_socket_id
== 0)
4224 gtk_window_resize(GTK_WINDOW(gui
.mainwin
), pixel_width
, pixel_height
);
4226 gtk_form_set_size(GTK_FORM(gui
.formwin
), pixel_width
, pixel_height
);
4228 update_window_manager_hints(0, 0);
4230 if (foreground_argument
!= NULL
)
4231 fg_pixel
= gui_get_color((char_u
*)foreground_argument
);
4232 if (fg_pixel
== INVALCOLOR
)
4233 fg_pixel
= gui_get_color((char_u
*)"Black");
4235 if (background_argument
!= NULL
)
4236 bg_pixel
= gui_get_color((char_u
*)background_argument
);
4237 if (bg_pixel
== INVALCOLOR
)
4238 bg_pixel
= gui_get_color((char_u
*)"White");
4240 if (found_reverse_arg
)
4242 gui
.def_norm_pixel
= bg_pixel
;
4243 gui
.def_back_pixel
= fg_pixel
;
4247 gui
.def_norm_pixel
= fg_pixel
;
4248 gui
.def_back_pixel
= bg_pixel
;
4251 /* Get the colors from the "Normal" and "Menu" group (set in syntax.c or
4252 * in a vimrc file) */
4253 set_normal_colors();
4255 /* Check that none of the colors are the same as the background color */
4258 /* Get the colors for the highlight groups (gui_check_colors() might have
4260 highlight_gui_started(); /* re-init colors and fonts */
4262 gtk_signal_connect(GTK_OBJECT(gui
.mainwin
), "destroy",
4263 GTK_SIGNAL_FUNC(mainwin_destroy_cb
), NULL
);
4265 #ifdef FEAT_HANGULIN
4266 hangul_keyboard_set();
4270 * Notify the fixed area about the need to resize the contents of the
4271 * gui.formwin, which we use for random positioning of the included
4274 * We connect this signal deferred finally after anything is in place,
4275 * since this is intended to handle resizements coming from the window
4276 * manager upon us and should not interfere with what VIM is requesting
4279 gtk_signal_connect(GTK_OBJECT(gui
.formwin
), "configure_event",
4280 GTK_SIGNAL_FUNC(form_configure_event
), NULL
);
4283 /* Set up for receiving DND items. */
4284 gui_gtk_set_dnd_targets();
4286 gtk_signal_connect(GTK_OBJECT(gui
.drawarea
), "drag_data_received",
4287 GTK_SIGNAL_FUNC(drag_data_received_cb
), NULL
);
4291 /* With GTK+ 2, we need to iconify the window before calling show()
4292 * to avoid mapping the window for a short time. This is just as one
4293 * would expect it to work, but it's different in GTK+ 1. The funny
4294 * thing is that iconifying after show() _does_ work with GTK+ 1.
4295 * (BTW doing this in the "realize" handler makes no difference.) */
4296 if (found_iconic_arg
&& gtk_socket_id
== 0)
4301 #if defined(FEAT_GUI_GNOME) && defined(HAVE_GTK2) && defined(FEAT_MENU)
4302 unsigned long menu_handler
= 0;
4303 # ifdef FEAT_TOOLBAR
4304 unsigned long tool_handler
= 0;
4307 * Urgh hackish :/ For some reason BonoboDockLayout always forces a
4308 * show when restoring the saved layout configuration. We can't just
4309 * hide the widgets again after gtk_widget_show(gui.mainwin) since it's
4310 * a toplevel window and thus will be realized immediately. Instead,
4311 * connect signal handlers to hide the widgets just after they've been
4312 * marked visible, but before the main window is realized.
4314 if (using_gnome
&& vim_strchr(p_go
, GO_MENUS
) == NULL
)
4315 menu_handler
= g_signal_connect_after(gui
.menubar_h
, "show",
4316 G_CALLBACK(>k_widget_hide
),
4318 # ifdef FEAT_TOOLBAR
4319 if (using_gnome
&& vim_strchr(p_go
, GO_TOOLBAR
) == NULL
4320 && (toolbar_flags
& (TOOLBAR_TEXT
| TOOLBAR_ICONS
)))
4321 tool_handler
= g_signal_connect_after(gui
.toolbar_h
, "show",
4322 G_CALLBACK(>k_widget_hide
),
4326 gtk_widget_show(gui
.mainwin
);
4328 #if defined(FEAT_GUI_GNOME) && defined(HAVE_GTK2) && defined(FEAT_MENU)
4329 if (menu_handler
!= 0)
4330 g_signal_handler_disconnect(gui
.menubar_h
, menu_handler
);
4331 # ifdef FEAT_TOOLBAR
4332 if (tool_handler
!= 0)
4333 g_signal_handler_disconnect(gui
.toolbar_h
, tool_handler
);
4339 /* With GTK+ 1, we need to iconify the window after calling show().
4340 * See the comment above for details. */
4341 if (found_iconic_arg
&& gtk_socket_id
== 0)
4350 gui_mch_exit(int rc UNUSED
)
4352 if (gui
.mainwin
!= NULL
)
4353 gtk_widget_destroy(gui
.mainwin
);
4355 if (gtk_main_level() > 0)
4360 * Get the position of the top left corner of the window.
4363 gui_mch_get_winpos(int *x
, int *y
)
4366 gtk_window_get_position(GTK_WINDOW(gui
.mainwin
), x
, y
);
4368 /* For some people this must be gdk_window_get_origin() for a correct
4369 * result. Where is the documentation! */
4370 gdk_window_get_root_origin(gui
.mainwin
->window
, x
, y
);
4376 * Set the position of the top left corner of the window to the given
4380 gui_mch_set_winpos(int x
, int y
)
4383 gtk_window_move(GTK_WINDOW(gui
.mainwin
), x
, y
);
4385 gdk_window_move(gui
.mainwin
->window
, x
, y
);
4391 static int resize_idle_installed
= FALSE
;
4393 * Idle handler to force resize. Used by gui_mch_set_shellsize() to ensure
4394 * the shell size doesn't exceed the window size, i.e. if the window manager
4395 * ignored our size request. Usually this happens if the window is maximized.
4397 * FIXME: It'd be nice if we could find a little more orthodox solution.
4398 * See also the remark below in gui_mch_set_shellsize().
4400 * DISABLED: When doing ":set lines+=1" this function would first invoke
4401 * gui_resize_shell() with the old size, then the normal callback would
4402 * report the new size through form_configure_event(). That caused the window
4403 * layout to be messed up.
4406 force_shell_resize_idle(gpointer data
)
4408 if (gui
.mainwin
!= NULL
4409 && GTK_WIDGET_REALIZED(gui
.mainwin
)
4410 && GTK_WIDGET_VISIBLE(gui
.mainwin
))
4415 gtk_window_get_size(GTK_WINDOW(gui
.mainwin
), &width
, &height
);
4417 width
-= get_menu_tool_width();
4418 height
-= get_menu_tool_height();
4420 gui_resize_shell(width
, height
);
4423 resize_idle_installed
= FALSE
;
4424 return FALSE
; /* don't call me again */
4427 #endif /* HAVE_GTK2 */
4429 #if defined(HAVE_GTK2) || defined(PROTO)
4431 * Return TRUE if the main window is maximized.
4436 return (gui
.mainwin
!= NULL
&& gui
.mainwin
->window
!= NULL
4437 && (gdk_window_get_state(gui
.mainwin
->window
)
4438 & GDK_WINDOW_STATE_MAXIMIZED
));
4442 * Unmaximize the main window
4445 gui_mch_unmaximize()
4447 if (gui
.mainwin
!= NULL
)
4448 gtk_window_unmaximize(GTK_WINDOW(gui
.mainwin
));
4453 * Set the windows size.
4456 gui_mch_set_shellsize(int width
, int height
,
4457 int min_width UNUSED
, int min_height UNUSED
,
4458 int base_width UNUSED
, int base_height UNUSED
,
4459 int direction UNUSED
)
4462 /* Hack: When the form already is at the desired size, the window might
4463 * have been resized with the mouse. Force a resize by setting a
4464 * different size first. */
4465 if (GTK_FORM(gui
.formwin
)->width
== width
4466 && GTK_FORM(gui
.formwin
)->height
== height
)
4468 gtk_form_set_size(GTK_FORM(gui
.formwin
), width
+ 1, height
+ 1);
4471 gtk_form_set_size(GTK_FORM(gui
.formwin
), width
, height
);
4474 /* give GTK+ a chance to put all widget's into place */
4478 /* this will cause the proper resizement to happen too */
4479 update_window_manager_hints(0, 0);
4482 /* this will cause the proper resizement to happen too */
4483 if (gtk_socket_id
== 0)
4484 update_window_manager_hints(0, 0);
4486 /* With GTK+ 2, changing the size of the form widget doesn't resize
4487 * the window. So let's do it the other way around and resize the
4488 * main window instead. */
4489 width
+= get_menu_tool_width();
4490 height
+= get_menu_tool_height();
4492 if (gtk_socket_id
== 0)
4493 gtk_window_resize(GTK_WINDOW(gui
.mainwin
), width
, height
);
4495 update_window_manager_hints(width
, height
);
4498 if (!resize_idle_installed
)
4500 g_idle_add_full(GDK_PRIORITY_EVENTS
+ 10,
4501 &force_shell_resize_idle
, NULL
, NULL
);
4502 resize_idle_installed
= TRUE
;
4506 * Wait until all events are processed to prevent a crash because the
4507 * real size of the drawing area doesn't reflect Vim's internal ideas.
4509 * This is a bit of a hack, since Vim is a terminal application with a GUI
4510 * on top, while the GUI expects to be the boss.
4518 * The screen size is used to make sure the initial window doesn't get bigger
4519 * than the screen. This subtracts some room for menubar, toolbar and window
4523 gui_mch_get_screen_dimensions(int *screen_w
, int *screen_h
)
4525 #ifdef HAVE_GTK_MULTIHEAD
4528 if (gui
.mainwin
!= NULL
&& gtk_widget_has_screen(gui
.mainwin
))
4529 screen
= gtk_widget_get_screen(gui
.mainwin
);
4531 screen
= gdk_screen_get_default();
4533 *screen_w
= gdk_screen_get_width(screen
);
4534 *screen_h
= gdk_screen_get_height(screen
) - p_ghr
;
4536 *screen_w
= gdk_screen_width();
4537 /* Subtract 'guiheadroom' from the height to allow some room for the
4538 * window manager (task list and window title bar). */
4539 *screen_h
= gdk_screen_height() - p_ghr
;
4543 * FIXME: dirty trick: Because the gui_get_base_height() doesn't include
4544 * the toolbar and menubar for GTK, we subtract them from the screen
4545 * hight, so that the window size can be made to fit on the screen.
4546 * This should be completely changed later.
4548 *screen_w
-= get_menu_tool_width();
4549 *screen_h
-= get_menu_tool_height();
4552 #if defined(FEAT_TITLE) || defined(PROTO)
4554 gui_mch_settitle(char_u
*title
, char_u
*icon UNUSED
)
4557 if (title
!= NULL
&& output_conv
.vc_type
!= CONV_NONE
)
4558 title
= string_convert(&output_conv
, title
, NULL
);
4561 gtk_window_set_title(GTK_WINDOW(gui
.mainwin
), (const char *)title
);
4564 if (output_conv
.vc_type
!= CONV_NONE
)
4568 #endif /* FEAT_TITLE */
4570 #if defined(FEAT_MENU) || defined(PROTO)
4572 gui_mch_enable_menu(int showit
)
4576 # ifdef FEAT_GUI_GNOME
4578 widget
= gui
.menubar_h
;
4581 widget
= gui
.menubar
;
4583 /* Do not disable the menu while starting up, otherwise F10 doesn't work. */
4584 if (!showit
!= !GTK_WIDGET_VISIBLE(widget
) && !gui
.starting
)
4587 gtk_widget_show(widget
);
4589 gtk_widget_hide(widget
);
4591 update_window_manager_hints(0, 0);
4594 #endif /* FEAT_MENU */
4596 #if defined(FEAT_TOOLBAR) || defined(PROTO)
4598 gui_mch_show_toolbar(int showit
)
4602 if (gui
.toolbar
== NULL
)
4605 # ifdef FEAT_GUI_GNOME
4607 widget
= gui
.toolbar_h
;
4610 widget
= gui
.toolbar
;
4613 set_toolbar_style(GTK_TOOLBAR(gui
.toolbar
));
4615 if (!showit
!= !GTK_WIDGET_VISIBLE(widget
))
4618 gtk_widget_show(widget
);
4620 gtk_widget_hide(widget
);
4622 update_window_manager_hints(0, 0);
4625 #endif /* FEAT_TOOLBAR */
4629 * Get a font structure for highlighting.
4630 * "cbdata" is a pointer to the global gui structure.
4633 font_sel_ok(GtkWidget
*wgt
, gpointer cbdata
)
4635 gui_T
*vw
= (gui_T
*)cbdata
;
4636 GtkFontSelectionDialog
*fs
= (GtkFontSelectionDialog
*)vw
->fontdlg
;
4639 g_free(vw
->fontname
);
4641 vw
->fontname
= (char_u
*)gtk_font_selection_dialog_get_font_name(fs
);
4642 gtk_widget_hide(vw
->fontdlg
);
4643 if (gtk_main_level() > 0)
4648 font_sel_cancel(GtkWidget
*wgt
, gpointer cbdata
)
4650 gui_T
*vw
= (gui_T
*)cbdata
;
4652 gtk_widget_hide(vw
->fontdlg
);
4653 if (gtk_main_level() > 0)
4658 font_sel_destroy(GtkWidget
*wgt
, gpointer cbdata
)
4660 gui_T
*vw
= (gui_T
*)cbdata
;
4663 if (gtk_main_level() > 0)
4666 #endif /* !HAVE_GTK2 */
4670 * Check if a given font is a CJK font. This is done in a very crude manner. It
4671 * just see if U+04E00 for zh and ja and U+AC00 for ko are covered in a given
4672 * font. Consequently, this function cannot be used as a general purpose check
4673 * for CJK-ness for which fontconfig APIs should be used. This is only used by
4674 * gui_mch_init_font() to deal with 'CJK fixed width fonts'.
4677 is_cjk_font(PangoFontDescription
*font_desc
)
4679 static const char * const cjk_langs
[] =
4680 {"zh_CN", "zh_TW", "zh_HK", "ja", "ko"};
4686 font
= pango_context_load_font(gui
.text_context
, font_desc
);
4691 for (i
= 0; !is_cjk
&& i
< G_N_ELEMENTS(cjk_langs
); ++i
)
4693 PangoCoverage
*coverage
;
4696 coverage
= pango_font_get_coverage(
4697 font
, pango_language_from_string(cjk_langs
[i
]));
4699 if (coverage
!= NULL
)
4701 uc
= (cjk_langs
[i
][0] == 'k') ? 0xAC00 : 0x4E00;
4702 is_cjk
= (pango_coverage_get(coverage
, uc
) == PANGO_COVERAGE_EXACT
);
4703 pango_coverage_unref(coverage
);
4707 g_object_unref(font
);
4711 #endif /* HAVE_GTK2 */
4714 * Adjust gui.char_height (after 'linespace' was changed).
4717 gui_mch_adjust_charheight(void)
4720 PangoFontMetrics
*metrics
;
4724 metrics
= pango_context_get_metrics(gui
.text_context
, gui
.norm_font
,
4725 pango_context_get_language(gui
.text_context
));
4726 ascent
= pango_font_metrics_get_ascent(metrics
);
4727 descent
= pango_font_metrics_get_descent(metrics
);
4729 pango_font_metrics_unref(metrics
);
4731 gui
.char_height
= (ascent
+ descent
+ PANGO_SCALE
- 1) / PANGO_SCALE
4733 /* LINTED: avoid warning: bitwise operation on signed value */
4734 gui
.char_ascent
= PANGO_PIXELS(ascent
+ p_linespace
* PANGO_SCALE
/ 2);
4736 #else /* !HAVE_GTK2 */
4738 gui
.char_height
= gui
.current_font
->ascent
+ gui
.current_font
->descent
4740 gui
.char_ascent
= gui
.current_font
->ascent
+ p_linespace
/ 2;
4742 #endif /* !HAVE_GTK2 */
4744 /* A not-positive value of char_height may crash Vim. Only happens
4745 * if 'linespace' is negative (which does make sense sometimes). */
4746 gui
.char_ascent
= MAX(gui
.char_ascent
, 0);
4747 gui
.char_height
= MAX(gui
.char_height
, gui
.char_ascent
+ 1);
4752 #if defined(FEAT_XFONTSET) || defined(PROTO)
4754 * Try to load the requested fontset.
4757 gui_mch_get_fontset(char_u
*name
, int report_error
, int fixed_width
)
4761 if (!gui
.in_use
|| name
== NULL
)
4764 font
= gdk_fontset_load((gchar
*)name
);
4769 EMSG2(_(e_fontset
), name
);
4772 /* TODO: check if the font is fixed width. */
4774 /* reference this font as being in use */
4777 return (GuiFontset
)font
;
4779 #endif /* FEAT_XFONTSET */
4783 * Put up a font dialog and return the selected font name in allocated memory.
4784 * "oldval" is the previous value.
4785 * Return NULL when cancelled.
4788 gui_mch_font_dialog(char_u
*oldval
)
4790 char_u
*fontname
= NULL
;
4794 GtkFontSelectionDialog
*fsd
= NULL
;
4796 gui
.fontdlg
= gtk_font_selection_dialog_new(_("Font Selection"));
4797 fsd
= GTK_FONT_SELECTION_DIALOG(gui
.fontdlg
);
4798 gtk_window_set_modal(GTK_WINDOW(gui
.fontdlg
), TRUE
);
4799 gtk_window_set_transient_for(GTK_WINDOW(gui
.fontdlg
),
4800 GTK_WINDOW(gui
.mainwin
));
4801 gtk_signal_connect(GTK_OBJECT(gui
.fontdlg
), "destroy",
4802 GTK_SIGNAL_FUNC(font_sel_destroy
), &gui
);
4803 gtk_signal_connect(GTK_OBJECT(fsd
->ok_button
), "clicked",
4804 GTK_SIGNAL_FUNC(font_sel_ok
), &gui
);
4805 gtk_signal_connect(GTK_OBJECT(fsd
->cancel_button
), "clicked",
4806 GTK_SIGNAL_FUNC(font_sel_cancel
), &gui
);
4809 if (oldval
!= NULL
&& *oldval
!= NUL
)
4810 gtk_font_selection_dialog_set_font_name(
4811 GTK_FONT_SELECTION_DIALOG(gui
.fontdlg
), (char *)oldval
);
4813 gtk_font_selection_dialog_set_font_name(
4814 GTK_FONT_SELECTION_DIALOG(gui
.fontdlg
), DEFAULT_FONT
);
4818 g_free(gui
.fontname
);
4819 gui
.fontname
= NULL
;
4821 gtk_window_position(GTK_WINDOW(gui
.fontdlg
), GTK_WIN_POS_MOUSE
);
4822 gtk_widget_show(gui
.fontdlg
);
4824 static gchar
*spacings
[] = {"c", "m", NULL
};
4826 /* In GTK 1.2.3 this must be after the gtk_widget_show() call,
4827 * otherwise everything is blocked for ten seconds. */
4828 gtk_font_selection_dialog_set_filter(
4829 GTK_FONT_SELECTION_DIALOG(gui
.fontdlg
),
4830 GTK_FONT_FILTER_BASE
,
4831 GTK_FONT_ALL
, NULL
, NULL
,
4832 NULL
, NULL
, spacings
, NULL
);
4835 /* Wait for the font dialog to be closed. */
4836 while (gui
.fontdlg
&& GTK_WIDGET_DRAWABLE(gui
.fontdlg
))
4837 gtk_main_iteration_do(TRUE
);
4839 if (gui
.fontname
!= NULL
)
4841 /* Apparently some font names include a comma, need to escape that,
4842 * because in 'guifont' it separates names. */
4843 fontname
= vim_strsave_escaped(gui
.fontname
, (char_u
*)",");
4844 g_free(gui
.fontname
);
4845 gui
.fontname
= NULL
;
4849 #endif /* !HAVE_GTK2 */
4853 * Put up a font dialog and return the selected font name in allocated memory.
4854 * "oldval" is the previous value. Return NULL when cancelled.
4855 * This should probably go into gui_gtk.c. Hmm.
4857 * The GTK2 font selection dialog has no filtering API. So we could either
4858 * a) implement our own (possibly copying the code from somewhere else) or
4859 * b) just live with it.
4862 gui_mch_font_dialog(char_u
*oldval
)
4866 char_u
*fontname
= NULL
;
4869 dialog
= gtk_font_selection_dialog_new(NULL
);
4871 gtk_window_set_transient_for(GTK_WINDOW(dialog
), GTK_WINDOW(gui
.mainwin
));
4872 gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog
), TRUE
);
4874 if (oldval
!= NULL
&& oldval
[0] != NUL
)
4876 if (output_conv
.vc_type
!= CONV_NONE
)
4877 oldname
= string_convert(&output_conv
, oldval
, NULL
);
4881 /* Annoying bug in GTK (or Pango): if the font name does not include a
4882 * size, zero is used. Use default point size ten. */
4883 if (!vim_isdigit(oldname
[STRLEN(oldname
) - 1]))
4885 char_u
*p
= vim_strnsave(oldname
, STRLEN(oldname
) + 3);
4889 STRCPY(p
+ STRLEN(p
), " 10");
4890 if (oldname
!= oldval
)
4896 gtk_font_selection_dialog_set_font_name(
4897 GTK_FONT_SELECTION_DIALOG(dialog
), (const char *)oldname
);
4899 if (oldname
!= oldval
)
4903 gtk_font_selection_dialog_set_font_name(
4904 GTK_FONT_SELECTION_DIALOG(dialog
), DEFAULT_FONT
);
4906 response
= gtk_dialog_run(GTK_DIALOG(dialog
));
4908 if (response
== GTK_RESPONSE_OK
)
4912 name
= gtk_font_selection_dialog_get_font_name(
4913 GTK_FONT_SELECTION_DIALOG(dialog
));
4918 /* Apparently some font names include a comma, need to escape
4919 * that, because in 'guifont' it separates names. */
4920 p
= vim_strsave_escaped((char_u
*)name
, (char_u
*)",");
4922 if (p
!= NULL
&& input_conv
.vc_type
!= CONV_NONE
)
4924 fontname
= string_convert(&input_conv
, p
, NULL
);
4932 if (response
!= GTK_RESPONSE_NONE
)
4933 gtk_widget_destroy(dialog
);
4939 * Some monospace fonts don't support a bold weight, and fall back
4940 * silently to the regular weight. But this is no good since our text
4941 * drawing function can emulate bold by overstriking. So let's try
4942 * to detect whether bold weight is actually available and emulate it
4945 * Note that we don't need to check for italic style since Xft can
4946 * emulate italic on its own, provided you have a proper fontconfig
4947 * setup. We wouldn't be able to emulate it in Vim anyway.
4950 get_styled_font_variants(void)
4952 PangoFontDescription
*bold_font_desc
;
4953 PangoFont
*plain_font
;
4954 PangoFont
*bold_font
;
4956 gui
.font_can_bold
= FALSE
;
4958 plain_font
= pango_context_load_font(gui
.text_context
, gui
.norm_font
);
4960 if (plain_font
== NULL
)
4963 bold_font_desc
= pango_font_description_copy_static(gui
.norm_font
);
4964 pango_font_description_set_weight(bold_font_desc
, PANGO_WEIGHT_BOLD
);
4966 bold_font
= pango_context_load_font(gui
.text_context
, bold_font_desc
);
4968 * The comparison relies on the unique handle nature of a PangoFont*,
4969 * i.e. it's assumed that a different PangoFont* won't refer to the
4970 * same font. Seems to work, and failing here isn't critical anyway.
4972 if (bold_font
!= NULL
)
4974 gui
.font_can_bold
= (bold_font
!= plain_font
);
4975 g_object_unref(bold_font
);
4978 pango_font_description_free(bold_font_desc
);
4979 g_object_unref(plain_font
);
4982 #else /* !HAVE_GTK2 */
4985 * There is only one excuse I can give for the following attempt to manage font
4988 * I HATE THE BRAIN DEAD WAY X11 IS HANDLING FONTS (--mdcki)
4989 * (Me too. --danielk)
4992 get_styled_font_variants(char_u
* font_name
)
4998 GuiFont
*styled_font
[3];
5000 styled_font
[0] = &gui
.bold_font
;
5001 styled_font
[1] = &gui
.ital_font
;
5002 styled_font
[2] = &gui
.boldital_font
;
5004 /* First free whatever was previously there. */
5005 for (i
= 0; i
< 3; ++i
)
5006 if (*styled_font
[i
])
5008 gdk_font_unref(*styled_font
[i
]);
5009 *styled_font
[i
] = NULL
;
5012 if ((sdup
= g_strdup((const char *)font_name
)) == NULL
)
5015 /* split up the whole */
5017 for (tmp
= sdup
; *tmp
!= '\0'; ++tmp
)
5033 GdkFont
*font
= NULL
;
5034 const char *bold_chunk
[3] = { "bold", NULL
, "bold" };
5035 const char *italic_chunk
[3] = { NULL
, "o", "o" };
5037 /* font name was complete */
5038 len
= strlen((const char *)font_name
) + 32;
5040 for (i
= 0; i
< 3; ++i
)
5045 styled_name
= (char *)alloc(len
);
5046 if (styled_name
== NULL
)
5052 *styled_name
= '\0';
5054 for (j
= 0; j
< 14; ++j
)
5056 strcat(styled_name
, "-");
5057 if (j
== 2 && bold_chunk
[i
] != NULL
)
5058 strcat(styled_name
, bold_chunk
[i
]);
5059 else if (j
== 3 && italic_chunk
[i
] != NULL
)
5060 strcat(styled_name
, italic_chunk
[i
]);
5062 strcat(styled_name
, chunk
[j
]);
5065 font
= gui_mch_get_font((char_u
*)styled_name
, FALSE
);
5067 *styled_font
[i
] = font
;
5069 vim_free(styled_name
);
5075 #endif /* !HAVE_GTK2 */
5078 static PangoEngineShape
*default_shape_engine
= NULL
;
5081 * Create a map from ASCII characters in the range [32,126] to glyphs
5082 * of the current font. This is used by gui_gtk2_draw_string() to skip
5083 * the itemize and shaping process for the most common case.
5086 ascii_glyph_table_init(void)
5088 char_u ascii_chars
[128];
5089 PangoAttrList
*attr_list
;
5093 if (gui
.ascii_glyphs
!= NULL
)
5094 pango_glyph_string_free(gui
.ascii_glyphs
);
5095 if (gui
.ascii_font
!= NULL
)
5096 g_object_unref(gui
.ascii_font
);
5098 gui
.ascii_glyphs
= NULL
;
5099 gui
.ascii_font
= NULL
;
5101 /* For safety, fill in question marks for the control characters. */
5102 for (i
= 0; i
< 32; ++i
)
5103 ascii_chars
[i
] = '?';
5104 for (; i
< 127; ++i
)
5106 ascii_chars
[i
] = '?';
5108 attr_list
= pango_attr_list_new();
5109 item_list
= pango_itemize(gui
.text_context
, (const char *)ascii_chars
,
5110 0, sizeof(ascii_chars
), attr_list
, NULL
);
5112 if (item_list
!= NULL
&& item_list
->next
== NULL
) /* play safe */
5117 item
= (PangoItem
*)item_list
->data
;
5118 width
= gui
.char_width
* PANGO_SCALE
;
5120 /* Remember the shape engine used for ASCII. */
5121 default_shape_engine
= item
->analysis
.shape_engine
;
5123 gui
.ascii_font
= item
->analysis
.font
;
5124 g_object_ref(gui
.ascii_font
);
5126 gui
.ascii_glyphs
= pango_glyph_string_new();
5128 pango_shape((const char *)ascii_chars
, sizeof(ascii_chars
),
5129 &item
->analysis
, gui
.ascii_glyphs
);
5131 g_return_if_fail(gui
.ascii_glyphs
->num_glyphs
== sizeof(ascii_chars
));
5133 for (i
= 0; i
< gui
.ascii_glyphs
->num_glyphs
; ++i
)
5135 PangoGlyphGeometry
*geom
;
5137 geom
= &gui
.ascii_glyphs
->glyphs
[i
].geometry
;
5138 geom
->x_offset
+= MAX(0, width
- geom
->width
) / 2;
5139 geom
->width
= width
;
5143 g_list_foreach(item_list
, (GFunc
)&pango_item_free
, NULL
);
5144 g_list_free(item_list
);
5145 pango_attr_list_unref(attr_list
);
5147 #endif /* HAVE_GTK2 */
5150 * Initialize Vim to use the font or fontset with the given name.
5151 * Return FAIL if the font could not be loaded, OK otherwise.
5154 gui_mch_init_font(char_u
*font_name
, int fontset UNUSED
)
5157 PangoFontDescription
*font_desc
;
5158 PangoLayout
*layout
;
5161 /* If font_name is NULL, this means to use the default, which should
5162 * be present on all proper Pango/fontconfig installations. */
5163 if (font_name
== NULL
)
5164 font_name
= (char_u
*)DEFAULT_FONT
;
5166 font_desc
= gui_mch_get_font(font_name
, FALSE
);
5168 if (font_desc
== NULL
)
5171 gui_mch_free_font(gui
.norm_font
);
5172 gui
.norm_font
= font_desc
;
5174 pango_context_set_font_description(gui
.text_context
, font_desc
);
5176 layout
= pango_layout_new(gui
.text_context
);
5177 pango_layout_set_text(layout
, "MW", 2);
5178 pango_layout_get_size(layout
, &width
, NULL
);
5180 * Set char_width to half the width obtained from pango_layout_get_size()
5181 * for CJK fixed_width/bi-width fonts. An unpatched version of Xft leads
5182 * Pango to use the same width for both non-CJK characters (e.g. Latin
5183 * letters and numbers) and CJK characters. This results in 's p a c e d
5184 * o u t' rendering when a CJK 'fixed width' font is used. To work around
5185 * that, divide the width returned by Pango by 2 if cjk_width is equal to
5186 * width for CJK fonts.
5188 * For related bugs, see:
5189 * http://bugzilla.gnome.org/show_bug.cgi?id=106618
5190 * http://bugzilla.gnome.org/show_bug.cgi?id=106624
5192 * With this, for all four of the following cases, Vim works fine:
5193 * guifont=CJK_fixed_width_font
5194 * guifont=Non_CJK_fixed_font
5195 * guifont=Non_CJK_fixed_font,CJK_Fixed_font
5196 * guifont=Non_CJK_fixed_font guifontwide=CJK_fixed_font
5198 if (is_cjk_font(gui
.norm_font
))
5202 /* Measure the text extent of U+4E00 and U+4E8C */
5203 pango_layout_set_text(layout
, "\344\270\200\344\272\214", -1);
5204 pango_layout_get_size(layout
, &cjk_width
, NULL
);
5206 if (width
== cjk_width
) /* Xft not patched */
5209 g_object_unref(layout
);
5211 gui
.char_width
= (width
/ 2 + PANGO_SCALE
- 1) / PANGO_SCALE
;
5213 /* A zero width may cause a crash. Happens for semi-invalid fontsets. */
5214 if (gui
.char_width
<= 0)
5217 gui_mch_adjust_charheight();
5219 /* Set the fontname, which will be used for information purposes */
5220 hl_set_font_name(font_name
);
5222 get_styled_font_variants();
5223 ascii_glyph_table_init();
5225 /* Avoid unnecessary overhead if 'guifontwide' is equal to 'guifont'. */
5226 if (gui
.wide_font
!= NULL
5227 && pango_font_description_equal(gui
.norm_font
, gui
.wide_font
))
5229 pango_font_description_free(gui
.wide_font
);
5230 gui
.wide_font
= NULL
;
5233 #else /* !HAVE_GTK2 */
5235 GdkFont
*font
= NULL
;
5237 # ifdef FEAT_XFONTSET
5238 /* Try loading a fontset. If this fails we try loading a normal font. */
5239 if (fontset
&& font_name
!= NULL
)
5240 font
= gui_mch_get_fontset(font_name
, TRUE
, TRUE
);
5245 /* If font_name is NULL, this means to use the default, which should
5246 * be present on all X11 servers. */
5247 if (font_name
== NULL
)
5248 font_name
= (char_u
*)DEFAULT_FONT
;
5249 font
= gui_mch_get_font(font_name
, FALSE
);
5255 gui_mch_free_font(gui
.norm_font
);
5256 # ifdef FEAT_XFONTSET
5257 gui_mch_free_fontset(gui
.fontset
);
5258 if (font
->type
== GDK_FONT_FONTSET
)
5260 gui
.norm_font
= NOFONT
;
5261 gui
.fontset
= (GuiFontset
)font
;
5262 /* Use two bytes, this works around the problem that the result would
5263 * be zero if no 8-bit font was found. */
5264 gui
.char_width
= gdk_string_width(font
, "xW") / 2;
5269 gui
.norm_font
= font
;
5270 # ifdef FEAT_XFONTSET
5271 gui
.fontset
= NOFONTSET
;
5273 gui
.char_width
= ((XFontStruct
*)
5274 GDK_FONT_XFONT(font
))->max_bounds
.width
;
5277 /* A zero width may cause a crash. Happens for semi-invalid fontsets. */
5278 if (gui
.char_width
<= 0)
5281 gui
.char_height
= font
->ascent
+ font
->descent
+ p_linespace
;
5282 gui
.char_ascent
= font
->ascent
+ p_linespace
/ 2;
5284 /* A not-positive value of char_height may crash Vim. Only happens
5285 * if 'linespace' is negative (which does make sense sometimes). */
5286 gui
.char_ascent
= MAX(gui
.char_ascent
, 0);
5287 gui
.char_height
= MAX(gui
.char_height
, gui
.char_ascent
+ 1);
5289 /* Set the fontname, which will be used for information purposes */
5290 hl_set_font_name(font_name
);
5292 if (font
->type
!= GDK_FONT_FONTSET
)
5293 get_styled_font_variants(font_name
);
5295 /* Synchronize the fonts used in user input dialogs, since otherwise
5296 * search/replace will be esp. annoying in case of international font
5299 gui_gtk_synch_fonts();
5302 /* Adjust input management behaviour to the capabilities of the new
5304 xim_decide_input_style();
5305 if (xim_get_status_area_height())
5307 /* Status area is required. Just create the empty container so that
5308 * mainwin will allocate the extra space for status area. */
5309 GtkWidget
*alignment
= gtk_alignment_new((gfloat
)0.5, (gfloat
)0.5,
5310 (gfloat
)1.0, (gfloat
)1.0);
5312 gtk_widget_set_usize(alignment
, 20, gui
.char_height
+ 2);
5313 gtk_box_pack_end(GTK_BOX(GTK_BIN(gui
.mainwin
)->child
),
5314 alignment
, FALSE
, FALSE
, 0);
5315 gtk_widget_show(alignment
);
5318 #endif /* !HAVE_GTK2 */
5321 if (gui_mch_maximized())
5325 /* Update lines and columns in accordance with the new font, keep the
5326 * window maximized. */
5327 gtk_window_get_size(GTK_WINDOW(gui
.mainwin
), &w
, &h
);
5328 w
-= get_menu_tool_width();
5329 h
-= get_menu_tool_height();
5330 gui_resize_shell(w
, h
);
5335 /* Preserve the logical dimensions of the screen. */
5336 update_window_manager_hints(0, 0);
5343 * Get a reference to the font "name".
5344 * Return zero for failure.
5347 gui_mch_get_font(char_u
*name
, int report_error
)
5350 PangoFontDescription
*font
;
5355 /* can't do this when GUI is not running */
5356 if (!gui
.in_use
|| name
== NULL
)
5360 if (output_conv
.vc_type
!= CONV_NONE
)
5364 buf
= string_convert(&output_conv
, name
, NULL
);
5367 font
= pango_font_description_from_string((const char *)buf
);
5374 font
= pango_font_description_from_string((const char *)name
);
5378 PangoFont
*real_font
;
5380 /* pango_context_load_font() bails out if no font size is set */
5381 if (pango_font_description_get_size(font
) <= 0)
5382 pango_font_description_set_size(font
, 10 * PANGO_SCALE
);
5384 real_font
= pango_context_load_font(gui
.text_context
, font
);
5386 if (real_font
== NULL
)
5388 pango_font_description_free(font
);
5392 g_object_unref(real_font
);
5395 font
= gdk_font_load((const gchar
*)name
);
5401 EMSG2(_((char *)e_font
), name
);
5407 * The fixed-width check has been disabled for GTK+ 2. Rationale:
5409 * - The check tends to report false positives, particularly
5410 * in non-Latin locales or with old X fonts.
5411 * - Thanks to our fixed-width hack in gui_gtk2_draw_string(),
5412 * GTK+ 2 Vim is actually capable of displaying variable width
5413 * fonts. Those will just be spaced out like in AA xterm.
5414 * - Failing here for the default font causes GUI startup to fail
5415 * even with wiped out configuration files.
5416 * - The font dialog displays all fonts unfiltered, and it's rather
5417 * annoying if 95% of the listed fonts produce an error message.
5421 /* Check that this is a mono-spaced font. Naturally, this is a bit
5422 * hackish -- fixed-width isn't really suitable for i18n text :/ */
5423 PangoLayout
*layout
;
5425 int last_width
= -1;
5426 const char test_chars
[] = { 'W', 'i', ',', 'x' }; /* arbitrary */
5428 layout
= pango_layout_new(gui
.text_context
);
5429 pango_layout_set_font_description(layout
, font
);
5431 for (i
= 0; i
< G_N_ELEMENTS(test_chars
); ++i
)
5435 pango_layout_set_text(layout
, &test_chars
[i
], 1);
5436 pango_layout_get_size(layout
, &width
, NULL
);
5438 if (last_width
>= 0 && width
!= last_width
)
5440 pango_font_description_free(font
);
5448 g_object_unref(layout
);
5451 #else /* !HAVE_GTK2 */
5455 /* reference this font as being in use */
5458 /* Check that this is a mono-spaced font.
5460 xfont
= (XFontStruct
*) GDK_FONT_XFONT(font
);
5462 if (xfont
->max_bounds
.width
!= xfont
->min_bounds
.width
)
5464 gdk_font_unref(font
);
5468 #endif /* !HAVE_GTK2 */
5470 #if !defined(HAVE_GTK2) || 0 /* disabled for GTK+ 2, see above */
5471 if (font
== NULL
&& report_error
)
5472 EMSG2(_(e_fontwidth
), name
);
5478 #if defined(FEAT_EVAL) || defined(PROTO)
5480 * Return the name of font "font" in allocated memory.
5483 gui_mch_get_fontname(GuiFont font
, char_u
*name UNUSED
)
5488 char *pangoname
= pango_font_description_to_string(font
);
5490 if (pangoname
!= NULL
)
5492 char_u
*s
= vim_strsave((char_u
*)pangoname
);
5499 /* Don't know how to get the name, return what we got. */
5501 return vim_strsave(name
);
5507 #if !defined(HAVE_GTK2) || defined(PROTO)
5509 * Set the current text font.
5510 * Since we create all GC on demand, we use just gui.current_font to
5511 * indicate the desired current font.
5514 gui_mch_set_font(GuiFont font
)
5516 gui
.current_font
= font
;
5520 #if defined(FEAT_XFONTSET) || defined(PROTO)
5522 * Set the current text fontset.
5525 gui_mch_set_fontset(GuiFontset fontset
)
5527 gui
.current_font
= fontset
;
5532 * If a font is not going to be used, free its structure.
5535 gui_mch_free_font(GuiFont font
)
5539 pango_font_description_free(font
);
5541 gdk_font_unref(font
);
5545 #if defined(FEAT_XFONTSET) || defined(PROTO)
5547 * If a fontset is not going to be used, free its structure.
5550 gui_mch_free_fontset(GuiFontset fontset
)
5552 if (fontset
!= NOFONTSET
)
5553 gdk_font_unref(fontset
);
5559 * Return the Pixel value (color) for the given color name. This routine was
5560 * pretty much taken from example code in the Silicon Graphics OSF/Motif
5561 * Programmer's Guide.
5562 * Return INVALCOLOR for error.
5565 gui_mch_get_color(char_u
*name
)
5567 /* A number of colors that some X11 systems don't have */
5568 static const char *const vimnames
[][2] =
5570 {"LightRed", "#FFBBBB"},
5571 {"LightGreen", "#88FF88"},
5572 {"LightMagenta","#FFBBFF"},
5573 {"DarkCyan", "#008888"},
5574 {"DarkBlue", "#0000BB"},
5575 {"DarkRed", "#BB0000"},
5576 {"DarkMagenta", "#BB00BB"},
5577 {"DarkGrey", "#BBBBBB"},
5578 {"DarkYellow", "#BBBB00"},
5579 {"Gray10", "#1A1A1A"},
5580 {"Grey10", "#1A1A1A"},
5581 {"Gray20", "#333333"},
5582 {"Grey20", "#333333"},
5583 {"Gray30", "#4D4D4D"},
5584 {"Grey30", "#4D4D4D"},
5585 {"Gray40", "#666666"},
5586 {"Grey40", "#666666"},
5587 {"Gray50", "#7F7F7F"},
5588 {"Grey50", "#7F7F7F"},
5589 {"Gray60", "#999999"},
5590 {"Grey60", "#999999"},
5591 {"Gray70", "#B3B3B3"},
5592 {"Grey70", "#B3B3B3"},
5593 {"Gray80", "#CCCCCC"},
5594 {"Grey80", "#CCCCCC"},
5595 {"Gray90", "#E5E5E5"},
5596 {"Grey90", "#E5E5E5"},
5600 if (!gui
.in_use
) /* can't do this when GUI not running */
5603 while (name
!= NULL
)
5609 parsed
= gdk_color_parse((const char *)name
, &color
);
5611 #ifndef HAVE_GTK2 /* ohh, lovely GTK+ 2, eases our pain :) */
5613 * Since we have already called gtk_set_locale here the bugger
5614 * XParseColor will accept only explicit color names in the language
5615 * of the current locale. However this will interfere with:
5616 * 1. Vim's global startup files
5617 * 2. Explicit color names in .vimrc
5619 * Therefore we first try to parse the color in the current locale and
5620 * if it fails, we fall back to the portable "C" one.
5626 current
= setlocale(LC_ALL
, NULL
);
5627 if (current
!= NULL
)
5631 saved
= g_strdup(current
);
5632 setlocale(LC_ALL
, "C");
5634 parsed
= gdk_color_parse((const gchar
*)name
, &color
);
5636 setlocale(LC_ALL
, saved
);
5642 #endif /* !HAVE_GTK2 */
5647 gdk_colormap_alloc_color(gtk_widget_get_colormap(gui
.drawarea
),
5648 &color
, FALSE
, TRUE
);
5650 gdk_color_alloc(gtk_widget_get_colormap(gui
.drawarea
), &color
);
5652 return (guicolor_T
)color
.pixel
;
5654 /* add a few builtin names and try again */
5657 if (vimnames
[i
][0] == NULL
)
5662 if (STRICMP(name
, vimnames
[i
][0]) == 0)
5664 name
= (char_u
*)vimnames
[i
][1];
5674 * Set the current text foreground color.
5677 gui_mch_set_fg_color(guicolor_T color
)
5679 gui
.fgcolor
->pixel
= (unsigned long)color
;
5683 * Set the current text background color.
5686 gui_mch_set_bg_color(guicolor_T color
)
5688 gui
.bgcolor
->pixel
= (unsigned long)color
;
5692 * Set the current text special color.
5695 gui_mch_set_sp_color(guicolor_T color
)
5697 gui
.spcolor
->pixel
= (unsigned long)color
;
5702 * Function-like convenience macro for the sake of efficiency.
5704 #define INSERT_PANGO_ATTR(Attribute, AttrList, Start, End) \
5706 PangoAttribute *tmp_attr_; \
5707 tmp_attr_ = (Attribute); \
5708 tmp_attr_->start_index = (Start); \
5709 tmp_attr_->end_index = (End); \
5710 pango_attr_list_insert((AttrList), tmp_attr_); \
5714 apply_wide_font_attr(char_u
*s
, int len
, PangoAttrList
*attr_list
)
5716 char_u
*start
= NULL
;
5720 for (p
= s
; p
< s
+ len
; p
+= utf_byte2len(*p
))
5722 uc
= utf_ptr2char(p
);
5726 if (uc
>= 0x80 && utf_char2cells(uc
) == 2)
5729 else if (uc
< 0x80 /* optimization shortcut */
5730 || (utf_char2cells(uc
) != 2 && !utf_iscomposing(uc
)))
5732 INSERT_PANGO_ATTR(pango_attr_font_desc_new(gui
.wide_font
),
5733 attr_list
, start
- s
, p
- s
);
5739 INSERT_PANGO_ATTR(pango_attr_font_desc_new(gui
.wide_font
),
5740 attr_list
, start
- s
, len
);
5744 count_cluster_cells(char_u
*s
, PangoItem
*item
,
5745 PangoGlyphString
* glyphs
, int i
,
5747 int *last_glyph_rbearing
)
5750 int next
; /* glyph start index of next cluster */
5751 int start
, end
; /* string segment of current cluster */
5752 int width
; /* real cluster width in Pango units */
5756 width
= glyphs
->glyphs
[i
].geometry
.width
;
5758 for (next
= i
+ 1; next
< glyphs
->num_glyphs
; ++next
)
5760 if (glyphs
->glyphs
[next
].attr
.is_cluster_start
)
5762 else if (glyphs
->glyphs
[next
].geometry
.width
> width
)
5763 width
= glyphs
->glyphs
[next
].geometry
.width
;
5766 start
= item
->offset
+ glyphs
->log_clusters
[i
];
5767 end
= item
->offset
+ ((next
< glyphs
->num_glyphs
) ?
5768 glyphs
->log_clusters
[next
] : item
->length
);
5770 for (p
= s
+ start
; p
< s
+ end
; p
+= utf_byte2len(*p
))
5772 uc
= utf_ptr2char(p
);
5775 else if (!utf_iscomposing(uc
))
5776 cellcount
+= utf_char2cells(uc
);
5779 if (last_glyph_rbearing
!= NULL
5780 && cellcount
> 0 && next
== glyphs
->num_glyphs
)
5782 PangoRectangle ink_rect
;
5784 * If a certain combining mark had to be taken from a non-monospace
5785 * font, we have to compensate manually by adapting x_offset according
5786 * to the ink extents of the previous glyph.
5788 pango_font_get_glyph_extents(item
->analysis
.font
,
5789 glyphs
->glyphs
[i
].glyph
,
5792 if (PANGO_RBEARING(ink_rect
) > 0)
5793 *last_glyph_rbearing
= PANGO_RBEARING(ink_rect
);
5797 *cluster_width
= width
;
5803 * If there are only combining characters in the cluster, we cannot just
5804 * change the width of the previous glyph since there is none. Therefore
5805 * some guesswork is needed.
5807 * If ink_rect.x is negative Pango apparently has taken care of the composing
5808 * by itself. Actually setting x_offset = 0 should be sufficient then, but due
5809 * to problems with composing from different fonts we still need to fine-tune
5810 * x_offset to avoid uglyness.
5812 * If ink_rect.x is not negative, force overstriking by pointing x_offset to
5813 * the position of the previous glyph. Apparently this happens only with old
5814 * X fonts which don't provide the special combining information needed by
5818 setup_zero_width_cluster(PangoItem
*item
, PangoGlyphInfo
*glyph
,
5819 int last_cellcount
, int last_cluster_width
,
5820 int last_glyph_rbearing
)
5822 PangoRectangle ink_rect
;
5823 PangoRectangle logical_rect
;
5826 width
= last_cellcount
* gui
.char_width
* PANGO_SCALE
;
5827 glyph
->geometry
.x_offset
= -width
+ MAX(0, width
- last_cluster_width
) / 2;
5828 glyph
->geometry
.width
= 0;
5830 pango_font_get_glyph_extents(item
->analysis
.font
,
5832 &ink_rect
, &logical_rect
);
5835 glyph
->geometry
.x_offset
+= last_glyph_rbearing
;
5836 glyph
->geometry
.y_offset
= logical_rect
.height
5837 - (gui
.char_height
- p_linespace
) * PANGO_SCALE
;
5842 draw_glyph_string(int row
, int col
, int num_cells
, int flags
,
5843 PangoFont
*font
, PangoGlyphString
*glyphs
)
5845 if (!(flags
& DRAW_TRANSP
))
5847 gdk_gc_set_foreground(gui
.text_gc
, gui
.bgcolor
);
5849 gdk_draw_rectangle(gui
.drawarea
->window
,
5854 num_cells
* gui
.char_width
,
5858 gdk_gc_set_foreground(gui
.text_gc
, gui
.fgcolor
);
5860 gdk_draw_glyphs(gui
.drawarea
->window
,
5867 /* redraw the contents with an offset of 1 to emulate bold */
5868 if ((flags
& DRAW_BOLD
) && !gui
.font_can_bold
)
5869 gdk_draw_glyphs(gui
.drawarea
->window
,
5877 #endif /* HAVE_GTK2 */
5880 * Draw underline and undercurl at the bottom of the character cell.
5883 draw_under(int flags
, int row
, int col
, int cells
)
5887 static const int val
[8] = {1, 0, 0, 0, 1, 2, 2, 2 };
5888 int y
= FILL_Y(row
+ 1) - 1;
5890 /* Undercurl: draw curl at the bottom of the character cell. */
5891 if (flags
& DRAW_UNDERC
)
5893 gdk_gc_set_foreground(gui
.text_gc
, gui
.spcolor
);
5894 for (i
= FILL_X(col
); i
< FILL_X(col
+ cells
); ++i
)
5896 offset
= val
[i
% 8];
5897 gdk_draw_point(gui
.drawarea
->window
, gui
.text_gc
, i
, y
- offset
);
5899 gdk_gc_set_foreground(gui
.text_gc
, gui
.fgcolor
);
5902 /* Underline: draw a line at the bottom of the character cell. */
5903 if (flags
& DRAW_UNDERL
)
5905 /* When p_linespace is 0, overwrite the bottom row of pixels.
5906 * Otherwise put the line just below the character. */
5907 if (p_linespace
> 1)
5908 y
-= p_linespace
- 1;
5909 gdk_draw_line(gui
.drawarea
->window
, gui
.text_gc
,
5911 FILL_X(col
+ cells
) - 1, y
);
5915 #if defined(HAVE_GTK2) || defined(PROTO)
5917 gui_gtk2_draw_string(int row
, int col
, char_u
*s
, int len
, int flags
)
5919 GdkRectangle area
; /* area for clip mask */
5920 PangoGlyphString
*glyphs
; /* glyphs of current item */
5921 int column_offset
= 0; /* column offset in cells */
5923 char_u
*conv_buf
= NULL
; /* result of UTF-8 conversion */
5924 char_u
*new_conv_buf
;
5929 if (gui
.text_context
== NULL
|| gui
.drawarea
->window
== NULL
)
5932 if (output_conv
.vc_type
!= CONV_NONE
)
5935 * Convert characters from 'encoding' to 'termencoding', which is set
5936 * to UTF-8 by gui_mch_init(). did_set_string_option() in option.c
5937 * prohibits changing this to something else than UTF-8 if the GUI is
5941 conv_buf
= string_convert(&output_conv
, s
, &convlen
);
5942 g_return_val_if_fail(conv_buf
!= NULL
, len
);
5944 /* Correct for differences in char width: some chars are
5945 * double-wide in 'encoding' but single-wide in utf-8. Add a space to
5946 * compensate for that. */
5947 for (sp
= s
, bp
= conv_buf
; sp
< s
+ len
&& bp
< conv_buf
+ convlen
; )
5949 plen
= utf_ptr2len(bp
);
5950 if ((*mb_ptr2cells
)(sp
) == 2 && utf_ptr2cells(bp
) == 1)
5952 new_conv_buf
= alloc(convlen
+ 2);
5953 if (new_conv_buf
== NULL
)
5955 plen
+= bp
- conv_buf
;
5956 mch_memmove(new_conv_buf
, conv_buf
, plen
);
5957 new_conv_buf
[plen
] = ' ';
5958 mch_memmove(new_conv_buf
+ plen
+ 1, conv_buf
+ plen
,
5959 convlen
- plen
+ 1);
5961 conv_buf
= new_conv_buf
;
5963 bp
= conv_buf
+ plen
;
5966 sp
+= (*mb_ptr2len
)(sp
);
5974 * Restrict all drawing to the current screen line in order to prevent
5975 * fuzzy font lookups from messing up the screen.
5977 area
.x
= gui
.border_offset
;
5978 area
.y
= FILL_Y(row
);
5979 area
.width
= gui
.num_cols
* gui
.char_width
;
5980 area
.height
= gui
.char_height
;
5982 gdk_gc_set_clip_origin(gui
.text_gc
, 0, 0);
5983 gdk_gc_set_clip_rectangle(gui
.text_gc
, &area
);
5985 glyphs
= pango_glyph_string_new();
5988 * Optimization hack: If possible, skip the itemize and shaping process
5989 * for pure ASCII strings. This optimization is particularly effective
5990 * because Vim draws space characters to clear parts of the screen.
5992 if (!(flags
& DRAW_ITALIC
)
5993 && !((flags
& DRAW_BOLD
) && gui
.font_can_bold
)
5994 && gui
.ascii_glyphs
!= NULL
)
5998 for (p
= s
; p
< s
+ len
; ++p
)
6002 pango_glyph_string_set_size(glyphs
, len
);
6004 for (i
= 0; i
< len
; ++i
)
6006 glyphs
->glyphs
[i
] = gui
.ascii_glyphs
->glyphs
[s
[i
]];
6007 glyphs
->log_clusters
[i
] = i
;
6010 draw_glyph_string(row
, col
, len
, flags
, gui
.ascii_font
, glyphs
);
6012 column_offset
= len
;
6017 PangoAttrList
*attr_list
;
6020 int last_glyph_rbearing
;
6021 int cells
= 0; /* cells occupied by current cluster */
6023 int monospace13
= STRICMP(p_guifont
, "monospace 13") == 0;
6026 /* Safety check: pango crashes when invoked with invalid utf-8
6028 if (!utf_valid_string(s
, s
+ len
))
6030 column_offset
= len
;
6034 /* original width of the current cluster */
6035 cluster_width
= PANGO_SCALE
* gui
.char_width
;
6037 /* right bearing of the last non-composing glyph */
6038 last_glyph_rbearing
= PANGO_SCALE
* gui
.char_width
;
6040 attr_list
= pango_attr_list_new();
6042 /* If 'guifontwide' is set then use that for double-width characters.
6043 * Otherwise just go with 'guifont' and let Pango do its thing. */
6044 if (gui
.wide_font
!= NULL
)
6045 apply_wide_font_attr(s
, len
, attr_list
);
6047 if ((flags
& DRAW_BOLD
) && gui
.font_can_bold
)
6048 INSERT_PANGO_ATTR(pango_attr_weight_new(PANGO_WEIGHT_BOLD
),
6050 if (flags
& DRAW_ITALIC
)
6051 INSERT_PANGO_ATTR(pango_attr_style_new(PANGO_STYLE_ITALIC
),
6054 * Break the text into segments with consistent directional level
6055 * and shaping engine. Pure Latin text needs only a single segment,
6056 * so there's no need to worry about the loop's efficiency. Better
6057 * try to optimize elsewhere, e.g. reducing exposes and stuff :)
6059 item_list
= pango_itemize(gui
.text_context
,
6060 (const char *)s
, 0, len
, attr_list
, NULL
);
6062 while (item_list
!= NULL
)
6065 int item_cells
= 0; /* item length in cells */
6067 item
= (PangoItem
*)item_list
->data
;
6068 item_list
= g_list_delete_link(item_list
, item_list
);
6070 * Increment the bidirectional embedding level by 1 if it is not
6071 * even. An odd number means the output will be RTL, but we don't
6072 * want that since Vim handles right-to-left text on its own. It
6073 * would probably be sufficient to just set level = 0, but you can
6076 * Unfortunately we can't take advantage of Pango's ability to
6077 * render both LTR and RTL at the same time. In order to support
6078 * that, Vim's main screen engine would have to make use of Pango
6081 item
->analysis
.level
= (item
->analysis
.level
+ 1) & (~1U);
6083 /* HACK: Overrule the shape engine, we don't want shaping to be
6084 * done, because drawing the cursor would change the display. */
6085 item
->analysis
.shape_engine
= default_shape_engine
;
6087 pango_shape((const char *)s
+ item
->offset
, item
->length
,
6088 &item
->analysis
, glyphs
);
6090 * Fixed-width hack: iterate over the array and assign a fixed
6091 * width to each glyph, thus overriding the choice made by the
6092 * shaping engine. We use utf_char2cells() to determine the
6093 * number of cells needed.
6095 * Also perform all kind of dark magic to get composing
6096 * characters right (and pretty too of course).
6098 for (i
= 0; i
< glyphs
->num_glyphs
; ++i
)
6100 PangoGlyphInfo
*glyph
;
6102 glyph
= &glyphs
->glyphs
[i
];
6104 if (glyph
->attr
.is_cluster_start
)
6108 cellcount
= count_cluster_cells(
6109 s
, item
, glyphs
, i
, &cluster_width
,
6110 (item_list
!= NULL
) ? &last_glyph_rbearing
: NULL
);
6116 width
= cellcount
* gui
.char_width
* PANGO_SCALE
;
6117 glyph
->geometry
.x_offset
+=
6118 MAX(0, width
- cluster_width
) / 2;
6119 glyph
->geometry
.width
= width
;
6123 /* If there are only combining characters in the
6124 * cluster, we cannot just change the width of the
6125 * previous glyph since there is none. Therefore
6126 * some guesswork is needed. */
6127 setup_zero_width_cluster(item
, glyph
, cells
,
6129 last_glyph_rbearing
);
6132 item_cells
+= cellcount
;
6139 /* There is a previous glyph, so we deal with combining
6140 * characters the canonical way. That is, setting the
6141 * width of the previous glyph to 0. */
6142 glyphs
->glyphs
[i
- 1].geometry
.width
= 0;
6143 width
= cells
* gui
.char_width
* PANGO_SCALE
;
6144 glyph
->geometry
.x_offset
+=
6145 MAX(0, width
- cluster_width
) / 2;
6147 /* Dirty hack: for "monospace 13" font there is a bug that
6148 * draws composing chars in the wrong position. Add
6149 * "width" to the offset to work around that. */
6151 glyph
->geometry
.x_offset
= width
;
6154 glyph
->geometry
.width
= width
;
6156 else /* i == 0 "cannot happen" */
6158 glyph
->geometry
.width
= 0;
6162 /*** Aaaaand action! ***/
6163 draw_glyph_string(row
, col
+ column_offset
, item_cells
,
6164 flags
, item
->analysis
.font
, glyphs
);
6166 pango_item_free(item
);
6168 column_offset
+= item_cells
;
6171 pango_attr_list_unref(attr_list
);
6175 /* Draw underline and undercurl. */
6176 draw_under(flags
, row
, col
, column_offset
);
6178 pango_glyph_string_free(glyphs
);
6181 gdk_gc_set_clip_rectangle(gui
.text_gc
, NULL
);
6183 return column_offset
;
6185 #endif /* HAVE_GTK2 */
6187 #if !defined(HAVE_GTK2) || defined(PROTO)
6189 gui_mch_draw_string(int row
, int col
, char_u
*s
, int len
, int flags
)
6191 static XChar2b
*buf
= NULL
;
6192 static int buflen
= 0;
6203 if (gui
.current_font
== NULL
|| gui
.drawarea
->window
== NULL
)
6207 * Yeah yeah apparently the font support in GTK+ 1.2 only cares for either:
6208 * asians or 8-bit fonts. It is broken there, but no wonder the whole font
6209 * stuff is broken in X11 in first place. And the internationalization API
6210 * isn't something you would really like to use.
6213 xfont
= (XFontStruct
*)((GdkFontPrivate
*)gui
.current_font
)->xfont
;
6214 is_wide
= ((xfont
->min_byte1
!= 0 || xfont
->max_byte1
!= 0)
6215 # ifdef FEAT_XFONTSET
6216 && gui
.fontset
== NOFONTSET
6222 /* Convert a byte sequence to 16 bit characters for the Gdk functions.
6223 * Need a buffer for the 16 bit characters. Keep it between calls,
6224 * because allocating it each time is slow. */
6227 XtFree((char *)buf
);
6228 buf
= (XChar2b
*)XtMalloc(len
* sizeof(XChar2b
));
6242 /* TODO: use the composing characters */
6243 c
= utfc_ptr2char_len(p
, pcc
, len
- (p
- s
));
6244 if (c
>= 0x10000) /* show chars > 0xffff as ? */
6246 buf
[textlen
].byte1
= c
>> 8;
6247 buf
[textlen
].byte2
= c
;
6248 p
+= utfc_ptr2len_len(p
, len
- (p
- s
));
6249 width
+= utf_char2cells(c
);
6254 buf
[textlen
].byte1
= '\0'; /* high eight bits */
6255 buf
[textlen
].byte2
= *p
; /* low eight bits */
6262 textlen
= textlen
* 2;
6266 text
= (XChar2b
*)s
;
6272 for (p
= s
; p
< s
+ len
; p
+= (*mb_ptr2len_len
)(p
, len
- (p
- s
)))
6273 width
+= (*mb_ptr2cells_len
)(p
, len
- (p
- s
));
6280 if (!(flags
& DRAW_TRANSP
))
6282 gdk_gc_set_foreground(gui
.text_gc
, gui
.bgcolor
);
6283 gdk_draw_rectangle(gui
.drawarea
->window
,
6286 FILL_X(col
), FILL_Y(row
),
6287 width
* gui
.char_width
, gui
.char_height
);
6289 gdk_gc_set_foreground(gui
.text_gc
, gui
.fgcolor
);
6290 gdk_draw_text(gui
.drawarea
->window
,
6293 TEXT_X(col
), TEXT_Y(row
),
6294 (const gchar
*)text
, textlen
);
6296 /* redraw the contents with an offset of 1 to emulate bold */
6297 if (flags
& DRAW_BOLD
)
6298 gdk_draw_text(gui
.drawarea
->window
,
6301 TEXT_X(col
) + 1, TEXT_Y(row
),
6302 (const gchar
*)text
, textlen
);
6304 /* Draw underline and undercurl. */
6305 draw_under(flags
, row
, col
, width
);
6307 #endif /* !HAVE_GTK2 */
6310 * Return OK if the key with the termcap name "name" is supported.
6313 gui_mch_haskey(char_u
*name
)
6317 for (i
= 0; special_keys
[i
].key_sym
!= 0; i
++)
6318 if (name
[0] == special_keys
[i
].code0
6319 && name
[1] == special_keys
[i
].code1
)
6324 #if defined(FEAT_TITLE) \
6325 || (defined(FEAT_XIM) && !defined(HAVE_GTK2)) \
6328 * Return the text window-id and display. Only required for X-based GUI's
6331 gui_get_x11_windis(Window
*win
, Display
**dis
)
6333 if (gui
.mainwin
!= NULL
&& gui
.mainwin
->window
!= NULL
)
6335 *dis
= GDK_WINDOW_XDISPLAY(gui
.mainwin
->window
);
6336 *win
= GDK_WINDOW_XWINDOW(gui
.mainwin
->window
);
6346 #if defined(FEAT_CLIENTSERVER) \
6347 || (defined(FEAT_X11) && defined(FEAT_CLIPBOARD)) || defined(PROTO)
6350 gui_mch_get_display(void)
6352 if (gui
.mainwin
!= NULL
&& gui
.mainwin
->window
!= NULL
)
6353 return GDK_WINDOW_XDISPLAY(gui
.mainwin
->window
);
6362 #ifdef HAVE_GTK_MULTIHEAD
6363 GdkDisplay
*display
;
6365 if (gui
.mainwin
!= NULL
&& GTK_WIDGET_REALIZED(gui
.mainwin
))
6366 display
= gtk_widget_get_display(gui
.mainwin
);
6368 display
= gdk_display_get_default();
6370 if (display
!= NULL
)
6371 gdk_display_beep(display
);
6378 gui_mch_flash(int msec
)
6383 if (gui
.drawarea
->window
== NULL
)
6386 values
.foreground
.pixel
= gui
.norm_pixel
^ gui
.back_pixel
;
6387 values
.background
.pixel
= gui
.norm_pixel
^ gui
.back_pixel
;
6388 values
.function
= GDK_XOR
;
6389 invert_gc
= gdk_gc_new_with_values(gui
.drawarea
->window
,
6394 gdk_gc_set_exposures(invert_gc
,
6395 gui
.visibility
!= GDK_VISIBILITY_UNOBSCURED
);
6397 * Do a visual beep by changing back and forth in some undetermined way,
6398 * the foreground and background colors. This is due to the fact that
6399 * there can't be really any prediction about the effects of XOR on
6400 * arbitrary X11 servers. However this seems to be enough for what we
6403 gdk_draw_rectangle(gui
.drawarea
->window
, invert_gc
,
6406 FILL_X((int)Columns
) + gui
.border_offset
,
6407 FILL_Y((int)Rows
) + gui
.border_offset
);
6410 ui_delay((long)msec
, TRUE
); /* wait so many msec */
6412 gdk_draw_rectangle(gui
.drawarea
->window
, invert_gc
,
6415 FILL_X((int)Columns
) + gui
.border_offset
,
6416 FILL_Y((int)Rows
) + gui
.border_offset
);
6418 gdk_gc_destroy(invert_gc
);
6422 * Invert a rectangle from row r, column c, for nr rows and nc columns.
6425 gui_mch_invert_rectangle(int r
, int c
, int nr
, int nc
)
6430 if (gui
.drawarea
->window
== NULL
)
6433 values
.foreground
.pixel
= gui
.norm_pixel
^ gui
.back_pixel
;
6434 values
.background
.pixel
= gui
.norm_pixel
^ gui
.back_pixel
;
6435 values
.function
= GDK_XOR
;
6436 invert_gc
= gdk_gc_new_with_values(gui
.drawarea
->window
,
6441 gdk_gc_set_exposures(invert_gc
, gui
.visibility
!=
6442 GDK_VISIBILITY_UNOBSCURED
);
6443 gdk_draw_rectangle(gui
.drawarea
->window
, invert_gc
,
6445 FILL_X(c
), FILL_Y(r
),
6446 (nc
) * gui
.char_width
, (nr
) * gui
.char_height
);
6447 gdk_gc_destroy(invert_gc
);
6451 * Iconify the GUI window.
6454 gui_mch_iconify(void)
6457 gtk_window_iconify(GTK_WINDOW(gui
.mainwin
));
6459 XIconifyWindow(GDK_WINDOW_XDISPLAY(gui
.mainwin
->window
),
6460 GDK_WINDOW_XWINDOW(gui
.mainwin
->window
),
6461 DefaultScreen(GDK_WINDOW_XDISPLAY(gui
.mainwin
->window
)));
6465 #if defined(FEAT_EVAL) || defined(PROTO)
6467 * Bring the Vim window to the foreground.
6470 gui_mch_set_foreground(void)
6473 gtk_window_present(GTK_WINDOW(gui
.mainwin
));
6475 gdk_window_raise(gui
.mainwin
->window
);
6481 * Draw a cursor without focus.
6484 gui_mch_draw_hollow_cursor(guicolor_T color
)
6488 if (gui
.drawarea
->window
== NULL
)
6491 gui_mch_set_fg_color(color
);
6493 gdk_gc_set_foreground(gui
.text_gc
, gui
.fgcolor
);
6495 if (mb_lefthalve(gui
.row
, gui
.col
))
6498 gdk_draw_rectangle(gui
.drawarea
->window
, gui
.text_gc
,
6500 FILL_X(gui
.col
), FILL_Y(gui
.row
),
6501 i
* gui
.char_width
- 1, gui
.char_height
- 1);
6505 * Draw part of a cursor, "w" pixels wide, and "h" pixels high, using
6509 gui_mch_draw_part_cursor(int w
, int h
, guicolor_T color
)
6511 if (gui
.drawarea
->window
== NULL
)
6514 gui_mch_set_fg_color(color
);
6516 gdk_gc_set_foreground(gui
.text_gc
, gui
.fgcolor
);
6517 gdk_draw_rectangle(gui
.drawarea
->window
, gui
.text_gc
,
6519 #ifdef FEAT_RIGHTLEFT
6520 /* vertical line should be on the right of current point */
6521 CURSOR_BAR_RIGHT
? FILL_X(gui
.col
+ 1) - w
:
6524 FILL_Y(gui
.row
) + gui
.char_height
- h
,
6530 * Catch up with any queued X11 events. This may put keyboard input into the
6531 * input buffer, call resize call-backs, trigger timers etc. If there is
6532 * nothing in the X11 event queue (& no timers pending), then we return
6536 gui_mch_update(void)
6538 while (gtk_events_pending() && !vim_is_input_buf_full())
6539 gtk_main_iteration_do(FALSE
);
6543 input_timer_cb(gpointer data
)
6545 int *timed_out
= (int *) data
;
6547 /* Just inform the caller about the occurrence of it */
6550 if (gtk_main_level() > 0)
6553 return FALSE
; /* don't happen again */
6558 * Callback function, used when data is available on the SNiFF connection.
6564 GdkInputCondition condition
)
6566 static char_u bytes
[3] = {CSI
, (int)KS_EXTRA
, (int)KE_SNIFF
};
6568 add_to_input_buf(bytes
, 3);
6570 if (gtk_main_level() > 0)
6576 * GUI input routine called by gui_wait_for_chars(). Waits for a character
6577 * from the keyboard.
6578 * wtime == -1 Wait forever.
6579 * wtime == 0 This should never happen.
6580 * wtime > 0 Wait wtime milliseconds for a character.
6581 * Returns OK if a character was found to be available within the given time,
6582 * or FAIL otherwise.
6585 gui_mch_wait_for_chars(long wtime
)
6589 static int timed_out
;
6591 static int sniff_on
= 0;
6592 static gint sniff_input_id
= 0;
6596 if (sniff_on
&& !want_sniff_request
)
6599 gdk_input_remove(sniff_input_id
);
6602 else if (!sniff_on
&& want_sniff_request
)
6604 /* Add fd_from_sniff to watch for available data in main loop. */
6605 sniff_input_id
= gdk_input_add(fd_from_sniff
,
6606 GDK_INPUT_READ
, sniff_request_cb
, NULL
);
6613 /* this timeout makes sure that we will return if no characters arrived in
6617 timer
= gtk_timeout_add((guint32
)wtime
, input_timer_cb
, &timed_out
);
6621 focus
= gui
.in_focus
;
6625 /* Stop or start blinking when focus changes */
6626 if (gui
.in_focus
!= focus
)
6629 gui_mch_start_blink();
6631 gui_mch_stop_blink();
6632 focus
= gui
.in_focus
;
6635 #if defined(FEAT_NETBEANS_INTG)
6636 /* Process the queued netbeans messages. */
6637 netbeans_parse_messages();
6641 * Loop in GTK+ processing until a timeout or input occurs.
6642 * Skip this if input is available anyway (can happen in rare
6643 * situations, sort of race condition).
6645 if (!input_available())
6648 /* Got char, return immediately */
6649 if (input_available())
6651 if (timer
!= 0 && !timed_out
)
6652 gtk_timeout_remove(timer
);
6655 } while (wtime
< 0 || !timed_out
);
6658 * Flush all eventually pending (drawing) events.
6666 /****************************************************************************
6667 * Output drawing routines.
6668 ****************************************************************************/
6671 /* Flush any output to the screen */
6675 #ifdef HAVE_GTK_MULTIHEAD
6676 if (gui
.mainwin
!= NULL
&& GTK_WIDGET_REALIZED(gui
.mainwin
))
6677 gdk_display_sync(gtk_widget_get_display(gui
.mainwin
));
6679 gdk_flush(); /* historical misnomer: calls XSync(), not XFlush() */
6682 /* This happens to actually do what gui_mch_flush() is supposed to do,
6683 * according to the comment above. */
6684 if (gui
.drawarea
!= NULL
&& gui
.drawarea
->window
!= NULL
)
6685 gdk_window_process_updates(gui
.drawarea
->window
, FALSE
);
6690 * Clear a rectangular region of the screen from text pos (row1, col1) to
6691 * (row2, col2) inclusive.
6694 gui_mch_clear_block(int row1
, int col1
, int row2
, int col2
)
6698 if (gui
.drawarea
->window
== NULL
)
6701 color
.pixel
= gui
.back_pixel
;
6703 gdk_gc_set_foreground(gui
.text_gc
, &color
);
6705 /* Clear one extra pixel at the far right, for when bold characters have
6706 * spilled over to the window border. */
6707 gdk_draw_rectangle(gui
.drawarea
->window
, gui
.text_gc
, TRUE
,
6708 FILL_X(col1
), FILL_Y(row1
),
6709 (col2
- col1
+ 1) * gui
.char_width
6710 + (col2
== Columns
- 1),
6711 (row2
- row1
+ 1) * gui
.char_height
);
6715 gui_mch_clear_all(void)
6717 if (gui
.drawarea
->window
!= NULL
)
6718 gdk_window_clear(gui
.drawarea
->window
);
6722 * Redraw any text revealed by scrolling up/down.
6725 check_copy_area(void)
6730 if (gui
.visibility
!= GDK_VISIBILITY_PARTIAL
)
6733 /* Avoid redrawing the cursor while scrolling or it'll end up where
6734 * we don't want it to be. I'm not sure if it's correct to call
6735 * gui_dont_update_cursor() at this point but it works as a quick
6737 gui_dont_update_cursor();
6741 /* Wait to check whether the scroll worked or not. */
6742 event
= gdk_event_get_graphics_expose(gui
.drawarea
->window
);
6745 break; /* received NoExpose event */
6747 gui_redraw(event
->expose
.area
.x
, event
->expose
.area
.y
,
6748 event
->expose
.area
.width
, event
->expose
.area
.height
);
6750 expose_count
= event
->expose
.count
;
6751 gdk_event_free(event
);
6753 while (expose_count
> 0); /* more events follow */
6755 gui_can_update_cursor();
6759 * Delete the given number of lines from the given row, scrolling up any
6760 * text further down within the scroll region.
6763 gui_mch_delete_lines(int row
, int num_lines
)
6765 if (gui
.visibility
== GDK_VISIBILITY_FULLY_OBSCURED
)
6766 return; /* Can't see the window */
6768 gdk_gc_set_foreground(gui
.text_gc
, gui
.fgcolor
);
6769 gdk_gc_set_background(gui
.text_gc
, gui
.bgcolor
);
6771 /* copy one extra pixel, for when bold has spilled over */
6772 gdk_window_copy_area(gui
.drawarea
->window
, gui
.text_gc
,
6773 FILL_X(gui
.scroll_region_left
), FILL_Y(row
),
6774 gui
.drawarea
->window
,
6775 FILL_X(gui
.scroll_region_left
),
6776 FILL_Y(row
+ num_lines
),
6777 gui
.char_width
* (gui
.scroll_region_right
6778 - gui
.scroll_region_left
+ 1) + 1,
6779 gui
.char_height
* (gui
.scroll_region_bot
- row
- num_lines
+ 1));
6781 gui_clear_block(gui
.scroll_region_bot
- num_lines
+ 1,
6782 gui
.scroll_region_left
,
6783 gui
.scroll_region_bot
, gui
.scroll_region_right
);
6788 * Insert the given number of lines before the given row, scrolling down any
6789 * following text within the scroll region.
6792 gui_mch_insert_lines(int row
, int num_lines
)
6794 if (gui
.visibility
== GDK_VISIBILITY_FULLY_OBSCURED
)
6795 return; /* Can't see the window */
6797 gdk_gc_set_foreground(gui
.text_gc
, gui
.fgcolor
);
6798 gdk_gc_set_background(gui
.text_gc
, gui
.bgcolor
);
6800 /* copy one extra pixel, for when bold has spilled over */
6801 gdk_window_copy_area(gui
.drawarea
->window
, gui
.text_gc
,
6802 FILL_X(gui
.scroll_region_left
), FILL_Y(row
+ num_lines
),
6803 gui
.drawarea
->window
,
6804 FILL_X(gui
.scroll_region_left
), FILL_Y(row
),
6805 gui
.char_width
* (gui
.scroll_region_right
6806 - gui
.scroll_region_left
+ 1) + 1,
6807 gui
.char_height
* (gui
.scroll_region_bot
- row
- num_lines
+ 1));
6809 gui_clear_block(row
, gui
.scroll_region_left
,
6810 row
+ num_lines
- 1, gui
.scroll_region_right
);
6815 * X Selection stuff, for cutting and pasting text to other windows.
6818 clip_mch_request_selection(VimClipboard
*cbd
)
6824 for (i
= 0; i
< N_SELECTION_TARGETS
; ++i
)
6827 if (!clip_html
&& selection_targets
[i
].info
== TARGET_HTML
)
6830 received_selection
= RS_NONE
;
6831 target
= gdk_atom_intern(selection_targets
[i
].target
, FALSE
);
6833 gtk_selection_convert(gui
.drawarea
,
6834 cbd
->gtk_sel_atom
, target
,
6835 (guint32
)GDK_CURRENT_TIME
);
6837 /* Hack: Wait up to three seconds for the selection. A hang was
6838 * noticed here when using the netrw plugin combined with ":gui"
6839 * during the FocusGained event. */
6841 while (received_selection
== RS_NONE
&& time(NULL
) < start
+ 3)
6842 gtk_main(); /* wait for selection_received_cb */
6844 if (received_selection
!= RS_FAIL
)
6848 /* Final fallback position - use the X CUT_BUFFER0 store */
6849 yank_cut_buffer0(GDK_WINDOW_XDISPLAY(gui
.mainwin
->window
), cbd
);
6853 * Disown the selection.
6856 clip_mch_lose_selection(VimClipboard
*cbd UNUSED
)
6858 /* WEIRD: when using NULL to actually disown the selection, we lose the
6859 * selection the first time we own it. */
6861 gtk_selection_owner_set(NULL, cbd->gtk_sel_atom, (guint32)GDK_CURRENT_TIME);
6867 * Own the selection and return OK if it worked.
6870 clip_mch_own_selection(VimClipboard
*cbd
)
6874 success
= gtk_selection_owner_set(gui
.drawarea
, cbd
->gtk_sel_atom
,
6875 (guint32
)GDK_CURRENT_TIME
);
6877 return (success
) ? OK
: FAIL
;
6881 * Send the current selection to the clipboard. Do nothing for X because we
6882 * will fill in the selection only when requested by another app.
6885 clip_mch_set_selection(VimClipboard
*cbd UNUSED
)
6890 #if defined(FEAT_MENU) || defined(PROTO)
6892 * Make a menu item appear either active or not active (grey or not grey).
6895 gui_mch_menu_grey(vimmenu_T
*menu
, int grey
)
6897 if (menu
->id
== NULL
)
6900 if (menu_is_separator(menu
->name
))
6903 gui_mch_menu_hidden(menu
, FALSE
);
6904 /* Be clever about bitfields versus true booleans here! */
6905 if (!GTK_WIDGET_SENSITIVE(menu
->id
) == !grey
)
6907 gtk_widget_set_sensitive(menu
->id
, !grey
);
6913 * Make menu item hidden or not hidden.
6916 gui_mch_menu_hidden(vimmenu_T
*menu
, int hidden
)
6923 if (GTK_WIDGET_VISIBLE(menu
->id
))
6925 gtk_widget_hide(menu
->id
);
6931 if (!GTK_WIDGET_VISIBLE(menu
->id
))
6933 gtk_widget_show(menu
->id
);
6940 * This is called after setting all the menus to grey/hidden or not.
6943 gui_mch_draw_menubar(void)
6945 /* just make sure that the visual changes get effect immediately */
6948 #endif /* FEAT_MENU */
6954 gui_mch_enable_scrollbar(scrollbar_T
*sb
, int flag
)
6960 gtk_widget_show(sb
->id
);
6962 gtk_widget_hide(sb
->id
);
6964 update_window_manager_hints(0, 0);
6969 * Return the RGB value of a pixel as long.
6972 gui_mch_get_rgb(guicolor_T pixel
)
6976 GdkColorContext
*cc
;
6978 cc
= gdk_color_context_new(gtk_widget_get_visual(gui
.drawarea
),
6979 gtk_widget_get_colormap(gui
.drawarea
));
6980 color
.pixel
= pixel
;
6981 gdk_color_context_query_color(cc
, &color
);
6983 gdk_color_context_free(cc
);
6985 gdk_colormap_query_color(gtk_widget_get_colormap(gui
.drawarea
),
6986 (unsigned long)pixel
, &color
);
6989 return (((unsigned)color
.red
& 0xff00) << 8)
6990 | ((unsigned)color
.green
& 0xff00)
6991 | (((unsigned)color
.blue
& 0xff00) >> 8);
6995 * Get current mouse coordinates in text window.
6998 gui_mch_getmouse(int *x
, int *y
)
7000 gdk_window_get_pointer(gui
.drawarea
->window
, x
, y
, NULL
);
7004 gui_mch_setmouse(int x
, int y
)
7006 /* Sorry for the Xlib call, but we can't avoid it, since there is no
7007 * internal GDK mechanism present to accomplish this. (and for good
7009 XWarpPointer(GDK_WINDOW_XDISPLAY(gui
.drawarea
->window
),
7010 (Window
)0, GDK_WINDOW_XWINDOW(gui
.drawarea
->window
),
7011 0, 0, 0U, 0U, x
, y
);
7015 #ifdef FEAT_MOUSESHAPE
7016 /* The last set mouse pointer shape is remembered, to be used when it goes
7017 * from hidden to not hidden. */
7018 static int last_shape
= 0;
7022 * Use the blank mouse pointer or not.
7024 * hide: TRUE = use blank ptr, FALSE = use parent ptr
7027 gui_mch_mousehide(int hide
)
7029 if (gui
.pointer_hidden
!= hide
)
7031 gui
.pointer_hidden
= hide
;
7032 if (gui
.drawarea
->window
&& gui
.blank_pointer
!= NULL
)
7035 gdk_window_set_cursor(gui
.drawarea
->window
, gui
.blank_pointer
);
7037 #ifdef FEAT_MOUSESHAPE
7038 mch_set_mouse_shape(last_shape
);
7040 gdk_window_set_cursor(gui
.drawarea
->window
, NULL
);
7046 #if defined(FEAT_MOUSESHAPE) || defined(PROTO)
7048 /* Table for shape IDs. Keep in sync with the mshape_names[] table in
7050 static const int mshape_ids
[] =
7052 GDK_LEFT_PTR
, /* arrow */
7053 GDK_CURSOR_IS_PIXMAP
, /* blank */
7054 GDK_XTERM
, /* beam */
7055 GDK_SB_V_DOUBLE_ARROW
, /* updown */
7056 GDK_SIZING
, /* udsizing */
7057 GDK_SB_H_DOUBLE_ARROW
, /* leftright */
7058 GDK_SIZING
, /* lrsizing */
7059 GDK_WATCH
, /* busy */
7060 GDK_X_CURSOR
, /* no */
7061 GDK_CROSSHAIR
, /* crosshair */
7062 GDK_HAND1
, /* hand1 */
7063 GDK_HAND2
, /* hand2 */
7064 GDK_PENCIL
, /* pencil */
7065 GDK_QUESTION_ARROW
, /* question */
7066 GDK_RIGHT_PTR
, /* right-arrow */
7067 GDK_CENTER_PTR
, /* up-arrow */
7068 GDK_LEFT_PTR
/* last one */
7072 mch_set_mouse_shape(int shape
)
7077 if (gui
.drawarea
->window
== NULL
)
7080 if (shape
== MSHAPE_HIDE
|| gui
.pointer_hidden
)
7081 gdk_window_set_cursor(gui
.drawarea
->window
, gui
.blank_pointer
);
7084 if (shape
>= MSHAPE_NUMBERED
)
7086 id
= shape
- MSHAPE_NUMBERED
;
7087 if (id
>= GDK_LAST_CURSOR
)
7090 id
&= ~1; /* they are always even (why?) */
7092 else if (shape
< (int)(sizeof(mshape_ids
) / sizeof(int)))
7093 id
= mshape_ids
[shape
];
7096 # ifdef HAVE_GTK_MULTIHEAD
7097 c
= gdk_cursor_new_for_display(
7098 gtk_widget_get_display(gui
.drawarea
), (GdkCursorType
)id
);
7100 c
= gdk_cursor_new((GdkCursorType
)id
);
7102 gdk_window_set_cursor(gui
.drawarea
->window
, c
);
7103 gdk_cursor_destroy(c
); /* Unref, actually. Bloody GTK+ 1. */
7105 if (shape
!= MSHAPE_HIDE
)
7108 #endif /* FEAT_MOUSESHAPE */
7111 #if defined(FEAT_SIGN_ICONS) || defined(PROTO)
7113 * Signs are currently always 2 chars wide. With GTK+ 2, the image will be
7114 * scaled down if the current font is not big enough, or scaled up if the image
7115 * size is less than 3/4 of the maximum sign size. With GTK+ 1, the pixmap
7116 * will be cut off if the current font is not big enough, or centered if it's
7119 # define SIGN_WIDTH (2 * gui.char_width)
7120 # define SIGN_HEIGHT (gui.char_height)
7121 # define SIGN_ASPECT ((double)SIGN_HEIGHT / (double)SIGN_WIDTH)
7126 gui_mch_drawsign(int row
, int col
, int typenr
)
7130 sign
= (GdkPixbuf
*)sign_get_image(typenr
);
7132 if (sign
!= NULL
&& gui
.drawarea
!= NULL
&& gui
.drawarea
->window
!= NULL
)
7140 width
= gdk_pixbuf_get_width(sign
);
7141 height
= gdk_pixbuf_get_height(sign
);
7143 * Decide whether we need to scale. Allow one pixel of border
7144 * width to be cut off, in order to avoid excessive scaling for
7145 * tiny differences in font size.
7147 need_scale
= (width
> SIGN_WIDTH
+ 2
7148 || height
> SIGN_HEIGHT
+ 2
7149 || (width
< 3 * SIGN_WIDTH
/ 4
7150 && height
< 3 * SIGN_HEIGHT
/ 4));
7155 /* Keep the original aspect ratio */
7156 aspect
= (double)height
/ (double)width
;
7157 width
= (double)SIGN_WIDTH
* SIGN_ASPECT
/ aspect
;
7158 width
= MIN(width
, SIGN_WIDTH
);
7159 height
= (double)width
* aspect
;
7161 /* This doesn't seem to be worth caching, and doing so
7162 * would complicate the code quite a bit. */
7163 sign
= gdk_pixbuf_scale_simple(sign
, width
, height
,
7164 GDK_INTERP_BILINEAR
);
7166 return; /* out of memory */
7169 /* The origin is the upper-left corner of the pixmap. Therefore
7170 * these offset may become negative if the pixmap is smaller than
7171 * the 2x1 cells reserved for the sign icon. */
7172 xoffset
= (width
- SIGN_WIDTH
) / 2;
7173 yoffset
= (height
- SIGN_HEIGHT
) / 2;
7175 gdk_gc_set_foreground(gui
.text_gc
, gui
.bgcolor
);
7177 gdk_draw_rectangle(gui
.drawarea
->window
,
7185 # if GTK_CHECK_VERSION(2,1,1)
7186 gdk_draw_pixbuf(gui
.drawarea
->window
,
7191 FILL_X(col
) - MIN(0, xoffset
),
7192 FILL_Y(row
) - MIN(0, yoffset
),
7193 MIN(width
, SIGN_WIDTH
),
7194 MIN(height
, SIGN_HEIGHT
),
7195 GDK_RGB_DITHER_NORMAL
,
7198 gdk_pixbuf_render_to_drawable_alpha(sign
,
7199 gui
.drawarea
->window
,
7202 FILL_X(col
) - MIN(0, xoffset
),
7203 FILL_Y(row
) - MIN(0, yoffset
),
7204 MIN(width
, SIGN_WIDTH
),
7205 MIN(height
, SIGN_HEIGHT
),
7206 GDK_PIXBUF_ALPHA_BILEVEL
,
7208 GDK_RGB_DITHER_NORMAL
,
7212 g_object_unref(sign
);
7217 gui_mch_register_sign(char_u
*signfile
)
7219 if (signfile
[0] != NUL
&& signfile
[0] != '-' && gui
.in_use
)
7222 GError
*error
= NULL
;
7225 sign
= gdk_pixbuf_new_from_file((const char *)signfile
, &error
);
7230 message
= (char_u
*)error
->message
;
7232 if (message
!= NULL
&& input_conv
.vc_type
!= CONV_NONE
)
7233 message
= string_convert(&input_conv
, message
, NULL
);
7235 if (message
!= NULL
)
7237 /* The error message is already translated and will be more
7238 * descriptive than anything we could possibly do ourselves. */
7239 EMSG2("E255: %s", message
);
7241 if (input_conv
.vc_type
!= CONV_NONE
)
7244 g_error_free(error
);
7251 gui_mch_destroy_sign(void *sign
)
7254 g_object_unref(sign
);
7257 # else /* !HAVE_GTK2 */
7267 gui_mch_drawsign(int row
, int col
, int typenr
)
7271 sign
= (signicon_T
*)sign_get_image(typenr
);
7273 if (sign
!= NULL
&& sign
->pixmap
!= NULL
7274 && gui
.drawarea
!= NULL
&& gui
.drawarea
->window
!= NULL
)
7281 gdk_window_get_size(sign
->pixmap
, &width
, &height
);
7283 /* The origin is the upper-left corner of the pixmap. Therefore
7284 * these offset may become negative if the pixmap is smaller than
7285 * the 2x1 cells reserved for the sign icon. */
7286 xoffset
= (width
- SIGN_WIDTH
) / 2;
7287 yoffset
= (height
- SIGN_HEIGHT
) / 2;
7289 gdk_gc_set_foreground(gui
.text_gc
, gui
.bgcolor
);
7291 gdk_draw_rectangle(gui
.drawarea
->window
,
7299 /* Set the clip mask for bilevel transparency */
7300 if (sign
->mask
!= NULL
)
7302 gdk_gc_set_clip_origin(gui
.text_gc
,
7303 FILL_X(col
) - xoffset
,
7304 FILL_Y(row
) - yoffset
);
7305 gdk_gc_set_clip_mask(gui
.text_gc
, sign
->mask
);
7308 gdk_draw_pixmap(gui
.drawarea
->window
,
7313 FILL_X(col
) - MIN(0, xoffset
),
7314 FILL_Y(row
) - MIN(0, yoffset
),
7315 MIN(width
, SIGN_WIDTH
),
7316 MIN(height
, SIGN_HEIGHT
));
7318 gdk_gc_set_clip_mask(gui
.text_gc
, NULL
);
7323 gui_mch_register_sign(char_u
*signfile
)
7325 signicon_T
*sign
= NULL
;
7327 if (signfile
[0] != NUL
&& signfile
[0] != '-'
7328 && gui
.drawarea
!= NULL
&& gui
.drawarea
->window
!= NULL
)
7330 sign
= (signicon_T
*)alloc(sizeof(signicon_T
));
7332 if (sign
!= NULL
) /* NULL == OOM == "cannot really happen" */
7335 sign
->pixmap
= gdk_pixmap_colormap_create_from_xpm(
7336 gui
.drawarea
->window
, NULL
,
7338 (const char *)signfile
);
7340 if (sign
->pixmap
== NULL
)
7344 EMSG(_(e_signdata
));
7352 gui_mch_destroy_sign(void *sign
)
7356 signicon_T
*signicon
= (signicon_T
*)sign
;
7358 if (signicon
->pixmap
!= NULL
)
7359 gdk_pixmap_unref(signicon
->pixmap
);
7360 if (signicon
->mask
!= NULL
)
7361 gdk_bitmap_unref(signicon
->mask
);
7366 # endif /* !HAVE_GTK2 */
7368 #endif /* FEAT_SIGN_ICONS */