1 /* vi:set ts=8 sts=4 sw=4 noet:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
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.
8 */
9
10 /*
11 * Porting to GTK+ was done by:
12 *
13 * (C) 1998,1999,2000 by Marcin Dalecki <martin@dalecki.de>
14 *
15 * With GREAT support and continuous encouragements by Andy Kahn and of
16 * course Bram Moolenaar!
17 *
18 * Support for GTK+ 2 was added by:
19 *
20 * (C) 2002,2003 Jason Hildebrand <jason@peaceworks.ca>
21 * Daniel Elstner <daniel.elstner@gmx.net>
22 *
23 * Support for GTK+ 3 was added by:
24 *
25 * 2016 Kazunobu Kuriyama <kazunobu.kuriyama@gmail.com>
26 */
27
28 #include "vim.h"
29 #ifdef USE_GRESOURCE
30 #include "auto/gui_gtk_gresources.h"
31 #endif
32
33 #ifdef FEAT_GUI_GNOME
34 // Gnome redefines _() and N_(). Grrr...
35 # ifdef _
36 # undef _
37 # endif
38 # ifdef N_
39 # undef N_
40 # endif
41 # ifdef textdomain
42 # undef textdomain
43 # endif
44 # ifdef bindtextdomain
45 # undef bindtextdomain
46 # endif
47 # ifdef bind_textdomain_codeset
48 # undef bind_textdomain_codeset
49 # endif
50 # if defined(FEAT_GETTEXT) && !defined(ENABLE_NLS)
51 # define ENABLE_NLS // so the texts in the dialog boxes are translated
52 # endif
53 # include <gnome.h>
54 # include "version.h"
55 // missing prototype in bonobo-dock-item.h
56 extern void bonobo_dock_item_set_behavior(BonoboDockItem *dock_item, BonoboDockItemBehavior beh);
57 #endif
58
59 #if !defined(FEAT_GUI_GTK) && defined(PROTO)
60 // When generating prototypes we don't want syntax errors.
61 # define GdkAtom int
62 # define GdkEventExpose int
63 # define GdkEventFocus int
64 # define GdkEventVisibility int
65 # define GdkEventProperty int
66 # define GtkContainer int
67 # define GtkTargetEntry int
68 # define GtkType int
69 # define GtkWidget int
70 # define gint int
71 # define gpointer int
72 # define guint int
73 # define GdkEventKey int
74 # define GdkEventSelection int
75 # define GtkSelectionData int
76 # define GdkEventMotion int
77 # define GdkEventButton int
78 # define GdkDragContext int
79 # define GdkEventConfigure int
80 # define GdkEventClient int
81 #else
82 # if GTK_CHECK_VERSION(3,0,0)
83 # include <gdk/gdkkeysyms-compat.h>
84 # include <gtk/gtkx.h>
85 # else
86 # include <gdk/gdkkeysyms.h>
87 # endif
88 # include <gdk/gdk.h>
89 # ifdef MSWIN
90 # include <gdk/gdkwin32.h>
91 # else
92 # include <gdk/gdkx.h>
93 # endif
94 # include <gtk/gtk.h>
95 # include "gui_gtk_f.h"
96 #endif
97
98 #ifdef HAVE_X11_SUNKEYSYM_H
99 # include <X11/Sunkeysym.h>
100 #endif
101
102 /*
103 * Easy-to-use macro for multihead support.
104 */
105 #define GET_X_ATOM(atom) gdk_x11_atom_to_xatom_for_display( \
106 gtk_widget_get_display(gui.mainwin), atom)
107
108 // Selection type distinguishers
109 enum
110 {
111 TARGET_TYPE_NONE,
112 TARGET_UTF8_STRING,
113 TARGET_STRING,
114 TARGET_COMPOUND_TEXT,
115 TARGET_HTML,
116 TARGET_TEXT,
117 TARGET_TEXT_URI_LIST,
118 TARGET_TEXT_PLAIN,
119 TARGET_VIM,
120 TARGET_VIMENC
121 };
122
123 /*
124 * Table of selection targets supported by Vim.
125 * Note: Order matters, preferred types should come first.
126 */
127 static const GtkTargetEntry selection_targets[] =
128 {
129 {VIMENC_ATOM_NAME, 0, TARGET_VIMENC},
130 {VIM_ATOM_NAME, 0, TARGET_VIM},
131 {"text/html", 0, TARGET_HTML},
132 {"UTF8_STRING", 0, TARGET_UTF8_STRING},
133 {"COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT},
134 {"TEXT", 0, TARGET_TEXT},
135 {"STRING", 0, TARGET_STRING}
136 };
137 #define N_SELECTION_TARGETS ARRAY_LENGTH(selection_targets)
138
139 #ifdef FEAT_DND
140 /*
141 * Table of DnD targets supported by Vim.
142 * Note: Order matters, preferred types should come first.
143 */
144 static const GtkTargetEntry dnd_targets[] =
145 {
146 {"text/uri-list", 0, TARGET_TEXT_URI_LIST},
147 {"text/html", 0, TARGET_HTML},
148 {"UTF8_STRING", 0, TARGET_UTF8_STRING},
149 {"STRING", 0, TARGET_STRING},
150 {"text/plain", 0, TARGET_TEXT_PLAIN}
151 };
152 # define N_DND_TARGETS ARRAY_LENGTH(dnd_targets)
153 #endif
154
155
156 /*
157 * "Monospace" is a standard font alias that should be present
158 * on all proper Pango/fontconfig installations.
159 */
160 # define DEFAULT_FONT "Monospace 10"
161
162 #if defined(FEAT_GUI_GNOME) && defined(FEAT_SESSION)
163 # define USE_GNOME_SESSION
164 #endif
165
166 #if !defined(FEAT_GUI_GNOME)
167 /*
168 * Atoms used to communicate save-yourself from the X11 session manager. There
169 * is no need to move them into the GUI struct, since they should be constant.
170 */
171 static GdkAtom wm_protocols_atom = GDK_NONE;
172 static GdkAtom save_yourself_atom = GDK_NONE;
173 #endif
174
175 /*
176 * Atoms used to control/reference X11 selections.
177 */
178 static GdkAtom html_atom = GDK_NONE;
179 static GdkAtom utf8_string_atom = GDK_NONE;
180 static GdkAtom vim_atom = GDK_NONE; // Vim's own special selection format
181 static GdkAtom vimenc_atom = GDK_NONE; // Vim's extended selection format
182
183 /*
184 * Keycodes recognized by vim.
185 * NOTE: when changing this, the table in gui_x11.c probably needs the same
186 * change!
187 */
188 static struct special_key
189 {
190 guint key_sym;
191 char_u code0;
192 char_u code1;
193 }
194 const special_keys[] =
195 {
196 {GDK_Up, 'k', 'u'},
197 {GDK_Down, 'k', 'd'},
198 {GDK_Left, 'k', 'l'},
199 {GDK_Right, 'k', 'r'},
200 {GDK_F1, 'k', '1'},
201 {GDK_F2, 'k', '2'},
202 {GDK_F3, 'k', '3'},
203 {GDK_F4, 'k', '4'},
204 {GDK_F5, 'k', '5'},
205 {GDK_F6, 'k', '6'},
206 {GDK_F7, 'k', '7'},
207 {GDK_F8, 'k', '8'},
208 {GDK_F9, 'k', '9'},
209 {GDK_F10, 'k', ';'},
210 {GDK_F11, 'F', '1'},
211 {GDK_F12, 'F', '2'},
212 {GDK_F13, 'F', '3'},
213 {GDK_F14, 'F', '4'},
214 {GDK_F15, 'F', '5'},
215 {GDK_F16, 'F', '6'},
216 {GDK_F17, 'F', '7'},
217 {GDK_F18, 'F', '8'},
218 {GDK_F19, 'F', '9'},
219 {GDK_F20, 'F', 'A'},
220 {GDK_F21, 'F', 'B'},
221 {GDK_Pause, 'F', 'B'}, // Pause == F21 according to netbeans.txt
222 {GDK_F22, 'F', 'C'},
223 {GDK_F23, 'F', 'D'},
224 {GDK_F24, 'F', 'E'},
225 {GDK_F25, 'F', 'F'},
226 {GDK_F26, 'F', 'G'},
227 {GDK_F27, 'F', 'H'},
228 {GDK_F28, 'F', 'I'},
229 {GDK_F29, 'F', 'J'},
230 {GDK_F30, 'F', 'K'},
231 {GDK_F31, 'F', 'L'},
232 {GDK_F32, 'F', 'M'},
233 {GDK_F33, 'F', 'N'},
234 {GDK_F34, 'F', 'O'},
235 {GDK_F35, 'F', 'P'},
236 #ifdef SunXK_F36
237 {SunXK_F36, 'F', 'Q'},
238 {SunXK_F37, 'F', 'R'},
239 #endif
240 {GDK_Help, '%', '1'},
241 {GDK_Undo, '&', '8'},
242 {GDK_BackSpace, 'k', 'b'},
243 {GDK_Insert, 'k', 'I'},
244 {GDK_Delete, 'k', 'D'},
245 {GDK_3270_BackTab, 'k', 'B'},
246 {GDK_Clear, 'k', 'C'},
247 {GDK_Home, 'k', 'h'},
248 {GDK_End, '@', '7'},
249 {GDK_Prior, 'k', 'P'},
250 {GDK_Next, 'k', 'N'},
251 {GDK_Print, '%', '9'},
252 // Keypad keys:
253 {GDK_KP_Left, 'k', 'l'},
254 {GDK_KP_Right, 'k', 'r'},
255 {GDK_KP_Up, 'k', 'u'},
256 {GDK_KP_Down, 'k', 'd'},
257 {GDK_KP_Insert, KS_EXTRA, (char_u)KE_KINS},
258 {GDK_KP_Delete, KS_EXTRA, (char_u)KE_KDEL},
259 {GDK_KP_Home, 'K', '1'},
260 {GDK_KP_End, 'K', '4'},
261 {GDK_KP_Prior, 'K', '3'}, // page up
262 {GDK_KP_Next, 'K', '5'}, // page down
263
264 {GDK_KP_Add, 'K', '6'},
265 {GDK_KP_Subtract, 'K', '7'},
266 {GDK_KP_Divide, 'K', '8'},
267 {GDK_KP_Multiply, 'K', '9'},
268 {GDK_KP_Enter, 'K', 'A'},
269 {GDK_KP_Decimal, 'K', 'B'},
270
271 {GDK_KP_0, 'K', 'C'},
272 {GDK_KP_1, 'K', 'D'},
273 {GDK_KP_2, 'K', 'E'},
274 {GDK_KP_3, 'K', 'F'},
275 {GDK_KP_4, 'K', 'G'},
276 {GDK_KP_5, 'K', 'H'},
277 {GDK_KP_6, 'K', 'I'},
278 {GDK_KP_7, 'K', 'J'},
279 {GDK_KP_8, 'K', 'K'},
280 {GDK_KP_9, 'K', 'L'},
281
282 // End of list marker:
283 {0, 0, 0}
284 };
285
286 /*
287 * Flags for command line options table below.
288 */
289 #define ARG_FONT 1
290 #define ARG_GEOMETRY 2
291 #define ARG_REVERSE 3
292 #define ARG_NOREVERSE 4
293 #define ARG_BACKGROUND 5
294 #define ARG_FOREGROUND 6
295 #define ARG_ICONIC 7
296 #define ARG_ROLE 8
297 #define ARG_NETBEANS 9
298 #define ARG_XRM 10 // ignored
299 #define ARG_MENUFONT 11 // ignored
300 #define ARG_INDEX_MASK 0x00ff
301 #define ARG_HAS_VALUE 0x0100 // a value is expected after the argument
302 #define ARG_NEEDS_GUI 0x0200 // need to initialize the GUI for this
303 #define ARG_FOR_GTK 0x0400 // argument is handled by GTK+ or GNOME
304 #define ARG_COMPAT_LONG 0x0800 // accept -foo but substitute with --foo
305 #define ARG_KEEP 0x1000 // don't remove argument from argv[]
306
307 /*
308 * This table holds all the X GUI command line options allowed. This includes
309 * the standard ones so that we can skip them when Vim is started without the
310 * GUI (but the GUI might start up later).
311 *
312 * When changing this, also update doc/gui_x11.txt and the usage message!!!
313 */
314 typedef struct
315 {
316 const char *name;
317 unsigned int flags;
318 }
319 cmdline_option_T;
320
321 static const cmdline_option_T cmdline_options[] =
322 {
323 // We handle these options ourselves
324 {"-fn", ARG_FONT|ARG_HAS_VALUE},
325 {"-font", ARG_FONT|ARG_HAS_VALUE},
326 {"-geom", ARG_GEOMETRY|ARG_HAS_VALUE},
327 {"-geometry", ARG_GEOMETRY|ARG_HAS_VALUE},
328 {"-rv", ARG_REVERSE},
329 {"-reverse", ARG_REVERSE},
330 {"+rv", ARG_NOREVERSE},
331 {"+reverse", ARG_NOREVERSE},
332 {"-bg", ARG_BACKGROUND|ARG_HAS_VALUE},
333 {"-background", ARG_BACKGROUND|ARG_HAS_VALUE},
334 {"-fg", ARG_FOREGROUND|ARG_HAS_VALUE},
335 {"-foreground", ARG_FOREGROUND|ARG_HAS_VALUE},
336 {"-iconic", ARG_ICONIC},
337 {"--role", ARG_ROLE|ARG_HAS_VALUE},
338 #ifdef FEAT_NETBEANS_INTG
339 {"-nb", ARG_NETBEANS}, // non-standard value format
340 {"-xrm", ARG_XRM|ARG_HAS_VALUE}, // not implemented
341 {"-mf", ARG_MENUFONT|ARG_HAS_VALUE}, // not implemented
342 {"-menufont", ARG_MENUFONT|ARG_HAS_VALUE}, // not implemented
343 #endif
344 // Arguments handled by GTK (and GNOME) internally.
345 {"--g-fatal-warnings", ARG_FOR_GTK},
346 {"--gdk-debug", ARG_FOR_GTK|ARG_HAS_VALUE},
347 {"--gdk-no-debug", ARG_FOR_GTK|ARG_HAS_VALUE},
348 {"--gtk-debug", ARG_FOR_GTK|ARG_HAS_VALUE},
349 {"--gtk-no-debug", ARG_FOR_GTK|ARG_HAS_VALUE},
350 {"--gtk-module", ARG_FOR_GTK|ARG_HAS_VALUE},
351 {"--sync", ARG_FOR_GTK},
352 {"--display", ARG_FOR_GTK|ARG_HAS_VALUE|ARG_COMPAT_LONG},
353 {"--name", ARG_FOR_GTK|ARG_HAS_VALUE|ARG_COMPAT_LONG},
354 {"--class", ARG_FOR_GTK|ARG_HAS_VALUE|ARG_COMPAT_LONG},
355 {"--screen", ARG_FOR_GTK|ARG_HAS_VALUE},
356 {"--gxid-host", ARG_FOR_GTK|ARG_HAS_VALUE},
357 {"--gxid-port", ARG_FOR_GTK|ARG_HAS_VALUE},
358 #ifdef FEAT_GUI_GNOME
359 {"--load-modules", ARG_FOR_GTK|ARG_HAS_VALUE},
360 {"--sm-client-id", ARG_FOR_GTK|ARG_HAS_VALUE},
361 {"--sm-config-prefix", ARG_FOR_GTK|ARG_HAS_VALUE},
362 {"--sm-disable", ARG_FOR_GTK},
363 {"--oaf-ior-fd", ARG_FOR_GTK|ARG_HAS_VALUE},
364 {"--oaf-activate-iid", ARG_FOR_GTK|ARG_HAS_VALUE},
365 {"--oaf-private", ARG_FOR_GTK},
366 {"--enable-sound", ARG_FOR_GTK},
367 {"--disable-sound", ARG_FOR_GTK},
368 {"--espeaker", ARG_FOR_GTK|ARG_HAS_VALUE},
369 {"-?", ARG_FOR_GTK|ARG_NEEDS_GUI},
370 {"--help", ARG_FOR_GTK|ARG_NEEDS_GUI|ARG_KEEP},
371 {"--usage", ARG_FOR_GTK|ARG_NEEDS_GUI},
372 # if 0 // conflicts with Vim's own --version argument
373 {"--version", ARG_FOR_GTK|ARG_NEEDS_GUI},
374 # endif
375 {"--disable-crash-dialog", ARG_FOR_GTK},
376 #endif
377 {NULL, 0}
378 };
379
380 static int gui_argc = 0;
381 static char **gui_argv = NULL;
382
383 static const char *role_argument = NULL;
384 #if defined(USE_GNOME_SESSION)
385 static const char *restart_command = NULL;
386 static char *abs_restart_command = NULL;
387 #endif
388 static int found_iconic_arg = FALSE;
389
390 #ifdef FEAT_GUI_GNOME
391 /*
392 * Can't use Gnome if --socketid given
393 */
394 static int using_gnome = 0;
395 #else
396 # define using_gnome 0
397 #endif
398
399 /*
400 * GTK doesn't set the GDK_BUTTON1_MASK state when dragging a touch. Add this
401 * state when dragging.
402 */
403 static guint dragging_button_state = 0;
404
405 /*
406 * Parse the GUI related command-line arguments. Any arguments used are
407 * deleted from argv, and *argc is decremented accordingly. This is called
408 * when vim is started, whether or not the GUI has been started.
409 */
410 void
gui_mch_prepare(int * argc,char ** argv)411 gui_mch_prepare(int *argc, char **argv)
412 {
413 const cmdline_option_T *option;
414 int i = 0;
415 int len = 0;
416
417 #if defined(USE_GNOME_SESSION)
418 /*
419 * Determine the command used to invoke Vim, to be passed as restart
420 * command to the session manager. If argv[0] contains any directory
421 * components try building an absolute path, otherwise leave it as is.
422 */
423 restart_command = argv[0];
424
425 if (strchr(argv[0], G_DIR_SEPARATOR) != NULL)
426 {
427 char_u buf[MAXPATHL];
428
429 if (mch_FullName((char_u *)argv[0], buf, (int)sizeof(buf), TRUE) == OK)
430 {
431 abs_restart_command = (char *)vim_strsave(buf);
432 restart_command = abs_restart_command;
433 }
434 }
435 #endif
436
437 /*
438 * Move all the entries in argv which are relevant to GTK+ and GNOME
439 * into gui_argv. Freed later in gui_mch_init().
440 */
441 gui_argc = 0;
442 gui_argv = ALLOC_MULT(char *, *argc + 1);
443
444 g_return_if_fail(gui_argv != NULL);
445
446 gui_argv[gui_argc++] = argv[i++];
447
448 while (i < *argc)
449 {
450 // Don't waste CPU cycles on non-option arguments.
451 if (argv[i][0] != '-' && argv[i][0] != '+')
452 {
453 ++i;
454 continue;
455 }
456
457 // Look for argv[i] in cmdline_options[] table.
458 for (option = &cmdline_options[0]; option->name != NULL; ++option)
459 {
460 len = strlen(option->name);
461
462 if (strncmp(argv[i], option->name, len) == 0)
463 {
464 if (argv[i][len] == '\0')
465 break;
466 // allow --foo=bar style
467 if (argv[i][len] == '=' && (option->flags & ARG_HAS_VALUE))
468 break;
469 #ifdef FEAT_NETBEANS_INTG
470 // darn, -nb has non-standard syntax
471 if (vim_strchr((char_u *)":=", argv[i][len]) != NULL
472 && (option->flags & ARG_INDEX_MASK) == ARG_NETBEANS)
473 break;
474 #endif
475 }
476 else if ((option->flags & ARG_COMPAT_LONG)
477 && strcmp(argv[i], option->name + 1) == 0)
478 {
479 // Replace the standard X arguments "-name" and "-display"
480 // with their GNU-style long option counterparts.
481 argv[i] = (char *)option->name;
482 break;
483 }
484 }
485 if (option->name == NULL) // no match
486 {
487 ++i;
488 continue;
489 }
490
491 if (option->flags & ARG_FOR_GTK)
492 {
493 // Move the argument into gui_argv, which
494 // will later be passed to gtk_init_check()
495 gui_argv[gui_argc++] = argv[i];
496 }
497 else
498 {
499 char *value = NULL;
500
501 // Extract the option's value if there is one.
502 // Accept both "--foo bar" and "--foo=bar" style.
503 if (option->flags & ARG_HAS_VALUE)
504 {
505 if (argv[i][len] == '=')
506 value = &argv[i][len + 1];
507 else if (i + 1 < *argc && strcmp(argv[i + 1], "--") != 0)
508 value = argv[i + 1];
509 }
510
511 // Check for options handled by Vim itself
512 switch (option->flags & ARG_INDEX_MASK)
513 {
514 case ARG_REVERSE:
515 found_reverse_arg = TRUE;
516 break;
517 case ARG_NOREVERSE:
518 found_reverse_arg = FALSE;
519 break;
520 case ARG_FONT:
521 font_argument = value;
522 break;
523 case ARG_GEOMETRY:
524 if (value != NULL)
525 gui.geom = vim_strsave((char_u *)value);
526 break;
527 case ARG_BACKGROUND:
528 background_argument = value;
529 break;
530 case ARG_FOREGROUND:
531 foreground_argument = value;
532 break;
533 case ARG_ICONIC:
534 found_iconic_arg = TRUE;
535 break;
536 case ARG_ROLE:
537 role_argument = value; // used later in gui_mch_open()
538 break;
539 #ifdef FEAT_NETBEANS_INTG
540 case ARG_NETBEANS:
541 gui.dofork = FALSE; // don't fork() when starting GUI
542 netbeansArg = argv[i];
543 break;
544 #endif
545 default:
546 break;
547 }
548 }
549
550 // These arguments make gnome_program_init() print a message and exit.
551 // Must start the GUI for this, otherwise ":gui" will exit later!
552 // Only when the GUI can start.
553 if ((option->flags & ARG_NEEDS_GUI)
554 && gui_mch_early_init_check(FALSE) == OK)
555 gui.starting = TRUE;
556
557 if (option->flags & ARG_KEEP)
558 ++i;
559 else
560 {
561 // Remove the flag from the argument vector.
562 if (--*argc > i)
563 {
564 int n_strip = 1;
565
566 // Move the argument's value as well, if there is one.
567 if ((option->flags & ARG_HAS_VALUE)
568 && argv[i][len] != '='
569 && strcmp(argv[i + 1], "--") != 0)
570 {
571 ++n_strip;
572 --*argc;
573 if (option->flags & ARG_FOR_GTK)
574 gui_argv[gui_argc++] = argv[i + 1];
575 }
576
577 if (*argc > i)
578 mch_memmove(&argv[i], &argv[i + n_strip],
579 (*argc - i) * sizeof(char *));
580 }
581 argv[*argc] = NULL;
582 }
583 }
584
585 gui_argv[gui_argc] = NULL;
586 }
587
588 #if defined(EXITFREE) || defined(PROTO)
589 void
gui_mch_free_all(void)590 gui_mch_free_all(void)
591 {
592 vim_free(gui_argv);
593 #if defined(USE_GNOME_SESSION)
594 vim_free(abs_restart_command);
595 #endif
596 }
597 #endif
598
599 #if !GTK_CHECK_VERSION(3,0,0)
600 /*
601 * This should be maybe completely removed.
602 * Doesn't seem possible, since check_copy_area() relies on
603 * this information. --danielk
604 */
605 static gint
visibility_event(GtkWidget * widget UNUSED,GdkEventVisibility * event,gpointer data UNUSED)606 visibility_event(GtkWidget *widget UNUSED,
607 GdkEventVisibility *event,
608 gpointer data UNUSED)
609 {
610 gui.visibility = event->state;
611 /*
612 * When we do an gdk_window_copy_area(), and the window is partially
613 * obscured, we want to receive an event to tell us whether it worked
614 * or not.
615 */
616 if (gui.text_gc != NULL)
617 gdk_gc_set_exposures(gui.text_gc,
618 gui.visibility != GDK_VISIBILITY_UNOBSCURED);
619 return FALSE;
620 }
621 #endif // !GTK_CHECK_VERSION(3,0,0)
622
623 /*
624 * Redraw the corresponding portions of the screen.
625 */
626 #if GTK_CHECK_VERSION(3,0,0)
627 static gboolean
draw_event(GtkWidget * widget UNUSED,cairo_t * cr,gpointer user_data UNUSED)628 draw_event(GtkWidget *widget UNUSED,
629 cairo_t *cr,
630 gpointer user_data UNUSED)
631 {
632 // Skip this when the GUI isn't set up yet, will redraw later.
633 if (gui.starting)
634 return FALSE;
635
636 out_flush(); // make sure all output has been processed
637 // for GTK+ 3, may induce other draw events.
638
639 cairo_set_source_surface(cr, gui.surface, 0, 0);
640
641 {
642 cairo_rectangle_list_t *list = NULL;
643
644 list = cairo_copy_clip_rectangle_list(cr);
645 if (list->status != CAIRO_STATUS_CLIP_NOT_REPRESENTABLE)
646 {
647 int i;
648
649 for (i = 0; i < list->num_rectangles; i++)
650 {
651 const cairo_rectangle_t *rect = &list->rectangles[i];
652 cairo_rectangle(cr, rect->x, rect->y, rect->width, rect->height);
653 cairo_fill(cr);
654 }
655 }
656 cairo_rectangle_list_destroy(list);
657 }
658
659 return FALSE;
660 }
661 #else // !GTK_CHECK_VERSION(3,0,0)
662 static gint
expose_event(GtkWidget * widget UNUSED,GdkEventExpose * event,gpointer data UNUSED)663 expose_event(GtkWidget *widget UNUSED,
664 GdkEventExpose *event,
665 gpointer data UNUSED)
666 {
667 // Skip this when the GUI isn't set up yet, will redraw later.
668 if (gui.starting)
669 return FALSE;
670
671 out_flush(); // make sure all output has been processed
672 gui_redraw(event->area.x, event->area.y,
673 event->area.width, event->area.height);
674
675 // Clear the border areas if needed
676 if (event->area.x < FILL_X(0))
677 gdk_window_clear_area(gui.drawarea->window, 0, 0, FILL_X(0), 0);
678 if (event->area.y < FILL_Y(0))
679 gdk_window_clear_area(gui.drawarea->window, 0, 0, 0, FILL_Y(0));
680 if (event->area.x > FILL_X(Columns))
681 gdk_window_clear_area(gui.drawarea->window,
682 FILL_X((int)Columns), 0, 0, 0);
683 if (event->area.y > FILL_Y(Rows))
684 gdk_window_clear_area(gui.drawarea->window, 0, FILL_Y((int)Rows), 0, 0);
685
686 return FALSE;
687 }
688 #endif // !GTK_CHECK_VERSION(3,0,0)
689
690 #ifdef FEAT_CLIENTSERVER
691 /*
692 * Handle changes to the "Comm" property
693 */
694 static gint
property_event(GtkWidget * widget,GdkEventProperty * event,gpointer data UNUSED)695 property_event(GtkWidget *widget,
696 GdkEventProperty *event,
697 gpointer data UNUSED)
698 {
699 if (event->type == GDK_PROPERTY_NOTIFY
700 && event->state == (int)GDK_PROPERTY_NEW_VALUE
701 && GDK_WINDOW_XID(event->window) == commWindow
702 && GET_X_ATOM(event->atom) == commProperty)
703 {
704 XEvent xev;
705
706 // Translate to XLib
707 xev.xproperty.type = PropertyNotify;
708 xev.xproperty.atom = commProperty;
709 xev.xproperty.window = commWindow;
710 xev.xproperty.state = PropertyNewValue;
711 serverEventProc(GDK_WINDOW_XDISPLAY(gtk_widget_get_window(widget)),
712 &xev, 0);
713 }
714 return FALSE;
715 }
716 #endif // defined(FEAT_CLIENTSERVER)
717
718 /*
719 * Handle changes to the "Xft/DPI" setting
720 */
721 static void
gtk_settings_xft_dpi_changed_cb(GtkSettings * gtk_settings UNUSED,GParamSpec * pspec UNUSED,gpointer data UNUSED)722 gtk_settings_xft_dpi_changed_cb(GtkSettings *gtk_settings UNUSED,
723 GParamSpec *pspec UNUSED,
724 gpointer data UNUSED)
725 {
726 // Create a new PangoContext for this screen, and initialize it
727 // with the current font if necessary.
728 if (gui.text_context != NULL)
729 g_object_unref(gui.text_context);
730
731 gui.text_context = gtk_widget_create_pango_context(gui.mainwin);
732 pango_context_set_base_dir(gui.text_context, PANGO_DIRECTION_LTR);
733
734 if (gui.norm_font != NULL)
735 {
736 // force default font
737 gui_mch_init_font(*p_guifont == NUL ? NULL : p_guifont, FALSE);
738 gui_set_shellsize(TRUE, FALSE, RESIZE_BOTH);
739 }
740 }
741
742 typedef gboolean timeout_cb_type;
743
744 /*
745 * Start a timer that will invoke the specified callback.
746 * Returns the ID of the timer.
747 */
748 static guint
timeout_add(int time,timeout_cb_type (* callback)(gpointer),int * flagp)749 timeout_add(int time, timeout_cb_type (*callback)(gpointer), int *flagp)
750 {
751 return g_timeout_add((guint)time, (GSourceFunc)callback, flagp);
752 }
753
754 static void
timeout_remove(guint timer)755 timeout_remove(guint timer)
756 {
757 g_source_remove(timer);
758 }
759
760
761 /////////////////////////////////////////////////////////////////////////////
762 // Focus handlers:
763
764
765 /*
766 * This is a simple state machine:
767 * BLINK_NONE not blinking at all
768 * BLINK_OFF blinking, cursor is not shown
769 * BLINK_ON blinking, cursor is shown
770 */
771
772 #define BLINK_NONE 0
773 #define BLINK_OFF 1
774 #define BLINK_ON 2
775
776 static int blink_state = BLINK_NONE;
777 static long_u blink_waittime = 700;
778 static long_u blink_ontime = 400;
779 static long_u blink_offtime = 250;
780 static guint blink_timer = 0;
781
782 int
gui_mch_is_blinking(void)783 gui_mch_is_blinking(void)
784 {
785 return blink_state != BLINK_NONE;
786 }
787
788 int
gui_mch_is_blink_off(void)789 gui_mch_is_blink_off(void)
790 {
791 return blink_state == BLINK_OFF;
792 }
793
794 void
gui_mch_set_blinking(long waittime,long on,long off)795 gui_mch_set_blinking(long waittime, long on, long off)
796 {
797 blink_waittime = waittime;
798 blink_ontime = on;
799 blink_offtime = off;
800 }
801
802 /*
803 * Stop the cursor blinking. Show the cursor if it wasn't shown.
804 */
805 void
gui_mch_stop_blink(int may_call_gui_update_cursor)806 gui_mch_stop_blink(int may_call_gui_update_cursor)
807 {
808 if (blink_timer)
809 {
810 timeout_remove(blink_timer);
811 blink_timer = 0;
812 }
813 if (blink_state == BLINK_OFF && may_call_gui_update_cursor)
814 {
815 gui_update_cursor(TRUE, FALSE);
816 #if !GTK_CHECK_VERSION(3,0,0)
817 gui_mch_flush();
818 #endif
819 }
820 blink_state = BLINK_NONE;
821 }
822
823 static timeout_cb_type
blink_cb(gpointer data UNUSED)824 blink_cb(gpointer data UNUSED)
825 {
826 if (blink_state == BLINK_ON)
827 {
828 gui_undraw_cursor();
829 blink_state = BLINK_OFF;
830 blink_timer = timeout_add(blink_offtime, blink_cb, NULL);
831 }
832 else
833 {
834 gui_update_cursor(TRUE, FALSE);
835 blink_state = BLINK_ON;
836 blink_timer = timeout_add(blink_ontime, blink_cb, NULL);
837 }
838 #if !GTK_CHECK_VERSION(3,0,0)
839 gui_mch_flush();
840 #endif
841
842 return FALSE; // don't happen again
843 }
844
845 /*
846 * Start the cursor blinking. If it was already blinking, this restarts the
847 * waiting time and shows the cursor.
848 */
849 void
gui_mch_start_blink(void)850 gui_mch_start_blink(void)
851 {
852 if (blink_timer)
853 {
854 timeout_remove(blink_timer);
855 blink_timer = 0;
856 }
857 // Only switch blinking on if none of the times is zero
858 if (blink_waittime && blink_ontime && blink_offtime && gui.in_focus)
859 {
860 blink_timer = timeout_add(blink_waittime, blink_cb, NULL);
861 blink_state = BLINK_ON;
862 gui_update_cursor(TRUE, FALSE);
863 #if !GTK_CHECK_VERSION(3,0,0)
864 gui_mch_flush();
865 #endif
866 }
867 }
868
869 static gint
enter_notify_event(GtkWidget * widget UNUSED,GdkEventCrossing * event UNUSED,gpointer data UNUSED)870 enter_notify_event(GtkWidget *widget UNUSED,
871 GdkEventCrossing *event UNUSED,
872 gpointer data UNUSED)
873 {
874 if (blink_state == BLINK_NONE)
875 gui_mch_start_blink();
876
877 // make sure keyboard input goes there
878 if (gtk_socket_id == 0 || !gtk_widget_has_focus(gui.drawarea))
879 gtk_widget_grab_focus(gui.drawarea);
880
881 return FALSE;
882 }
883
884 static gint
leave_notify_event(GtkWidget * widget UNUSED,GdkEventCrossing * event UNUSED,gpointer data UNUSED)885 leave_notify_event(GtkWidget *widget UNUSED,
886 GdkEventCrossing *event UNUSED,
887 gpointer data UNUSED)
888 {
889 if (blink_state != BLINK_NONE)
890 gui_mch_stop_blink(TRUE);
891
892 return FALSE;
893 }
894
895 static gint
focus_in_event(GtkWidget * widget,GdkEventFocus * event UNUSED,gpointer data UNUSED)896 focus_in_event(GtkWidget *widget,
897 GdkEventFocus *event UNUSED,
898 gpointer data UNUSED)
899 {
900 gui_focus_change(TRUE);
901
902 if (blink_state == BLINK_NONE)
903 gui_mch_start_blink();
904
905 // make sure keyboard input goes to the draw area (if this is focus for a
906 // window)
907 if (widget != gui.drawarea)
908 gtk_widget_grab_focus(gui.drawarea);
909
910 return TRUE;
911 }
912
913 static gint
focus_out_event(GtkWidget * widget UNUSED,GdkEventFocus * event UNUSED,gpointer data UNUSED)914 focus_out_event(GtkWidget *widget UNUSED,
915 GdkEventFocus *event UNUSED,
916 gpointer data UNUSED)
917 {
918 gui_focus_change(FALSE);
919
920 if (blink_state != BLINK_NONE)
921 gui_mch_stop_blink(TRUE);
922
923 return TRUE;
924 }
925
926
927 /*
928 * Translate a GDK key value to UTF-8 independently of the current locale.
929 * The output is written to string, which must have room for at least 6 bytes
930 * plus the NUL terminator. Returns the length in bytes.
931 *
932 * event->string is evil; see here why:
933 * http://developer.gnome.org/doc/API/2.0/gdk/gdk-Event-Structures.html#GdkEventKey
934 */
935 static int
keyval_to_string(unsigned int keyval,char_u * string)936 keyval_to_string(unsigned int keyval, char_u *string)
937 {
938 int len;
939 guint32 uc;
940
941 uc = gdk_keyval_to_unicode(keyval);
942 if (uc != 0)
943 {
944 // Translate a normal key to UTF-8. This doesn't work for dead
945 // keys of course, you _have_ to use an input method for that.
946 len = utf_char2bytes((int)uc, string);
947 }
948 else
949 {
950 // Translate keys which are represented by ASCII control codes in Vim.
951 // There are only a few of those; most control keys are translated to
952 // special terminal-like control sequences.
953 len = 1;
954 switch (keyval)
955 {
956 case GDK_Tab: case GDK_KP_Tab: case GDK_ISO_Left_Tab:
957 string[0] = TAB;
958 break;
959 case GDK_Linefeed:
960 string[0] = NL;
961 break;
962 case GDK_Return: case GDK_ISO_Enter: case GDK_3270_Enter:
963 string[0] = CAR;
964 break;
965 case GDK_Escape:
966 string[0] = ESC;
967 break;
968 default:
969 len = 0;
970 break;
971 }
972 }
973 string[len] = NUL;
974
975 return len;
976 }
977
978 static int
modifiers_gdk2vim(guint state)979 modifiers_gdk2vim(guint state)
980 {
981 int modifiers = 0;
982
983 if (state & GDK_SHIFT_MASK)
984 modifiers |= MOD_MASK_SHIFT;
985 if (state & GDK_CONTROL_MASK)
986 modifiers |= MOD_MASK_CTRL;
987 if (state & GDK_MOD1_MASK)
988 modifiers |= MOD_MASK_ALT;
989 #if GTK_CHECK_VERSION(2,10,0)
990 if (state & GDK_SUPER_MASK)
991 modifiers |= MOD_MASK_META;
992 #endif
993 if (state & GDK_MOD4_MASK)
994 modifiers |= MOD_MASK_META;
995
996 return modifiers;
997 }
998
999 static int
modifiers_gdk2mouse(guint state)1000 modifiers_gdk2mouse(guint state)
1001 {
1002 int modifiers = 0;
1003
1004 if (state & GDK_SHIFT_MASK)
1005 modifiers |= MOUSE_SHIFT;
1006 if (state & GDK_CONTROL_MASK)
1007 modifiers |= MOUSE_CTRL;
1008 if (state & GDK_MOD1_MASK)
1009 modifiers |= MOUSE_ALT;
1010
1011 return modifiers;
1012 }
1013
1014 /*
1015 * Main keyboard handler:
1016 */
1017 static gint
key_press_event(GtkWidget * widget UNUSED,GdkEventKey * event,gpointer data UNUSED)1018 key_press_event(GtkWidget *widget UNUSED,
1019 GdkEventKey *event,
1020 gpointer data UNUSED)
1021 {
1022 // For GTK+ 2 we know for sure how large the string might get.
1023 // (That is, up to 6 bytes + NUL + CSI escapes + safety measure.)
1024 char_u string[32], string2[32];
1025 guint key_sym;
1026 int len;
1027 int i;
1028 int modifiers;
1029 int key;
1030 guint state;
1031 char_u *s, *d;
1032
1033 gui.event_time = event->time;
1034 key_sym = event->keyval;
1035 state = event->state;
1036
1037 #ifdef FEAT_XIM
1038 if (xim_queue_key_press_event(event, TRUE))
1039 return TRUE;
1040 #endif
1041
1042 #ifdef SunXK_F36
1043 /*
1044 * These keys have bogus lookup strings, and trapping them here is
1045 * easier than trying to XRebindKeysym() on them with every possible
1046 * combination of modifiers.
1047 */
1048 if (key_sym == SunXK_F36 || key_sym == SunXK_F37)
1049 len = 0;
1050 else
1051 #endif
1052 {
1053 len = keyval_to_string(key_sym, string2);
1054
1055 // Careful: convert_input() doesn't handle the NUL character.
1056 // No need to convert pure ASCII anyway, thus the len > 1 check.
1057 if (len > 1 && input_conv.vc_type != CONV_NONE)
1058 len = convert_input(string2, len, sizeof(string2));
1059
1060 s = string2;
1061 d = string;
1062 for (i = 0; i < len; ++i)
1063 {
1064 *d++ = s[i];
1065 if (d[-1] == CSI && d + 2 < string + sizeof(string))
1066 {
1067 // Turn CSI into K_CSI.
1068 *d++ = KS_EXTRA;
1069 *d++ = (int)KE_CSI;
1070 }
1071 }
1072 len = d - string;
1073 }
1074
1075 // Shift-Tab results in Left_Tab, but we want <S-Tab>
1076 if (key_sym == GDK_ISO_Left_Tab)
1077 {
1078 key_sym = GDK_Tab;
1079 state |= GDK_SHIFT_MASK;
1080 }
1081
1082 #ifdef FEAT_MENU
1083 // If there is a menu and 'wak' is "yes", or 'wak' is "menu" and the key
1084 // is a menu shortcut, we ignore everything with the ALT modifier.
1085 if ((state & GDK_MOD1_MASK)
1086 && gui.menu_is_active
1087 && (*p_wak == 'y'
1088 || (*p_wak == 'm'
1089 && len == 1
1090 && gui_is_menu_shortcut(string[0]))))
1091 // For GTK2 we return false to signify that we haven't handled the
1092 // keypress, so that gtk will handle the mnemonic or accelerator.
1093 return FALSE;
1094 #endif
1095
1096 // We used to apply Alt/Meta to the key here (Mod1Mask), but that is now
1097 // done later, the same as it happens for the terminal. Hopefully that
1098 // works for everybody...
1099
1100 // Check for special keys. Also do this when len == 1 (key has an ASCII
1101 // value) to detect backspace, delete and keypad keys.
1102 if (len == 0 || len == 1)
1103 {
1104 for (i = 0; special_keys[i].key_sym != 0; i++)
1105 {
1106 if (special_keys[i].key_sym == key_sym)
1107 {
1108 string[0] = CSI;
1109 string[1] = special_keys[i].code0;
1110 string[2] = special_keys[i].code1;
1111 len = -3;
1112 break;
1113 }
1114 }
1115 }
1116
1117 if (len == 0) // Unrecognized key
1118 return TRUE;
1119
1120 // For some keys a shift modifier is translated into another key code.
1121 if (len == -3)
1122 key = TO_SPECIAL(string[1], string[2]);
1123 else
1124 {
1125 string[len] = NUL;
1126 key = mb_ptr2char(string);
1127 }
1128
1129 // Handle modifiers.
1130 modifiers = modifiers_gdk2vim(state);
1131
1132 // Recognize special keys.
1133 key = simplify_key(key, &modifiers);
1134 if (key == CSI)
1135 key = K_CSI;
1136 if (IS_SPECIAL(key))
1137 {
1138 string[0] = CSI;
1139 string[1] = K_SECOND(key);
1140 string[2] = K_THIRD(key);
1141 len = 3;
1142 }
1143 else
1144 {
1145 // Some keys need adjustment when the Ctrl modifier is used.
1146 key = may_adjust_key_for_ctrl(modifiers, key);
1147
1148 // May remove the Shift modifier if it's included in the key.
1149 modifiers = may_remove_shift_modifier(modifiers, key);
1150
1151 len = mb_char2bytes(key, string);
1152 }
1153
1154 if (modifiers != 0)
1155 {
1156 string2[0] = CSI;
1157 string2[1] = KS_MODIFIER;
1158 string2[2] = modifiers;
1159 add_to_input_buf(string2, 3);
1160 }
1161
1162 // Check if the key interrupts.
1163 {
1164 int int_ch = check_for_interrupt(key, modifiers);
1165
1166 if (int_ch != NUL)
1167 {
1168 trash_input_buf();
1169 string[0] = int_ch;
1170 len = 1;
1171 }
1172 }
1173
1174 add_to_input_buf(string, len);
1175
1176 // blank out the pointer if necessary
1177 if (p_mh)
1178 gui_mch_mousehide(TRUE);
1179
1180 return TRUE;
1181 }
1182
1183 #if defined(FEAT_XIM) || GTK_CHECK_VERSION(3,0,0)
1184 static gboolean
key_release_event(GtkWidget * widget UNUSED,GdkEventKey * event,gpointer data UNUSED)1185 key_release_event(GtkWidget *widget UNUSED,
1186 GdkEventKey *event,
1187 gpointer data UNUSED)
1188 {
1189 # if defined(FEAT_XIM)
1190 gui.event_time = event->time;
1191 /*
1192 * GTK+ 2 input methods may do fancy stuff on key release events too.
1193 * With the default IM for instance, you can enter any UCS code point
1194 * by holding down CTRL-SHIFT and typing hexadecimal digits.
1195 */
1196 return xim_queue_key_press_event(event, FALSE);
1197 # else
1198 return TRUE;
1199 # endif
1200 }
1201 #endif
1202
1203
1204 /////////////////////////////////////////////////////////////////////////////
1205 // Selection handlers:
1206
1207 // Remember when clip_lose_selection was called from here, we must not call
1208 // gtk_selection_owner_set() then.
1209 static int in_selection_clear_event = FALSE;
1210
1211 static gint
selection_clear_event(GtkWidget * widget UNUSED,GdkEventSelection * event,gpointer user_data UNUSED)1212 selection_clear_event(GtkWidget *widget UNUSED,
1213 GdkEventSelection *event,
1214 gpointer user_data UNUSED)
1215 {
1216 in_selection_clear_event = TRUE;
1217 if (event->selection == clip_plus.gtk_sel_atom)
1218 clip_lose_selection(&clip_plus);
1219 else
1220 clip_lose_selection(&clip_star);
1221 in_selection_clear_event = FALSE;
1222
1223 return TRUE;
1224 }
1225
1226 #define RS_NONE 0 // selection_received_cb() not called yet
1227 #define RS_OK 1 // selection_received_cb() called and OK
1228 #define RS_FAIL 2 // selection_received_cb() called and failed
1229 static int received_selection = RS_NONE;
1230
1231 static void
selection_received_cb(GtkWidget * widget UNUSED,GtkSelectionData * data,guint time_ UNUSED,gpointer user_data UNUSED)1232 selection_received_cb(GtkWidget *widget UNUSED,
1233 GtkSelectionData *data,
1234 guint time_ UNUSED,
1235 gpointer user_data UNUSED)
1236 {
1237 Clipboard_T *cbd;
1238 char_u *text;
1239 char_u *tmpbuf = NULL;
1240 guchar *tmpbuf_utf8 = NULL;
1241 int len;
1242 int motion_type = MAUTO;
1243
1244 if (gtk_selection_data_get_selection(data) == clip_plus.gtk_sel_atom)
1245 cbd = &clip_plus;
1246 else
1247 cbd = &clip_star;
1248
1249 text = (char_u *)gtk_selection_data_get_data(data);
1250 len = gtk_selection_data_get_length(data);
1251
1252 if (text == NULL || len <= 0)
1253 {
1254 received_selection = RS_FAIL;
1255 // clip_free_selection(cbd); ???
1256
1257 return;
1258 }
1259
1260 if (gtk_selection_data_get_data_type(data) == vim_atom)
1261 {
1262 motion_type = *text++;
1263 --len;
1264 }
1265 else if (gtk_selection_data_get_data_type(data) == vimenc_atom)
1266 {
1267 char_u *enc;
1268 vimconv_T conv;
1269
1270 motion_type = *text++;
1271 --len;
1272
1273 enc = text;
1274 text += STRLEN(text) + 1;
1275 len -= text - enc;
1276
1277 // If the encoding of the text is different from 'encoding', attempt
1278 // converting it.
1279 conv.vc_type = CONV_NONE;
1280 convert_setup(&conv, enc, p_enc);
1281 if (conv.vc_type != CONV_NONE)
1282 {
1283 tmpbuf = string_convert(&conv, text, &len);
1284 if (tmpbuf != NULL)
1285 text = tmpbuf;
1286 convert_setup(&conv, NULL, NULL);
1287 }
1288 }
1289
1290 // gtk_selection_data_get_text() handles all the nasty details
1291 // and targets and encodings etc. This rocks so hard.
1292 else
1293 {
1294 tmpbuf_utf8 = gtk_selection_data_get_text(data);
1295 if (tmpbuf_utf8 != NULL)
1296 {
1297 len = STRLEN(tmpbuf_utf8);
1298 if (input_conv.vc_type != CONV_NONE)
1299 {
1300 tmpbuf = string_convert(&input_conv, tmpbuf_utf8, &len);
1301 if (tmpbuf != NULL)
1302 text = tmpbuf;
1303 }
1304 else
1305 text = tmpbuf_utf8;
1306 }
1307 else if (len >= 2 && text[0] == 0xff && text[1] == 0xfe)
1308 {
1309 vimconv_T conv;
1310
1311 // UTF-16, we get this for HTML
1312 conv.vc_type = CONV_NONE;
1313 convert_setup_ext(&conv, (char_u *)"utf-16le", FALSE, p_enc, TRUE);
1314
1315 if (conv.vc_type != CONV_NONE)
1316 {
1317 text += 2;
1318 len -= 2;
1319 tmpbuf = string_convert(&conv, text, &len);
1320 convert_setup(&conv, NULL, NULL);
1321 }
1322 if (tmpbuf != NULL)
1323 text = tmpbuf;
1324 }
1325 }
1326
1327 // Chop off any trailing NUL bytes. OpenOffice sends these.
1328 while (len > 0 && text[len - 1] == NUL)
1329 --len;
1330
1331 clip_yank_selection(motion_type, text, (long)len, cbd);
1332 received_selection = RS_OK;
1333 vim_free(tmpbuf);
1334 g_free(tmpbuf_utf8);
1335 }
1336
1337 /*
1338 * Prepare our selection data for passing it to the external selection
1339 * client.
1340 */
1341 static void
selection_get_cb(GtkWidget * widget UNUSED,GtkSelectionData * selection_data,guint info,guint time_ UNUSED,gpointer user_data UNUSED)1342 selection_get_cb(GtkWidget *widget UNUSED,
1343 GtkSelectionData *selection_data,
1344 guint info,
1345 guint time_ UNUSED,
1346 gpointer user_data UNUSED)
1347 {
1348 char_u *string;
1349 char_u *tmpbuf;
1350 long_u tmplen;
1351 int length;
1352 int motion_type;
1353 GdkAtom type;
1354 Clipboard_T *cbd;
1355
1356 if (gtk_selection_data_get_selection(selection_data)
1357 == clip_plus.gtk_sel_atom)
1358 cbd = &clip_plus;
1359 else
1360 cbd = &clip_star;
1361
1362 if (!cbd->owned)
1363 return; // Shouldn't ever happen
1364
1365 if (info != (guint)TARGET_STRING
1366 && (!clip_html || info != (guint)TARGET_HTML)
1367 && info != (guint)TARGET_UTF8_STRING
1368 && info != (guint)TARGET_VIMENC
1369 && info != (guint)TARGET_VIM
1370 && info != (guint)TARGET_COMPOUND_TEXT
1371 && info != (guint)TARGET_TEXT)
1372 return;
1373
1374 // get the selection from the '*'/'+' register
1375 clip_get_selection(cbd);
1376
1377 motion_type = clip_convert_selection(&string, &tmplen, cbd);
1378 if (motion_type < 0 || string == NULL)
1379 return;
1380 // Due to int arguments we can't handle more than G_MAXINT. Also
1381 // reserve one extra byte for NUL or the motion type; just in case.
1382 // (Not that pasting 2G of text is ever going to work, but... ;-)
1383 length = MIN(tmplen, (long_u)(G_MAXINT - 1));
1384
1385 if (info == (guint)TARGET_VIM)
1386 {
1387 tmpbuf = alloc(length + 1);
1388 if (tmpbuf != NULL)
1389 {
1390 tmpbuf[0] = motion_type;
1391 mch_memmove(tmpbuf + 1, string, (size_t)length);
1392 }
1393 // For our own format, the first byte contains the motion type
1394 ++length;
1395 vim_free(string);
1396 string = tmpbuf;
1397 type = vim_atom;
1398 }
1399
1400 else if (info == (guint)TARGET_HTML)
1401 {
1402 vimconv_T conv;
1403
1404 // Since we get utf-16, we probably should set it as well.
1405 conv.vc_type = CONV_NONE;
1406 convert_setup_ext(&conv, p_enc, TRUE, (char_u *)"utf-16le", FALSE);
1407 if (conv.vc_type != CONV_NONE)
1408 {
1409 tmpbuf = string_convert(&conv, string, &length);
1410 convert_setup(&conv, NULL, NULL);
1411 vim_free(string);
1412 string = tmpbuf;
1413 }
1414
1415 // Prepend the BOM: "fffe"
1416 if (string != NULL)
1417 {
1418 tmpbuf = alloc(length + 2);
1419 if (tmpbuf != NULL)
1420 {
1421 tmpbuf[0] = 0xff;
1422 tmpbuf[1] = 0xfe;
1423 mch_memmove(tmpbuf + 2, string, (size_t)length);
1424 vim_free(string);
1425 string = tmpbuf;
1426 length += 2;
1427 }
1428
1429 #if !GTK_CHECK_VERSION(3,0,0)
1430 // Looks redundant even for GTK2 because these values are
1431 // overwritten by gtk_selection_data_set() that follows.
1432 selection_data->type = selection_data->target;
1433 selection_data->format = 16; // 16 bits per char
1434 #endif
1435 gtk_selection_data_set(selection_data, html_atom, 16,
1436 string, length);
1437 vim_free(string);
1438 }
1439 return;
1440 }
1441 else if (info == (guint)TARGET_VIMENC)
1442 {
1443 int l = STRLEN(p_enc);
1444
1445 // contents: motion_type 'encoding' NUL text
1446 tmpbuf = alloc(length + l + 2);
1447 if (tmpbuf != NULL)
1448 {
1449 tmpbuf[0] = motion_type;
1450 STRCPY(tmpbuf + 1, p_enc);
1451 mch_memmove(tmpbuf + l + 2, string, (size_t)length);
1452 length += l + 2;
1453 vim_free(string);
1454 string = tmpbuf;
1455 }
1456 type = vimenc_atom;
1457 }
1458
1459 // gtk_selection_data_set_text() handles everything for us. This is
1460 // so easy and simple and cool, it'd be insane not to use it.
1461 else
1462 {
1463 if (output_conv.vc_type != CONV_NONE)
1464 {
1465 tmpbuf = string_convert(&output_conv, string, &length);
1466 vim_free(string);
1467 if (tmpbuf == NULL)
1468 return;
1469 string = tmpbuf;
1470 }
1471 // Validate the string to avoid runtime warnings
1472 if (g_utf8_validate((const char *)string, (gssize)length, NULL))
1473 {
1474 gtk_selection_data_set_text(selection_data,
1475 (const char *)string, length);
1476 }
1477 vim_free(string);
1478 return;
1479 }
1480
1481 if (string != NULL)
1482 {
1483 #if !GTK_CHECK_VERSION(3,0,0)
1484 // Looks redundant even for GTK2 because these values are
1485 // overwritten by gtk_selection_data_set() that follows.
1486 selection_data->type = selection_data->target;
1487 selection_data->format = 8; // 8 bits per char
1488 #endif
1489 gtk_selection_data_set(selection_data, type, 8, string, length);
1490 vim_free(string);
1491 }
1492 }
1493
1494 /*
1495 * Check if the GUI can be started. Called before gvimrc is sourced and
1496 * before fork().
1497 * Return OK or FAIL.
1498 */
1499 int
gui_mch_early_init_check(int give_message)1500 gui_mch_early_init_check(int give_message)
1501 {
1502 char_u *p;
1503
1504 // Guess that when $DISPLAY isn't set the GUI can't start.
1505 p = mch_getenv((char_u *)"DISPLAY");
1506 if (p == NULL || *p == NUL)
1507 {
1508 gui.dying = TRUE;
1509 if (give_message)
1510 emsg(_((char *)e_opendisp));
1511 return FAIL;
1512 }
1513 return OK;
1514 }
1515
1516 /*
1517 * Check if the GUI can be started. Called before gvimrc is sourced but after
1518 * fork().
1519 * Return OK or FAIL.
1520 */
1521 int
gui_mch_init_check(void)1522 gui_mch_init_check(void)
1523 {
1524 #ifdef USE_GRESOURCE
1525 static int res_registered = FALSE;
1526
1527 if (!res_registered)
1528 {
1529 // Call this function in the GUI process; otherwise, the resources
1530 // won't be available. Don't call it twice.
1531 res_registered = TRUE;
1532 gui_gtk_register_resource();
1533 }
1534 #endif
1535
1536 #if GTK_CHECK_VERSION(3,10,0)
1537 // Vim currently assumes that Gtk means X11, so it cannot use native Gtk
1538 // support for other backends such as Wayland.
1539 gdk_set_allowed_backends ("x11");
1540 #endif
1541
1542 #ifdef FEAT_GUI_GNOME
1543 if (gtk_socket_id == 0)
1544 using_gnome = 1;
1545 #endif
1546
1547 // This defaults to argv[0], but we want it to match the name of the
1548 // shipped gvim.desktop so that Vim's windows can be associated with this
1549 // file.
1550 g_set_prgname("gvim");
1551
1552 // Don't use gtk_init() or gnome_init(), it exits on failure.
1553 if (!gtk_init_check(&gui_argc, &gui_argv))
1554 {
1555 gui.dying = TRUE;
1556 emsg(_((char *)e_opendisp));
1557 return FAIL;
1558 }
1559
1560 return OK;
1561 }
1562
1563 /////////////////////////////////////////////////////////////////////////////
1564 // Mouse handling callbacks
1565
1566
1567 static guint mouse_click_timer = 0;
1568 static int mouse_timed_out = TRUE;
1569
1570 /*
1571 * Timer used to recognize multiple clicks of the mouse button
1572 */
1573 static timeout_cb_type
mouse_click_timer_cb(gpointer data)1574 mouse_click_timer_cb(gpointer data)
1575 {
1576 // we don't use this information currently
1577 int *timed_out = (int *) data;
1578
1579 *timed_out = TRUE;
1580 return FALSE; // don't happen again
1581 }
1582
1583 static guint motion_repeat_timer = 0;
1584 static int motion_repeat_offset = FALSE;
1585 static timeout_cb_type motion_repeat_timer_cb(gpointer);
1586
1587 static void
process_motion_notify(int x,int y,GdkModifierType state)1588 process_motion_notify(int x, int y, GdkModifierType state)
1589 {
1590 int button;
1591 int_u vim_modifiers;
1592 GtkAllocation allocation;
1593
1594 // Need to add GDK_BUTTON1_MASK state when dragging a touch.
1595 state |= dragging_button_state;
1596
1597 button = (state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK |
1598 GDK_BUTTON3_MASK | GDK_BUTTON4_MASK |
1599 GDK_BUTTON5_MASK))
1600 ? MOUSE_DRAG : ' ';
1601
1602 // If our pointer is currently hidden, then we should show it.
1603 gui_mch_mousehide(FALSE);
1604
1605 // Just moving the rodent above the drawing area without any button
1606 // being pressed.
1607 if (button != MOUSE_DRAG)
1608 {
1609 gui_mouse_moved(x, y);
1610 return;
1611 }
1612
1613 // translate modifier coding between the main engine and GTK
1614 vim_modifiers = modifiers_gdk2mouse(state);
1615
1616 // inform the editor engine about the occurrence of this event
1617 gui_send_mouse_event(button, x, y, FALSE, vim_modifiers);
1618
1619 /*
1620 * Auto repeat timer handling.
1621 */
1622 gtk_widget_get_allocation(gui.drawarea, &allocation);
1623
1624 if (x < 0 || y < 0
1625 || x >= allocation.width
1626 || y >= allocation.height)
1627 {
1628
1629 int dx;
1630 int dy;
1631 int offshoot;
1632 int delay = 10;
1633
1634 // Calculate the maximal distance of the cursor from the drawing area.
1635 // (offshoot can't become negative here!).
1636 dx = x < 0 ? -x : x - allocation.width;
1637 dy = y < 0 ? -y : y - allocation.height;
1638
1639 offshoot = dx > dy ? dx : dy;
1640
1641 // Make a linearly decaying timer delay with a threshold of 5 at a
1642 // distance of 127 pixels from the main window.
1643 //
1644 // One could think endlessly about the most ergonomic variant here.
1645 // For example it could make sense to calculate the distance from the
1646 // drags start instead...
1647 //
1648 // Maybe a parabolic interpolation would suite us better here too...
1649 if (offshoot > 127)
1650 {
1651 // 5 appears to be somehow near to my perceptual limits :-).
1652 delay = 5;
1653 }
1654 else
1655 {
1656 delay = (130 * (127 - offshoot)) / 127 + 5;
1657 }
1658
1659 // shoot again
1660 if (!motion_repeat_timer)
1661 motion_repeat_timer = timeout_add(delay, motion_repeat_timer_cb,
1662 NULL);
1663 }
1664 }
1665
1666 #if GTK_CHECK_VERSION(3,0,0)
1667 static GdkDevice *
gui_gtk_get_pointer_device(GtkWidget * widget)1668 gui_gtk_get_pointer_device(GtkWidget *widget)
1669 {
1670 GdkWindow * const win = gtk_widget_get_window(widget);
1671 GdkDisplay * const dpy = gdk_window_get_display(win);
1672 # if GTK_CHECK_VERSION(3,20,0)
1673 GdkSeat * const seat = gdk_display_get_default_seat(dpy);
1674 return gdk_seat_get_pointer(seat);
1675 # else
1676 GdkDeviceManager * const mngr = gdk_display_get_device_manager(dpy);
1677 return gdk_device_manager_get_client_pointer(mngr);
1678 # endif
1679 }
1680
1681 static GdkWindow *
gui_gtk_get_pointer(GtkWidget * widget,gint * x,gint * y,GdkModifierType * state)1682 gui_gtk_get_pointer(GtkWidget *widget,
1683 gint *x,
1684 gint *y,
1685 GdkModifierType *state)
1686 {
1687 GdkWindow * const win = gtk_widget_get_window(widget);
1688 GdkDevice * const dev = gui_gtk_get_pointer_device(widget);
1689 return gdk_window_get_device_position(win, dev , x, y, state);
1690 }
1691
1692 # if defined(FEAT_GUI_TABLINE) || defined(PROTO)
1693 static GdkWindow *
gui_gtk_window_at_position(GtkWidget * widget,gint * x,gint * y)1694 gui_gtk_window_at_position(GtkWidget *widget,
1695 gint *x,
1696 gint *y)
1697 {
1698 GdkDevice * const dev = gui_gtk_get_pointer_device(widget);
1699 return gdk_device_get_window_at_position(dev, x, y);
1700 }
1701 # endif
1702 #else // !GTK_CHECK_VERSION(3,0,0)
1703 # define gui_gtk_get_pointer(wid, x, y, s) \
1704 gdk_window_get_pointer((wid)->window, x, y, s)
1705 # define gui_gtk_window_at_position(wid, x, y) gdk_window_at_pointer(x, y)
1706 #endif
1707
1708 /*
1709 * Timer used to recognize multiple clicks of the mouse button.
1710 */
1711 static timeout_cb_type
motion_repeat_timer_cb(gpointer data UNUSED)1712 motion_repeat_timer_cb(gpointer data UNUSED)
1713 {
1714 int x;
1715 int y;
1716 GdkModifierType state;
1717
1718 gui_gtk_get_pointer(gui.drawarea, &x, &y, &state);
1719
1720 if (!(state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK |
1721 GDK_BUTTON3_MASK | GDK_BUTTON4_MASK |
1722 GDK_BUTTON5_MASK)))
1723 {
1724 motion_repeat_timer = 0;
1725 return FALSE;
1726 }
1727
1728 // If there already is a mouse click in the input buffer, wait another
1729 // time (otherwise we would create a backlog of clicks)
1730 if (vim_used_in_input_buf() > 10)
1731 return TRUE;
1732
1733 motion_repeat_timer = 0;
1734
1735 /*
1736 * Fake a motion event.
1737 * Trick: Pretend the mouse moved to the next character on every other
1738 * event, otherwise drag events will be discarded, because they are still
1739 * in the same character.
1740 */
1741 if (motion_repeat_offset)
1742 x += gui.char_width;
1743
1744 motion_repeat_offset = !motion_repeat_offset;
1745 process_motion_notify(x, y, state);
1746
1747 // Don't happen again. We will get reinstalled in the synthetic event
1748 // if needed -- thus repeating should still work.
1749 return FALSE;
1750 }
1751
1752 static gint
motion_notify_event(GtkWidget * widget,GdkEventMotion * event,gpointer data UNUSED)1753 motion_notify_event(GtkWidget *widget,
1754 GdkEventMotion *event,
1755 gpointer data UNUSED)
1756 {
1757 if (event->is_hint)
1758 {
1759 int x;
1760 int y;
1761 GdkModifierType state;
1762
1763 gui_gtk_get_pointer(widget, &x, &y, &state);
1764 process_motion_notify(x, y, state);
1765 }
1766 else
1767 {
1768 process_motion_notify((int)event->x, (int)event->y,
1769 (GdkModifierType)event->state);
1770 }
1771
1772 return TRUE; // handled
1773 }
1774
1775
1776 /*
1777 * Mouse button handling. Note please that we are capturing multiple click's
1778 * by our own timeout mechanism instead of the one provided by GTK+ itself.
1779 * This is due to the way the generic VIM code is recognizing multiple clicks.
1780 */
1781 static gint
button_press_event(GtkWidget * widget,GdkEventButton * event,gpointer data UNUSED)1782 button_press_event(GtkWidget *widget,
1783 GdkEventButton *event,
1784 gpointer data UNUSED)
1785 {
1786 int button;
1787 int repeated_click = FALSE;
1788 int x, y;
1789 int_u vim_modifiers;
1790
1791 gui.event_time = event->time;
1792
1793 // Make sure we have focus now we've been selected
1794 if (gtk_socket_id != 0 && !gtk_widget_has_focus(widget))
1795 gtk_widget_grab_focus(widget);
1796
1797 /*
1798 * Don't let additional events about multiple clicks send by GTK to us
1799 * after the initial button press event confuse us.
1800 */
1801 if (event->type != GDK_BUTTON_PRESS)
1802 return FALSE;
1803
1804 x = event->x;
1805 y = event->y;
1806
1807 // Handle multiple clicks
1808 if (!mouse_timed_out && mouse_click_timer)
1809 {
1810 timeout_remove(mouse_click_timer);
1811 mouse_click_timer = 0;
1812 repeated_click = TRUE;
1813 }
1814
1815 mouse_timed_out = FALSE;
1816 mouse_click_timer = timeout_add(p_mouset, mouse_click_timer_cb,
1817 &mouse_timed_out);
1818
1819 switch (event->button)
1820 {
1821 // Keep in sync with gui_x11.c.
1822 // Buttons 4-7 are handled in scroll_event()
1823 case 1:
1824 button = MOUSE_LEFT;
1825 // needed for touch-drag
1826 dragging_button_state |= GDK_BUTTON1_MASK;
1827 break;
1828 case 2: button = MOUSE_MIDDLE; break;
1829 case 3: button = MOUSE_RIGHT; break;
1830 case 8: button = MOUSE_X1; break;
1831 case 9: button = MOUSE_X2; break;
1832 default:
1833 return FALSE; // Unknown button
1834 }
1835
1836 #ifdef FEAT_XIM
1837 // cancel any preediting
1838 if (im_is_preediting())
1839 xim_reset();
1840 #endif
1841
1842 vim_modifiers = modifiers_gdk2mouse(event->state);
1843
1844 gui_send_mouse_event(button, x, y, repeated_click, vim_modifiers);
1845
1846 return TRUE;
1847 }
1848
1849 /*
1850 * GTK+ 2 abstracts scrolling via the GdkEventScroll.
1851 */
1852 static gboolean
scroll_event(GtkWidget * widget,GdkEventScroll * event,gpointer data UNUSED)1853 scroll_event(GtkWidget *widget,
1854 GdkEventScroll *event,
1855 gpointer data UNUSED)
1856 {
1857 int button;
1858 int_u vim_modifiers;
1859
1860 if (gtk_socket_id != 0 && !gtk_widget_has_focus(widget))
1861 gtk_widget_grab_focus(widget);
1862
1863 switch (event->direction)
1864 {
1865 case GDK_SCROLL_UP:
1866 button = MOUSE_4;
1867 break;
1868 case GDK_SCROLL_DOWN:
1869 button = MOUSE_5;
1870 break;
1871 case GDK_SCROLL_LEFT:
1872 button = MOUSE_7;
1873 break;
1874 case GDK_SCROLL_RIGHT:
1875 button = MOUSE_6;
1876 break;
1877 default: // This shouldn't happen
1878 return FALSE;
1879 }
1880
1881 # ifdef FEAT_XIM
1882 // cancel any preediting
1883 if (im_is_preediting())
1884 xim_reset();
1885 # endif
1886
1887 vim_modifiers = modifiers_gdk2mouse(event->state);
1888
1889 gui_send_mouse_event(button, (int)event->x, (int)event->y,
1890 FALSE, vim_modifiers);
1891
1892 return TRUE;
1893 }
1894
1895
1896 static gint
button_release_event(GtkWidget * widget UNUSED,GdkEventButton * event,gpointer data UNUSED)1897 button_release_event(GtkWidget *widget UNUSED,
1898 GdkEventButton *event,
1899 gpointer data UNUSED)
1900 {
1901 int x, y;
1902 int_u vim_modifiers;
1903
1904 gui.event_time = event->time;
1905
1906 // Remove any motion "machine gun" timers used for automatic further
1907 // extension of allocation areas if outside of the applications window
1908 // area .
1909 if (motion_repeat_timer)
1910 {
1911 timeout_remove(motion_repeat_timer);
1912 motion_repeat_timer = 0;
1913 }
1914
1915 x = event->x;
1916 y = event->y;
1917
1918 vim_modifiers = modifiers_gdk2mouse(event->state);
1919
1920 gui_send_mouse_event(MOUSE_RELEASE, x, y, FALSE, vim_modifiers);
1921
1922 switch (event->button)
1923 {
1924 case 1: // MOUSE_LEFT
1925 dragging_button_state = 0;
1926 break;
1927 }
1928
1929 return TRUE;
1930 }
1931
1932
1933 #ifdef FEAT_DND
1934 /////////////////////////////////////////////////////////////////////////////
1935 // Drag aNd Drop support handlers.
1936
1937 /*
1938 * Count how many items there may be and separate them with a NUL.
1939 * Apparently the items are separated with \r\n. This is not documented,
1940 * thus be careful not to go past the end. Also allow separation with
1941 * NUL characters.
1942 */
1943 static int
count_and_decode_uri_list(char_u * out,char_u * raw,int len)1944 count_and_decode_uri_list(char_u *out, char_u *raw, int len)
1945 {
1946 int i;
1947 char_u *p = out;
1948 int count = 0;
1949
1950 for (i = 0; i < len; ++i)
1951 {
1952 if (raw[i] == NUL || raw[i] == '\n' || raw[i] == '\r')
1953 {
1954 if (p > out && p[-1] != NUL)
1955 {
1956 ++count;
1957 *p++ = NUL;
1958 }
1959 }
1960 else if (raw[i] == '%' && i + 2 < len && hexhex2nr(raw + i + 1) > 0)
1961 {
1962 *p++ = hexhex2nr(raw + i + 1);
1963 i += 2;
1964 }
1965 else
1966 *p++ = raw[i];
1967 }
1968 if (p > out && p[-1] != NUL)
1969 {
1970 *p = NUL; // last item didn't have \r or \n
1971 ++count;
1972 }
1973 return count;
1974 }
1975
1976 /*
1977 * Parse NUL separated "src" strings. Make it an array "outlist" form. On
1978 * this process, URI which protocol is not "file:" are removed. Return
1979 * length of array (less than "max").
1980 */
1981 static int
filter_uri_list(char_u ** outlist,int max,char_u * src)1982 filter_uri_list(char_u **outlist, int max, char_u *src)
1983 {
1984 int i, j;
1985
1986 for (i = j = 0; i < max; ++i)
1987 {
1988 outlist[i] = NULL;
1989 if (STRNCMP(src, "file:", 5) == 0)
1990 {
1991 src += 5;
1992 if (STRNCMP(src, "//localhost", 11) == 0)
1993 src += 11;
1994 while (src[0] == '/' && src[1] == '/')
1995 ++src;
1996 outlist[j++] = vim_strsave(src);
1997 }
1998 src += STRLEN(src) + 1;
1999 }
2000 return j;
2001 }
2002
2003 static char_u **
parse_uri_list(int * count,char_u * data,int len)2004 parse_uri_list(int *count, char_u *data, int len)
2005 {
2006 int n = 0;
2007 char_u *tmp = NULL;
2008 char_u **array = NULL;
2009
2010 if (data != NULL && len > 0 && (tmp = alloc(len + 1)) != NULL)
2011 {
2012 n = count_and_decode_uri_list(tmp, data, len);
2013 if (n > 0 && (array = ALLOC_MULT(char_u *, n)) != NULL)
2014 n = filter_uri_list(array, n, tmp);
2015 }
2016 vim_free(tmp);
2017 *count = n;
2018 return array;
2019 }
2020
2021 static void
drag_handle_uri_list(GdkDragContext * context,GtkSelectionData * data,guint time_,GdkModifierType state,gint x,gint y)2022 drag_handle_uri_list(GdkDragContext *context,
2023 GtkSelectionData *data,
2024 guint time_,
2025 GdkModifierType state,
2026 gint x,
2027 gint y)
2028 {
2029 char_u **fnames;
2030 int nfiles = 0;
2031
2032 fnames = parse_uri_list(&nfiles,
2033 (char_u *)gtk_selection_data_get_data(data),
2034 gtk_selection_data_get_length(data));
2035
2036 if (fnames != NULL && nfiles > 0)
2037 {
2038 int_u modifiers;
2039
2040 gtk_drag_finish(context, TRUE, FALSE, time_); // accept
2041
2042 modifiers = modifiers_gdk2mouse(state);
2043
2044 gui_handle_drop(x, y, modifiers, fnames, nfiles);
2045 }
2046 else
2047 vim_free(fnames);
2048 }
2049
2050 static void
drag_handle_text(GdkDragContext * context,GtkSelectionData * data,guint time_,GdkModifierType state)2051 drag_handle_text(GdkDragContext *context,
2052 GtkSelectionData *data,
2053 guint time_,
2054 GdkModifierType state)
2055 {
2056 char_u dropkey[6] = {CSI, KS_MODIFIER, 0, CSI, KS_EXTRA, (char_u)KE_DROP};
2057 char_u *text;
2058 int len;
2059 char_u *tmpbuf = NULL;
2060
2061 text = (char_u *)gtk_selection_data_get_data(data);
2062 len = gtk_selection_data_get_length(data);
2063
2064 if (gtk_selection_data_get_data_type(data) == utf8_string_atom)
2065 {
2066 if (input_conv.vc_type != CONV_NONE)
2067 tmpbuf = string_convert(&input_conv, text, &len);
2068 if (tmpbuf != NULL)
2069 text = tmpbuf;
2070 }
2071
2072 dnd_yank_drag_data(text, (long)len);
2073 gtk_drag_finish(context, TRUE, FALSE, time_); // accept
2074 vim_free(tmpbuf);
2075
2076 dropkey[2] = modifiers_gdk2vim(state);
2077
2078 if (dropkey[2] != 0)
2079 add_to_input_buf(dropkey, (int)sizeof(dropkey));
2080 else
2081 add_to_input_buf(dropkey + 3, (int)(sizeof(dropkey) - 3));
2082 }
2083
2084 /*
2085 * DND receiver.
2086 */
2087 static void
drag_data_received_cb(GtkWidget * widget,GdkDragContext * context,gint x,gint y,GtkSelectionData * data,guint info,guint time_,gpointer user_data UNUSED)2088 drag_data_received_cb(GtkWidget *widget,
2089 GdkDragContext *context,
2090 gint x,
2091 gint y,
2092 GtkSelectionData *data,
2093 guint info,
2094 guint time_,
2095 gpointer user_data UNUSED)
2096 {
2097 GdkModifierType state;
2098
2099 // Guard against trash
2100 const guchar * const data_data = gtk_selection_data_get_data(data);
2101 const gint data_length = gtk_selection_data_get_length(data);
2102 const gint data_format = gtk_selection_data_get_format(data);
2103
2104 if (data_data == NULL
2105 || data_length <= 0
2106 || data_format != 8
2107 || data_data[data_length] != '\0')
2108 {
2109 gtk_drag_finish(context, FALSE, FALSE, time_);
2110 return;
2111 }
2112
2113 // Get the current modifier state for proper distinguishment between
2114 // different operations later.
2115 gui_gtk_get_pointer(widget, NULL, NULL, &state);
2116
2117 // Not sure about the role of "text/plain" here...
2118 if (info == (guint)TARGET_TEXT_URI_LIST)
2119 drag_handle_uri_list(context, data, time_, state, x, y);
2120 else
2121 drag_handle_text(context, data, time_, state);
2122
2123 }
2124 #endif // FEAT_DND
2125
2126
2127 #if defined(USE_GNOME_SESSION)
2128 /*
2129 * GnomeClient interact callback. Check for unsaved buffers that cannot
2130 * be abandoned and pop up a dialog asking the user for confirmation if
2131 * necessary.
2132 */
2133 static void
sm_client_check_changed_any(GnomeClient * client UNUSED,gint key,GnomeDialogType type UNUSED,gpointer data UNUSED)2134 sm_client_check_changed_any(GnomeClient *client UNUSED,
2135 gint key,
2136 GnomeDialogType type UNUSED,
2137 gpointer data UNUSED)
2138 {
2139 cmdmod_T save_cmdmod;
2140 gboolean shutdown_cancelled;
2141
2142 save_cmdmod = cmdmod;
2143
2144 # ifdef FEAT_BROWSE
2145 cmdmod.cmod_flags |= CMOD_BROWSE;
2146 # endif
2147 # if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
2148 cmdmod.cmod_flags |= CMOD_CONFIRM;
2149 # endif
2150 /*
2151 * If there are changed buffers, present the user with
2152 * a dialog if possible, otherwise give an error message.
2153 */
2154 shutdown_cancelled = check_changed_any(FALSE, FALSE);
2155
2156 exiting = FALSE;
2157 cmdmod = save_cmdmod;
2158 setcursor(); // position the cursor
2159 out_flush();
2160 /*
2161 * If the user hit the [Cancel] button the whole shutdown
2162 * will be cancelled. Wow, quite powerful feature (:
2163 */
2164 gnome_interaction_key_return(key, shutdown_cancelled);
2165 }
2166
2167 /*
2168 * "save_yourself" signal handler. Initiate an interaction to ask the user
2169 * for confirmation if necessary. Save the current editing session and tell
2170 * the session manager how to restart Vim.
2171 */
2172 static gboolean
sm_client_save_yourself(GnomeClient * client,gint phase UNUSED,GnomeSaveStyle save_style UNUSED,gboolean shutdown UNUSED,GnomeInteractStyle interact_style,gboolean fast UNUSED,gpointer data UNUSED)2173 sm_client_save_yourself(GnomeClient *client,
2174 gint phase UNUSED,
2175 GnomeSaveStyle save_style UNUSED,
2176 gboolean shutdown UNUSED,
2177 GnomeInteractStyle interact_style,
2178 gboolean fast UNUSED,
2179 gpointer data UNUSED)
2180 {
2181 static const char suffix[] = "-session.vim";
2182 char *session_file;
2183 unsigned int len;
2184 gboolean success;
2185
2186 // Always request an interaction if possible. check_changed_any()
2187 // won't actually show a dialog unless any buffers have been modified.
2188 // There doesn't seem to be an obvious way to check that without
2189 // automatically firing the dialog. Anyway, it works just fine.
2190 if (interact_style == GNOME_INTERACT_ANY)
2191 gnome_client_request_interaction(client, GNOME_DIALOG_NORMAL,
2192 &sm_client_check_changed_any,
2193 NULL);
2194 out_flush();
2195 ml_sync_all(FALSE, FALSE); // preserve all swap files
2196
2197 // The path is unique for each session save. We do neither know nor care
2198 // which session script will actually be used later. This decision is in
2199 // the domain of the session manager.
2200 session_file = gnome_config_get_real_path(
2201 gnome_client_get_config_prefix(client));
2202 len = strlen(session_file);
2203
2204 if (len > 0 && session_file[len-1] == G_DIR_SEPARATOR)
2205 --len; // get rid of the superfluous trailing '/'
2206
2207 session_file = g_renew(char, session_file, len + sizeof(suffix));
2208 memcpy(session_file + len, suffix, sizeof(suffix));
2209
2210 success = write_session_file((char_u *)session_file);
2211
2212 if (success)
2213 {
2214 const char *argv[8];
2215 int i;
2216
2217 // Tell the session manager how to wipe out the stored session data.
2218 // This isn't as dangerous as it looks, don't worry :) session_file
2219 // is a unique absolute filename. Usually it'll be something like
2220 // `/home/user/.gnome2/vim-XXXXXX-session.vim'.
2221 i = 0;
2222 argv[i++] = "rm";
2223 argv[i++] = session_file;
2224 argv[i] = NULL;
2225
2226 gnome_client_set_discard_command(client, i, (char **)argv);
2227
2228 // Tell the session manager how to restore the just saved session.
2229 // This is easily done thanks to Vim's -S option. Pass the -f flag
2230 // since there's no need to fork -- it might even cause confusion.
2231 // Also pass the window role to give the WM something to match on.
2232 // The role is set in gui_mch_open(), thus should _never_ be NULL.
2233 i = 0;
2234 argv[i++] = restart_command;
2235 argv[i++] = "-f";
2236 argv[i++] = "-g";
2237 argv[i++] = "--role";
2238 argv[i++] = gtk_window_get_role(GTK_WINDOW(gui.mainwin));
2239 argv[i++] = "-S";
2240 argv[i++] = session_file;
2241 argv[i] = NULL;
2242
2243 gnome_client_set_restart_command(client, i, (char **)argv);
2244 gnome_client_set_clone_command(client, 0, NULL);
2245 }
2246
2247 g_free(session_file);
2248
2249 return success;
2250 }
2251
2252 /*
2253 * Called when the session manager wants us to die. There isn't much to save
2254 * here since "save_yourself" has been emitted before (unless serious trouble
2255 * is happening).
2256 */
2257 static void
sm_client_die(GnomeClient * client UNUSED,gpointer data UNUSED)2258 sm_client_die(GnomeClient *client UNUSED, gpointer data UNUSED)
2259 {
2260 // Don't write messages to the GUI anymore
2261 full_screen = FALSE;
2262
2263 vim_strncpy(IObuff, (char_u *)
2264 _("Vim: Received \"die\" request from session manager\n"),
2265 IOSIZE - 1);
2266 preserve_exit();
2267 }
2268
2269 /*
2270 * Connect our signal handlers to be notified on session save and shutdown.
2271 */
2272 static void
setup_save_yourself(void)2273 setup_save_yourself(void)
2274 {
2275 GnomeClient *client;
2276
2277 client = gnome_master_client();
2278
2279 if (client != NULL)
2280 {
2281 // Must use the deprecated gtk_signal_connect() for compatibility
2282 // with GNOME 1. Arrgh, zombies!
2283 gtk_signal_connect(GTK_OBJECT(client), "save_yourself",
2284 GTK_SIGNAL_FUNC(&sm_client_save_yourself), NULL);
2285 gtk_signal_connect(GTK_OBJECT(client), "die",
2286 GTK_SIGNAL_FUNC(&sm_client_die), NULL);
2287 }
2288 }
2289
2290 #else // !USE_GNOME_SESSION
2291
2292 # ifdef USE_XSMP
2293 /*
2294 * GTK tells us that XSMP needs attention
2295 */
2296 static gboolean
local_xsmp_handle_requests(GIOChannel * source UNUSED,GIOCondition condition,gpointer data)2297 local_xsmp_handle_requests(
2298 GIOChannel *source UNUSED,
2299 GIOCondition condition,
2300 gpointer data)
2301 {
2302 if (condition == G_IO_IN)
2303 {
2304 // Do stuff; maybe close connection
2305 if (xsmp_handle_requests() == FAIL)
2306 g_io_channel_unref((GIOChannel *)data);
2307 return TRUE;
2308 }
2309 // Error
2310 g_io_channel_unref((GIOChannel *)data);
2311 xsmp_close();
2312 return TRUE;
2313 }
2314 # endif // USE_XSMP
2315
2316 /*
2317 * Setup the WM_PROTOCOLS to indicate we want the WM_SAVE_YOURSELF event.
2318 * This is an ugly use of X functions. GTK doesn't offer an alternative.
2319 */
2320 static void
setup_save_yourself(void)2321 setup_save_yourself(void)
2322 {
2323 Atom *existing_atoms = NULL;
2324 int count = 0;
2325
2326 # ifdef USE_XSMP
2327 if (xsmp_icefd != -1)
2328 {
2329 /*
2330 * Use XSMP is preference to legacy WM_SAVE_YOURSELF;
2331 * set up GTK IO monitor
2332 */
2333 GIOChannel *g_io = g_io_channel_unix_new(xsmp_icefd);
2334
2335 g_io_add_watch(g_io, G_IO_IN | G_IO_ERR | G_IO_HUP,
2336 local_xsmp_handle_requests, (gpointer)g_io);
2337 g_io_channel_unref(g_io);
2338 }
2339 else
2340 # endif
2341 {
2342 // Fall back to old method
2343
2344 // first get the existing value
2345 GdkWindow * const mainwin_win = gtk_widget_get_window(gui.mainwin);
2346
2347 if (XGetWMProtocols(GDK_WINDOW_XDISPLAY(mainwin_win),
2348 GDK_WINDOW_XID(mainwin_win),
2349 &existing_atoms, &count))
2350 {
2351 Atom *new_atoms;
2352 Atom save_yourself_xatom;
2353 int i;
2354
2355 save_yourself_xatom = GET_X_ATOM(save_yourself_atom);
2356
2357 // check if WM_SAVE_YOURSELF isn't there yet
2358 for (i = 0; i < count; ++i)
2359 if (existing_atoms[i] == save_yourself_xatom)
2360 break;
2361
2362 if (i == count)
2363 {
2364 // allocate an Atoms array which is one item longer
2365 new_atoms = ALLOC_MULT(Atom, count + 1);
2366 if (new_atoms != NULL)
2367 {
2368 memcpy(new_atoms, existing_atoms, count * sizeof(Atom));
2369 new_atoms[count] = save_yourself_xatom;
2370 XSetWMProtocols(GDK_WINDOW_XDISPLAY(mainwin_win),
2371 GDK_WINDOW_XID(mainwin_win),
2372 new_atoms, count + 1);
2373 vim_free(new_atoms);
2374 }
2375 }
2376 XFree(existing_atoms);
2377 }
2378 }
2379 }
2380
2381 /*
2382 * Installing a global event filter seems to be the only way to catch
2383 * client messages of type WM_PROTOCOLS without overriding GDK's own
2384 * client message event filter. Well, that's still better than trying
2385 * to guess what the GDK filter had done if it had been invoked instead
2386 *
2387 * GTK2_FIXME: This doesn't seem to work. For some reason we never
2388 * receive WM_SAVE_YOURSELF even though everything is set up correctly.
2389 * I have the nasty feeling modern session managers just don't send this
2390 * deprecated message anymore. Addition: confirmed by several people.
2391 *
2392 * The GNOME session support is much cooler anyway. Unlike this ugly
2393 * WM_SAVE_YOURSELF hack it actually stores the session... And yes,
2394 * it should work with KDE as well.
2395 */
2396 static GdkFilterReturn
global_event_filter(GdkXEvent * xev,GdkEvent * event UNUSED,gpointer data UNUSED)2397 global_event_filter(GdkXEvent *xev,
2398 GdkEvent *event UNUSED,
2399 gpointer data UNUSED)
2400 {
2401 XEvent *xevent = (XEvent *)xev;
2402
2403 if (xevent != NULL
2404 && xevent->type == ClientMessage
2405 && xevent->xclient.message_type == GET_X_ATOM(wm_protocols_atom)
2406 && (long_u)xevent->xclient.data.l[0]
2407 == GET_X_ATOM(save_yourself_atom))
2408 {
2409 out_flush();
2410 ml_sync_all(FALSE, FALSE); // preserve all swap files
2411 /*
2412 * Set the window's WM_COMMAND property, to let the window manager
2413 * know we are done saving ourselves. We don't want to be
2414 * restarted, thus set argv to NULL.
2415 */
2416 XSetCommand(GDK_WINDOW_XDISPLAY(gtk_widget_get_window(gui.mainwin)),
2417 GDK_WINDOW_XID(gtk_widget_get_window(gui.mainwin)),
2418 NULL, 0);
2419 return GDK_FILTER_REMOVE;
2420 }
2421
2422 return GDK_FILTER_CONTINUE;
2423 }
2424 #endif // !USE_GNOME_SESSION
2425
2426
2427 /*
2428 * Setup the window icon & xcmdsrv comm after the main window has been realized.
2429 */
2430 static void
mainwin_realize(GtkWidget * widget UNUSED,gpointer data UNUSED)2431 mainwin_realize(GtkWidget *widget UNUSED, gpointer data UNUSED)
2432 {
2433 // If you get an error message here, you still need to unpack the runtime
2434 // archive!
2435 #ifdef magick
2436 # undef magick
2437 #endif
2438 // A bit hackish, but avoids casting later and allows optimization
2439 # define static static const
2440 #define magick vim32x32
2441 #include "../runtime/vim32x32.xpm"
2442 #undef magick
2443 #define magick vim16x16
2444 #include "../runtime/vim16x16.xpm"
2445 #undef magick
2446 #define magick vim48x48
2447 #include "../runtime/vim48x48.xpm"
2448 #undef magick
2449 # undef static
2450
2451 GdkWindow * const mainwin_win = gtk_widget_get_window(gui.mainwin);
2452
2453 // When started with "--echo-wid" argument, write window ID on stdout.
2454 if (echo_wid_arg)
2455 {
2456 printf("WID: %ld\n", (long)GDK_WINDOW_XID(mainwin_win));
2457 fflush(stdout);
2458 }
2459
2460 if (vim_strchr(p_go, GO_ICON) != NULL)
2461 {
2462 /*
2463 * Add an icon to the main window. For fun and convenience of the user.
2464 */
2465 GList *icons = NULL;
2466
2467 icons = g_list_prepend(icons, gdk_pixbuf_new_from_xpm_data(vim16x16));
2468 icons = g_list_prepend(icons, gdk_pixbuf_new_from_xpm_data(vim32x32));
2469 icons = g_list_prepend(icons, gdk_pixbuf_new_from_xpm_data(vim48x48));
2470
2471 gtk_window_set_icon_list(GTK_WINDOW(gui.mainwin), icons);
2472
2473 // TODO: is this type cast OK?
2474 g_list_foreach(icons, (GFunc)(void *)&g_object_unref, NULL);
2475 g_list_free(icons);
2476 }
2477
2478 #if !defined(USE_GNOME_SESSION)
2479 // Register a handler for WM_SAVE_YOURSELF with GDK's low-level X I/F
2480 gdk_window_add_filter(NULL, &global_event_filter, NULL);
2481 #endif
2482 // Setup to indicate to the window manager that we want to catch the
2483 // WM_SAVE_YOURSELF event. For GNOME, this connects to the session
2484 // manager instead.
2485 #if defined(USE_GNOME_SESSION)
2486 if (using_gnome)
2487 #endif
2488 setup_save_yourself();
2489
2490 #ifdef FEAT_CLIENTSERVER
2491 if (serverName == NULL && serverDelayedStartName != NULL)
2492 {
2493 // This is a :gui command in a plain vim with no previous server
2494 commWindow = GDK_WINDOW_XID(mainwin_win);
2495
2496 (void)serverRegisterName(GDK_WINDOW_XDISPLAY(mainwin_win),
2497 serverDelayedStartName);
2498 }
2499 else
2500 {
2501 /*
2502 * Cannot handle "XLib-only" windows with gtk event routines, we'll
2503 * have to change the "server" registration to that of the main window
2504 * If we have not registered a name yet, remember the window.
2505 */
2506 serverChangeRegisteredWindow(GDK_WINDOW_XDISPLAY(mainwin_win),
2507 GDK_WINDOW_XID(mainwin_win));
2508 }
2509 gtk_widget_add_events(gui.mainwin, GDK_PROPERTY_CHANGE_MASK);
2510 g_signal_connect(G_OBJECT(gui.mainwin), "property-notify-event",
2511 G_CALLBACK(property_event), NULL);
2512 #endif
2513 }
2514
2515 static GdkCursor *
create_blank_pointer(void)2516 create_blank_pointer(void)
2517 {
2518 GdkWindow *root_window = NULL;
2519 #if GTK_CHECK_VERSION(3,0,0)
2520 GdkPixbuf *blank_mask;
2521 #else
2522 GdkPixmap *blank_mask;
2523 #endif
2524 GdkCursor *cursor;
2525 #if GTK_CHECK_VERSION(3,0,0)
2526 GdkRGBA color = { 0.0, 0.0, 0.0, 1.0 };
2527 #else
2528 GdkColor color = { 0, 0, 0, 0 };
2529 char blank_data[] = { 0x0 };
2530 #endif
2531
2532 #if GTK_CHECK_VERSION(3,12,0)
2533 {
2534 GdkWindow * const win = gtk_widget_get_window(gui.mainwin);
2535 GdkScreen * const scrn = gdk_window_get_screen(win);
2536 root_window = gdk_screen_get_root_window(scrn);
2537 }
2538 #else
2539 root_window = gtk_widget_get_root_window(gui.mainwin);
2540 #endif
2541
2542 // Create a pseudo blank pointer, which is in fact one pixel by one pixel
2543 // in size.
2544 #if GTK_CHECK_VERSION(3,0,0)
2545 {
2546 cairo_surface_t *surf;
2547 cairo_t *cr;
2548
2549 surf = cairo_image_surface_create(CAIRO_FORMAT_A1, 1, 1);
2550 cr = cairo_create(surf);
2551
2552 cairo_set_source_rgba(cr,
2553 color.red,
2554 color.green,
2555 color.blue,
2556 color.alpha);
2557 cairo_rectangle(cr, 0, 0, 1, 1);
2558 cairo_fill(cr);
2559 cairo_destroy(cr);
2560
2561 blank_mask = gdk_pixbuf_get_from_surface(surf, 0, 0, 1, 1);
2562 cairo_surface_destroy(surf);
2563
2564 cursor = gdk_cursor_new_from_pixbuf(gdk_window_get_display(root_window),
2565 blank_mask, 0, 0);
2566 g_object_unref(blank_mask);
2567 }
2568 #else
2569 blank_mask = gdk_bitmap_create_from_data(root_window, blank_data, 1, 1);
2570 cursor = gdk_cursor_new_from_pixmap(blank_mask, blank_mask,
2571 &color, &color, 0, 0);
2572 gdk_bitmap_unref(blank_mask);
2573 #endif
2574
2575 return cursor;
2576 }
2577
2578 static void
mainwin_screen_changed_cb(GtkWidget * widget,GdkScreen * previous_screen UNUSED,gpointer data UNUSED)2579 mainwin_screen_changed_cb(GtkWidget *widget,
2580 GdkScreen *previous_screen UNUSED,
2581 gpointer data UNUSED)
2582 {
2583 if (!gtk_widget_has_screen(widget))
2584 return;
2585
2586 /*
2587 * Recreate the invisible mouse cursor.
2588 */
2589 if (gui.blank_pointer != NULL)
2590 #if GTK_CHECK_VERSION(3,0,0)
2591 g_object_unref(G_OBJECT(gui.blank_pointer));
2592 #else
2593 gdk_cursor_unref(gui.blank_pointer);
2594 #endif
2595
2596 gui.blank_pointer = create_blank_pointer();
2597
2598 if (gui.pointer_hidden && gtk_widget_get_window(gui.drawarea) != NULL)
2599 gdk_window_set_cursor(gtk_widget_get_window(gui.drawarea),
2600 gui.blank_pointer);
2601
2602 /*
2603 * Create a new PangoContext for this screen, and initialize it
2604 * with the current font if necessary.
2605 */
2606 if (gui.text_context != NULL)
2607 g_object_unref(gui.text_context);
2608
2609 gui.text_context = gtk_widget_create_pango_context(widget);
2610 pango_context_set_base_dir(gui.text_context, PANGO_DIRECTION_LTR);
2611
2612 if (gui.norm_font != NULL)
2613 {
2614 gui_mch_init_font(p_guifont, FALSE);
2615 gui_set_shellsize(TRUE, FALSE, RESIZE_BOTH);
2616 }
2617 }
2618
2619 /*
2620 * After the drawing area comes up, we calculate all colors and create the
2621 * dummy blank cursor.
2622 *
2623 * Don't try to set any VIM scrollbar sizes anywhere here. I'm relying on the
2624 * fact that the main VIM engine doesn't take them into account anywhere.
2625 */
2626 static void
drawarea_realize_cb(GtkWidget * widget,gpointer data UNUSED)2627 drawarea_realize_cb(GtkWidget *widget, gpointer data UNUSED)
2628 {
2629 GtkWidget *sbar;
2630 GtkAllocation allocation;
2631
2632 #ifdef FEAT_XIM
2633 xim_init();
2634 #endif
2635 gui_mch_new_colors();
2636 #if GTK_CHECK_VERSION(3,0,0)
2637 gui.surface = gdk_window_create_similar_surface(
2638 gtk_widget_get_window(widget),
2639 CAIRO_CONTENT_COLOR_ALPHA,
2640 gtk_widget_get_allocated_width(widget),
2641 gtk_widget_get_allocated_height(widget));
2642 #else
2643 gui.text_gc = gdk_gc_new(gui.drawarea->window);
2644 #endif
2645
2646 gui.blank_pointer = create_blank_pointer();
2647 if (gui.pointer_hidden)
2648 gdk_window_set_cursor(gtk_widget_get_window(widget), gui.blank_pointer);
2649
2650 // get the actual size of the scrollbars, if they are realized
2651 sbar = firstwin->w_scrollbars[SBAR_LEFT].id;
2652 if (!sbar || (!gui.which_scrollbars[SBAR_LEFT]
2653 && firstwin->w_scrollbars[SBAR_RIGHT].id))
2654 sbar = firstwin->w_scrollbars[SBAR_RIGHT].id;
2655 gtk_widget_get_allocation(sbar, &allocation);
2656 if (sbar && gtk_widget_get_realized(sbar) && allocation.width)
2657 gui.scrollbar_width = allocation.width;
2658
2659 sbar = gui.bottom_sbar.id;
2660 if (sbar && gtk_widget_get_realized(sbar) && allocation.height)
2661 gui.scrollbar_height = allocation.height;
2662 }
2663
2664 /*
2665 * Properly clean up on shutdown.
2666 */
2667 static void
drawarea_unrealize_cb(GtkWidget * widget UNUSED,gpointer data UNUSED)2668 drawarea_unrealize_cb(GtkWidget *widget UNUSED, gpointer data UNUSED)
2669 {
2670 // Don't write messages to the GUI anymore
2671 full_screen = FALSE;
2672
2673 #ifdef FEAT_XIM
2674 im_shutdown();
2675 #endif
2676 if (gui.ascii_glyphs != NULL)
2677 {
2678 pango_glyph_string_free(gui.ascii_glyphs);
2679 gui.ascii_glyphs = NULL;
2680 }
2681 if (gui.ascii_font != NULL)
2682 {
2683 g_object_unref(gui.ascii_font);
2684 gui.ascii_font = NULL;
2685 }
2686 g_object_unref(gui.text_context);
2687 gui.text_context = NULL;
2688
2689 #if GTK_CHECK_VERSION(3,0,0)
2690 if (gui.surface != NULL)
2691 {
2692 cairo_surface_destroy(gui.surface);
2693 gui.surface = NULL;
2694 }
2695 #else
2696 g_object_unref(gui.text_gc);
2697 gui.text_gc = NULL;
2698 #endif
2699
2700 #if GTK_CHECK_VERSION(3,0,0)
2701 g_object_unref(G_OBJECT(gui.blank_pointer));
2702 #else
2703 gdk_cursor_unref(gui.blank_pointer);
2704 #endif
2705 gui.blank_pointer = NULL;
2706 }
2707
2708 #if GTK_CHECK_VERSION(3,22,2)
2709 static void
drawarea_style_updated_cb(GtkWidget * widget UNUSED,gpointer data UNUSED)2710 drawarea_style_updated_cb(GtkWidget *widget UNUSED,
2711 gpointer data UNUSED)
2712 #else
2713 static void
2714 drawarea_style_set_cb(GtkWidget *widget UNUSED,
2715 GtkStyle *previous_style UNUSED,
2716 gpointer data UNUSED)
2717 #endif
2718 {
2719 gui_mch_new_colors();
2720 }
2721
2722 #if GTK_CHECK_VERSION(3,0,0)
2723 static gboolean
drawarea_configure_event_cb(GtkWidget * widget,GdkEventConfigure * event,gpointer data UNUSED)2724 drawarea_configure_event_cb(GtkWidget *widget,
2725 GdkEventConfigure *event,
2726 gpointer data UNUSED)
2727 {
2728 static int cur_width = 0;
2729 static int cur_height = 0;
2730
2731 g_return_val_if_fail(event
2732 && event->width >= 1 && event->height >= 1, TRUE);
2733
2734 # if GTK_CHECK_VERSION(3,22,2) && !GTK_CHECK_VERSION(3,22,4)
2735 // As of 3.22.2, GdkWindows have started distributing configure events to
2736 // their "native" children (https://git.gnome.org/browse/gtk+/commit/?h=gtk-3-22&id=12579fe71b3b8f79eb9c1b80e429443bcc437dd0).
2737 //
2738 // As can be seen from the implementation of move_native_children() and
2739 // configure_native_child() in gdkwindow.c, those functions actually
2740 // propagate configure events to every child, failing to distinguish
2741 // "native" one from non-native one.
2742 //
2743 // Naturally, configure events propagated to here like that are fallacious
2744 // and, as a matter of fact, they trigger a geometric collapse of
2745 // gui.drawarea in fullscreen and maximized modes.
2746 //
2747 // To filter out such nuisance events, we are making use of the fact that
2748 // the field send_event of such GdkEventConfigures is set to FALSE in
2749 // configure_native_child().
2750 //
2751 // Obviously, this is a terrible hack making GVim depend on GTK's
2752 // implementation details. Therefore, watch out any relevant internal
2753 // changes happening in GTK in the feature (sigh).
2754 //
2755 // Follow-up
2756 // After a few weeks later, the GdkWindow change mentioned above was
2757 // reverted (https://git.gnome.org/browse/gtk+/commit/?h=gtk-3-22&id=f70039cb9603a02d2369fec4038abf40a1711155).
2758 // The corresponding official release is 3.22.4.
2759 if (event->send_event == FALSE)
2760 return TRUE;
2761 # endif
2762
2763 if (event->width == cur_width && event->height == cur_height)
2764 return TRUE;
2765
2766 cur_width = event->width;
2767 cur_height = event->height;
2768
2769 if (gui.surface != NULL)
2770 cairo_surface_destroy(gui.surface);
2771
2772 gui.surface = gdk_window_create_similar_surface(
2773 gtk_widget_get_window(widget),
2774 CAIRO_CONTENT_COLOR_ALPHA,
2775 event->width, event->height);
2776
2777 gtk_widget_queue_draw(widget);
2778
2779 return TRUE;
2780 }
2781 #endif
2782
2783 /*
2784 * Callback routine for the "delete_event" signal on the toplevel window.
2785 * Tries to vim gracefully, or refuses to exit with changed buffers.
2786 */
2787 static gint
delete_event_cb(GtkWidget * widget UNUSED,GdkEventAny * event UNUSED,gpointer data UNUSED)2788 delete_event_cb(GtkWidget *widget UNUSED,
2789 GdkEventAny *event UNUSED,
2790 gpointer data UNUSED)
2791 {
2792 gui_shell_closed();
2793 return TRUE;
2794 }
2795
2796 #if defined(FEAT_MENU) || defined(FEAT_TOOLBAR) || defined(FEAT_GUI_TABLINE)
2797 static int
get_item_dimensions(GtkWidget * widget,GtkOrientation orientation)2798 get_item_dimensions(GtkWidget *widget, GtkOrientation orientation)
2799 {
2800 # ifdef FEAT_GUI_GNOME
2801 GtkOrientation item_orientation = GTK_ORIENTATION_HORIZONTAL;
2802
2803 if (using_gnome && widget != NULL)
2804 {
2805 GtkWidget *parent;
2806 BonoboDockItem *dockitem;
2807
2808 parent = gtk_widget_get_parent(widget);
2809 if (G_TYPE_FROM_INSTANCE(parent) == BONOBO_TYPE_DOCK_ITEM)
2810 {
2811 // Only menu & toolbar are dock items. Could tabline be?
2812 // Seem to be only the 2 defined in GNOME
2813 widget = parent;
2814 dockitem = BONOBO_DOCK_ITEM(widget);
2815
2816 if (dockitem == NULL || dockitem->is_floating)
2817 return 0;
2818 item_orientation = bonobo_dock_item_get_orientation(dockitem);
2819 }
2820 }
2821 # else
2822 # define item_orientation GTK_ORIENTATION_HORIZONTAL
2823 # endif
2824
2825 if (widget != NULL
2826 && item_orientation == orientation
2827 && gtk_widget_get_realized(widget)
2828 && gtk_widget_get_visible(widget))
2829 {
2830 # if GTK_CHECK_VERSION(3,0,0) || !defined(FEAT_GUI_GNOME)
2831 GtkAllocation allocation;
2832
2833 gtk_widget_get_allocation(widget, &allocation);
2834 return allocation.height;
2835 # else
2836 if (orientation == GTK_ORIENTATION_HORIZONTAL)
2837 return widget->allocation.height;
2838 else
2839 return widget->allocation.width;
2840 # endif
2841 }
2842 return 0;
2843 }
2844 #endif
2845
2846 static int
get_menu_tool_width(void)2847 get_menu_tool_width(void)
2848 {
2849 int width = 0;
2850
2851 #ifdef FEAT_GUI_GNOME // these are never vertical without GNOME
2852 # ifdef FEAT_MENU
2853 width += get_item_dimensions(gui.menubar, GTK_ORIENTATION_VERTICAL);
2854 # endif
2855 # ifdef FEAT_TOOLBAR
2856 width += get_item_dimensions(gui.toolbar, GTK_ORIENTATION_VERTICAL);
2857 # endif
2858 # ifdef FEAT_GUI_TABLINE
2859 if (gui.tabline != NULL)
2860 width += get_item_dimensions(gui.tabline, GTK_ORIENTATION_VERTICAL);
2861 # endif
2862 #endif
2863
2864 return width;
2865 }
2866
2867 static int
get_menu_tool_height(void)2868 get_menu_tool_height(void)
2869 {
2870 int height = 0;
2871
2872 #ifdef FEAT_MENU
2873 height += get_item_dimensions(gui.menubar, GTK_ORIENTATION_HORIZONTAL);
2874 #endif
2875 #ifdef FEAT_TOOLBAR
2876 height += get_item_dimensions(gui.toolbar, GTK_ORIENTATION_HORIZONTAL);
2877 #endif
2878 #ifdef FEAT_GUI_TABLINE
2879 if (gui.tabline != NULL)
2880 height += get_item_dimensions(gui.tabline, GTK_ORIENTATION_HORIZONTAL);
2881 #endif
2882
2883 return height;
2884 }
2885
2886 // This controls whether we can set the real window hints at
2887 // start-up when in a GtkPlug.
2888 // 0 = normal processing (default)
2889 // 1 = init. hints set, no-one's tried to reset since last check
2890 // 2 = init. hints set, attempt made to change hints
2891 static int init_window_hints_state = 0;
2892
2893 static void
update_window_manager_hints(int force_width,int force_height)2894 update_window_manager_hints(int force_width, int force_height)
2895 {
2896 static int old_width = 0;
2897 static int old_height = 0;
2898 static int old_min_width = 0;
2899 static int old_min_height = 0;
2900 static int old_char_width = 0;
2901 static int old_char_height = 0;
2902
2903 int width;
2904 int height;
2905 int min_width;
2906 int min_height;
2907
2908 // At start-up, don't try to set the hints until the initial
2909 // values have been used (those that dictate our initial size)
2910 // Let forced (i.e., correct) values through always.
2911 if (!(force_width && force_height) && init_window_hints_state > 0)
2912 {
2913 // Don't do it!
2914 init_window_hints_state = 2;
2915 return;
2916 }
2917
2918 // This also needs to be done when the main window isn't there yet,
2919 // otherwise the hints don't work.
2920 width = gui_get_base_width();
2921 height = gui_get_base_height();
2922 # ifdef FEAT_MENU
2923 height += tabline_height() * gui.char_height;
2924 # endif
2925 width += get_menu_tool_width();
2926 height += get_menu_tool_height();
2927
2928 // GtkSockets use GtkPlug's [gui,mainwin] min-size hints to determine
2929 // their actual widget size. When we set our size ourselves (e.g.,
2930 // 'set columns=' or init. -geom) we briefly set the min. to the size
2931 // we wish to be instead of the legitimate minimum so that we actually
2932 // resize correctly.
2933 if (force_width && force_height)
2934 {
2935 min_width = force_width;
2936 min_height = force_height;
2937 }
2938 else
2939 {
2940 min_width = width + MIN_COLUMNS * gui.char_width;
2941 min_height = height + MIN_LINES * gui.char_height;
2942 }
2943
2944 // Avoid an expose event when the size didn't change.
2945 if (width != old_width
2946 || height != old_height
2947 || min_width != old_min_width
2948 || min_height != old_min_height
2949 || gui.char_width != old_char_width
2950 || gui.char_height != old_char_height)
2951 {
2952 GdkGeometry geometry;
2953 GdkWindowHints geometry_mask;
2954
2955 geometry.width_inc = gui.char_width;
2956 geometry.height_inc = gui.char_height;
2957 geometry.base_width = width;
2958 geometry.base_height = height;
2959 geometry.min_width = min_width;
2960 geometry.min_height = min_height;
2961 geometry_mask = GDK_HINT_BASE_SIZE|GDK_HINT_RESIZE_INC
2962 |GDK_HINT_MIN_SIZE;
2963 // Using gui.formwin as geometry widget doesn't work as expected
2964 // with GTK+ 2 -- dunno why. Presumably all the resizing hacks
2965 // in Vim confuse GTK+.
2966 gtk_window_set_geometry_hints(GTK_WINDOW(gui.mainwin), gui.mainwin,
2967 &geometry, geometry_mask);
2968 old_width = width;
2969 old_height = height;
2970 old_min_width = min_width;
2971 old_min_height = min_height;
2972 old_char_width = gui.char_width;
2973 old_char_height = gui.char_height;
2974 }
2975 }
2976
2977 #if defined(FEAT_GUI_DARKTHEME) || defined(PROTO)
2978 void
gui_mch_set_dark_theme(int dark)2979 gui_mch_set_dark_theme(int dark)
2980 {
2981 # if GTK_CHECK_VERSION(3,0,0)
2982 GtkSettings *gtk_settings;
2983
2984 gtk_settings = gtk_settings_get_for_screen(gdk_screen_get_default());
2985 g_object_set(gtk_settings, "gtk-application-prefer-dark-theme", (gboolean)dark, NULL);
2986 # endif
2987 }
2988 #endif // FEAT_GUI_DARKTHEME
2989
2990 #ifdef FEAT_TOOLBAR
2991
2992 /*
2993 * This extra effort wouldn't be necessary if we only used stock icons in the
2994 * toolbar, as we do for all builtin icons. But user-defined toolbar icons
2995 * shouldn't be treated differently, thus we do need this.
2996 */
2997 static void
icon_size_changed_foreach(GtkWidget * widget,gpointer user_data)2998 icon_size_changed_foreach(GtkWidget *widget, gpointer user_data)
2999 {
3000 if (GTK_IS_IMAGE(widget))
3001 {
3002 GtkImage *image = (GtkImage *)widget;
3003
3004 # if GTK_CHECK_VERSION(3,10,0)
3005 if (gtk_image_get_storage_type(image) == GTK_IMAGE_ICON_NAME)
3006 {
3007 const GtkIconSize icon_size = GPOINTER_TO_INT(user_data);
3008 const gchar *icon_name;
3009
3010 gtk_image_get_icon_name(image, &icon_name, NULL);
3011 image = (GtkImage *)gtk_image_new_from_icon_name(
3012 icon_name, icon_size);
3013 }
3014 # else
3015 // User-defined icons are stored in a GtkIconSet
3016 if (gtk_image_get_storage_type(image) == GTK_IMAGE_ICON_SET)
3017 {
3018 GtkIconSet *icon_set;
3019 GtkIconSize icon_size;
3020
3021 gtk_image_get_icon_set(image, &icon_set, &icon_size);
3022 icon_size = (GtkIconSize)(long)user_data;
3023
3024 gtk_icon_set_ref(icon_set);
3025 gtk_image_set_from_icon_set(image, icon_set, icon_size);
3026 gtk_icon_set_unref(icon_set);
3027 }
3028 # endif
3029 }
3030 else if (GTK_IS_CONTAINER(widget))
3031 {
3032 gtk_container_foreach((GtkContainer *)widget,
3033 &icon_size_changed_foreach,
3034 user_data);
3035 }
3036 }
3037
3038 static void
set_toolbar_style(GtkToolbar * toolbar)3039 set_toolbar_style(GtkToolbar *toolbar)
3040 {
3041 GtkToolbarStyle style;
3042 GtkIconSize size;
3043 GtkIconSize oldsize;
3044
3045 if ((toolbar_flags & (TOOLBAR_TEXT | TOOLBAR_ICONS | TOOLBAR_HORIZ))
3046 == (TOOLBAR_TEXT | TOOLBAR_ICONS | TOOLBAR_HORIZ))
3047 style = GTK_TOOLBAR_BOTH_HORIZ;
3048 else if ((toolbar_flags & (TOOLBAR_TEXT | TOOLBAR_ICONS))
3049 == (TOOLBAR_TEXT | TOOLBAR_ICONS))
3050 style = GTK_TOOLBAR_BOTH;
3051 else if (toolbar_flags & TOOLBAR_TEXT)
3052 style = GTK_TOOLBAR_TEXT;
3053 else
3054 style = GTK_TOOLBAR_ICONS;
3055
3056 gtk_toolbar_set_style(toolbar, style);
3057 # if !GTK_CHECK_VERSION(3,0,0)
3058 gtk_toolbar_set_tooltips(toolbar, (toolbar_flags & TOOLBAR_TOOLTIPS) != 0);
3059 # endif
3060
3061 switch (tbis_flags)
3062 {
3063 case TBIS_TINY: size = GTK_ICON_SIZE_MENU; break;
3064 case TBIS_SMALL: size = GTK_ICON_SIZE_SMALL_TOOLBAR; break;
3065 case TBIS_MEDIUM: size = GTK_ICON_SIZE_BUTTON; break;
3066 case TBIS_LARGE: size = GTK_ICON_SIZE_LARGE_TOOLBAR; break;
3067 case TBIS_HUGE: size = GTK_ICON_SIZE_DND; break;
3068 case TBIS_GIANT: size = GTK_ICON_SIZE_DIALOG; break;
3069 default: size = GTK_ICON_SIZE_INVALID; break;
3070 }
3071 oldsize = gtk_toolbar_get_icon_size(toolbar);
3072
3073 if (size == GTK_ICON_SIZE_INVALID)
3074 {
3075 // Let global user preferences decide the icon size.
3076 gtk_toolbar_unset_icon_size(toolbar);
3077 size = gtk_toolbar_get_icon_size(toolbar);
3078 }
3079 if (size != oldsize)
3080 {
3081 gtk_container_foreach(GTK_CONTAINER(toolbar),
3082 &icon_size_changed_foreach,
3083 GINT_TO_POINTER((int)size));
3084 }
3085 gtk_toolbar_set_icon_size(toolbar, size);
3086 }
3087
3088 #endif // FEAT_TOOLBAR
3089
3090 #if defined(FEAT_GUI_TABLINE) || defined(PROTO)
3091 static int ignore_tabline_evt = FALSE;
3092 static GtkWidget *tabline_menu;
3093 # if !GTK_CHECK_VERSION(3,0,0)
3094 static GtkTooltips *tabline_tooltip;
3095 # endif
3096 static int clicked_page; // page clicked in tab line
3097
3098 /*
3099 * Handle selecting an item in the tab line popup menu.
3100 */
3101 static void
tabline_menu_handler(GtkMenuItem * item UNUSED,gpointer user_data)3102 tabline_menu_handler(GtkMenuItem *item UNUSED, gpointer user_data)
3103 {
3104 // Add the string cmd into input buffer
3105 send_tabline_menu_event(clicked_page, (int)(long)user_data);
3106 }
3107
3108 static void
add_tabline_menu_item(GtkWidget * menu,char_u * text,int resp)3109 add_tabline_menu_item(GtkWidget *menu, char_u *text, int resp)
3110 {
3111 GtkWidget *item;
3112 char_u *utf_text;
3113
3114 utf_text = CONVERT_TO_UTF8(text);
3115 item = gtk_menu_item_new_with_label((const char *)utf_text);
3116 gtk_widget_show(item);
3117 CONVERT_TO_UTF8_FREE(utf_text);
3118
3119 gtk_container_add(GTK_CONTAINER(menu), item);
3120 g_signal_connect(G_OBJECT(item), "activate",
3121 G_CALLBACK(tabline_menu_handler),
3122 GINT_TO_POINTER(resp));
3123 }
3124
3125 /*
3126 * Create a menu for the tab line.
3127 */
3128 static GtkWidget *
create_tabline_menu(void)3129 create_tabline_menu(void)
3130 {
3131 GtkWidget *menu;
3132
3133 menu = gtk_menu_new();
3134 add_tabline_menu_item(menu, (char_u *)_("Close tab"), TABLINE_MENU_CLOSE);
3135 add_tabline_menu_item(menu, (char_u *)_("New tab"), TABLINE_MENU_NEW);
3136 add_tabline_menu_item(menu, (char_u *)_("Open Tab..."), TABLINE_MENU_OPEN);
3137
3138 return menu;
3139 }
3140
3141 static gboolean
on_tabline_menu(GtkWidget * widget,GdkEvent * event)3142 on_tabline_menu(GtkWidget *widget, GdkEvent *event)
3143 {
3144 // Was this button press event ?
3145 if (event->type == GDK_BUTTON_PRESS)
3146 {
3147 GdkEventButton *bevent = (GdkEventButton *)event;
3148 int x = bevent->x;
3149 int y = bevent->y;
3150 GtkWidget *tabwidget;
3151 GdkWindow *tabwin;
3152
3153 // When ignoring events return TRUE so that the selected page doesn't
3154 // change.
3155 if (hold_gui_events
3156 # ifdef FEAT_CMDWIN
3157 || cmdwin_type != 0
3158 # endif
3159 )
3160 return TRUE;
3161
3162 tabwin = gui_gtk_window_at_position(gui.mainwin, &x, &y);
3163
3164 gdk_window_get_user_data(tabwin, (gpointer)&tabwidget);
3165 clicked_page = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(tabwidget),
3166 "tab_num"));
3167
3168 // If the event was generated for 3rd button popup the menu.
3169 if (bevent->button == 3)
3170 {
3171 # if GTK_CHECK_VERSION(3,22,2)
3172 gtk_menu_popup_at_pointer(GTK_MENU(widget), event);
3173 # else
3174 gtk_menu_popup(GTK_MENU(widget), NULL, NULL, NULL, NULL,
3175 bevent->button, bevent->time);
3176 # endif
3177 // We handled the event.
3178 return TRUE;
3179 }
3180 else if (bevent->button == 1)
3181 {
3182 if (clicked_page == 0)
3183 {
3184 // Click after all tabs moves to next tab page. When "x" is
3185 // small guess it's the left button.
3186 send_tabline_event(x < 50 ? -1 : 0);
3187 }
3188 }
3189 }
3190
3191 // We didn't handle the event.
3192 return FALSE;
3193 }
3194
3195 /*
3196 * Handle selecting one of the tabs.
3197 */
3198 static void
on_select_tab(GtkNotebook * notebook UNUSED,gpointer * page UNUSED,gint idx,gpointer data UNUSED)3199 on_select_tab(
3200 GtkNotebook *notebook UNUSED,
3201 gpointer *page UNUSED,
3202 gint idx,
3203 gpointer data UNUSED)
3204 {
3205 if (!ignore_tabline_evt)
3206 send_tabline_event(idx + 1);
3207 }
3208
3209 # if GTK_CHECK_VERSION(2,10,0)
3210 /*
3211 * Handle reordering the tabs (using D&D).
3212 */
3213 static void
on_tab_reordered(GtkNotebook * notebook UNUSED,gpointer * page UNUSED,gint idx,gpointer data UNUSED)3214 on_tab_reordered(
3215 GtkNotebook *notebook UNUSED,
3216 gpointer *page UNUSED,
3217 gint idx,
3218 gpointer data UNUSED)
3219 {
3220 if (!ignore_tabline_evt)
3221 {
3222 if ((tabpage_index(curtab) - 1) < idx)
3223 tabpage_move(idx + 1);
3224 else
3225 tabpage_move(idx);
3226 }
3227 }
3228 # endif
3229
3230 /*
3231 * Show or hide the tabline.
3232 */
3233 void
gui_mch_show_tabline(int showit)3234 gui_mch_show_tabline(int showit)
3235 {
3236 if (gui.tabline == NULL)
3237 return;
3238
3239 if (!showit != !gtk_notebook_get_show_tabs(GTK_NOTEBOOK(gui.tabline)))
3240 {
3241 // Note: this may cause a resize event
3242 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(gui.tabline), showit);
3243 update_window_manager_hints(0, 0);
3244 if (showit)
3245 gtk_widget_set_can_focus(GTK_WIDGET(gui.tabline), FALSE);
3246 }
3247
3248 gui_mch_update();
3249 }
3250
3251 /*
3252 * Return TRUE when tabline is displayed.
3253 */
3254 int
gui_mch_showing_tabline(void)3255 gui_mch_showing_tabline(void)
3256 {
3257 return gui.tabline != NULL
3258 && gtk_notebook_get_show_tabs(GTK_NOTEBOOK(gui.tabline));
3259 }
3260
3261 /*
3262 * Update the labels of the tabline.
3263 */
3264 void
gui_mch_update_tabline(void)3265 gui_mch_update_tabline(void)
3266 {
3267 GtkWidget *page;
3268 GtkWidget *event_box;
3269 GtkWidget *label;
3270 tabpage_T *tp;
3271 int nr = 0;
3272 int tab_num;
3273 int curtabidx = 0;
3274 char_u *labeltext;
3275
3276 if (gui.tabline == NULL)
3277 return;
3278
3279 ignore_tabline_evt = TRUE;
3280
3281 // Add a label for each tab page. They all contain the same text area.
3282 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next, ++nr)
3283 {
3284 if (tp == curtab)
3285 curtabidx = nr;
3286
3287 tab_num = nr + 1;
3288
3289 page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(gui.tabline), nr);
3290 if (page == NULL)
3291 {
3292 // Add notebook page
3293 # if GTK_CHECK_VERSION(3,2,0)
3294 page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
3295 gtk_box_set_homogeneous(GTK_BOX(page), FALSE);
3296 # else
3297 page = gtk_vbox_new(FALSE, 0);
3298 # endif
3299 gtk_widget_show(page);
3300 event_box = gtk_event_box_new();
3301 gtk_widget_show(event_box);
3302 label = gtk_label_new("-Empty-");
3303 # if !GTK_CHECK_VERSION(3,14,0)
3304 gtk_misc_set_padding(GTK_MISC(label), 2, 2);
3305 # endif
3306 gtk_container_add(GTK_CONTAINER(event_box), label);
3307 gtk_widget_show(label);
3308 gtk_notebook_insert_page(GTK_NOTEBOOK(gui.tabline),
3309 page,
3310 event_box,
3311 nr++);
3312 # if GTK_CHECK_VERSION(2,10,0)
3313 gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(gui.tabline),
3314 page,
3315 TRUE);
3316 # endif
3317 }
3318
3319 event_box = gtk_notebook_get_tab_label(GTK_NOTEBOOK(gui.tabline), page);
3320 g_object_set_data(G_OBJECT(event_box), "tab_num",
3321 GINT_TO_POINTER(tab_num));
3322 label = gtk_bin_get_child(GTK_BIN(event_box));
3323 get_tabline_label(tp, FALSE);
3324 labeltext = CONVERT_TO_UTF8(NameBuff);
3325 gtk_label_set_text(GTK_LABEL(label), (const char *)labeltext);
3326 CONVERT_TO_UTF8_FREE(labeltext);
3327
3328 get_tabline_label(tp, TRUE);
3329 labeltext = CONVERT_TO_UTF8(NameBuff);
3330 # if GTK_CHECK_VERSION(3,0,0)
3331 gtk_widget_set_tooltip_text(event_box, (const gchar *)labeltext);
3332 # else
3333 gtk_tooltips_set_tip(GTK_TOOLTIPS(tabline_tooltip), event_box,
3334 (const char *)labeltext, NULL);
3335 # endif
3336 CONVERT_TO_UTF8_FREE(labeltext);
3337 }
3338
3339 // Remove any old labels.
3340 while (gtk_notebook_get_nth_page(GTK_NOTEBOOK(gui.tabline), nr) != NULL)
3341 gtk_notebook_remove_page(GTK_NOTEBOOK(gui.tabline), nr);
3342
3343 if (gtk_notebook_get_current_page(GTK_NOTEBOOK(gui.tabline)) != curtabidx)
3344 gtk_notebook_set_current_page(GTK_NOTEBOOK(gui.tabline), curtabidx);
3345
3346 // Make sure everything is in place before drawing text.
3347 gui_mch_update();
3348
3349 ignore_tabline_evt = FALSE;
3350 }
3351
3352 /*
3353 * Set the current tab to "nr". First tab is 1.
3354 */
3355 void
gui_mch_set_curtab(int nr)3356 gui_mch_set_curtab(int nr)
3357 {
3358 if (gui.tabline == NULL)
3359 return;
3360
3361 ignore_tabline_evt = TRUE;
3362 if (gtk_notebook_get_current_page(GTK_NOTEBOOK(gui.tabline)) != nr - 1)
3363 gtk_notebook_set_current_page(GTK_NOTEBOOK(gui.tabline), nr - 1);
3364 ignore_tabline_evt = FALSE;
3365 }
3366
3367 #endif // FEAT_GUI_TABLINE
3368
3369 /*
3370 * Add selection targets for PRIMARY and CLIPBOARD selections.
3371 */
3372 void
gui_gtk_set_selection_targets(void)3373 gui_gtk_set_selection_targets(void)
3374 {
3375 int i, j = 0;
3376 int n_targets = N_SELECTION_TARGETS;
3377 GtkTargetEntry targets[N_SELECTION_TARGETS];
3378
3379 for (i = 0; i < (int)N_SELECTION_TARGETS; ++i)
3380 {
3381 // OpenOffice tries to use TARGET_HTML and fails when we don't
3382 // return something, instead of trying another target. Therefore only
3383 // offer TARGET_HTML when it works.
3384 if (!clip_html && selection_targets[i].info == TARGET_HTML)
3385 n_targets--;
3386 else
3387 targets[j++] = selection_targets[i];
3388 }
3389
3390 gtk_selection_clear_targets(gui.drawarea, (GdkAtom)GDK_SELECTION_PRIMARY);
3391 gtk_selection_clear_targets(gui.drawarea, (GdkAtom)clip_plus.gtk_sel_atom);
3392 gtk_selection_add_targets(gui.drawarea,
3393 (GdkAtom)GDK_SELECTION_PRIMARY,
3394 targets, n_targets);
3395 gtk_selection_add_targets(gui.drawarea,
3396 (GdkAtom)clip_plus.gtk_sel_atom,
3397 targets, n_targets);
3398 }
3399
3400 /*
3401 * Set up for receiving DND items.
3402 */
3403 void
gui_gtk_set_dnd_targets(void)3404 gui_gtk_set_dnd_targets(void)
3405 {
3406 int i, j = 0;
3407 int n_targets = N_DND_TARGETS;
3408 GtkTargetEntry targets[N_DND_TARGETS];
3409
3410 for (i = 0; i < (int)N_DND_TARGETS; ++i)
3411 {
3412 if (!clip_html && dnd_targets[i].info == TARGET_HTML)
3413 n_targets--;
3414 else
3415 targets[j++] = dnd_targets[i];
3416 }
3417
3418 gtk_drag_dest_unset(gui.drawarea);
3419 gtk_drag_dest_set(gui.drawarea,
3420 GTK_DEST_DEFAULT_ALL,
3421 targets, n_targets,
3422 GDK_ACTION_COPY | GDK_ACTION_MOVE);
3423 }
3424
3425 /*
3426 * Initialize the GUI. Create all the windows, set up all the callbacks etc.
3427 * Returns OK for success, FAIL when the GUI can't be started.
3428 */
3429 int
gui_mch_init(void)3430 gui_mch_init(void)
3431 {
3432 GtkWidget *vbox;
3433
3434 #ifdef FEAT_GUI_GNOME
3435 // Initialize the GNOME libraries. gnome_program_init()/gnome_init()
3436 // exits on failure, but that's a non-issue because we already called
3437 // gtk_init_check() in gui_mch_init_check().
3438 if (using_gnome)
3439 {
3440 gnome_program_init(VIMPACKAGE, VIM_VERSION_SHORT,
3441 LIBGNOMEUI_MODULE, gui_argc, gui_argv, NULL);
3442 # if defined(FEAT_FLOAT) && defined(LC_NUMERIC)
3443 {
3444 char *p = setlocale(LC_NUMERIC, NULL);
3445
3446 // Make sure strtod() uses a decimal point, not a comma. Gnome
3447 // init may change it.
3448 if (p == NULL || strcmp(p, "C") != 0)
3449 setlocale(LC_NUMERIC, "C");
3450 }
3451 # endif
3452 }
3453 #endif
3454 VIM_CLEAR(gui_argv);
3455
3456 #if GLIB_CHECK_VERSION(2,1,3)
3457 // Set the human-readable application name
3458 g_set_application_name("Vim");
3459 #endif
3460 /*
3461 * Force UTF-8 output no matter what the value of 'encoding' is.
3462 * did_set_string_option() in option.c prohibits changing 'termencoding'
3463 * to something else than UTF-8 if the GUI is in use.
3464 */
3465 set_option_value((char_u *)"termencoding", 0L, (char_u *)"utf-8", 0);
3466
3467 #ifdef FEAT_TOOLBAR
3468 gui_gtk_register_stock_icons();
3469 #endif
3470 // FIXME: Need to install the classic icons and a gtkrc.classic file.
3471 // The hard part is deciding install locations and the Makefile magic.
3472 #if !GTK_CHECK_VERSION(3,0,0)
3473 # if 0
3474 gtk_rc_parse("gtkrc");
3475 # endif
3476 #endif
3477
3478 // Initialize values
3479 gui.border_width = 2;
3480 gui.scrollbar_width = SB_DEFAULT_WIDTH;
3481 gui.scrollbar_height = SB_DEFAULT_WIDTH;
3482 #if GTK_CHECK_VERSION(3,0,0)
3483 gui.fgcolor = g_new(GdkRGBA, 1);
3484 gui.bgcolor = g_new(GdkRGBA, 1);
3485 gui.spcolor = g_new(GdkRGBA, 1);
3486 #else
3487 // LINTED: avoid warning: conversion to 'unsigned long'
3488 gui.fgcolor = g_new0(GdkColor, 1);
3489 // LINTED: avoid warning: conversion to 'unsigned long'
3490 gui.bgcolor = g_new0(GdkColor, 1);
3491 // LINTED: avoid warning: conversion to 'unsigned long'
3492 gui.spcolor = g_new0(GdkColor, 1);
3493 #endif
3494
3495 // Initialise atoms
3496 html_atom = gdk_atom_intern("text/html", FALSE);
3497 utf8_string_atom = gdk_atom_intern("UTF8_STRING", FALSE);
3498
3499 // Set default foreground and background colors.
3500 gui.norm_pixel = gui.def_norm_pixel;
3501 gui.back_pixel = gui.def_back_pixel;
3502
3503 if (gtk_socket_id != 0)
3504 {
3505 GtkWidget *plug;
3506
3507 // Use GtkSocket from another app.
3508 plug = gtk_plug_new_for_display(gdk_display_get_default(),
3509 gtk_socket_id);
3510 if (plug != NULL && gtk_plug_get_socket_window(GTK_PLUG(plug)) != NULL)
3511 {
3512 gui.mainwin = plug;
3513 }
3514 else
3515 {
3516 g_warning("Connection to GTK+ socket (ID %u) failed",
3517 (unsigned int)gtk_socket_id);
3518 // Pretend we never wanted it if it failed (get own window)
3519 gtk_socket_id = 0;
3520 }
3521 }
3522
3523 if (gtk_socket_id == 0)
3524 {
3525 #ifdef FEAT_GUI_GNOME
3526 if (using_gnome)
3527 {
3528 gui.mainwin = gnome_app_new("Vim", NULL);
3529 # ifdef USE_XSMP
3530 // Use the GNOME save-yourself functionality now.
3531 xsmp_close();
3532 # endif
3533 }
3534 else
3535 #endif
3536 gui.mainwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
3537 }
3538
3539 gtk_widget_set_name(gui.mainwin, "vim-main-window");
3540
3541 // Create the PangoContext used for drawing all text.
3542 gui.text_context = gtk_widget_create_pango_context(gui.mainwin);
3543 pango_context_set_base_dir(gui.text_context, PANGO_DIRECTION_LTR);
3544
3545 gtk_container_set_border_width(GTK_CONTAINER(gui.mainwin), 0);
3546 gtk_widget_add_events(gui.mainwin, GDK_VISIBILITY_NOTIFY_MASK);
3547
3548 g_signal_connect(G_OBJECT(gui.mainwin), "delete-event",
3549 G_CALLBACK(&delete_event_cb), NULL);
3550
3551 g_signal_connect(G_OBJECT(gui.mainwin), "realize",
3552 G_CALLBACK(&mainwin_realize), NULL);
3553
3554 g_signal_connect(G_OBJECT(gui.mainwin), "screen-changed",
3555 G_CALLBACK(&mainwin_screen_changed_cb), NULL);
3556
3557 gui.accel_group = gtk_accel_group_new();
3558 gtk_window_add_accel_group(GTK_WINDOW(gui.mainwin), gui.accel_group);
3559
3560 // A vertical box holds the menubar, toolbar and main text window.
3561 #if GTK_CHECK_VERSION(3,2,0)
3562 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
3563 gtk_box_set_homogeneous(GTK_BOX(vbox), FALSE);
3564 #else
3565 vbox = gtk_vbox_new(FALSE, 0);
3566 #endif
3567
3568 #ifdef FEAT_GUI_GNOME
3569 if (using_gnome)
3570 {
3571 # if defined(FEAT_MENU)
3572 // automagically restore menubar/toolbar placement
3573 gnome_app_enable_layout_config(GNOME_APP(gui.mainwin), TRUE);
3574 # endif
3575 gnome_app_set_contents(GNOME_APP(gui.mainwin), vbox);
3576 }
3577 else
3578 #endif
3579 {
3580 gtk_container_add(GTK_CONTAINER(gui.mainwin), vbox);
3581 gtk_widget_show(vbox);
3582 }
3583
3584 #ifdef FEAT_MENU
3585 /*
3586 * Create the menubar and handle
3587 */
3588 gui.menubar = gtk_menu_bar_new();
3589 gtk_widget_set_name(gui.menubar, "vim-menubar");
3590
3591 // Avoid that GTK takes <F10> away from us.
3592 {
3593 GtkSettings *gtk_settings;
3594
3595 gtk_settings = gtk_settings_get_for_screen(gdk_screen_get_default());
3596 g_object_set(gtk_settings, "gtk-menu-bar-accel", NULL, NULL);
3597 }
3598
3599
3600 # ifdef FEAT_GUI_GNOME
3601 if (using_gnome)
3602 {
3603 BonoboDockItem *dockitem;
3604
3605 gnome_app_set_menus(GNOME_APP(gui.mainwin), GTK_MENU_BAR(gui.menubar));
3606 dockitem = gnome_app_get_dock_item_by_name(GNOME_APP(gui.mainwin),
3607 GNOME_APP_MENUBAR_NAME);
3608 // We don't want the menu to float.
3609 bonobo_dock_item_set_behavior(dockitem,
3610 bonobo_dock_item_get_behavior(dockitem)
3611 | BONOBO_DOCK_ITEM_BEH_NEVER_FLOATING);
3612 gui.menubar_h = GTK_WIDGET(dockitem);
3613 }
3614 else
3615 # endif // FEAT_GUI_GNOME
3616 {
3617 // Always show the menubar, otherwise <F10> doesn't work. It may be
3618 // disabled in gui_init() later.
3619 gtk_widget_show(gui.menubar);
3620 gtk_box_pack_start(GTK_BOX(vbox), gui.menubar, FALSE, FALSE, 0);
3621 }
3622 #endif // FEAT_MENU
3623
3624 #ifdef FEAT_TOOLBAR
3625 /*
3626 * Create the toolbar and handle
3627 */
3628 // some aesthetics on the toolbar
3629 # ifdef USE_GTK3
3630 // TODO: Add GTK+ 3 code here using GtkCssProvider if necessary.
3631 // N.B. Since the default value of GtkToolbar::button-relief is
3632 // GTK_RELIEF_NONE, there's no need to specify that, probably.
3633 # else
3634 gtk_rc_parse_string(
3635 "style \"vim-toolbar-style\" {\n"
3636 " GtkToolbar::button_relief = GTK_RELIEF_NONE\n"
3637 "}\n"
3638 "widget \"*.vim-toolbar\" style \"vim-toolbar-style\"\n");
3639 # endif
3640 gui.toolbar = gtk_toolbar_new();
3641 gtk_widget_set_name(gui.toolbar, "vim-toolbar");
3642 set_toolbar_style(GTK_TOOLBAR(gui.toolbar));
3643
3644 # ifdef FEAT_GUI_GNOME
3645 if (using_gnome)
3646 {
3647 BonoboDockItem *dockitem;
3648
3649 gnome_app_set_toolbar(GNOME_APP(gui.mainwin), GTK_TOOLBAR(gui.toolbar));
3650 dockitem = gnome_app_get_dock_item_by_name(GNOME_APP(gui.mainwin),
3651 GNOME_APP_TOOLBAR_NAME);
3652 gui.toolbar_h = GTK_WIDGET(dockitem);
3653 // When the toolbar is floating it gets stuck. So long as that isn't
3654 // fixed let's disallow floating.
3655 bonobo_dock_item_set_behavior(dockitem,
3656 bonobo_dock_item_get_behavior(dockitem)
3657 | BONOBO_DOCK_ITEM_BEH_NEVER_FLOATING);
3658 gtk_container_set_border_width(GTK_CONTAINER(gui.toolbar), 0);
3659 }
3660 else
3661 # endif // FEAT_GUI_GNOME
3662 {
3663 if (vim_strchr(p_go, GO_TOOLBAR) != NULL
3664 && (toolbar_flags & (TOOLBAR_TEXT | TOOLBAR_ICONS)))
3665 gtk_widget_show(gui.toolbar);
3666 gtk_box_pack_start(GTK_BOX(vbox), gui.toolbar, FALSE, FALSE, 0);
3667 }
3668 #endif // FEAT_TOOLBAR
3669
3670 #ifdef FEAT_GUI_TABLINE
3671 /*
3672 * Use a Notebook for the tab pages labels. The labels are hidden by
3673 * default.
3674 */
3675 gui.tabline = gtk_notebook_new();
3676 gtk_widget_show(gui.tabline);
3677 gtk_box_pack_start(GTK_BOX(vbox), gui.tabline, FALSE, FALSE, 0);
3678 gtk_notebook_set_show_border(GTK_NOTEBOOK(gui.tabline), FALSE);
3679 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(gui.tabline), FALSE);
3680 gtk_notebook_set_scrollable(GTK_NOTEBOOK(gui.tabline), TRUE);
3681 # if !GTK_CHECK_VERSION(3,0,0)
3682 gtk_notebook_set_tab_border(GTK_NOTEBOOK(gui.tabline), FALSE);
3683 # endif
3684
3685 # if !GTK_CHECK_VERSION(3,0,0)
3686 tabline_tooltip = gtk_tooltips_new();
3687 gtk_tooltips_enable(GTK_TOOLTIPS(tabline_tooltip));
3688 # endif
3689
3690 {
3691 GtkWidget *page, *label, *event_box;
3692
3693 // Add the first tab.
3694 # if GTK_CHECK_VERSION(3,2,0)
3695 page = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
3696 gtk_box_set_homogeneous(GTK_BOX(page), FALSE);
3697 # else
3698 page = gtk_vbox_new(FALSE, 0);
3699 # endif
3700 gtk_widget_show(page);
3701 gtk_container_add(GTK_CONTAINER(gui.tabline), page);
3702 label = gtk_label_new("-Empty-");
3703 gtk_widget_show(label);
3704 event_box = gtk_event_box_new();
3705 gtk_widget_show(event_box);
3706 g_object_set_data(G_OBJECT(event_box), "tab_num", GINT_TO_POINTER(1L));
3707 # if !GTK_CHECK_VERSION(3,14,0)
3708 gtk_misc_set_padding(GTK_MISC(label), 2, 2);
3709 # endif
3710 gtk_container_add(GTK_CONTAINER(event_box), label);
3711 gtk_notebook_set_tab_label(GTK_NOTEBOOK(gui.tabline), page, event_box);
3712 # if GTK_CHECK_VERSION(2,10,0)
3713 gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(gui.tabline), page, TRUE);
3714 # endif
3715 }
3716
3717 g_signal_connect(G_OBJECT(gui.tabline), "switch-page",
3718 G_CALLBACK(on_select_tab), NULL);
3719 # if GTK_CHECK_VERSION(2,10,0)
3720 g_signal_connect(G_OBJECT(gui.tabline), "page-reordered",
3721 G_CALLBACK(on_tab_reordered), NULL);
3722 # endif
3723
3724 // Create a popup menu for the tab line and connect it.
3725 tabline_menu = create_tabline_menu();
3726 g_signal_connect_swapped(G_OBJECT(gui.tabline), "button-press-event",
3727 G_CALLBACK(on_tabline_menu), G_OBJECT(tabline_menu));
3728 #endif // FEAT_GUI_TABLINE
3729
3730 gui.formwin = gui_gtk_form_new();
3731 gtk_container_set_border_width(GTK_CONTAINER(gui.formwin), 0);
3732 #if !GTK_CHECK_VERSION(3,0,0)
3733 gtk_widget_set_events(gui.formwin, GDK_EXPOSURE_MASK);
3734 #endif
3735 #if GTK_CHECK_VERSION(3,22,2)
3736 gtk_widget_set_name(gui.formwin, "vim-gtk-form");
3737 #endif
3738
3739 gui.drawarea = gtk_drawing_area_new();
3740 #if GTK_CHECK_VERSION(3,0,0)
3741 gui.surface = NULL;
3742 #endif
3743
3744 // Determine which events we will filter.
3745 gtk_widget_set_events(gui.drawarea,
3746 GDK_EXPOSURE_MASK |
3747 GDK_ENTER_NOTIFY_MASK |
3748 GDK_LEAVE_NOTIFY_MASK |
3749 GDK_BUTTON_PRESS_MASK |
3750 GDK_BUTTON_RELEASE_MASK |
3751 GDK_SCROLL_MASK |
3752 GDK_KEY_PRESS_MASK |
3753 GDK_KEY_RELEASE_MASK |
3754 GDK_POINTER_MOTION_MASK |
3755 GDK_POINTER_MOTION_HINT_MASK);
3756
3757 gtk_widget_show(gui.drawarea);
3758 gui_gtk_form_put(GTK_FORM(gui.formwin), gui.drawarea, 0, 0);
3759 gtk_widget_show(gui.formwin);
3760 gtk_box_pack_start(GTK_BOX(vbox), gui.formwin, TRUE, TRUE, 0);
3761
3762 // For GtkSockets, key-presses must go to the focus widget (drawarea)
3763 // and not the window.
3764 g_signal_connect((gtk_socket_id == 0) ? G_OBJECT(gui.mainwin)
3765 : G_OBJECT(gui.drawarea),
3766 "key-press-event",
3767 G_CALLBACK(key_press_event), NULL);
3768 #if defined(FEAT_XIM) || GTK_CHECK_VERSION(3,0,0)
3769 // Also forward key release events for the benefit of GTK+ 2 input
3770 // modules. Try CTRL-SHIFT-xdigits to enter a Unicode code point.
3771 g_signal_connect((gtk_socket_id == 0) ? G_OBJECT(gui.mainwin)
3772 : G_OBJECT(gui.drawarea),
3773 "key-release-event",
3774 G_CALLBACK(&key_release_event), NULL);
3775 #endif
3776 g_signal_connect(G_OBJECT(gui.drawarea), "realize",
3777 G_CALLBACK(drawarea_realize_cb), NULL);
3778 g_signal_connect(G_OBJECT(gui.drawarea), "unrealize",
3779 G_CALLBACK(drawarea_unrealize_cb), NULL);
3780 #if GTK_CHECK_VERSION(3,0,0)
3781 g_signal_connect(G_OBJECT(gui.drawarea), "configure-event",
3782 G_CALLBACK(drawarea_configure_event_cb), NULL);
3783 #endif
3784 #if GTK_CHECK_VERSION(3,22,2)
3785 g_signal_connect_after(G_OBJECT(gui.drawarea), "style-updated",
3786 G_CALLBACK(&drawarea_style_updated_cb), NULL);
3787 #else
3788 g_signal_connect_after(G_OBJECT(gui.drawarea), "style-set",
3789 G_CALLBACK(&drawarea_style_set_cb), NULL);
3790 #endif
3791
3792 #if !GTK_CHECK_VERSION(3,0,0)
3793 gui.visibility = GDK_VISIBILITY_UNOBSCURED;
3794 #endif
3795
3796 #if !defined(USE_GNOME_SESSION)
3797 wm_protocols_atom = gdk_atom_intern("WM_PROTOCOLS", FALSE);
3798 save_yourself_atom = gdk_atom_intern("WM_SAVE_YOURSELF", FALSE);
3799 #endif
3800
3801 if (gtk_socket_id != 0)
3802 // make sure keyboard input can go to the drawarea
3803 gtk_widget_set_can_focus(gui.drawarea, TRUE);
3804
3805 /*
3806 * Set clipboard specific atoms
3807 */
3808 vim_atom = gdk_atom_intern(VIM_ATOM_NAME, FALSE);
3809 vimenc_atom = gdk_atom_intern(VIMENC_ATOM_NAME, FALSE);
3810 clip_star.gtk_sel_atom = GDK_SELECTION_PRIMARY;
3811 clip_plus.gtk_sel_atom = gdk_atom_intern("CLIPBOARD", FALSE);
3812
3813 /*
3814 * Start out by adding the configured border width into the border offset.
3815 */
3816 gui.border_offset = gui.border_width;
3817
3818 #if GTK_CHECK_VERSION(3,0,0)
3819 g_signal_connect(G_OBJECT(gui.drawarea), "draw",
3820 G_CALLBACK(draw_event), NULL);
3821 #else
3822 gtk_signal_connect(GTK_OBJECT(gui.mainwin), "visibility_notify_event",
3823 GTK_SIGNAL_FUNC(visibility_event), NULL);
3824 gtk_signal_connect(GTK_OBJECT(gui.drawarea), "expose_event",
3825 GTK_SIGNAL_FUNC(expose_event), NULL);
3826 #endif
3827
3828 /*
3829 * Only install these enter/leave callbacks when 'p' in 'guioptions'.
3830 * Only needed for some window managers.
3831 */
3832 if (vim_strchr(p_go, GO_POINTER) != NULL)
3833 {
3834 g_signal_connect(G_OBJECT(gui.drawarea), "leave-notify-event",
3835 G_CALLBACK(leave_notify_event), NULL);
3836 g_signal_connect(G_OBJECT(gui.drawarea), "enter-notify-event",
3837 G_CALLBACK(enter_notify_event), NULL);
3838 }
3839
3840 // Real windows can get focus ... GtkPlug, being a mere container can't,
3841 // only its widgets. Arguably, this could be common code and we not use
3842 // the window focus at all, but let's be safe.
3843 if (gtk_socket_id == 0)
3844 {
3845 g_signal_connect(G_OBJECT(gui.mainwin), "focus-out-event",
3846 G_CALLBACK(focus_out_event), NULL);
3847 g_signal_connect(G_OBJECT(gui.mainwin), "focus-in-event",
3848 G_CALLBACK(focus_in_event), NULL);
3849 }
3850 else
3851 {
3852 g_signal_connect(G_OBJECT(gui.drawarea), "focus-out-event",
3853 G_CALLBACK(focus_out_event), NULL);
3854 g_signal_connect(G_OBJECT(gui.drawarea), "focus-in-event",
3855 G_CALLBACK(focus_in_event), NULL);
3856 #ifdef FEAT_GUI_TABLINE
3857 g_signal_connect(G_OBJECT(gui.tabline), "focus-out-event",
3858 G_CALLBACK(focus_out_event), NULL);
3859 g_signal_connect(G_OBJECT(gui.tabline), "focus-in-event",
3860 G_CALLBACK(focus_in_event), NULL);
3861 #endif // FEAT_GUI_TABLINE
3862 }
3863
3864 g_signal_connect(G_OBJECT(gui.drawarea), "motion-notify-event",
3865 G_CALLBACK(motion_notify_event), NULL);
3866 g_signal_connect(G_OBJECT(gui.drawarea), "button-press-event",
3867 G_CALLBACK(button_press_event), NULL);
3868 g_signal_connect(G_OBJECT(gui.drawarea), "button-release-event",
3869 G_CALLBACK(button_release_event), NULL);
3870 g_signal_connect(G_OBJECT(gui.drawarea), "scroll-event",
3871 G_CALLBACK(&scroll_event), NULL);
3872
3873 /*
3874 * Add selection handler functions.
3875 */
3876 g_signal_connect(G_OBJECT(gui.drawarea), "selection-clear-event",
3877 G_CALLBACK(selection_clear_event), NULL);
3878 g_signal_connect(G_OBJECT(gui.drawarea), "selection-received",
3879 G_CALLBACK(selection_received_cb), NULL);
3880
3881 gui_gtk_set_selection_targets();
3882
3883 g_signal_connect(G_OBJECT(gui.drawarea), "selection-get",
3884 G_CALLBACK(selection_get_cb), NULL);
3885
3886 // Pretend we don't have input focus, we will get an event if we do.
3887 gui.in_focus = FALSE;
3888
3889 // Handle changes to the "Xft/DPI" setting.
3890 {
3891 GtkSettings *gtk_settings =
3892 gtk_settings_get_for_screen(gdk_screen_get_default());
3893
3894 g_signal_connect(gtk_settings, "notify::gtk-xft-dpi",
3895 G_CALLBACK(gtk_settings_xft_dpi_changed_cb), NULL);
3896 }
3897
3898 return OK;
3899 }
3900
3901 #if defined(USE_GNOME_SESSION) || defined(PROTO)
3902 /*
3903 * This is called from gui_start() after a fork() has been done.
3904 * We have to tell the session manager our new PID.
3905 */
3906 void
gui_mch_forked(void)3907 gui_mch_forked(void)
3908 {
3909 if (using_gnome)
3910 {
3911 GnomeClient *client;
3912
3913 client = gnome_master_client();
3914
3915 if (client != NULL)
3916 gnome_client_set_process_id(client, getpid());
3917 }
3918 }
3919 #endif // USE_GNOME_SESSION
3920
3921 #if GTK_CHECK_VERSION(3,0,0)
3922 static GdkRGBA
color_to_rgba(guicolor_T color)3923 color_to_rgba(guicolor_T color)
3924 {
3925 GdkRGBA rgba;
3926 rgba.red = ((color & 0xff0000) >> 16) / 255.0;
3927 rgba.green = ((color & 0xff00) >> 8) / 255.0;
3928 rgba.blue = ((color & 0xff)) / 255.0;
3929 rgba.alpha = 1.0;
3930 return rgba;
3931 }
3932
3933 static void
set_cairo_source_rgba_from_color(cairo_t * cr,guicolor_T color)3934 set_cairo_source_rgba_from_color(cairo_t *cr, guicolor_T color)
3935 {
3936 const GdkRGBA rgba = color_to_rgba(color);
3937 cairo_set_source_rgba(cr, rgba.red, rgba.green, rgba.blue, rgba.alpha);
3938 }
3939 #endif // GTK_CHECK_VERSION(3,0,0)
3940
3941 /*
3942 * Called when the foreground or background color has been changed.
3943 * This used to change the graphics contexts directly but we are
3944 * currently manipulating them where desired.
3945 */
3946 void
gui_mch_new_colors(void)3947 gui_mch_new_colors(void)
3948 {
3949 if (gui.drawarea != NULL
3950 #if GTK_CHECK_VERSION(3,22,2)
3951 && gui.formwin != NULL
3952 #endif
3953 && gtk_widget_get_window(gui.drawarea) != NULL)
3954 {
3955 #if !GTK_CHECK_VERSION(3,22,2)
3956 GdkWindow * const da_win = gtk_widget_get_window(gui.drawarea);
3957 #endif
3958 #if GTK_CHECK_VERSION(3,22,2)
3959 GtkStyleContext * const context =
3960 gtk_widget_get_style_context(gui.formwin);
3961 GtkCssProvider * const provider = gtk_css_provider_new();
3962 gchar * const css = g_strdup_printf(
3963 "widget#vim-gtk-form {\n"
3964 " background-color: #%.2lx%.2lx%.2lx;\n"
3965 "}\n",
3966 (gui.back_pixel >> 16) & 0xff,
3967 (gui.back_pixel >> 8) & 0xff,
3968 gui.back_pixel & 0xff);
3969
3970 gtk_css_provider_load_from_data(provider, css, -1, NULL);
3971 gtk_style_context_add_provider(context,
3972 GTK_STYLE_PROVIDER(provider), G_MAXUINT);
3973
3974 g_free(css);
3975 g_object_unref(provider);
3976 #elif GTK_CHECK_VERSION(3,4,0) // !GTK_CHECK_VERSION(3,22,2)
3977 GdkRGBA rgba;
3978
3979 rgba = color_to_rgba(gui.back_pixel);
3980 {
3981 cairo_pattern_t * const pat = cairo_pattern_create_rgba(
3982 rgba.red, rgba.green, rgba.blue, rgba.alpha);
3983 if (pat != NULL)
3984 {
3985 gdk_window_set_background_pattern(da_win, pat);
3986 cairo_pattern_destroy(pat);
3987 }
3988 else
3989 gdk_window_set_background_rgba(da_win, &rgba);
3990 }
3991 #else // !GTK_CHECK_VERSION(3,4,0)
3992 GdkColor color = { 0, 0, 0, 0 };
3993
3994 color.pixel = gui.back_pixel;
3995 gdk_window_set_background(da_win, &color);
3996 #endif // !GTK_CHECK_VERSION(3,22,2)
3997 }
3998 }
3999
4000 /*
4001 * This signal informs us about the need to rearrange our sub-widgets.
4002 */
4003 static gint
form_configure_event(GtkWidget * widget UNUSED,GdkEventConfigure * event,gpointer data UNUSED)4004 form_configure_event(GtkWidget *widget UNUSED,
4005 GdkEventConfigure *event,
4006 gpointer data UNUSED)
4007 {
4008 int usable_height = event->height;
4009
4010 #if GTK_CHECK_VERSION(3,22,2) && !GTK_CHECK_VERSION(3,22,4)
4011 // As of 3.22.2, GdkWindows have started distributing configure events to
4012 // their "native" children (https://git.gnome.org/browse/gtk+/commit/?h=gtk-3-22&id=12579fe71b3b8f79eb9c1b80e429443bcc437dd0).
4013 //
4014 // As can be seen from the implementation of move_native_children() and
4015 // configure_native_child() in gdkwindow.c, those functions actually
4016 // propagate configure events to every child, failing to distinguish
4017 // "native" one from non-native one.
4018 //
4019 // Naturally, configure events propagated to here like that are fallacious
4020 // and, as a matter of fact, they trigger a geometric collapse of
4021 // gui.formwin.
4022 //
4023 // To filter out such fallacious events, check if the given event is the
4024 // one that was sent out to the right place. Ignore it if not.
4025 //
4026 // Follow-up
4027 // After a few weeks later, the GdkWindow change mentioned above was
4028 // reverted (https://git.gnome.org/browse/gtk+/commit/?h=gtk-3-22&id=f70039cb9603a02d2369fec4038abf40a1711155).
4029 // The corresponding official release is 3.22.4.
4030 if (event->window != gtk_widget_get_window(gui.formwin))
4031 return TRUE;
4032 #endif
4033
4034 // When in a GtkPlug, we can't guarantee valid heights (as a round
4035 // no. of char-heights), so we have to manually sanitise them.
4036 // Widths seem to sort themselves out, don't ask me why.
4037 if (gtk_socket_id != 0)
4038 usable_height -= (gui.char_height - (gui.char_height/2)); // sic.
4039
4040 gui_gtk_form_freeze(GTK_FORM(gui.formwin));
4041 gui_resize_shell(event->width, usable_height);
4042 gui_gtk_form_thaw(GTK_FORM(gui.formwin));
4043
4044 return TRUE;
4045 }
4046
4047 /*
4048 * Function called when window already closed.
4049 * We can't do much more here than to trying to preserve what had been done,
4050 * since the window is already inevitably going away.
4051 */
4052 static void
mainwin_destroy_cb(GObject * object UNUSED,gpointer data UNUSED)4053 mainwin_destroy_cb(GObject *object UNUSED, gpointer data UNUSED)
4054 {
4055 // Don't write messages to the GUI anymore
4056 full_screen = FALSE;
4057
4058 gui.mainwin = NULL;
4059 gui.drawarea = NULL;
4060
4061 if (!exiting) // only do anything if the destroy was unexpected
4062 {
4063 vim_strncpy(IObuff,
4064 (char_u *)_("Vim: Main window unexpectedly destroyed\n"),
4065 IOSIZE - 1);
4066 preserve_exit();
4067 }
4068 #ifdef USE_GRESOURCE
4069 gui_gtk_unregister_resource();
4070 #endif
4071 }
4072
4073 void
gui_gtk_get_screen_geom_of_win(GtkWidget * wid,int point_x,int point_y,int * screen_x,int * screen_y,int * width,int * height)4074 gui_gtk_get_screen_geom_of_win(
4075 GtkWidget *wid,
4076 int point_x, // x position of window if not initialized
4077 int point_y, // y position of window if not initialized
4078 int *screen_x,
4079 int *screen_y,
4080 int *width,
4081 int *height)
4082 {
4083 GdkRectangle geometry;
4084 GdkWindow *win = gtk_widget_get_window(wid);
4085 #if GTK_CHECK_VERSION(3,22,0)
4086 GdkDisplay *dpy;
4087 GdkMonitor *monitor;
4088
4089 if (wid != NULL && gtk_widget_get_realized(wid))
4090 dpy = gtk_widget_get_display(wid);
4091 else
4092 dpy = gdk_display_get_default();
4093 if (win != NULL)
4094 monitor = gdk_display_get_monitor_at_window(dpy, win);
4095 else
4096 monitor = gdk_display_get_monitor_at_point(dpy, point_x, point_y);
4097 gdk_monitor_get_geometry(monitor, &geometry);
4098 #else
4099 GdkScreen* screen;
4100 int monitor;
4101
4102 if (wid != NULL && gtk_widget_has_screen(wid))
4103 screen = gtk_widget_get_screen(wid);
4104 else
4105 screen = gdk_screen_get_default();
4106 if (win != NULL)
4107 monitor = gdk_screen_get_monitor_at_window(screen, win);
4108 else
4109 monitor = gdk_screen_get_monitor_at_point(screen, point_x, point_y);
4110 gdk_screen_get_monitor_geometry(screen, monitor, &geometry);
4111 #endif
4112 *screen_x = geometry.x;
4113 *screen_y = geometry.y;
4114 *width = geometry.width;
4115 *height = geometry.height;
4116 }
4117
4118 /*
4119 * The screen size is used to make sure the initial window doesn't get bigger
4120 * than the screen. This subtracts some room for menubar, toolbar and window
4121 * decorations.
4122 */
4123 static void
gui_gtk_get_screen_dimensions(int point_x,int point_y,int * screen_w,int * screen_h)4124 gui_gtk_get_screen_dimensions(
4125 int point_x,
4126 int point_y,
4127 int *screen_w,
4128 int *screen_h)
4129 {
4130 int x, y;
4131
4132 gui_gtk_get_screen_geom_of_win(gui.mainwin, point_x, point_y,
4133 &x, &y, screen_w, screen_h);
4134
4135 // Subtract 'guiheadroom' from the height to allow some room for the
4136 // window manager (task list and window title bar).
4137 *screen_h -= p_ghr;
4138
4139 /*
4140 * FIXME: dirty trick: Because the gui_get_base_height() doesn't include
4141 * the toolbar and menubar for GTK, we subtract them from the screen
4142 * height, so that the window size can be made to fit on the screen.
4143 * This should be completely changed later.
4144 */
4145 *screen_w -= get_menu_tool_width();
4146 *screen_h -= get_menu_tool_height();
4147 }
4148
4149 void
gui_mch_get_screen_dimensions(int * screen_w,int * screen_h)4150 gui_mch_get_screen_dimensions(int *screen_w, int *screen_h)
4151 {
4152 gui_gtk_get_screen_dimensions(0, 0, screen_w, screen_h);
4153 }
4154
4155
4156 /*
4157 * Bit of a hack to ensure we start GtkPlug windows with the correct window
4158 * hints (and thus the required size from -geom), but that after that we
4159 * put the hints back to normal (the actual minimum size) so we may
4160 * subsequently be resized smaller. GtkSocket (the parent end) uses the
4161 * plug's window 'min hints to set *its* minimum size, but that's also the
4162 * only way we have of making ourselves bigger (by set lines/columns).
4163 * Thus set hints at start-up to ensure correct init. size, then a
4164 * second after the final attempt to reset the real minimum hints (done by
4165 * scrollbar init.), actually do the standard hints and stop the timer.
4166 * We'll not let the default hints be set while this timer's active.
4167 */
4168 static timeout_cb_type
check_startup_plug_hints(gpointer data UNUSED)4169 check_startup_plug_hints(gpointer data UNUSED)
4170 {
4171 if (init_window_hints_state == 1)
4172 {
4173 // Safe to use normal hints now
4174 init_window_hints_state = 0;
4175 update_window_manager_hints(0, 0);
4176 return FALSE; // stop timer
4177 }
4178
4179 // Keep on trying
4180 init_window_hints_state = 1;
4181 return TRUE;
4182 }
4183
4184 /*
4185 * Open the GUI window which was created by a call to gui_mch_init().
4186 */
4187 int
gui_mch_open(void)4188 gui_mch_open(void)
4189 {
4190 guicolor_T fg_pixel = INVALCOLOR;
4191 guicolor_T bg_pixel = INVALCOLOR;
4192 guint pixel_width;
4193 guint pixel_height;
4194
4195 /*
4196 * Allow setting a window role on the command line, or invent one
4197 * if none was specified. This is mainly useful for GNOME session
4198 * support; allowing the WM to restore window placement.
4199 */
4200 if (role_argument != NULL)
4201 {
4202 gtk_window_set_role(GTK_WINDOW(gui.mainwin), role_argument);
4203 }
4204 else
4205 {
4206 char *role;
4207
4208 // Invent a unique-enough ID string for the role
4209 role = g_strdup_printf("vim-%u-%u-%u",
4210 (unsigned)mch_get_pid(),
4211 (unsigned)g_random_int(),
4212 (unsigned)time(NULL));
4213
4214 gtk_window_set_role(GTK_WINDOW(gui.mainwin), role);
4215 g_free(role);
4216 }
4217
4218 if (gui_win_x != -1 && gui_win_y != -1)
4219 gtk_window_move(GTK_WINDOW(gui.mainwin), gui_win_x, gui_win_y);
4220
4221 // Determine user specified geometry, if present.
4222 if (gui.geom != NULL)
4223 {
4224 int mask;
4225 unsigned int w, h;
4226 int x = 0;
4227 int y = 0;
4228
4229 mask = XParseGeometry((char *)gui.geom, &x, &y, &w, &h);
4230
4231 if (mask & WidthValue)
4232 Columns = w;
4233 if (mask & HeightValue)
4234 {
4235 if (p_window > (long)h - 1 || !option_was_set((char_u *)"window"))
4236 p_window = h - 1;
4237 Rows = h;
4238 }
4239 limit_screen_size();
4240
4241 pixel_width = (guint)(gui_get_base_width() + Columns * gui.char_width);
4242 pixel_height = (guint)(gui_get_base_height() + Rows * gui.char_height);
4243
4244 pixel_width += get_menu_tool_width();
4245 pixel_height += get_menu_tool_height();
4246
4247 if (mask & (XValue | YValue))
4248 {
4249 int ww, hh;
4250
4251 #ifdef FEAT_GUI_GTK
4252 gui_gtk_get_screen_dimensions(x, y, &ww, &hh);
4253 #else
4254 gui_mch_get_screen_dimensions(&ww, &hh);
4255 #endif
4256 hh += p_ghr + get_menu_tool_height();
4257 ww += get_menu_tool_width();
4258 if (mask & XNegative)
4259 x += ww - pixel_width;
4260 if (mask & YNegative)
4261 y += hh - pixel_height;
4262 gtk_window_move(GTK_WINDOW(gui.mainwin), x, y);
4263 }
4264 VIM_CLEAR(gui.geom);
4265
4266 // From now until everyone's stopped trying to set the window hints
4267 // to their correct minimum values, stop them being set as we need
4268 // them to remain at our required size for the parent GtkSocket to
4269 // give us the right initial size.
4270 if (gtk_socket_id != 0 && (mask & WidthValue || mask & HeightValue))
4271 {
4272 update_window_manager_hints(pixel_width, pixel_height);
4273 init_window_hints_state = 1;
4274 timeout_add(1000, check_startup_plug_hints, NULL);
4275 }
4276 }
4277
4278 pixel_width = (guint)(gui_get_base_width() + Columns * gui.char_width);
4279 pixel_height = (guint)(gui_get_base_height() + Rows * gui.char_height);
4280 // For GTK2 changing the size of the form widget doesn't cause window
4281 // resizing.
4282 if (gtk_socket_id == 0)
4283 gtk_window_resize(GTK_WINDOW(gui.mainwin), pixel_width, pixel_height);
4284 update_window_manager_hints(0, 0);
4285
4286 if (foreground_argument != NULL)
4287 fg_pixel = gui_get_color((char_u *)foreground_argument);
4288 if (fg_pixel == INVALCOLOR)
4289 fg_pixel = gui_get_color((char_u *)"Black");
4290
4291 if (background_argument != NULL)
4292 bg_pixel = gui_get_color((char_u *)background_argument);
4293 if (bg_pixel == INVALCOLOR)
4294 bg_pixel = gui_get_color((char_u *)"White");
4295
4296 if (found_reverse_arg)
4297 {
4298 gui.def_norm_pixel = bg_pixel;
4299 gui.def_back_pixel = fg_pixel;
4300 }
4301 else
4302 {
4303 gui.def_norm_pixel = fg_pixel;
4304 gui.def_back_pixel = bg_pixel;
4305 }
4306
4307 // Get the colors from the "Normal" and "Menu" group (set in syntax.c or
4308 // in a vimrc file)
4309 set_normal_colors();
4310
4311 // Check that none of the colors are the same as the background color
4312 gui_check_colors();
4313
4314 // Get the colors for the highlight groups (gui_check_colors() might have
4315 // changed them).
4316 highlight_gui_started(); // re-init colors and fonts
4317
4318 g_signal_connect(G_OBJECT(gui.mainwin), "destroy",
4319 G_CALLBACK(mainwin_destroy_cb), NULL);
4320
4321 /*
4322 * Notify the fixed area about the need to resize the contents of the
4323 * gui.formwin, which we use for random positioning of the included
4324 * components.
4325 *
4326 * We connect this signal deferred finally after anything is in place,
4327 * since this is intended to handle resizements coming from the window
4328 * manager upon us and should not interfere with what VIM is requesting
4329 * upon startup.
4330 */
4331 g_signal_connect(G_OBJECT(gui.formwin), "configure-event",
4332 G_CALLBACK(form_configure_event), NULL);
4333
4334 #ifdef FEAT_DND
4335 // Set up for receiving DND items.
4336 gui_gtk_set_dnd_targets();
4337
4338 g_signal_connect(G_OBJECT(gui.drawarea), "drag-data-received",
4339 G_CALLBACK(drag_data_received_cb), NULL);
4340 #endif
4341
4342 // With GTK+ 2, we need to iconify the window before calling show()
4343 // to avoid mapping the window for a short time.
4344 if (found_iconic_arg && gtk_socket_id == 0)
4345 gui_mch_iconify();
4346
4347 {
4348 #if defined(FEAT_GUI_GNOME) && defined(FEAT_MENU)
4349 unsigned long menu_handler = 0;
4350 # ifdef FEAT_TOOLBAR
4351 unsigned long tool_handler = 0;
4352 # endif
4353 /*
4354 * Urgh hackish :/ For some reason BonoboDockLayout always forces a
4355 * show when restoring the saved layout configuration. We can't just
4356 * hide the widgets again after gtk_widget_show(gui.mainwin) since it's
4357 * a toplevel window and thus will be realized immediately. Instead,
4358 * connect signal handlers to hide the widgets just after they've been
4359 * marked visible, but before the main window is realized.
4360 */
4361 if (using_gnome && vim_strchr(p_go, GO_MENUS) == NULL)
4362 menu_handler = g_signal_connect_after(gui.menubar_h, "show",
4363 G_CALLBACK(>k_widget_hide),
4364 NULL);
4365 # ifdef FEAT_TOOLBAR
4366 if (using_gnome && vim_strchr(p_go, GO_TOOLBAR) == NULL
4367 && (toolbar_flags & (TOOLBAR_TEXT | TOOLBAR_ICONS)))
4368 tool_handler = g_signal_connect_after(gui.toolbar_h, "show",
4369 G_CALLBACK(>k_widget_hide),
4370 NULL);
4371 # endif
4372 #endif
4373 gtk_widget_show(gui.mainwin);
4374
4375 #if defined(FEAT_GUI_GNOME) && defined(FEAT_MENU)
4376 if (menu_handler != 0)
4377 g_signal_handler_disconnect(gui.menubar_h, menu_handler);
4378 # ifdef FEAT_TOOLBAR
4379 if (tool_handler != 0)
4380 g_signal_handler_disconnect(gui.toolbar_h, tool_handler);
4381 # endif
4382 #endif
4383 }
4384
4385 return OK;
4386 }
4387
4388 /*
4389 * Clean up for when exiting Vim.
4390 */
4391 void
gui_mch_exit(int rc UNUSED)4392 gui_mch_exit(int rc UNUSED)
4393 {
4394 // Clean up, unless we don't want to invoke free().
4395 if (gui.mainwin != NULL && !really_exiting)
4396 gtk_widget_destroy(gui.mainwin);
4397 }
4398
4399 /*
4400 * Get the position of the top left corner of the window.
4401 */
4402 int
gui_mch_get_winpos(int * x,int * y)4403 gui_mch_get_winpos(int *x, int *y)
4404 {
4405 gtk_window_get_position(GTK_WINDOW(gui.mainwin), x, y);
4406 return OK;
4407 }
4408
4409 /*
4410 * Set the position of the top left corner of the window to the given
4411 * coordinates.
4412 */
4413 void
gui_mch_set_winpos(int x,int y)4414 gui_mch_set_winpos(int x, int y)
4415 {
4416 gtk_window_move(GTK_WINDOW(gui.mainwin), x, y);
4417 }
4418
4419 #if !GTK_CHECK_VERSION(3,0,0)
4420 # if 0
4421 static int resize_idle_installed = FALSE;
4422 /*
4423 * Idle handler to force resize. Used by gui_mch_set_shellsize() to ensure
4424 * the shell size doesn't exceed the window size, i.e. if the window manager
4425 * ignored our size request. Usually this happens if the window is maximized.
4426 *
4427 * FIXME: It'd be nice if we could find a little more orthodox solution.
4428 * See also the remark below in gui_mch_set_shellsize().
4429 *
4430 * DISABLED: When doing ":set lines+=1" this function would first invoke
4431 * gui_resize_shell() with the old size, then the normal callback would
4432 * report the new size through form_configure_event(). That caused the window
4433 * layout to be messed up.
4434 */
4435 static gboolean
4436 force_shell_resize_idle(gpointer data)
4437 {
4438 if (gui.mainwin != NULL
4439 && GTK_WIDGET_REALIZED(gui.mainwin)
4440 && GTK_WIDGET_VISIBLE(gui.mainwin))
4441 {
4442 int width;
4443 int height;
4444
4445 gtk_window_get_size(GTK_WINDOW(gui.mainwin), &width, &height);
4446
4447 width -= get_menu_tool_width();
4448 height -= get_menu_tool_height();
4449
4450 gui_resize_shell(width, height);
4451 }
4452
4453 resize_idle_installed = FALSE;
4454 return FALSE; // don't call me again
4455 }
4456 # endif
4457 #endif // !GTK_CHECK_VERSION(3,0,0)
4458
4459 /*
4460 * Return TRUE if the main window is maximized.
4461 */
4462 int
gui_mch_maximized(void)4463 gui_mch_maximized(void)
4464 {
4465 return (gui.mainwin != NULL && gtk_widget_get_window(gui.mainwin) != NULL
4466 && (gdk_window_get_state(gtk_widget_get_window(gui.mainwin))
4467 & GDK_WINDOW_STATE_MAXIMIZED));
4468 }
4469
4470 /*
4471 * Unmaximize the main window
4472 */
4473 void
gui_mch_unmaximize(void)4474 gui_mch_unmaximize(void)
4475 {
4476 if (gui.mainwin != NULL)
4477 gtk_window_unmaximize(GTK_WINDOW(gui.mainwin));
4478 }
4479
4480 /*
4481 * Called when the font changed while the window is maximized or GO_KEEPWINSIZE
4482 * is set. Compute the new Rows and Columns. This is like resizing the
4483 * window.
4484 */
4485 void
gui_mch_newfont(void)4486 gui_mch_newfont(void)
4487 {
4488 int w, h;
4489
4490 gtk_window_get_size(GTK_WINDOW(gui.mainwin), &w, &h);
4491 w -= get_menu_tool_width();
4492 h -= get_menu_tool_height();
4493 gui_resize_shell(w, h);
4494 }
4495
4496 /*
4497 * Set the windows size.
4498 */
4499 void
gui_mch_set_shellsize(int width,int height,int min_width UNUSED,int min_height UNUSED,int base_width UNUSED,int base_height UNUSED,int direction UNUSED)4500 gui_mch_set_shellsize(int width, int height,
4501 int min_width UNUSED, int min_height UNUSED,
4502 int base_width UNUSED, int base_height UNUSED,
4503 int direction UNUSED)
4504 {
4505 // give GTK+ a chance to put all widget's into place
4506 gui_mch_update();
4507
4508 // this will cause the proper resizement to happen too
4509 if (gtk_socket_id == 0)
4510 update_window_manager_hints(0, 0);
4511
4512 // With GTK+ 2, changing the size of the form widget doesn't resize
4513 // the window. So let's do it the other way around and resize the
4514 // main window instead.
4515 width += get_menu_tool_width();
4516 height += get_menu_tool_height();
4517
4518 if (gtk_socket_id == 0)
4519 gtk_window_resize(GTK_WINDOW(gui.mainwin), width, height);
4520 else
4521 update_window_manager_hints(width, height);
4522
4523 # if !GTK_CHECK_VERSION(3,0,0)
4524 # if 0
4525 if (!resize_idle_installed)
4526 {
4527 g_idle_add_full(GDK_PRIORITY_EVENTS + 10,
4528 &force_shell_resize_idle, NULL, NULL);
4529 resize_idle_installed = TRUE;
4530 }
4531 # endif
4532 # endif // !GTK_CHECK_VERSION(3,0,0)
4533 /*
4534 * Wait until all events are processed to prevent a crash because the
4535 * real size of the drawing area doesn't reflect Vim's internal ideas.
4536 *
4537 * This is a bit of a hack, since Vim is a terminal application with a GUI
4538 * on top, while the GUI expects to be the boss.
4539 */
4540 gui_mch_update();
4541 }
4542
4543 void
gui_mch_settitle(char_u * title,char_u * icon UNUSED)4544 gui_mch_settitle(char_u *title, char_u *icon UNUSED)
4545 {
4546 if (title != NULL && output_conv.vc_type != CONV_NONE)
4547 title = string_convert(&output_conv, title, NULL);
4548
4549 gtk_window_set_title(GTK_WINDOW(gui.mainwin), (const char *)title);
4550
4551 if (output_conv.vc_type != CONV_NONE)
4552 vim_free(title);
4553 }
4554
4555 #if defined(FEAT_MENU) || defined(PROTO)
4556 void
gui_mch_enable_menu(int showit)4557 gui_mch_enable_menu(int showit)
4558 {
4559 GtkWidget *widget;
4560
4561 # ifdef FEAT_GUI_GNOME
4562 if (using_gnome)
4563 widget = gui.menubar_h;
4564 else
4565 # endif
4566 widget = gui.menubar;
4567
4568 // Do not disable the menu while starting up, otherwise F10 doesn't work.
4569 if (!showit != !gtk_widget_get_visible(widget) && !gui.starting)
4570 {
4571 if (showit)
4572 gtk_widget_show(widget);
4573 else
4574 gtk_widget_hide(widget);
4575
4576 update_window_manager_hints(0, 0);
4577 }
4578 }
4579 #endif // FEAT_MENU
4580
4581 #if defined(FEAT_TOOLBAR) || defined(PROTO)
4582 void
gui_mch_show_toolbar(int showit)4583 gui_mch_show_toolbar(int showit)
4584 {
4585 GtkWidget *widget;
4586
4587 if (gui.toolbar == NULL)
4588 return;
4589
4590 # ifdef FEAT_GUI_GNOME
4591 if (using_gnome)
4592 widget = gui.toolbar_h;
4593 else
4594 # endif
4595 widget = gui.toolbar;
4596
4597 if (showit)
4598 set_toolbar_style(GTK_TOOLBAR(gui.toolbar));
4599
4600 if (!showit != !gtk_widget_get_visible(widget))
4601 {
4602 if (showit)
4603 gtk_widget_show(widget);
4604 else
4605 gtk_widget_hide(widget);
4606
4607 update_window_manager_hints(0, 0);
4608 }
4609 }
4610 #endif // FEAT_TOOLBAR
4611
4612 /*
4613 * Check if a given font is a CJK font. This is done in a very crude manner. It
4614 * just see if U+04E00 for zh and ja and U+AC00 for ko are covered in a given
4615 * font. Consequently, this function cannot be used as a general purpose check
4616 * for CJK-ness for which fontconfig APIs should be used. This is only used by
4617 * gui_mch_init_font() to deal with 'CJK fixed width fonts'.
4618 */
4619 static int
is_cjk_font(PangoFontDescription * font_desc)4620 is_cjk_font(PangoFontDescription *font_desc)
4621 {
4622 static const char * const cjk_langs[] =
4623 {"zh_CN", "zh_TW", "zh_HK", "ja", "ko"};
4624
4625 PangoFont *font;
4626 unsigned i;
4627 int is_cjk = FALSE;
4628
4629 font = pango_context_load_font(gui.text_context, font_desc);
4630
4631 if (font == NULL)
4632 return FALSE;
4633
4634 for (i = 0; !is_cjk && i < G_N_ELEMENTS(cjk_langs); ++i)
4635 {
4636 PangoCoverage *coverage;
4637 gunichar uc;
4638
4639 // Valgrind reports a leak for pango_language_from_string(), but the
4640 // documentation says "This is owned by Pango and should not be freed".
4641 coverage = pango_font_get_coverage(
4642 font, pango_language_from_string(cjk_langs[i]));
4643
4644 if (coverage != NULL)
4645 {
4646 uc = (cjk_langs[i][0] == 'k') ? 0xAC00 : 0x4E00;
4647 is_cjk = (pango_coverage_get(coverage, uc) == PANGO_COVERAGE_EXACT);
4648 pango_coverage_unref(coverage);
4649 }
4650 }
4651
4652 g_object_unref(font);
4653
4654 return is_cjk;
4655 }
4656
4657 /*
4658 * Adjust gui.char_height (after 'linespace' was changed).
4659 */
4660 int
gui_mch_adjust_charheight(void)4661 gui_mch_adjust_charheight(void)
4662 {
4663 PangoFontMetrics *metrics;
4664 int ascent;
4665 int descent;
4666
4667 metrics = pango_context_get_metrics(gui.text_context, gui.norm_font,
4668 pango_context_get_language(gui.text_context));
4669 ascent = pango_font_metrics_get_ascent(metrics);
4670 descent = pango_font_metrics_get_descent(metrics);
4671
4672 pango_font_metrics_unref(metrics);
4673
4674 // Round up when the value is more than about 1/16 of a pixel above a whole
4675 // pixel (12.0624 becomes 12, 12.07 becomes 13). Then add 'linespace'.
4676 gui.char_height = (ascent + descent + (PANGO_SCALE * 15) / 16)
4677 / PANGO_SCALE + p_linespace;
4678 // LINTED: avoid warning: bitwise operation on signed value
4679 gui.char_ascent = PANGO_PIXELS(ascent + p_linespace * PANGO_SCALE / 2);
4680
4681 // A not-positive value of char_height may crash Vim. Only happens
4682 // if 'linespace' is negative (which does make sense sometimes).
4683 gui.char_ascent = MAX(gui.char_ascent, 0);
4684 gui.char_height = MAX(gui.char_height, gui.char_ascent + 1);
4685
4686 return OK;
4687 }
4688
4689 #if GTK_CHECK_VERSION(3,0,0)
4690 // Callback function used in gui_mch_font_dialog()
4691 static gboolean
font_filter(const PangoFontFamily * family,const PangoFontFace * face UNUSED,gpointer data UNUSED)4692 font_filter(const PangoFontFamily *family,
4693 const PangoFontFace *face UNUSED,
4694 gpointer data UNUSED)
4695 {
4696 return pango_font_family_is_monospace((PangoFontFamily *)family);
4697 }
4698 #endif
4699
4700 /*
4701 * Put up a font dialog and return the selected font name in allocated memory.
4702 * "oldval" is the previous value. Return NULL when cancelled.
4703 * This should probably go into gui_gtk.c. Hmm.
4704 * FIXME:
4705 * The GTK2 font selection dialog has no filtering API. So we could either
4706 * a) implement our own (possibly copying the code from somewhere else) or
4707 * b) just live with it.
4708 */
4709 char_u *
gui_mch_font_dialog(char_u * oldval)4710 gui_mch_font_dialog(char_u *oldval)
4711 {
4712 GtkWidget *dialog;
4713 int response;
4714 char_u *fontname = NULL;
4715 char_u *oldname;
4716
4717 #if GTK_CHECK_VERSION(3,2,0)
4718 dialog = gtk_font_chooser_dialog_new(NULL, NULL);
4719 gtk_font_chooser_set_filter_func(GTK_FONT_CHOOSER(dialog), font_filter,
4720 NULL, NULL);
4721 #else
4722 dialog = gtk_font_selection_dialog_new(NULL);
4723 #endif
4724
4725 gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(gui.mainwin));
4726 gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
4727
4728 if (oldval != NULL && oldval[0] != NUL)
4729 {
4730 if (output_conv.vc_type != CONV_NONE)
4731 oldname = string_convert(&output_conv, oldval, NULL);
4732 else
4733 oldname = oldval;
4734
4735 // Annoying bug in GTK (or Pango): if the font name does not include a
4736 // size, zero is used. Use default point size ten.
4737 if (!vim_isdigit(oldname[STRLEN(oldname) - 1]))
4738 {
4739 char_u *p = vim_strnsave(oldname, STRLEN(oldname) + 3);
4740
4741 if (p != NULL)
4742 {
4743 STRCPY(p + STRLEN(p), " 10");
4744 if (oldname != oldval)
4745 vim_free(oldname);
4746 oldname = p;
4747 }
4748 }
4749
4750 #if GTK_CHECK_VERSION(3,2,0)
4751 gtk_font_chooser_set_font(
4752 GTK_FONT_CHOOSER(dialog), (const gchar *)oldname);
4753 #else
4754 gtk_font_selection_dialog_set_font_name(
4755 GTK_FONT_SELECTION_DIALOG(dialog), (const char *)oldname);
4756 #endif
4757
4758 if (oldname != oldval)
4759 vim_free(oldname);
4760 }
4761 else
4762 #if GTK_CHECK_VERSION(3,2,0)
4763 gtk_font_chooser_set_font(
4764 GTK_FONT_CHOOSER(dialog), DEFAULT_FONT);
4765 #else
4766 gtk_font_selection_dialog_set_font_name(
4767 GTK_FONT_SELECTION_DIALOG(dialog), DEFAULT_FONT);
4768 #endif
4769
4770 response = gtk_dialog_run(GTK_DIALOG(dialog));
4771
4772 if (response == GTK_RESPONSE_OK)
4773 {
4774 char *name;
4775
4776 #if GTK_CHECK_VERSION(3,2,0)
4777 name = gtk_font_chooser_get_font(GTK_FONT_CHOOSER(dialog));
4778 #else
4779 name = gtk_font_selection_dialog_get_font_name(
4780 GTK_FONT_SELECTION_DIALOG(dialog));
4781 #endif
4782 if (name != NULL)
4783 {
4784 char_u *p;
4785
4786 // Apparently some font names include a comma, need to escape
4787 // that, because in 'guifont' it separates names.
4788 p = vim_strsave_escaped((char_u *)name, (char_u *)",");
4789 g_free(name);
4790 if (p != NULL && input_conv.vc_type != CONV_NONE)
4791 {
4792 fontname = string_convert(&input_conv, p, NULL);
4793 vim_free(p);
4794 }
4795 else
4796 fontname = p;
4797 }
4798 }
4799
4800 if (response != GTK_RESPONSE_NONE)
4801 gtk_widget_destroy(dialog);
4802
4803 return fontname;
4804 }
4805
4806 /*
4807 * Some monospace fonts don't support a bold weight, and fall back
4808 * silently to the regular weight. But this is no good since our text
4809 * drawing function can emulate bold by overstriking. So let's try
4810 * to detect whether bold weight is actually available and emulate it
4811 * otherwise.
4812 *
4813 * Note that we don't need to check for italic style since Xft can
4814 * emulate italic on its own, provided you have a proper fontconfig
4815 * setup. We wouldn't be able to emulate it in Vim anyway.
4816 */
4817 static void
get_styled_font_variants(void)4818 get_styled_font_variants(void)
4819 {
4820 PangoFontDescription *bold_font_desc;
4821 PangoFont *plain_font;
4822 PangoFont *bold_font;
4823
4824 gui.font_can_bold = FALSE;
4825
4826 plain_font = pango_context_load_font(gui.text_context, gui.norm_font);
4827
4828 if (plain_font == NULL)
4829 return;
4830
4831 bold_font_desc = pango_font_description_copy_static(gui.norm_font);
4832 pango_font_description_set_weight(bold_font_desc, PANGO_WEIGHT_BOLD);
4833
4834 bold_font = pango_context_load_font(gui.text_context, bold_font_desc);
4835 /*
4836 * The comparison relies on the unique handle nature of a PangoFont*,
4837 * i.e. it's assumed that a different PangoFont* won't refer to the
4838 * same font. Seems to work, and failing here isn't critical anyway.
4839 */
4840 if (bold_font != NULL)
4841 {
4842 gui.font_can_bold = (bold_font != plain_font);
4843 g_object_unref(bold_font);
4844 }
4845
4846 pango_font_description_free(bold_font_desc);
4847 g_object_unref(plain_font);
4848 }
4849
4850 static PangoEngineShape *default_shape_engine = NULL;
4851
4852 /*
4853 * Create a map from ASCII characters in the range [32,126] to glyphs
4854 * of the current font. This is used by gui_gtk2_draw_string() to skip
4855 * the itemize and shaping process for the most common case.
4856 */
4857 static void
ascii_glyph_table_init(void)4858 ascii_glyph_table_init(void)
4859 {
4860 char_u ascii_chars[2 * 128];
4861 PangoAttrList *attr_list;
4862 GList *item_list;
4863 int i;
4864
4865 if (gui.ascii_glyphs != NULL)
4866 pango_glyph_string_free(gui.ascii_glyphs);
4867 if (gui.ascii_font != NULL)
4868 g_object_unref(gui.ascii_font);
4869
4870 gui.ascii_glyphs = NULL;
4871 gui.ascii_font = NULL;
4872
4873 // For safety, fill in question marks for the control characters.
4874 // Put a space between characters to avoid shaping.
4875 for (i = 0; i < 128; ++i)
4876 {
4877 if (i >= 32 && i < 127)
4878 ascii_chars[2 * i] = i;
4879 else
4880 ascii_chars[2 * i] = '?';
4881 ascii_chars[2 * i + 1] = ' ';
4882 }
4883
4884 attr_list = pango_attr_list_new();
4885 item_list = pango_itemize(gui.text_context, (const char *)ascii_chars,
4886 0, sizeof(ascii_chars), attr_list, NULL);
4887
4888 if (item_list != NULL && item_list->next == NULL) // play safe
4889 {
4890 PangoItem *item;
4891 int width;
4892
4893 item = (PangoItem *)item_list->data;
4894 width = gui.char_width * PANGO_SCALE;
4895
4896 // Remember the shape engine used for ASCII.
4897 default_shape_engine = item->analysis.shape_engine;
4898
4899 gui.ascii_font = item->analysis.font;
4900 g_object_ref(gui.ascii_font);
4901
4902 gui.ascii_glyphs = pango_glyph_string_new();
4903
4904 pango_shape((const char *)ascii_chars, sizeof(ascii_chars),
4905 &item->analysis, gui.ascii_glyphs);
4906
4907 g_return_if_fail(gui.ascii_glyphs->num_glyphs == sizeof(ascii_chars));
4908
4909 for (i = 0; i < gui.ascii_glyphs->num_glyphs; ++i)
4910 {
4911 PangoGlyphGeometry *geom;
4912
4913 geom = &gui.ascii_glyphs->glyphs[i].geometry;
4914 geom->x_offset += MAX(0, width - geom->width) / 2;
4915 geom->width = width;
4916 }
4917 }
4918
4919 // TODO: is this type cast OK?
4920 g_list_foreach(item_list, (GFunc)(void *)&pango_item_free, NULL);
4921 g_list_free(item_list);
4922 pango_attr_list_unref(attr_list);
4923 }
4924
4925 /*
4926 * Initialize Vim to use the font or fontset with the given name.
4927 * Return FAIL if the font could not be loaded, OK otherwise.
4928 */
4929 int
gui_mch_init_font(char_u * font_name,int fontset UNUSED)4930 gui_mch_init_font(char_u *font_name, int fontset UNUSED)
4931 {
4932 PangoFontDescription *font_desc;
4933 PangoLayout *layout;
4934 int width;
4935
4936 // If font_name is NULL, this means to use the default, which should
4937 // be present on all proper Pango/fontconfig installations.
4938 if (font_name == NULL)
4939 font_name = (char_u *)DEFAULT_FONT;
4940
4941 font_desc = gui_mch_get_font(font_name, FALSE);
4942
4943 if (font_desc == NULL)
4944 return FAIL;
4945
4946 gui_mch_free_font(gui.norm_font);
4947 gui.norm_font = font_desc;
4948
4949 pango_context_set_font_description(gui.text_context, font_desc);
4950
4951 layout = pango_layout_new(gui.text_context);
4952 pango_layout_set_text(layout, "MW", 2);
4953 pango_layout_get_size(layout, &width, NULL);
4954 /*
4955 * Set char_width to half the width obtained from pango_layout_get_size()
4956 * for CJK fixed_width/bi-width fonts. An unpatched version of Xft leads
4957 * Pango to use the same width for both non-CJK characters (e.g. Latin
4958 * letters and numbers) and CJK characters. This results in 's p a c e d
4959 * o u t' rendering when a CJK 'fixed width' font is used. To work around
4960 * that, divide the width returned by Pango by 2 if cjk_width is equal to
4961 * width for CJK fonts.
4962 *
4963 * For related bugs, see:
4964 * http://bugzilla.gnome.org/show_bug.cgi?id=106618
4965 * http://bugzilla.gnome.org/show_bug.cgi?id=106624
4966 *
4967 * With this, for all four of the following cases, Vim works fine:
4968 * guifont=CJK_fixed_width_font
4969 * guifont=Non_CJK_fixed_font
4970 * guifont=Non_CJK_fixed_font,CJK_Fixed_font
4971 * guifont=Non_CJK_fixed_font guifontwide=CJK_fixed_font
4972 */
4973 if (is_cjk_font(gui.norm_font))
4974 {
4975 int cjk_width;
4976
4977 // Measure the text extent of U+4E00 and U+4E8C
4978 pango_layout_set_text(layout, "\344\270\200\344\272\214", -1);
4979 pango_layout_get_size(layout, &cjk_width, NULL);
4980
4981 if (width == cjk_width) // Xft not patched
4982 width /= 2;
4983 }
4984 g_object_unref(layout);
4985
4986 gui.char_width = (width / 2 + PANGO_SCALE - 1) / PANGO_SCALE;
4987
4988 // A zero width may cause a crash. Happens for semi-invalid fontsets.
4989 if (gui.char_width <= 0)
4990 gui.char_width = 8;
4991
4992 gui_mch_adjust_charheight();
4993
4994 // Set the fontname, which will be used for information purposes
4995 hl_set_font_name(font_name);
4996
4997 get_styled_font_variants();
4998 ascii_glyph_table_init();
4999
5000 // Avoid unnecessary overhead if 'guifontwide' is equal to 'guifont'.
5001 if (gui.wide_font != NULL
5002 && pango_font_description_equal(gui.norm_font, gui.wide_font))
5003 {
5004 pango_font_description_free(gui.wide_font);
5005 gui.wide_font = NULL;
5006 }
5007
5008 if (gui_mch_maximized())
5009 {
5010 // Update lines and columns in accordance with the new font, keep the
5011 // window maximized.
5012 gui_mch_newfont();
5013 }
5014 else
5015 {
5016 // Preserve the logical dimensions of the screen.
5017 update_window_manager_hints(0, 0);
5018 }
5019
5020 return OK;
5021 }
5022
5023 /*
5024 * Get a reference to the font "name".
5025 * Return zero for failure.
5026 */
5027 GuiFont
gui_mch_get_font(char_u * name,int report_error)5028 gui_mch_get_font(char_u *name, int report_error)
5029 {
5030 PangoFontDescription *font;
5031
5032 // can't do this when GUI is not running
5033 if (!gui.in_use || name == NULL)
5034 return NULL;
5035
5036 if (output_conv.vc_type != CONV_NONE)
5037 {
5038 char_u *buf;
5039
5040 buf = string_convert(&output_conv, name, NULL);
5041 if (buf != NULL)
5042 {
5043 font = pango_font_description_from_string((const char *)buf);
5044 vim_free(buf);
5045 }
5046 else
5047 font = NULL;
5048 }
5049 else
5050 font = pango_font_description_from_string((const char *)name);
5051
5052 if (font != NULL)
5053 {
5054 PangoFont *real_font;
5055
5056 // pango_context_load_font() bails out if no font size is set
5057 if (pango_font_description_get_size(font) <= 0)
5058 pango_font_description_set_size(font, 10 * PANGO_SCALE);
5059
5060 real_font = pango_context_load_font(gui.text_context, font);
5061
5062 if (real_font == NULL)
5063 {
5064 pango_font_description_free(font);
5065 font = NULL;
5066 }
5067 else
5068 g_object_unref(real_font);
5069 }
5070
5071 if (font == NULL)
5072 {
5073 if (report_error)
5074 semsg(_((char *)e_font), name);
5075 return NULL;
5076 }
5077
5078 return font;
5079 }
5080
5081 #if defined(FEAT_EVAL) || defined(PROTO)
5082 /*
5083 * Return the name of font "font" in allocated memory.
5084 */
5085 char_u *
gui_mch_get_fontname(GuiFont font,char_u * name UNUSED)5086 gui_mch_get_fontname(GuiFont font, char_u *name UNUSED)
5087 {
5088 if (font != NOFONT)
5089 {
5090 char *pangoname = pango_font_description_to_string(font);
5091
5092 if (pangoname != NULL)
5093 {
5094 char_u *s = vim_strsave((char_u *)pangoname);
5095
5096 g_free(pangoname);
5097 return s;
5098 }
5099 }
5100 return NULL;
5101 }
5102 #endif
5103
5104 /*
5105 * If a font is not going to be used, free its structure.
5106 */
5107 void
gui_mch_free_font(GuiFont font)5108 gui_mch_free_font(GuiFont font)
5109 {
5110 if (font != NOFONT)
5111 pango_font_description_free(font);
5112 }
5113
5114 /*
5115 * Return the Pixel value (color) for the given color name.
5116 *
5117 * Return INVALCOLOR for error.
5118 */
5119 guicolor_T
gui_mch_get_color(char_u * name)5120 gui_mch_get_color(char_u *name)
5121 {
5122 guicolor_T color = INVALCOLOR;
5123
5124 if (!gui.in_use) // can't do this when GUI not running
5125 return color;
5126
5127 if (name != NULL)
5128 color = gui_get_color_cmn(name);
5129
5130 #if GTK_CHECK_VERSION(3,0,0)
5131 return color;
5132 #else
5133 if (color == INVALCOLOR)
5134 return INVALCOLOR;
5135
5136 return gui_mch_get_rgb_color(
5137 (color & 0xff0000) >> 16,
5138 (color & 0xff00) >> 8,
5139 color & 0xff);
5140 #endif
5141 }
5142
5143 /*
5144 * Return the Pixel value (color) for the given RGB values.
5145 * Return INVALCOLOR for error.
5146 */
5147 guicolor_T
gui_mch_get_rgb_color(int r,int g,int b)5148 gui_mch_get_rgb_color(int r, int g, int b)
5149 {
5150 #if GTK_CHECK_VERSION(3,0,0)
5151 return gui_get_rgb_color_cmn(r, g, b);
5152 #else
5153 GdkColor gcolor;
5154 int ret;
5155
5156 gcolor.red = (guint16)(r / 255.0 * 65535 + 0.5);
5157 gcolor.green = (guint16)(g / 255.0 * 65535 + 0.5);
5158 gcolor.blue = (guint16)(b / 255.0 * 65535 + 0.5);
5159
5160 ret = gdk_colormap_alloc_color(gtk_widget_get_colormap(gui.drawarea),
5161 &gcolor, FALSE, TRUE);
5162
5163 return ret != 0 ? (guicolor_T)gcolor.pixel : INVALCOLOR;
5164 #endif
5165 }
5166
5167 /*
5168 * Set the current text foreground color.
5169 */
5170 void
gui_mch_set_fg_color(guicolor_T color)5171 gui_mch_set_fg_color(guicolor_T color)
5172 {
5173 #if GTK_CHECK_VERSION(3,0,0)
5174 *gui.fgcolor = color_to_rgba(color);
5175 #else
5176 gui.fgcolor->pixel = (unsigned long)color;
5177 #endif
5178 }
5179
5180 /*
5181 * Set the current text background color.
5182 */
5183 void
gui_mch_set_bg_color(guicolor_T color)5184 gui_mch_set_bg_color(guicolor_T color)
5185 {
5186 #if GTK_CHECK_VERSION(3,0,0)
5187 *gui.bgcolor = color_to_rgba(color);
5188 #else
5189 gui.bgcolor->pixel = (unsigned long)color;
5190 #endif
5191 }
5192
5193 /*
5194 * Set the current text special color.
5195 */
5196 void
gui_mch_set_sp_color(guicolor_T color)5197 gui_mch_set_sp_color(guicolor_T color)
5198 {
5199 #if GTK_CHECK_VERSION(3,0,0)
5200 *gui.spcolor = color_to_rgba(color);
5201 #else
5202 gui.spcolor->pixel = (unsigned long)color;
5203 #endif
5204 }
5205
5206 /*
5207 * Function-like convenience macro for the sake of efficiency.
5208 */
5209 #define INSERT_PANGO_ATTR(Attribute, AttrList, Start, End) \
5210 G_STMT_START{ \
5211 PangoAttribute *tmp_attr_; \
5212 tmp_attr_ = (Attribute); \
5213 tmp_attr_->start_index = (Start); \
5214 tmp_attr_->end_index = (End); \
5215 pango_attr_list_insert((AttrList), tmp_attr_); \
5216 }G_STMT_END
5217
5218 static void
apply_wide_font_attr(char_u * s,int len,PangoAttrList * attr_list)5219 apply_wide_font_attr(char_u *s, int len, PangoAttrList *attr_list)
5220 {
5221 char_u *start = NULL;
5222 char_u *p;
5223 int uc;
5224
5225 for (p = s; p < s + len; p += utf_byte2len(*p))
5226 {
5227 uc = utf_ptr2char(p);
5228
5229 if (start == NULL)
5230 {
5231 if (uc >= 0x80 && utf_char2cells(uc) == 2)
5232 start = p;
5233 }
5234 else if (uc < 0x80 // optimization shortcut
5235 || (utf_char2cells(uc) != 2 && !utf_iscomposing(uc)))
5236 {
5237 INSERT_PANGO_ATTR(pango_attr_font_desc_new(gui.wide_font),
5238 attr_list, start - s, p - s);
5239 start = NULL;
5240 }
5241 }
5242
5243 if (start != NULL)
5244 INSERT_PANGO_ATTR(pango_attr_font_desc_new(gui.wide_font),
5245 attr_list, start - s, len);
5246 }
5247
5248 static int
count_cluster_cells(char_u * s,PangoItem * item,PangoGlyphString * glyphs,int i,int * cluster_width,int * last_glyph_rbearing)5249 count_cluster_cells(char_u *s, PangoItem *item,
5250 PangoGlyphString* glyphs, int i,
5251 int *cluster_width,
5252 int *last_glyph_rbearing)
5253 {
5254 char_u *p;
5255 int next; // glyph start index of next cluster
5256 int start, end; // string segment of current cluster
5257 int width; // real cluster width in Pango units
5258 int uc;
5259 int cellcount = 0;
5260
5261 width = glyphs->glyphs[i].geometry.width;
5262
5263 for (next = i + 1; next < glyphs->num_glyphs; ++next)
5264 {
5265 if (glyphs->glyphs[next].attr.is_cluster_start)
5266 break;
5267 else if (glyphs->glyphs[next].geometry.width > width)
5268 width = glyphs->glyphs[next].geometry.width;
5269 }
5270
5271 start = item->offset + glyphs->log_clusters[i];
5272 end = item->offset + ((next < glyphs->num_glyphs) ?
5273 glyphs->log_clusters[next] : item->length);
5274
5275 for (p = s + start; p < s + end; p += utf_byte2len(*p))
5276 {
5277 uc = utf_ptr2char(p);
5278 if (uc < 0x80)
5279 ++cellcount;
5280 else if (!utf_iscomposing(uc))
5281 cellcount += utf_char2cells(uc);
5282 }
5283
5284 if (last_glyph_rbearing != NULL
5285 && cellcount > 0 && next == glyphs->num_glyphs)
5286 {
5287 PangoRectangle ink_rect;
5288 /*
5289 * If a certain combining mark had to be taken from a non-monospace
5290 * font, we have to compensate manually by adapting x_offset according
5291 * to the ink extents of the previous glyph.
5292 */
5293 pango_font_get_glyph_extents(item->analysis.font,
5294 glyphs->glyphs[i].glyph,
5295 &ink_rect, NULL);
5296
5297 if (PANGO_RBEARING(ink_rect) > 0)
5298 *last_glyph_rbearing = PANGO_RBEARING(ink_rect);
5299 }
5300
5301 if (cellcount > 0)
5302 *cluster_width = width;
5303
5304 return cellcount;
5305 }
5306
5307 /*
5308 * If there are only combining characters in the cluster, we cannot just
5309 * change the width of the previous glyph since there is none. Therefore
5310 * some guesswork is needed.
5311 *
5312 * If ink_rect.x is negative Pango apparently has taken care of the composing
5313 * by itself. Actually setting x_offset = 0 should be sufficient then, but due
5314 * to problems with composing from different fonts we still need to fine-tune
5315 * x_offset to avoid ugliness.
5316 *
5317 * If ink_rect.x is not negative, force overstriking by pointing x_offset to
5318 * the position of the previous glyph. Apparently this happens only with old
5319 * X fonts which don't provide the special combining information needed by
5320 * Pango.
5321 */
5322 static void
setup_zero_width_cluster(PangoItem * item,PangoGlyphInfo * glyph,int last_cellcount,int last_cluster_width,int last_glyph_rbearing)5323 setup_zero_width_cluster(PangoItem *item, PangoGlyphInfo *glyph,
5324 int last_cellcount, int last_cluster_width,
5325 int last_glyph_rbearing)
5326 {
5327 PangoRectangle ink_rect;
5328 PangoRectangle logical_rect;
5329 int width;
5330
5331 width = last_cellcount * gui.char_width * PANGO_SCALE;
5332 glyph->geometry.x_offset = -width + MAX(0, width - last_cluster_width) / 2;
5333 glyph->geometry.width = 0;
5334
5335 pango_font_get_glyph_extents(item->analysis.font,
5336 glyph->glyph,
5337 &ink_rect, &logical_rect);
5338 if (ink_rect.x < 0)
5339 {
5340 glyph->geometry.x_offset += last_glyph_rbearing;
5341 glyph->geometry.y_offset = logical_rect.height
5342 - (gui.char_height - p_linespace) * PANGO_SCALE;
5343 }
5344 else
5345 // If the accent width is smaller than the cluster width, position it
5346 // in the middle.
5347 glyph->geometry.x_offset = -width + MAX(0, width - ink_rect.width) / 2;
5348 }
5349
5350 #if GTK_CHECK_VERSION(3,0,0)
5351 static void
draw_glyph_string(int row,int col,int num_cells,int flags,PangoFont * font,PangoGlyphString * glyphs,cairo_t * cr)5352 draw_glyph_string(int row, int col, int num_cells, int flags,
5353 PangoFont *font, PangoGlyphString *glyphs,
5354 cairo_t *cr)
5355 #else
5356 static void
5357 draw_glyph_string(int row, int col, int num_cells, int flags,
5358 PangoFont *font, PangoGlyphString *glyphs)
5359 #endif
5360 {
5361 if (!(flags & DRAW_TRANSP))
5362 {
5363 #if GTK_CHECK_VERSION(3,0,0)
5364 cairo_set_source_rgba(cr,
5365 gui.bgcolor->red, gui.bgcolor->green, gui.bgcolor->blue,
5366 gui.bgcolor->alpha);
5367 cairo_rectangle(cr,
5368 FILL_X(col), FILL_Y(row),
5369 num_cells * gui.char_width, gui.char_height);
5370 cairo_fill(cr);
5371 #else
5372 gdk_gc_set_foreground(gui.text_gc, gui.bgcolor);
5373
5374 gdk_draw_rectangle(gui.drawarea->window,
5375 gui.text_gc,
5376 TRUE,
5377 FILL_X(col),
5378 FILL_Y(row),
5379 num_cells * gui.char_width,
5380 gui.char_height);
5381 #endif
5382 }
5383
5384 #if GTK_CHECK_VERSION(3,0,0)
5385 cairo_set_source_rgba(cr,
5386 gui.fgcolor->red, gui.fgcolor->green, gui.fgcolor->blue,
5387 gui.fgcolor->alpha);
5388 cairo_move_to(cr, TEXT_X(col), TEXT_Y(row));
5389 pango_cairo_show_glyph_string(cr, font, glyphs);
5390 #else
5391 gdk_gc_set_foreground(gui.text_gc, gui.fgcolor);
5392
5393 gdk_draw_glyphs(gui.drawarea->window,
5394 gui.text_gc,
5395 font,
5396 TEXT_X(col),
5397 TEXT_Y(row),
5398 glyphs);
5399 #endif
5400
5401 // redraw the contents with an offset of 1 to emulate bold
5402 if ((flags & DRAW_BOLD) && !gui.font_can_bold)
5403 #if GTK_CHECK_VERSION(3,0,0)
5404 {
5405 cairo_set_source_rgba(cr,
5406 gui.fgcolor->red, gui.fgcolor->green, gui.fgcolor->blue,
5407 gui.fgcolor->alpha);
5408 cairo_move_to(cr, TEXT_X(col) + 1, TEXT_Y(row));
5409 pango_cairo_show_glyph_string(cr, font, glyphs);
5410 }
5411 #else
5412 gdk_draw_glyphs(gui.drawarea->window,
5413 gui.text_gc,
5414 font,
5415 TEXT_X(col) + 1,
5416 TEXT_Y(row),
5417 glyphs);
5418 #endif
5419 }
5420
5421 /*
5422 * Draw underline and undercurl at the bottom of the character cell.
5423 */
5424 #if GTK_CHECK_VERSION(3,0,0)
5425 static void
draw_under(int flags,int row,int col,int cells,cairo_t * cr)5426 draw_under(int flags, int row, int col, int cells, cairo_t *cr)
5427 #else
5428 static void
5429 draw_under(int flags, int row, int col, int cells)
5430 #endif
5431 {
5432 int i;
5433 int offset;
5434 static const int val[8] = {1, 0, 0, 0, 1, 2, 2, 2 };
5435 int y = FILL_Y(row + 1) - 1;
5436
5437 // Undercurl: draw curl at the bottom of the character cell.
5438 if (flags & DRAW_UNDERC)
5439 {
5440 #if GTK_CHECK_VERSION(3,0,0)
5441 cairo_set_line_width(cr, 1.0);
5442 cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT);
5443 cairo_set_source_rgba(cr,
5444 gui.spcolor->red, gui.spcolor->green, gui.spcolor->blue,
5445 gui.spcolor->alpha);
5446 cairo_move_to(cr, FILL_X(col) + 1, y - 2 + 0.5);
5447 for (i = FILL_X(col) + 1; i < FILL_X(col + cells); ++i)
5448 {
5449 offset = val[i % 8];
5450 cairo_line_to(cr, i, y - offset + 0.5);
5451 }
5452 cairo_stroke(cr);
5453 #else
5454 gdk_gc_set_foreground(gui.text_gc, gui.spcolor);
5455 for (i = FILL_X(col); i < FILL_X(col + cells); ++i)
5456 {
5457 offset = val[i % 8];
5458 gdk_draw_point(gui.drawarea->window, gui.text_gc, i, y - offset);
5459 }
5460 gdk_gc_set_foreground(gui.text_gc, gui.fgcolor);
5461 #endif
5462 }
5463
5464 // Draw a strikethrough line
5465 if (flags & DRAW_STRIKE)
5466 {
5467 #if GTK_CHECK_VERSION(3,0,0)
5468 cairo_set_line_width(cr, 1.0);
5469 cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT);
5470 cairo_set_source_rgba(cr,
5471 gui.spcolor->red, gui.spcolor->green, gui.spcolor->blue,
5472 gui.spcolor->alpha);
5473 cairo_move_to(cr, FILL_X(col), y + 1 - gui.char_height/2 + 0.5);
5474 cairo_line_to(cr, FILL_X(col + cells), y + 1 - gui.char_height/2 + 0.5);
5475 cairo_stroke(cr);
5476 #else
5477 gdk_gc_set_foreground(gui.text_gc, gui.spcolor);
5478 gdk_draw_line(gui.drawarea->window, gui.text_gc,
5479 FILL_X(col), y + 1 - gui.char_height/2,
5480 FILL_X(col + cells), y + 1 - gui.char_height/2);
5481 gdk_gc_set_foreground(gui.text_gc, gui.fgcolor);
5482 #endif
5483 }
5484
5485 // Underline: draw a line at the bottom of the character cell.
5486 if (flags & DRAW_UNDERL)
5487 {
5488 // When p_linespace is 0, overwrite the bottom row of pixels.
5489 // Otherwise put the line just below the character.
5490 if (p_linespace > 1)
5491 y -= p_linespace - 1;
5492 #if GTK_CHECK_VERSION(3,0,0)
5493 cairo_set_line_width(cr, 1.0);
5494 cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT);
5495 cairo_set_source_rgba(cr,
5496 gui.fgcolor->red, gui.fgcolor->green, gui.fgcolor->blue,
5497 gui.fgcolor->alpha);
5498 cairo_move_to(cr, FILL_X(col), y + 0.5);
5499 cairo_line_to(cr, FILL_X(col + cells), y + 0.5);
5500 cairo_stroke(cr);
5501 #else
5502 gdk_draw_line(gui.drawarea->window, gui.text_gc,
5503 FILL_X(col), y,
5504 FILL_X(col + cells) - 1, y);
5505 #endif
5506 }
5507 }
5508
5509 int
gui_gtk2_draw_string(int row,int col,char_u * s,int len,int flags)5510 gui_gtk2_draw_string(int row, int col, char_u *s, int len, int flags)
5511 {
5512 char_u *conv_buf = NULL; // result of UTF-8 conversion
5513 char_u *new_conv_buf;
5514 int convlen;
5515 char_u *sp, *bp;
5516 int plen;
5517 int len_sum; // return value needs to add up since we are
5518 // printing substrings
5519 int byte_sum; // byte position in string
5520 char_u *cs; // current *s pointer
5521 int needs_pango; // look ahead, 0=ascii 1=unicode/ligatures
5522 int should_need_pango = FALSE;
5523 int slen;
5524 int is_ligature;
5525 int is_utf8;
5526 char_u backup_ch;
5527
5528 if (gui.text_context == NULL || gtk_widget_get_window(gui.drawarea) == NULL)
5529 return len;
5530
5531 if (output_conv.vc_type != CONV_NONE)
5532 {
5533 /*
5534 * Convert characters from 'encoding' to 'termencoding', which is set
5535 * to UTF-8 by gui_mch_init(). did_set_string_option() in option.c
5536 * prohibits changing this to something else than UTF-8 if the GUI is
5537 * in use.
5538 */
5539 convlen = len;
5540 conv_buf = string_convert(&output_conv, s, &convlen);
5541 g_return_val_if_fail(conv_buf != NULL, len);
5542
5543 // Correct for differences in char width: some chars are
5544 // double-wide in 'encoding' but single-wide in utf-8. Add a space to
5545 // compensate for that.
5546 for (sp = s, bp = conv_buf; sp < s + len && bp < conv_buf + convlen; )
5547 {
5548 plen = utf_ptr2len(bp);
5549 if ((*mb_ptr2cells)(sp) == 2 && utf_ptr2cells(bp) == 1)
5550 {
5551 new_conv_buf = alloc(convlen + 2);
5552 if (new_conv_buf == NULL)
5553 return len;
5554 plen += bp - conv_buf;
5555 mch_memmove(new_conv_buf, conv_buf, plen);
5556 new_conv_buf[plen] = ' ';
5557 mch_memmove(new_conv_buf + plen + 1, conv_buf + plen,
5558 convlen - plen + 1);
5559 vim_free(conv_buf);
5560 conv_buf = new_conv_buf;
5561 ++convlen;
5562 bp = conv_buf + plen;
5563 plen = 1;
5564 }
5565 sp += (*mb_ptr2len)(sp);
5566 bp += plen;
5567 }
5568 s = conv_buf;
5569 len = convlen;
5570 }
5571
5572 /*
5573 * Ligature support and complex utf-8 char optimization:
5574 * String received to output to screen can print using pre-cached glyphs
5575 * (fast) or Pango (slow). Ligatures and multibype utf-8 must use Pango.
5576 * Since we receive mixed content string, split it into logical segments
5577 * that are guaranteed to go trough glyphs as much as possible. Since
5578 * single ligature char prints as ascii, print it that way.
5579 */
5580 len_sum = 0; // return value needs to add up since we are printing
5581 // substrings
5582 byte_sum = 0;
5583 cs = s;
5584 // First char decides starting needs_pango mode, 0=ascii 1=utf8/ligatures.
5585 // Even if it is ligature char, two chars or more make ligature.
5586 // Ascii followed by utf8 is also going trough pango.
5587 is_utf8 = (*cs & 0x80);
5588 is_ligature = gui.ligatures_map[*cs] && (len > 1);
5589 if (is_ligature)
5590 is_ligature = gui.ligatures_map[*(cs + 1)];
5591 if (!is_utf8 && len > 1)
5592 is_utf8 = (*(cs + 1) & 0x80) != 0;
5593 needs_pango = is_utf8 || is_ligature;
5594
5595 // split string into ascii and non-ascii (ligatures + utf-8) substrings,
5596 // print glyphs or use Pango
5597 while (cs < s + len)
5598 {
5599 slen = 0;
5600 while (slen < (len - byte_sum))
5601 {
5602 is_ligature = gui.ligatures_map[*(cs + slen)];
5603 // look ahead, single ligature char between ascii is ascii
5604 if (is_ligature && !needs_pango)
5605 {
5606 if ((slen + 1) < (len - byte_sum))
5607 is_ligature = gui.ligatures_map[*(cs + slen + 1)];
5608 else
5609 is_ligature = 0;
5610 }
5611 is_utf8 = *(cs + slen) & 0x80;
5612 // ascii followed by utf8 could be combining
5613 // if so send it trough pango
5614 if ((!is_utf8) && ((slen + 1) < (len - byte_sum)))
5615 is_utf8 = (*(cs + slen + 1) & 0x80);
5616 should_need_pango = (is_ligature || is_utf8);
5617 if (needs_pango != should_need_pango) // mode switch
5618 break;
5619 if (needs_pango)
5620 {
5621 if (is_ligature)
5622 {
5623 slen++; // ligature char by char
5624 }
5625 else // is_utf8
5626 {
5627 if ((*(cs + slen) & 0xC0) == 0x80)
5628 {
5629 // a continuation, find next 0xC0 != 0x80 but don't
5630 // include it
5631 while ((slen < (len - byte_sum))
5632 && ((*(cs + slen) & 0xC0) == 0x80))
5633 {
5634 slen++;
5635 }
5636 }
5637 else if ((*(cs + slen) & 0xE0) == 0xC0)
5638 {
5639 // + one byte utf8
5640 slen++;
5641 }
5642 else if ((*(cs + slen) & 0xF0) == 0xE0)
5643 {
5644 // + two bytes utf8
5645 slen += 2;
5646 }
5647 else if ((*(cs + slen) & 0xF8) == 0xF0)
5648 {
5649 // + three bytes utf8
5650 slen += 3;
5651 }
5652 else
5653 {
5654 // this should not happen, try moving forward, Pango
5655 // will catch it
5656 slen++;
5657 }
5658 }
5659 }
5660 else
5661 {
5662 slen++; // ascii
5663 }
5664 }
5665
5666 if (slen < len)
5667 {
5668 // temporarily zero terminate substring, print, restore char, wrap
5669 backup_ch = *(cs + slen);
5670 *(cs + slen) = NUL;
5671 }
5672 len_sum += gui_gtk2_draw_string_ext(row, col + len_sum,
5673 cs, slen, flags, needs_pango);
5674 if (slen < len)
5675 *(cs + slen) = backup_ch;
5676 cs += slen;
5677 byte_sum += slen;
5678 needs_pango = should_need_pango;
5679 }
5680 vim_free(conv_buf);
5681 return len_sum;
5682 }
5683
5684 int
gui_gtk2_draw_string_ext(int row,int col,char_u * s,int len,int flags,int force_pango)5685 gui_gtk2_draw_string_ext(
5686 int row,
5687 int col,
5688 char_u *s,
5689 int len,
5690 int flags,
5691 int force_pango)
5692 {
5693 GdkRectangle area; // area for clip mask
5694 PangoGlyphString *glyphs; // glyphs of current item
5695 int column_offset = 0; // column offset in cells
5696 int i;
5697 #if GTK_CHECK_VERSION(3,0,0)
5698 cairo_t *cr;
5699 #endif
5700
5701 /*
5702 * Restrict all drawing to the current screen line in order to prevent
5703 * fuzzy font lookups from messing up the screen.
5704 */
5705 area.x = gui.border_offset;
5706 area.y = FILL_Y(row);
5707 area.width = gui.num_cols * gui.char_width;
5708 area.height = gui.char_height;
5709
5710 #if GTK_CHECK_VERSION(3,0,0)
5711 cr = cairo_create(gui.surface);
5712 cairo_rectangle(cr, area.x, area.y, area.width, area.height);
5713 cairo_clip(cr);
5714 #else
5715 gdk_gc_set_clip_origin(gui.text_gc, 0, 0);
5716 gdk_gc_set_clip_rectangle(gui.text_gc, &area);
5717 #endif
5718
5719 glyphs = pango_glyph_string_new();
5720
5721 /*
5722 * Optimization hack: If possible, skip the itemize and shaping process
5723 * for pure ASCII strings. This optimization is particularly effective
5724 * because Vim draws space characters to clear parts of the screen.
5725 */
5726 if (!(flags & DRAW_ITALIC)
5727 && !((flags & DRAW_BOLD) && gui.font_can_bold)
5728 && gui.ascii_glyphs != NULL
5729 && !force_pango)
5730 {
5731 char_u *p;
5732
5733 for (p = s; p < s + len; ++p)
5734 if (*p & 0x80)
5735 goto not_ascii;
5736
5737 pango_glyph_string_set_size(glyphs, len);
5738
5739 for (i = 0; i < len; ++i)
5740 {
5741 glyphs->glyphs[i] = gui.ascii_glyphs->glyphs[2 * s[i]];
5742 glyphs->log_clusters[i] = i;
5743 }
5744
5745 #if GTK_CHECK_VERSION(3,0,0)
5746 draw_glyph_string(row, col, len, flags, gui.ascii_font, glyphs, cr);
5747 #else
5748 draw_glyph_string(row, col, len, flags, gui.ascii_font, glyphs);
5749 #endif
5750
5751 column_offset = len;
5752 }
5753 else
5754 not_ascii:
5755 {
5756 PangoAttrList *attr_list;
5757 GList *item_list;
5758 int cluster_width;
5759 int last_glyph_rbearing;
5760 int cells = 0; // cells occupied by current cluster
5761
5762 // Safety check: pango crashes when invoked with invalid utf-8
5763 // characters.
5764 if (!utf_valid_string(s, s + len))
5765 {
5766 column_offset = len;
5767 goto skipitall;
5768 }
5769
5770 // original width of the current cluster
5771 cluster_width = PANGO_SCALE * gui.char_width;
5772
5773 // right bearing of the last non-composing glyph
5774 last_glyph_rbearing = PANGO_SCALE * gui.char_width;
5775
5776 attr_list = pango_attr_list_new();
5777
5778 // If 'guifontwide' is set then use that for double-width characters.
5779 // Otherwise just go with 'guifont' and let Pango do its thing.
5780 if (gui.wide_font != NULL)
5781 apply_wide_font_attr(s, len, attr_list);
5782
5783 if ((flags & DRAW_BOLD) && gui.font_can_bold)
5784 INSERT_PANGO_ATTR(pango_attr_weight_new(PANGO_WEIGHT_BOLD),
5785 attr_list, 0, len);
5786 if (flags & DRAW_ITALIC)
5787 INSERT_PANGO_ATTR(pango_attr_style_new(PANGO_STYLE_ITALIC),
5788 attr_list, 0, len);
5789 /*
5790 * Break the text into segments with consistent directional level
5791 * and shaping engine. Pure Latin text needs only a single segment,
5792 * so there's no need to worry about the loop's efficiency. Better
5793 * try to optimize elsewhere, e.g. reducing exposes and stuff :)
5794 */
5795 item_list = pango_itemize(gui.text_context,
5796 (const char *)s, 0, len, attr_list, NULL);
5797
5798 while (item_list != NULL)
5799 {
5800 PangoItem *item;
5801 int item_cells = 0; // item length in cells
5802
5803 item = (PangoItem *)item_list->data;
5804 item_list = g_list_delete_link(item_list, item_list);
5805 /*
5806 * Increment the bidirectional embedding level by 1 if it is not
5807 * even. An odd number means the output will be RTL, but we don't
5808 * want that since Vim handles right-to-left text on its own. It
5809 * would probably be sufficient to just set level = 0, but you can
5810 * never know :)
5811 *
5812 * Unfortunately we can't take advantage of Pango's ability to
5813 * render both LTR and RTL at the same time. In order to support
5814 * that, Vim's main screen engine would have to make use of Pango
5815 * functionality.
5816 */
5817 item->analysis.level = (item->analysis.level + 1) & (~1U);
5818
5819 // HACK: Overrule the shape engine, we don't want shaping to be
5820 // done, because drawing the cursor would change the display.
5821 item->analysis.shape_engine = default_shape_engine;
5822
5823 #ifdef HAVE_PANGO_SHAPE_FULL
5824 pango_shape_full((const char *)s + item->offset, item->length,
5825 (const char *)s, len, &item->analysis, glyphs);
5826 #else
5827 pango_shape((const char *)s + item->offset, item->length,
5828 &item->analysis, glyphs);
5829 #endif
5830 /*
5831 * Fixed-width hack: iterate over the array and assign a fixed
5832 * width to each glyph, thus overriding the choice made by the
5833 * shaping engine. We use utf_char2cells() to determine the
5834 * number of cells needed.
5835 *
5836 * Also perform all kind of dark magic to get composing
5837 * characters right (and pretty too of course).
5838 */
5839 for (i = 0; i < glyphs->num_glyphs; ++i)
5840 {
5841 PangoGlyphInfo *glyph;
5842
5843 glyph = &glyphs->glyphs[i];
5844
5845 if (glyph->attr.is_cluster_start)
5846 {
5847 int cellcount;
5848
5849 cellcount = count_cluster_cells(
5850 s, item, glyphs, i, &cluster_width,
5851 (item_list != NULL) ? &last_glyph_rbearing : NULL);
5852
5853 if (cellcount > 0)
5854 {
5855 int width;
5856
5857 width = cellcount * gui.char_width * PANGO_SCALE;
5858 glyph->geometry.x_offset +=
5859 MAX(0, width - cluster_width) / 2;
5860 glyph->geometry.width = width;
5861 }
5862 else
5863 {
5864 // If there are only combining characters in the
5865 // cluster, we cannot just change the width of the
5866 // previous glyph since there is none. Therefore
5867 // some guesswork is needed.
5868 setup_zero_width_cluster(item, glyph, cells,
5869 cluster_width,
5870 last_glyph_rbearing);
5871 }
5872
5873 item_cells += cellcount;
5874 cells = cellcount;
5875 }
5876 else if (i > 0)
5877 {
5878 int width;
5879
5880 // There is a previous glyph, so we deal with combining
5881 // characters the canonical way.
5882 // In some circumstances Pango uses a positive x_offset,
5883 // then use the width of the previous glyph for this one
5884 // and set the previous width to zero.
5885 // Otherwise we get a negative x_offset, Pango has already
5886 // positioned the combining char, keep the widths as they
5887 // are.
5888 // For both adjust the x_offset to position the glyph in
5889 // the middle.
5890 if (glyph->geometry.x_offset >= 0)
5891 {
5892 glyphs->glyphs[i].geometry.width =
5893 glyphs->glyphs[i - 1].geometry.width;
5894 glyphs->glyphs[i - 1].geometry.width = 0;
5895 }
5896 width = cells * gui.char_width * PANGO_SCALE;
5897 glyph->geometry.x_offset +=
5898 MAX(0, width - cluster_width) / 2;
5899 }
5900 else // i == 0 "cannot happen"
5901 {
5902 glyph->geometry.width = 0;
5903 }
5904 }
5905
5906 //// Aaaaand action! **
5907 #if GTK_CHECK_VERSION(3,0,0)
5908 draw_glyph_string(row, col + column_offset, item_cells,
5909 flags, item->analysis.font, glyphs,
5910 cr);
5911 #else
5912 draw_glyph_string(row, col + column_offset, item_cells,
5913 flags, item->analysis.font, glyphs);
5914 #endif
5915
5916 pango_item_free(item);
5917
5918 column_offset += item_cells;
5919 }
5920
5921 pango_attr_list_unref(attr_list);
5922 }
5923
5924 skipitall:
5925 // Draw underline and undercurl.
5926 #if GTK_CHECK_VERSION(3,0,0)
5927 draw_under(flags, row, col, column_offset, cr);
5928 #else
5929 draw_under(flags, row, col, column_offset);
5930 #endif
5931
5932 pango_glyph_string_free(glyphs);
5933
5934 #if GTK_CHECK_VERSION(3,0,0)
5935 cairo_destroy(cr);
5936 gtk_widget_queue_draw_area(gui.drawarea, area.x, area.y,
5937 area.width, area.height);
5938 #else
5939 gdk_gc_set_clip_rectangle(gui.text_gc, NULL);
5940 #endif
5941
5942 return column_offset;
5943 }
5944
5945 /*
5946 * Return OK if the key with the termcap name "name" is supported.
5947 */
5948 int
gui_mch_haskey(char_u * name)5949 gui_mch_haskey(char_u *name)
5950 {
5951 int i;
5952
5953 for (i = 0; special_keys[i].key_sym != 0; i++)
5954 if (name[0] == special_keys[i].code0
5955 && name[1] == special_keys[i].code1)
5956 return OK;
5957 return FAIL;
5958 }
5959
5960 #if defined(FEAT_TITLE) || defined(FEAT_EVAL) || defined(PROTO)
5961 /*
5962 * Return the text window-id and display. Only required for X-based GUI's
5963 */
5964 int
gui_get_x11_windis(Window * win,Display ** dis)5965 gui_get_x11_windis(Window *win, Display **dis)
5966 {
5967 if (gui.mainwin != NULL && gtk_widget_get_window(gui.mainwin) != NULL)
5968 {
5969 *dis = GDK_WINDOW_XDISPLAY(gtk_widget_get_window(gui.mainwin));
5970 *win = GDK_WINDOW_XID(gtk_widget_get_window(gui.mainwin));
5971 return OK;
5972 }
5973
5974 *dis = NULL;
5975 *win = 0;
5976 return FAIL;
5977 }
5978 #endif
5979
5980 #if defined(FEAT_CLIENTSERVER) \
5981 || (defined(FEAT_X11) && defined(FEAT_CLIPBOARD)) || defined(PROTO)
5982
5983 Display *
gui_mch_get_display(void)5984 gui_mch_get_display(void)
5985 {
5986 if (gui.mainwin != NULL && gtk_widget_get_window(gui.mainwin) != NULL)
5987 return GDK_WINDOW_XDISPLAY(gtk_widget_get_window(gui.mainwin));
5988 else
5989 return NULL;
5990 }
5991 #endif
5992
5993 void
gui_mch_beep(void)5994 gui_mch_beep(void)
5995 {
5996 GdkDisplay *display;
5997
5998 if (gui.mainwin != NULL && gtk_widget_get_realized(gui.mainwin))
5999 display = gtk_widget_get_display(gui.mainwin);
6000 else
6001 display = gdk_display_get_default();
6002
6003 if (display != NULL)
6004 gdk_display_beep(display);
6005 }
6006
6007 void
gui_mch_flash(int msec)6008 gui_mch_flash(int msec)
6009 {
6010 #if GTK_CHECK_VERSION(3,0,0)
6011 // TODO Replace GdkGC with Cairo
6012 (void)msec;
6013 #else
6014 GdkGCValues values;
6015 GdkGC *invert_gc;
6016
6017 if (gui.drawarea->window == NULL)
6018 return;
6019
6020 values.foreground.pixel = gui.norm_pixel ^ gui.back_pixel;
6021 values.background.pixel = gui.norm_pixel ^ gui.back_pixel;
6022 values.function = GDK_XOR;
6023 invert_gc = gdk_gc_new_with_values(gui.drawarea->window,
6024 &values,
6025 GDK_GC_FOREGROUND |
6026 GDK_GC_BACKGROUND |
6027 GDK_GC_FUNCTION);
6028 gdk_gc_set_exposures(invert_gc,
6029 gui.visibility != GDK_VISIBILITY_UNOBSCURED);
6030 /*
6031 * Do a visual beep by changing back and forth in some undetermined way,
6032 * the foreground and background colors. This is due to the fact that
6033 * there can't be really any prediction about the effects of XOR on
6034 * arbitrary X11 servers. However this seems to be enough for what we
6035 * intend it to do.
6036 */
6037 gdk_draw_rectangle(gui.drawarea->window, invert_gc,
6038 TRUE,
6039 0, 0,
6040 FILL_X((int)Columns) + gui.border_offset,
6041 FILL_Y((int)Rows) + gui.border_offset);
6042
6043 gui_mch_flush();
6044 ui_delay((long)msec, TRUE); // wait so many msec
6045
6046 gdk_draw_rectangle(gui.drawarea->window, invert_gc,
6047 TRUE,
6048 0, 0,
6049 FILL_X((int)Columns) + gui.border_offset,
6050 FILL_Y((int)Rows) + gui.border_offset);
6051
6052 gdk_gc_destroy(invert_gc);
6053 #endif
6054 }
6055
6056 /*
6057 * Invert a rectangle from row r, column c, for nr rows and nc columns.
6058 */
6059 void
gui_mch_invert_rectangle(int r,int c,int nr,int nc)6060 gui_mch_invert_rectangle(int r, int c, int nr, int nc)
6061 {
6062 #if GTK_CHECK_VERSION(3,0,0)
6063 const GdkRectangle rect = {
6064 FILL_X(c), FILL_Y(r), nc * gui.char_width, nr * gui.char_height
6065 };
6066 cairo_t * const cr = cairo_create(gui.surface);
6067
6068 set_cairo_source_rgba_from_color(cr, gui.norm_pixel ^ gui.back_pixel);
6069 # if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1,9,2)
6070 cairo_set_operator(cr, CAIRO_OPERATOR_DIFFERENCE);
6071 # else
6072 // Give an implementation for older cairo versions if necessary.
6073 # endif
6074 cairo_rectangle(cr, rect.x, rect.y, rect.width, rect.height);
6075 cairo_fill(cr);
6076
6077 cairo_destroy(cr);
6078
6079 gtk_widget_queue_draw_area(gui.drawarea, rect.x, rect.y,
6080 rect.width, rect.height);
6081 #else
6082 GdkGCValues values;
6083 GdkGC *invert_gc;
6084
6085 if (gui.drawarea->window == NULL)
6086 return;
6087
6088 values.foreground.pixel = gui.norm_pixel ^ gui.back_pixel;
6089 values.background.pixel = gui.norm_pixel ^ gui.back_pixel;
6090 values.function = GDK_XOR;
6091 invert_gc = gdk_gc_new_with_values(gui.drawarea->window,
6092 &values,
6093 GDK_GC_FOREGROUND |
6094 GDK_GC_BACKGROUND |
6095 GDK_GC_FUNCTION);
6096 gdk_gc_set_exposures(invert_gc, gui.visibility !=
6097 GDK_VISIBILITY_UNOBSCURED);
6098 gdk_draw_rectangle(gui.drawarea->window, invert_gc,
6099 TRUE,
6100 FILL_X(c), FILL_Y(r),
6101 (nc) * gui.char_width, (nr) * gui.char_height);
6102 gdk_gc_destroy(invert_gc);
6103 #endif
6104 }
6105
6106 /*
6107 * Iconify the GUI window.
6108 */
6109 void
gui_mch_iconify(void)6110 gui_mch_iconify(void)
6111 {
6112 gtk_window_iconify(GTK_WINDOW(gui.mainwin));
6113 }
6114
6115 #if defined(FEAT_EVAL) || defined(PROTO)
6116 /*
6117 * Bring the Vim window to the foreground.
6118 */
6119 void
gui_mch_set_foreground(void)6120 gui_mch_set_foreground(void)
6121 {
6122 gtk_window_present(GTK_WINDOW(gui.mainwin));
6123 }
6124 #endif
6125
6126 /*
6127 * Draw a cursor without focus.
6128 */
6129 void
gui_mch_draw_hollow_cursor(guicolor_T color)6130 gui_mch_draw_hollow_cursor(guicolor_T color)
6131 {
6132 int i = 1;
6133 #if GTK_CHECK_VERSION(3,0,0)
6134 cairo_t *cr;
6135 #endif
6136
6137 if (gtk_widget_get_window(gui.drawarea) == NULL)
6138 return;
6139
6140 #if GTK_CHECK_VERSION(3,0,0)
6141 cr = cairo_create(gui.surface);
6142 #endif
6143
6144 gui_mch_set_fg_color(color);
6145
6146 #if GTK_CHECK_VERSION(3,0,0)
6147 cairo_set_source_rgba(cr,
6148 gui.fgcolor->red, gui.fgcolor->green, gui.fgcolor->blue,
6149 gui.fgcolor->alpha);
6150 #else
6151 gdk_gc_set_foreground(gui.text_gc, gui.fgcolor);
6152 #endif
6153 if (mb_lefthalve(gui.row, gui.col))
6154 i = 2;
6155 #if GTK_CHECK_VERSION(3,0,0)
6156 cairo_set_line_width(cr, 1.0);
6157 cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT);
6158 cairo_rectangle(cr,
6159 FILL_X(gui.col) + 0.5, FILL_Y(gui.row) + 0.5,
6160 i * gui.char_width - 1, gui.char_height - 1);
6161 cairo_stroke(cr);
6162 cairo_destroy(cr);
6163 #else
6164 gdk_draw_rectangle(gui.drawarea->window, gui.text_gc,
6165 FALSE,
6166 FILL_X(gui.col), FILL_Y(gui.row),
6167 i * gui.char_width - 1, gui.char_height - 1);
6168 #endif
6169 }
6170
6171 /*
6172 * Draw part of a cursor, "w" pixels wide, and "h" pixels high, using
6173 * color "color".
6174 */
6175 void
gui_mch_draw_part_cursor(int w,int h,guicolor_T color)6176 gui_mch_draw_part_cursor(int w, int h, guicolor_T color)
6177 {
6178 if (gtk_widget_get_window(gui.drawarea) == NULL)
6179 return;
6180
6181 gui_mch_set_fg_color(color);
6182
6183 #if GTK_CHECK_VERSION(3,0,0)
6184 {
6185 cairo_t *cr;
6186
6187 cr = cairo_create(gui.surface);
6188 cairo_set_source_rgba(cr,
6189 gui.fgcolor->red, gui.fgcolor->green, gui.fgcolor->blue,
6190 gui.fgcolor->alpha);
6191 cairo_rectangle(cr,
6192 # ifdef FEAT_RIGHTLEFT
6193 // vertical line should be on the right of current point
6194 CURSOR_BAR_RIGHT ? FILL_X(gui.col + 1) - w :
6195 # endif
6196 FILL_X(gui.col), FILL_Y(gui.row) + gui.char_height - h,
6197 w, h);
6198 cairo_fill(cr);
6199 cairo_destroy(cr);
6200 }
6201 #else // !GTK_CHECK_VERSION(3,0,0)
6202 gdk_gc_set_foreground(gui.text_gc, gui.fgcolor);
6203 gdk_draw_rectangle(gui.drawarea->window, gui.text_gc,
6204 TRUE,
6205 # ifdef FEAT_RIGHTLEFT
6206 // vertical line should be on the right of current point
6207 CURSOR_BAR_RIGHT ? FILL_X(gui.col + 1) - w :
6208 # endif
6209 FILL_X(gui.col),
6210 FILL_Y(gui.row) + gui.char_height - h,
6211 w, h);
6212 #endif // !GTK_CHECK_VERSION(3,0,0)
6213 }
6214
6215
6216 /*
6217 * Catch up with any queued X11 events. This may put keyboard input into the
6218 * input buffer, call resize call-backs, trigger timers etc. If there is
6219 * nothing in the X11 event queue (& no timers pending), then we return
6220 * immediately.
6221 */
6222 void
gui_mch_update(void)6223 gui_mch_update(void)
6224 {
6225 while (g_main_context_pending(NULL) && !vim_is_input_buf_full())
6226 g_main_context_iteration(NULL, TRUE);
6227 }
6228
6229 static timeout_cb_type
input_timer_cb(gpointer data)6230 input_timer_cb(gpointer data)
6231 {
6232 int *timed_out = (int *) data;
6233
6234 // Just inform the caller about the occurrence of it
6235 *timed_out = TRUE;
6236
6237 return FALSE; // don't happen again
6238 }
6239
6240 #ifdef FEAT_JOB_CHANNEL
6241 static timeout_cb_type
channel_poll_cb(gpointer data UNUSED)6242 channel_poll_cb(gpointer data UNUSED)
6243 {
6244 // Using an event handler for a channel that may be disconnected does
6245 // not work, it hangs. Instead poll for messages.
6246 channel_handle_events(TRUE);
6247 parse_queued_messages();
6248
6249 return TRUE; // repeat
6250 }
6251 #endif
6252
6253 /*
6254 * GUI input routine called by gui_wait_for_chars(). Waits for a character
6255 * from the keyboard.
6256 * wtime == -1 Wait forever.
6257 * wtime == 0 This should never happen.
6258 * wtime > 0 Wait wtime milliseconds for a character.
6259 * Returns OK if a character was found to be available within the given time,
6260 * or FAIL otherwise.
6261 */
6262 int
gui_mch_wait_for_chars(long wtime)6263 gui_mch_wait_for_chars(long wtime)
6264 {
6265 int focus;
6266 guint timer;
6267 static int timed_out;
6268 int retval = FAIL;
6269 #ifdef FEAT_JOB_CHANNEL
6270 guint channel_timer = 0;
6271 #endif
6272
6273 timed_out = FALSE;
6274
6275 // This timeout makes sure that we will return if no characters arrived in
6276 // time. If "wtime" is zero just use one.
6277 if (wtime >= 0)
6278 timer = timeout_add(wtime == 0 ? 1L : wtime,
6279 input_timer_cb, &timed_out);
6280 else
6281 timer = 0;
6282
6283 #ifdef FEAT_JOB_CHANNEL
6284 // If there is a channel with the keep_open flag we need to poll for input
6285 // on them.
6286 if (channel_any_keep_open())
6287 channel_timer = timeout_add(20, channel_poll_cb, NULL);
6288 #endif
6289
6290 focus = gui.in_focus;
6291
6292 do
6293 {
6294 // Stop or start blinking when focus changes
6295 if (gui.in_focus != focus)
6296 {
6297 if (gui.in_focus)
6298 gui_mch_start_blink();
6299 else
6300 gui_mch_stop_blink(TRUE);
6301 focus = gui.in_focus;
6302 }
6303
6304 #ifdef MESSAGE_QUEUE
6305 # ifdef FEAT_TIMERS
6306 did_add_timer = FALSE;
6307 # endif
6308 parse_queued_messages();
6309 # ifdef FEAT_TIMERS
6310 if (did_add_timer)
6311 // Need to recompute the waiting time.
6312 goto theend;
6313 # endif
6314 #endif
6315
6316 /*
6317 * Loop in GTK+ processing until a timeout or input occurs.
6318 * Skip this if input is available anyway (can happen in rare
6319 * situations, sort of race condition).
6320 */
6321 if (!input_available())
6322 g_main_context_iteration(NULL, TRUE);
6323
6324 // Got char, return immediately
6325 if (input_available())
6326 {
6327 retval = OK;
6328 goto theend;
6329 }
6330 } while (wtime < 0 || !timed_out);
6331
6332 /*
6333 * Flush all eventually pending (drawing) events.
6334 */
6335 gui_mch_update();
6336
6337 theend:
6338 if (timer != 0 && !timed_out)
6339 timeout_remove(timer);
6340 #ifdef FEAT_JOB_CHANNEL
6341 if (channel_timer != 0)
6342 timeout_remove(channel_timer);
6343 #endif
6344
6345 return retval;
6346 }
6347
6348
6349 /////////////////////////////////////////////////////////////////////////////
6350 // Output drawing routines.
6351 //
6352
6353
6354 // Flush any output to the screen
6355 void
gui_mch_flush(void)6356 gui_mch_flush(void)
6357 {
6358 if (gui.mainwin != NULL && gtk_widget_get_realized(gui.mainwin))
6359 #if GTK_CHECK_VERSION(2,4,0)
6360 gdk_display_flush(gtk_widget_get_display(gui.mainwin));
6361 #else
6362 gdk_display_sync(gtk_widget_get_display(gui.mainwin));
6363 #endif
6364 }
6365
6366 /*
6367 * Clear a rectangular region of the screen from text pos (row1, col1) to
6368 * (row2, col2) inclusive.
6369 */
6370 void
gui_mch_clear_block(int row1arg,int col1arg,int row2arg,int col2arg)6371 gui_mch_clear_block(int row1arg, int col1arg, int row2arg, int col2arg)
6372 {
6373
6374 int col1 = check_col(col1arg);
6375 int col2 = check_col(col2arg);
6376 int row1 = check_row(row1arg);
6377 int row2 = check_row(row2arg);
6378
6379 #if GTK_CHECK_VERSION(3,0,0)
6380 if (gtk_widget_get_window(gui.drawarea) == NULL)
6381 return;
6382 #else
6383 GdkColor color;
6384
6385 if (gui.drawarea->window == NULL)
6386 return;
6387
6388 color.pixel = gui.back_pixel;
6389 #endif
6390
6391 #if GTK_CHECK_VERSION(3,0,0)
6392 {
6393 // Add one pixel to the far right column in case a double-stroked
6394 // bold glyph may sit there.
6395 const GdkRectangle rect = {
6396 FILL_X(col1), FILL_Y(row1),
6397 (col2 - col1 + 1) * gui.char_width + (col2 == Columns - 1),
6398 (row2 - row1 + 1) * gui.char_height
6399 };
6400 cairo_t * const cr = cairo_create(gui.surface);
6401 # if GTK_CHECK_VERSION(3,22,2)
6402 set_cairo_source_rgba_from_color(cr, gui.back_pixel);
6403 # else
6404 GdkWindow * const win = gtk_widget_get_window(gui.drawarea);
6405 cairo_pattern_t * const pat = gdk_window_get_background_pattern(win);
6406 if (pat != NULL)
6407 cairo_set_source(cr, pat);
6408 else
6409 set_cairo_source_rgba_from_color(cr, gui.back_pixel);
6410 # endif
6411 cairo_rectangle(cr, rect.x, rect.y, rect.width, rect.height);
6412 cairo_fill(cr);
6413 cairo_destroy(cr);
6414
6415 gtk_widget_queue_draw_area(gui.drawarea,
6416 rect.x, rect.y, rect.width, rect.height);
6417 }
6418 #else // !GTK_CHECK_VERSION(3,0,0)
6419 gdk_gc_set_foreground(gui.text_gc, &color);
6420
6421 // Clear one extra pixel at the far right, for when bold characters have
6422 // spilled over to the window border.
6423 gdk_draw_rectangle(gui.drawarea->window, gui.text_gc, TRUE,
6424 FILL_X(col1), FILL_Y(row1),
6425 (col2 - col1 + 1) * gui.char_width
6426 + (col2 == Columns - 1),
6427 (row2 - row1 + 1) * gui.char_height);
6428 #endif // !GTK_CHECK_VERSION(3,0,0)
6429 }
6430
6431 #if GTK_CHECK_VERSION(3,0,0)
6432 static void
gui_gtk_window_clear(GdkWindow * win)6433 gui_gtk_window_clear(GdkWindow *win)
6434 {
6435 const GdkRectangle rect = {
6436 0, 0, gdk_window_get_width(win), gdk_window_get_height(win)
6437 };
6438 cairo_t * const cr = cairo_create(gui.surface);
6439 # if GTK_CHECK_VERSION(3,22,2)
6440 set_cairo_source_rgba_from_color(cr, gui.back_pixel);
6441 # else
6442 cairo_pattern_t * const pat = gdk_window_get_background_pattern(win);
6443 if (pat != NULL)
6444 cairo_set_source(cr, pat);
6445 else
6446 set_cairo_source_rgba_from_color(cr, gui.back_pixel);
6447 # endif
6448 cairo_rectangle(cr, rect.x, rect.y, rect.width, rect.height);
6449 cairo_fill(cr);
6450 cairo_destroy(cr);
6451
6452 gtk_widget_queue_draw_area(gui.drawarea,
6453 rect.x, rect.y, rect.width, rect.height);
6454 }
6455 #else
6456 # define gui_gtk_window_clear(win) gdk_window_clear(win)
6457 #endif
6458
6459 void
gui_mch_clear_all(void)6460 gui_mch_clear_all(void)
6461 {
6462 if (gtk_widget_get_window(gui.drawarea) != NULL)
6463 gui_gtk_window_clear(gtk_widget_get_window(gui.drawarea));
6464 }
6465
6466 #if !GTK_CHECK_VERSION(3,0,0)
6467 /*
6468 * Redraw any text revealed by scrolling up/down.
6469 */
6470 static void
check_copy_area(void)6471 check_copy_area(void)
6472 {
6473 GdkEvent *event;
6474 int expose_count;
6475
6476 if (gui.visibility != GDK_VISIBILITY_PARTIAL)
6477 return;
6478
6479 // Avoid redrawing the cursor while scrolling or it'll end up where
6480 // we don't want it to be. I'm not sure if it's correct to call
6481 // gui_dont_update_cursor() at this point but it works as a quick
6482 // fix for now.
6483 gui_dont_update_cursor(TRUE);
6484
6485 do
6486 {
6487 // Wait to check whether the scroll worked or not.
6488 event = gdk_event_get_graphics_expose(gui.drawarea->window);
6489
6490 if (event == NULL)
6491 break; // received NoExpose event
6492
6493 gui_redraw(event->expose.area.x, event->expose.area.y,
6494 event->expose.area.width, event->expose.area.height);
6495
6496 expose_count = event->expose.count;
6497 gdk_event_free(event);
6498 }
6499 while (expose_count > 0); // more events follow
6500
6501 gui_can_update_cursor();
6502 }
6503 #endif // !GTK_CHECK_VERSION(3,0,0)
6504
6505 #if GTK_CHECK_VERSION(3,0,0)
6506 static void
gui_gtk_surface_copy_rect(int dest_x,int dest_y,int src_x,int src_y,int width,int height)6507 gui_gtk_surface_copy_rect(int dest_x, int dest_y,
6508 int src_x, int src_y,
6509 int width, int height)
6510 {
6511 cairo_t * const cr = cairo_create(gui.surface);
6512
6513 cairo_rectangle(cr, dest_x, dest_y, width, height);
6514 cairo_clip(cr);
6515 cairo_push_group(cr);
6516 cairo_set_source_surface(cr, gui.surface, dest_x - src_x, dest_y - src_y);
6517 cairo_paint(cr);
6518 cairo_pop_group_to_source(cr);
6519 cairo_paint(cr);
6520
6521 cairo_destroy(cr);
6522 }
6523 #endif
6524
6525 /*
6526 * Delete the given number of lines from the given row, scrolling up any
6527 * text further down within the scroll region.
6528 */
6529 void
gui_mch_delete_lines(int row,int num_lines)6530 gui_mch_delete_lines(int row, int num_lines)
6531 {
6532 #if GTK_CHECK_VERSION(3,0,0)
6533 const int ncols = gui.scroll_region_right - gui.scroll_region_left + 1;
6534 const int nrows = gui.scroll_region_bot - row + 1;
6535 const int src_nrows = nrows - num_lines;
6536
6537 gui_gtk_surface_copy_rect(
6538 FILL_X(gui.scroll_region_left), FILL_Y(row),
6539 FILL_X(gui.scroll_region_left), FILL_Y(row + num_lines),
6540 gui.char_width * ncols + 1, gui.char_height * src_nrows);
6541 gui_clear_block(
6542 gui.scroll_region_bot - num_lines + 1, gui.scroll_region_left,
6543 gui.scroll_region_bot, gui.scroll_region_right);
6544 gtk_widget_queue_draw_area(gui.drawarea,
6545 FILL_X(gui.scroll_region_left), FILL_Y(row),
6546 gui.char_width * ncols + 1, gui.char_height * nrows);
6547 #else
6548 if (gui.visibility == GDK_VISIBILITY_FULLY_OBSCURED)
6549 return; // Can't see the window
6550
6551 gdk_gc_set_foreground(gui.text_gc, gui.fgcolor);
6552 gdk_gc_set_background(gui.text_gc, gui.bgcolor);
6553
6554 // copy one extra pixel, for when bold has spilled over
6555 gdk_window_copy_area(gui.drawarea->window, gui.text_gc,
6556 FILL_X(gui.scroll_region_left), FILL_Y(row),
6557 gui.drawarea->window,
6558 FILL_X(gui.scroll_region_left),
6559 FILL_Y(row + num_lines),
6560 gui.char_width * (gui.scroll_region_right
6561 - gui.scroll_region_left + 1) + 1,
6562 gui.char_height * (gui.scroll_region_bot - row - num_lines + 1));
6563
6564 gui_clear_block(gui.scroll_region_bot - num_lines + 1,
6565 gui.scroll_region_left,
6566 gui.scroll_region_bot, gui.scroll_region_right);
6567 check_copy_area();
6568 #endif // !GTK_CHECK_VERSION(3,0,0)
6569 }
6570
6571 /*
6572 * Insert the given number of lines before the given row, scrolling down any
6573 * following text within the scroll region.
6574 */
6575 void
gui_mch_insert_lines(int row,int num_lines)6576 gui_mch_insert_lines(int row, int num_lines)
6577 {
6578 #if GTK_CHECK_VERSION(3,0,0)
6579 const int ncols = gui.scroll_region_right - gui.scroll_region_left + 1;
6580 const int nrows = gui.scroll_region_bot - row + 1;
6581 const int src_nrows = nrows - num_lines;
6582
6583 gui_gtk_surface_copy_rect(
6584 FILL_X(gui.scroll_region_left), FILL_Y(row + num_lines),
6585 FILL_X(gui.scroll_region_left), FILL_Y(row),
6586 gui.char_width * ncols + 1, gui.char_height * src_nrows);
6587 gui_clear_block(
6588 row, gui.scroll_region_left,
6589 row + num_lines - 1, gui.scroll_region_right);
6590 gtk_widget_queue_draw_area(gui.drawarea,
6591 FILL_X(gui.scroll_region_left), FILL_Y(row),
6592 gui.char_width * ncols + 1, gui.char_height * nrows);
6593 #else
6594 if (gui.visibility == GDK_VISIBILITY_FULLY_OBSCURED)
6595 return; // Can't see the window
6596
6597 gdk_gc_set_foreground(gui.text_gc, gui.fgcolor);
6598 gdk_gc_set_background(gui.text_gc, gui.bgcolor);
6599
6600 // copy one extra pixel, for when bold has spilled over
6601 gdk_window_copy_area(gui.drawarea->window, gui.text_gc,
6602 FILL_X(gui.scroll_region_left), FILL_Y(row + num_lines),
6603 gui.drawarea->window,
6604 FILL_X(gui.scroll_region_left), FILL_Y(row),
6605 gui.char_width * (gui.scroll_region_right
6606 - gui.scroll_region_left + 1) + 1,
6607 gui.char_height * (gui.scroll_region_bot - row - num_lines + 1));
6608
6609 gui_clear_block(row, gui.scroll_region_left,
6610 row + num_lines - 1, gui.scroll_region_right);
6611 check_copy_area();
6612 #endif // !GTK_CHECK_VERSION(3,0,0)
6613 }
6614
6615 /*
6616 * X Selection stuff, for cutting and pasting text to other windows.
6617 */
6618 void
clip_mch_request_selection(Clipboard_T * cbd)6619 clip_mch_request_selection(Clipboard_T *cbd)
6620 {
6621 GdkAtom target;
6622 unsigned i;
6623 time_t start;
6624
6625 for (i = 0; i < N_SELECTION_TARGETS; ++i)
6626 {
6627 if (!clip_html && selection_targets[i].info == TARGET_HTML)
6628 continue;
6629 received_selection = RS_NONE;
6630 target = gdk_atom_intern(selection_targets[i].target, FALSE);
6631
6632 gtk_selection_convert(gui.drawarea,
6633 cbd->gtk_sel_atom, target,
6634 (guint32)GDK_CURRENT_TIME);
6635
6636 // Hack: Wait up to three seconds for the selection. A hang was
6637 // noticed here when using the netrw plugin combined with ":gui"
6638 // during the FocusGained event.
6639 start = time(NULL);
6640 while (received_selection == RS_NONE && time(NULL) < start + 3)
6641 g_main_context_iteration(NULL, TRUE); // wait for selection_received_cb
6642
6643 if (received_selection != RS_FAIL)
6644 return;
6645 }
6646
6647 // Final fallback position - use the X CUT_BUFFER0 store
6648 yank_cut_buffer0(GDK_WINDOW_XDISPLAY(gtk_widget_get_window(gui.mainwin)),
6649 cbd);
6650 }
6651
6652 /*
6653 * Disown the selection.
6654 */
6655 void
clip_mch_lose_selection(Clipboard_T * cbd UNUSED)6656 clip_mch_lose_selection(Clipboard_T *cbd UNUSED)
6657 {
6658 if (!in_selection_clear_event)
6659 {
6660 gtk_selection_owner_set(NULL, cbd->gtk_sel_atom, gui.event_time);
6661 gui_mch_update();
6662 }
6663 }
6664
6665 /*
6666 * Own the selection and return OK if it worked.
6667 */
6668 int
clip_mch_own_selection(Clipboard_T * cbd)6669 clip_mch_own_selection(Clipboard_T *cbd)
6670 {
6671 int success;
6672
6673 success = gtk_selection_owner_set(gui.drawarea, cbd->gtk_sel_atom,
6674 gui.event_time);
6675 gui_mch_update();
6676 return (success) ? OK : FAIL;
6677 }
6678
6679 /*
6680 * Send the current selection to the clipboard. Do nothing for X because we
6681 * will fill in the selection only when requested by another app.
6682 */
6683 void
clip_mch_set_selection(Clipboard_T * cbd UNUSED)6684 clip_mch_set_selection(Clipboard_T *cbd UNUSED)
6685 {
6686 }
6687
6688 #if (defined(FEAT_XCLIPBOARD) && defined(USE_SYSTEM)) || defined(PROTO)
6689 int
clip_gtk_owner_exists(Clipboard_T * cbd)6690 clip_gtk_owner_exists(Clipboard_T *cbd)
6691 {
6692 return gdk_selection_owner_get(cbd->gtk_sel_atom) != NULL;
6693 }
6694 #endif
6695
6696
6697 #if defined(FEAT_MENU) || defined(PROTO)
6698 /*
6699 * Make a menu item appear either active or not active (grey or not grey).
6700 */
6701 void
gui_mch_menu_grey(vimmenu_T * menu,int grey)6702 gui_mch_menu_grey(vimmenu_T *menu, int grey)
6703 {
6704 if (menu->id == NULL)
6705 return;
6706
6707 if (menu_is_separator(menu->name))
6708 grey = TRUE;
6709
6710 gui_mch_menu_hidden(menu, FALSE);
6711 // Be clever about bitfields versus true booleans here!
6712 if (!gtk_widget_get_sensitive(menu->id) == !grey)
6713 {
6714 gtk_widget_set_sensitive(menu->id, !grey);
6715 gui_mch_update();
6716 }
6717 }
6718
6719 /*
6720 * Make menu item hidden or not hidden.
6721 */
6722 void
gui_mch_menu_hidden(vimmenu_T * menu,int hidden)6723 gui_mch_menu_hidden(vimmenu_T *menu, int hidden)
6724 {
6725 if (menu->id == 0)
6726 return;
6727
6728 if (hidden)
6729 {
6730 if (gtk_widget_get_visible(menu->id))
6731 {
6732 gtk_widget_hide(menu->id);
6733 gui_mch_update();
6734 }
6735 }
6736 else
6737 {
6738 if (!gtk_widget_get_visible(menu->id))
6739 {
6740 gtk_widget_show(menu->id);
6741 gui_mch_update();
6742 }
6743 }
6744 }
6745
6746 /*
6747 * This is called after setting all the menus to grey/hidden or not.
6748 */
6749 void
gui_mch_draw_menubar(void)6750 gui_mch_draw_menubar(void)
6751 {
6752 // just make sure that the visual changes get effect immediately
6753 gui_mch_update();
6754 }
6755 #endif // FEAT_MENU
6756
6757 /*
6758 * Scrollbar stuff.
6759 */
6760 void
gui_mch_enable_scrollbar(scrollbar_T * sb,int flag)6761 gui_mch_enable_scrollbar(scrollbar_T *sb, int flag)
6762 {
6763 if (sb->id == NULL)
6764 return;
6765
6766 gtk_widget_set_visible(sb->id, flag);
6767 update_window_manager_hints(0, 0);
6768 }
6769
6770
6771 /*
6772 * Return the RGB value of a pixel as long.
6773 */
6774 guicolor_T
gui_mch_get_rgb(guicolor_T pixel)6775 gui_mch_get_rgb(guicolor_T pixel)
6776 {
6777 #if GTK_CHECK_VERSION(3,0,0)
6778 return (long_u)pixel;
6779 #else
6780 GdkColor color;
6781
6782 gdk_colormap_query_color(gtk_widget_get_colormap(gui.drawarea),
6783 (unsigned long)pixel, &color);
6784
6785 return (guicolor_T)(
6786 (((unsigned)color.red & 0xff00) << 8)
6787 | ((unsigned)color.green & 0xff00)
6788 | (((unsigned)color.blue & 0xff00) >> 8));
6789 #endif
6790 }
6791
6792 /*
6793 * Get current mouse coordinates in text window.
6794 */
6795 void
gui_mch_getmouse(int * x,int * y)6796 gui_mch_getmouse(int *x, int *y)
6797 {
6798 gui_gtk_get_pointer(gui.drawarea, x, y, NULL);
6799 }
6800
6801 void
gui_mch_setmouse(int x,int y)6802 gui_mch_setmouse(int x, int y)
6803 {
6804 // Sorry for the Xlib call, but we can't avoid it, since there is no
6805 // internal GDK mechanism present to accomplish this. (and for good
6806 // reason...)
6807 XWarpPointer(GDK_WINDOW_XDISPLAY(gtk_widget_get_window(gui.drawarea)),
6808 (Window)0, GDK_WINDOW_XID(gtk_widget_get_window(gui.drawarea)),
6809 0, 0, 0U, 0U, x, y);
6810 }
6811
6812
6813 #ifdef FEAT_MOUSESHAPE
6814 // The last set mouse pointer shape is remembered, to be used when it goes
6815 // from hidden to not hidden.
6816 static int last_shape = 0;
6817 #endif
6818
6819 /*
6820 * Use the blank mouse pointer or not.
6821 *
6822 * hide: TRUE = use blank ptr, FALSE = use parent ptr
6823 */
6824 void
gui_mch_mousehide(int hide)6825 gui_mch_mousehide(int hide)
6826 {
6827 if (gui.pointer_hidden != hide)
6828 {
6829 gui.pointer_hidden = hide;
6830 if (gtk_widget_get_window(gui.drawarea) && gui.blank_pointer != NULL)
6831 {
6832 if (hide)
6833 gdk_window_set_cursor(gtk_widget_get_window(gui.drawarea),
6834 gui.blank_pointer);
6835 else
6836 #ifdef FEAT_MOUSESHAPE
6837 mch_set_mouse_shape(last_shape);
6838 #else
6839 gdk_window_set_cursor(gtk_widget_get_window(gui.drawarea), NULL);
6840 #endif
6841 }
6842 }
6843 }
6844
6845 #if defined(FEAT_MOUSESHAPE) || defined(PROTO)
6846
6847 // Table for shape IDs. Keep in sync with the mshape_names[] table in
6848 // misc2.c!
6849 static const int mshape_ids[] =
6850 {
6851 GDK_LEFT_PTR, // arrow
6852 GDK_CURSOR_IS_PIXMAP, // blank
6853 GDK_XTERM, // beam
6854 GDK_SB_V_DOUBLE_ARROW, // updown
6855 GDK_SIZING, // udsizing
6856 GDK_SB_H_DOUBLE_ARROW, // leftright
6857 GDK_SIZING, // lrsizing
6858 GDK_WATCH, // busy
6859 GDK_X_CURSOR, // no
6860 GDK_CROSSHAIR, // crosshair
6861 GDK_HAND1, // hand1
6862 GDK_HAND2, // hand2
6863 GDK_PENCIL, // pencil
6864 GDK_QUESTION_ARROW, // question
6865 GDK_RIGHT_PTR, // right-arrow
6866 GDK_CENTER_PTR, // up-arrow
6867 GDK_LEFT_PTR // last one
6868 };
6869
6870 void
mch_set_mouse_shape(int shape)6871 mch_set_mouse_shape(int shape)
6872 {
6873 int id;
6874 GdkCursor *c;
6875
6876 if (gtk_widget_get_window(gui.drawarea) == NULL)
6877 return;
6878
6879 if (shape == MSHAPE_HIDE || gui.pointer_hidden)
6880 gdk_window_set_cursor(gtk_widget_get_window(gui.drawarea),
6881 gui.blank_pointer);
6882 else
6883 {
6884 if (shape >= MSHAPE_NUMBERED)
6885 {
6886 id = shape - MSHAPE_NUMBERED;
6887 if (id >= GDK_LAST_CURSOR)
6888 id = GDK_LEFT_PTR;
6889 else
6890 id &= ~1; // they are always even (why?)
6891 }
6892 else if (shape < (int)ARRAY_LENGTH(mshape_ids))
6893 id = mshape_ids[shape];
6894 else
6895 return;
6896 c = gdk_cursor_new_for_display(
6897 gtk_widget_get_display(gui.drawarea), (GdkCursorType)id);
6898 gdk_window_set_cursor(gtk_widget_get_window(gui.drawarea), c);
6899 # if GTK_CHECK_VERSION(3,0,0)
6900 g_object_unref(G_OBJECT(c));
6901 # else
6902 gdk_cursor_destroy(c); // Unref, actually. Bloody GTK+ 1.
6903 # endif
6904 }
6905 if (shape != MSHAPE_HIDE)
6906 last_shape = shape;
6907 }
6908 #endif // FEAT_MOUSESHAPE
6909
6910
6911 #if defined(FEAT_SIGN_ICONS) || defined(PROTO)
6912 /*
6913 * Signs are currently always 2 chars wide. With GTK+ 2, the image will be
6914 * scaled down if the current font is not big enough, or scaled up if the image
6915 * size is less than 3/4 of the maximum sign size. With GTK+ 1, the pixmap
6916 * will be cut off if the current font is not big enough, or centered if it's
6917 * too small.
6918 */
6919 # define SIGN_WIDTH (2 * gui.char_width)
6920 # define SIGN_HEIGHT (gui.char_height)
6921 # define SIGN_ASPECT ((double)SIGN_HEIGHT / (double)SIGN_WIDTH)
6922
6923 void
gui_mch_drawsign(int row,int col,int typenr)6924 gui_mch_drawsign(int row, int col, int typenr)
6925 {
6926 GdkPixbuf *sign;
6927
6928 sign = (GdkPixbuf *)sign_get_image(typenr);
6929
6930 if (sign != NULL && gui.drawarea != NULL
6931 && gtk_widget_get_window(gui.drawarea) != NULL)
6932 {
6933 int width;
6934 int height;
6935 int xoffset;
6936 int yoffset;
6937 int need_scale;
6938
6939 width = gdk_pixbuf_get_width(sign);
6940 height = gdk_pixbuf_get_height(sign);
6941 /*
6942 * Decide whether we need to scale. Allow one pixel of border
6943 * width to be cut off, in order to avoid excessive scaling for
6944 * tiny differences in font size.
6945 * Do scale to fit the height to avoid gaps because of linespacing.
6946 */
6947 need_scale = (width > SIGN_WIDTH + 2
6948 || height != SIGN_HEIGHT
6949 || (width < 3 * SIGN_WIDTH / 4
6950 && height < 3 * SIGN_HEIGHT / 4));
6951 if (need_scale)
6952 {
6953 double aspect;
6954 int w = width;
6955 int h = height;
6956
6957 // Keep the original aspect ratio
6958 aspect = (double)height / (double)width;
6959 width = (double)SIGN_WIDTH * SIGN_ASPECT / aspect;
6960 width = MIN(width, SIGN_WIDTH);
6961 if (((double)(MAX(height, SIGN_HEIGHT)) /
6962 (double)(MIN(height, SIGN_HEIGHT))) < 1.15)
6963 {
6964 // Change the aspect ratio by at most 15% to fill the
6965 // available space completely.
6966 height = (double)SIGN_HEIGHT * SIGN_ASPECT / aspect;
6967 height = MIN(height, SIGN_HEIGHT);
6968 }
6969 else
6970 height = (double)width * aspect;
6971
6972 if (w == width && h == height)
6973 {
6974 // no change in dimensions; don't decrease reference counter
6975 // (below)
6976 need_scale = FALSE;
6977 }
6978 else
6979 {
6980 // This doesn't seem to be worth caching, and doing so would
6981 // complicate the code quite a bit.
6982 sign = gdk_pixbuf_scale_simple(sign, width, height,
6983 GDK_INTERP_BILINEAR);
6984 if (sign == NULL)
6985 return; // out of memory
6986 }
6987 }
6988
6989 // The origin is the upper-left corner of the pixmap. Therefore
6990 // these offset may become negative if the pixmap is smaller than
6991 // the 2x1 cells reserved for the sign icon.
6992 xoffset = (width - SIGN_WIDTH) / 2;
6993 yoffset = (height - SIGN_HEIGHT) / 2;
6994
6995 # if GTK_CHECK_VERSION(3,0,0)
6996 {
6997 cairo_t *cr;
6998 cairo_surface_t *bg_surf;
6999 cairo_t *bg_cr;
7000 cairo_surface_t *sign_surf;
7001 cairo_t *sign_cr;
7002
7003 cr = cairo_create(gui.surface);
7004
7005 bg_surf = cairo_surface_create_similar(gui.surface,
7006 cairo_surface_get_content(gui.surface),
7007 SIGN_WIDTH, SIGN_HEIGHT);
7008 bg_cr = cairo_create(bg_surf);
7009 cairo_set_source_rgba(bg_cr,
7010 gui.bgcolor->red, gui.bgcolor->green, gui.bgcolor->blue,
7011 gui.bgcolor->alpha);
7012 cairo_paint(bg_cr);
7013
7014 sign_surf = cairo_surface_create_similar(gui.surface,
7015 cairo_surface_get_content(gui.surface),
7016 SIGN_WIDTH, SIGN_HEIGHT);
7017 sign_cr = cairo_create(sign_surf);
7018 gdk_cairo_set_source_pixbuf(sign_cr, sign, -xoffset, -yoffset);
7019 cairo_paint(sign_cr);
7020
7021 cairo_set_operator(sign_cr, CAIRO_OPERATOR_DEST_OVER);
7022 cairo_set_source_surface(sign_cr, bg_surf, 0, 0);
7023 cairo_paint(sign_cr);
7024
7025 cairo_set_source_surface(cr, sign_surf, FILL_X(col), FILL_Y(row));
7026 cairo_paint(cr);
7027
7028 cairo_destroy(sign_cr);
7029 cairo_surface_destroy(sign_surf);
7030 cairo_destroy(bg_cr);
7031 cairo_surface_destroy(bg_surf);
7032 cairo_destroy(cr);
7033
7034 gtk_widget_queue_draw_area(gui.drawarea,
7035 FILL_X(col), FILL_Y(col), width, height);
7036
7037 }
7038 # else // !GTK_CHECK_VERSION(3,0,0)
7039 gdk_gc_set_foreground(gui.text_gc, gui.bgcolor);
7040
7041 gdk_draw_rectangle(gui.drawarea->window,
7042 gui.text_gc,
7043 TRUE,
7044 FILL_X(col),
7045 FILL_Y(row),
7046 SIGN_WIDTH,
7047 SIGN_HEIGHT);
7048
7049 gdk_pixbuf_render_to_drawable_alpha(sign,
7050 gui.drawarea->window,
7051 MAX(0, xoffset),
7052 MAX(0, yoffset),
7053 FILL_X(col) - MIN(0, xoffset),
7054 FILL_Y(row) - MIN(0, yoffset),
7055 MIN(width, SIGN_WIDTH),
7056 MIN(height, SIGN_HEIGHT),
7057 GDK_PIXBUF_ALPHA_BILEVEL,
7058 127,
7059 GDK_RGB_DITHER_NORMAL,
7060 0, 0);
7061 # endif // !GTK_CHECK_VERSION(3,0,0)
7062 if (need_scale)
7063 g_object_unref(sign);
7064 }
7065 }
7066
7067 void *
gui_mch_register_sign(char_u * signfile)7068 gui_mch_register_sign(char_u *signfile)
7069 {
7070 if (signfile[0] != NUL && signfile[0] != '-' && gui.in_use)
7071 {
7072 GdkPixbuf *sign;
7073 GError *error = NULL;
7074 char_u *message;
7075
7076 sign = gdk_pixbuf_new_from_file((const char *)signfile, &error);
7077
7078 if (error == NULL)
7079 return sign;
7080
7081 message = (char_u *)error->message;
7082
7083 if (message != NULL && input_conv.vc_type != CONV_NONE)
7084 message = string_convert(&input_conv, message, NULL);
7085
7086 if (message != NULL)
7087 {
7088 // The error message is already translated and will be more
7089 // descriptive than anything we could possibly do ourselves.
7090 semsg("E255: %s", message);
7091
7092 if (input_conv.vc_type != CONV_NONE)
7093 vim_free(message);
7094 }
7095 g_error_free(error);
7096 }
7097
7098 return NULL;
7099 }
7100
7101 void
gui_mch_destroy_sign(void * sign)7102 gui_mch_destroy_sign(void *sign)
7103 {
7104 if (sign != NULL)
7105 g_object_unref(sign);
7106 }
7107
7108 #endif // FEAT_SIGN_ICONS
7109