src/vte.c

   1 /*
   2  *      vte.c - this file is part of Geany, a fast and lightweight IDE
   3  *
   4  *      Copyright 2005-2012 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
   5  *      Copyright 2006-2012 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  *
  17  *      You should have received a copy of the GNU General Public License along
  18  *      with this program; if not, write to the Free Software Foundation, Inc.,
  19  *      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 /*
  23  * Virtual Terminal Emulation setup and handling code, using the libvte plugin library.
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #ifdef HAVE_VTE
  31
  32 #include "vte.h"
  33
  34 #include "callbacks.h"
  35 #include "document.h"
  36 #include "msgwindow.h"
  37 #include "prefs.h"
  38 #include "sciwrappers.h"
  39 #include "support.h"
  40 #include "ui_utils.h"
  41 #include "utils.h"
  42
  43 #include "gtkcompat.h"
  44
  45 /* include stdlib.h AND unistd.h, because on GNU/Linux pid_t seems to be
  46  * in stdlib.h, on FreeBSD in unistd.h, sys/types.h is needed for C89 */
  47 #include <stdlib.h>
  48 #include <sys/types.h>
  49 #include <unistd.h>
  50
  51 #include <gdk/gdkkeysyms.h>
  52 #include <signal.h>
  53 #include <string.h>
  54 #include <errno.h>
  55
  56
  57 VteInfo vte_info;
  58 VteConfig *vc;
  59
  60 static pid_t pid = 0;
  61 static gboolean clean = TRUE;
  62 static GModule *module = NULL;
  63 static struct VteFunctions *vf;
  64 static gchar *gtk_menu_key_accel = NULL;
  65
  66 /* use vte wordchars to select paths */
  67 static const gchar VTE_WORDCHARS[] = "-A-Za-z0-9,./?%&#:_";
  68
  69
  70 /* Incomplete VteTerminal struct from vte/vte.h. */
  71 typedef struct _VteTerminal VteTerminal;
  72 struct _VteTerminal
  73 {
  74         GtkWidget widget;
  75         GtkAdjustment *adjustment;
  76 };
  77
  78 #define VTE_TERMINAL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), VTE_TYPE_TERMINAL, VteTerminal))
  79 #define VTE_TYPE_TERMINAL (vf->vte_terminal_get_type())
  80
  81 typedef enum {
  82         VTE_CURSOR_BLINK_SYSTEM,
  83         VTE_CURSOR_BLINK_ON,
  84         VTE_CURSOR_BLINK_OFF
  85 } VteTerminalCursorBlinkMode;
  86
  87
  88 /* Holds function pointers we need to access the VTE API. */
  89 struct VteFunctions
  90 {
  91         GtkWidget* (*vte_terminal_new) (void);
  92         pid_t (*vte_terminal_fork_command) (VteTerminal *terminal, const char *command, char **argv,
  93                                                                                 char **envv, const char *directory, gboolean lastlog,
  94                                                                                 gboolean utmp, gboolean wtmp);
  95         void (*vte_terminal_set_size) (VteTerminal *terminal, glong columns, glong rows);
  96         void (*vte_terminal_set_word_chars) (VteTerminal *terminal, const char *spec);
  97         void (*vte_terminal_set_mouse_autohide) (VteTerminal *terminal, gboolean setting);
  98         void (*vte_terminal_reset) (VteTerminal *terminal, gboolean full, gboolean clear_history);
  99         GType (*vte_terminal_get_type) (void);
 100         void (*vte_terminal_set_scroll_on_output) (VteTerminal *terminal, gboolean scroll);
 101         void (*vte_terminal_set_scroll_on_keystroke) (VteTerminal *terminal, gboolean scroll);
 102         void (*vte_terminal_set_font_from_string) (VteTerminal *terminal, const char *name);
 103         void (*vte_terminal_set_scrollback_lines) (VteTerminal *terminal, glong lines);
 104         gboolean (*vte_terminal_get_has_selection) (VteTerminal *terminal);
 105         void (*vte_terminal_copy_clipboard) (VteTerminal *terminal);
 106         void (*vte_terminal_paste_clipboard) (VteTerminal *terminal);
 107         void (*vte_terminal_set_emulation) (VteTerminal *terminal, const gchar *emulation);
 108         void (*vte_terminal_set_color_foreground) (VteTerminal *terminal, const GdkColor *foreground);
 109         void (*vte_terminal_set_color_bold) (VteTerminal *terminal, const GdkColor *foreground);
 110         void (*vte_terminal_set_color_background) (VteTerminal *terminal, const GdkColor *background);
 111         void (*vte_terminal_feed_child) (VteTerminal *terminal, const char *data, glong length);
 112         void (*vte_terminal_im_append_menuitems) (VteTerminal *terminal, GtkMenuShell *menushell);
 113         void (*vte_terminal_set_cursor_blink_mode) (VteTerminal *terminal,
 114                                                                                                 VteTerminalCursorBlinkMode mode);
 115         void (*vte_terminal_set_cursor_blinks) (VteTerminal *terminal, gboolean blink);
 116         void (*vte_terminal_select_all) (VteTerminal *terminal);
 117         void (*vte_terminal_set_audible_bell) (VteTerminal *terminal, gboolean is_audible);
 118         void (*vte_terminal_set_background_image_file) (VteTerminal *terminal, const char *path);
 119 };
 120
 121
 122 static void create_vte(void);
 123 static void vte_start(GtkWidget *widget);
 124 static void vte_restart(GtkWidget *widget);
 125 static gboolean vte_button_pressed(GtkWidget *widget, GdkEventButton *event, gpointer user_data);
 126 static gboolean vte_keyrelease_cb(GtkWidget *widget, GdkEventKey *event, gpointer data);
 127 static gboolean vte_keypress_cb(GtkWidget *widget, GdkEventKey *event, gpointer data);
 128 static gboolean vte_register_symbols(GModule *module);
 129 static void vte_popup_menu_clicked(GtkMenuItem *menuitem, gpointer user_data);
 130 static GtkWidget *vte_create_popup_menu(void);
 131 static void vte_commit_cb(VteTerminal *vte, gchar *arg1, guint arg2, gpointer user_data);
 132 static void vte_drag_data_received(GtkWidget *widget, GdkDragContext *drag_context,
 133                                                                    gint x, gint y, GtkSelectionData *data, guint info, guint ltime);
 134
 135
 136 enum
 137 {
 138         POPUP_COPY,
 139         POPUP_PASTE,
 140         POPUP_SELECTALL,
 141         POPUP_CHANGEPATH,
 142         POPUP_RESTARTTERMINAL,
 143         POPUP_PREFERENCES,
 144         TARGET_UTF8_STRING = 0,
 145         TARGET_TEXT,
 146         TARGET_COMPOUND_TEXT,
 147         TARGET_STRING,
 148         TARGET_TEXT_PLAIN
 149 };
 150
 151 static const GtkTargetEntry dnd_targets[] =
 152 {
 153   { "UTF8_STRING", 0, TARGET_UTF8_STRING },
 154   { "TEXT", 0, TARGET_TEXT },
 155   { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
 156   { "STRING", 0, TARGET_STRING },
 157   { "text/plain", 0, TARGET_TEXT_PLAIN },
 158 };
 159
 160
 161 static gchar **vte_get_child_environment(void)
 162 {
 163         const gchar *exclude_vars[] = {"COLUMNS", "LINES", "TERM", NULL};
 164
 165         return utils_copy_environment(exclude_vars, "TERM", "xterm", NULL);
 166 }
 167
 168
 169 static void override_menu_key(void)
 170 {
 171         if (gtk_menu_key_accel == NULL) /* for restoring the default value */
 172                 g_object_get(G_OBJECT(gtk_settings_get_default()),
 173                         "gtk-menu-bar-accel", &gtk_menu_key_accel, NULL);
 174
 175         if (vc->ignore_menu_bar_accel)
 176                 gtk_settings_set_string_property(gtk_settings_get_default(),
 177                         "gtk-menu-bar-accel", "<Shift><Control><Mod1><Mod2><Mod3><Mod4><Mod5>F10", "Geany");
 178         else
 179                 gtk_settings_set_string_property(gtk_settings_get_default(),
 180                         "gtk-menu-bar-accel", gtk_menu_key_accel, "Geany");
 181 }
 182
 183
 184 void vte_init(void)
 185 {
 186         if (vte_info.have_vte == FALSE)
 187         {       /* vte_info.have_vte can be false even if VTE is compiled in, think of command line option */
 188                 geany_debug("Disabling terminal support");
 189                 return;
 190         }
 191
 192         if (!EMPTY(vte_info.lib_vte))
 193         {
 194                 module = g_module_open(vte_info.lib_vte, G_MODULE_BIND_LAZY);
 195         }
 196 #ifdef VTE_MODULE_PATH
 197         else
 198         {
 199                 module = g_module_open(VTE_MODULE_PATH, G_MODULE_BIND_LAZY);
 200         }
 201 #endif
 202
 203         if (module == NULL)
 204         {
 205                 gint i;
 206                 const gchar *sonames[] = {
 207 #if GTK_CHECK_VERSION(3, 0, 0)
 208                         "libvte2_90.so", "libvte2_90.so.9",
 209 #else
 210                         "libvte.so", "libvte.so.4", "libvte.so.8", "libvte.so.9",
 211 #endif
 212                         NULL
 213                 };
 214
 215                 for (i = 0; sonames[i] != NULL && module == NULL; i++)
 216                 {
 217                         module = g_module_open(sonames[i], G_MODULE_BIND_LAZY);
 218                 }
 219         }
 220
 221         if (module == NULL)
 222         {
 223                 vte_info.have_vte = FALSE;
 224                 geany_debug("Could not load libvte.so, embedded terminal support disabled");
 225                 return;
 226         }
 227         else
 228         {
 229                 vf = g_new0(struct VteFunctions, 1);
 230                 if (vte_register_symbols(module))
 231                         vte_info.have_vte = TRUE;
 232                 else
 233                 {
 234                         vte_info.have_vte = FALSE;
 235                         g_free(vf);
 236                         /* FIXME: is closing the module safe? see vte_close() and test on FreeBSD */
 237                         /*g_module_close(module);*/
 238                         module = NULL;
 239                         return;
 240                 }
 241         }
 242
 243         create_vte();
 244
 245         /* setup the F10 menu override (so it works before the widget is first realised). */
 246         override_menu_key();
 247 }
 248
 249
 250 static void on_vte_realize(void)
 251 {
 252         /* the vte widget has to be realised before color changes take effect */
 253         vte_apply_user_settings();
 254
 255         vf->vte_terminal_im_append_menuitems(VTE_TERMINAL(vc->vte), GTK_MENU_SHELL(vc->im_submenu));
 256 }
 257
 258
 259 static void create_vte(void)
 260 {
 261         GtkWidget *vte, *scrollbar, *hbox, *frame;
 262
 263         vc->vte = vte = vf->vte_terminal_new();
 264         scrollbar = gtk_vscrollbar_new(GTK_ADJUSTMENT(VTE_TERMINAL(vte)->adjustment));
 265         gtk_widget_set_can_focus(scrollbar, FALSE);
 266
 267         /* create menu now so copy/paste shortcuts work */
 268         vc->menu = vte_create_popup_menu();
 269         g_object_ref_sink(vc->menu);
 270
 271         frame = gtk_frame_new(NULL);
 272
 273         hbox = gtk_hbox_new(FALSE, 0);
 274         gtk_container_add(GTK_CONTAINER(frame), hbox);
 275         gtk_box_pack_start(GTK_BOX(hbox), vte, TRUE, TRUE, 0);
 276         gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, FALSE, 0);
 277
 278         /* set the default widget size first to prevent VTE expanding too much,
 279          * sometimes causing the hscrollbar to be too big or out of view. */
 280         gtk_widget_set_size_request(GTK_WIDGET(vte), 10, 10);
 281         vf->vte_terminal_set_size(VTE_TERMINAL(vte), 30, 1);
 282
 283         vf->vte_terminal_set_mouse_autohide(VTE_TERMINAL(vte), TRUE);
 284         vf->vte_terminal_set_word_chars(VTE_TERMINAL(vte), VTE_WORDCHARS);
 285
 286         gtk_drag_dest_set(vte, GTK_DEST_DEFAULT_ALL,
 287                 dnd_targets, G_N_ELEMENTS(dnd_targets), GDK_ACTION_COPY);
 288
 289         g_signal_connect(vte, "child-exited", G_CALLBACK(vte_start), NULL);
 290         g_signal_connect(vte, "button-press-event", G_CALLBACK(vte_button_pressed), NULL);
 291         g_signal_connect(vte, "event", G_CALLBACK(vte_keypress_cb), NULL);
 292         g_signal_connect(vte, "key-release-event", G_CALLBACK(vte_keyrelease_cb), NULL);
 293         g_signal_connect(vte, "commit", G_CALLBACK(vte_commit_cb), NULL);
 294         g_signal_connect(vte, "motion-notify-event", G_CALLBACK(on_motion_event), NULL);
 295         g_signal_connect(vte, "drag-data-received", G_CALLBACK(vte_drag_data_received), NULL);
 296
 297         vte_start(vte);
 298
 299         gtk_widget_show_all(frame);
 300         gtk_notebook_insert_page(GTK_NOTEBOOK(msgwindow.notebook), frame, gtk_label_new(_("Terminal")), MSG_VTE);
 301
 302         g_signal_connect_after(vte, "realize", G_CALLBACK(on_vte_realize), NULL);
 303 }
 304
 305
 306 void vte_close(void)
 307 {
 308         g_free(vf);
 309         /* free the vte widget before unloading vte module
 310          * this prevents a segfault on X close window if the message window is hidden */
 311         gtk_widget_destroy(vc->vte);
 312         gtk_widget_destroy(vc->menu);
 313         g_object_unref(vc->menu);
 314         g_free(vc->emulation);
 315         g_free(vc->shell);
 316         g_free(vc->image);
 317         g_free(vc->font);
 318         g_free(vc->send_cmd_prefix);
 319         g_free(vc);
 320         g_free(gtk_menu_key_accel);
 321         /* Don't unload the module explicitly because it causes a segfault on FreeBSD. The segfault
 322          * happens when the app really exits, not directly on g_module_close(). This still needs to
 323          * be investigated. */
 324         /*g_module_close(module); */
 325 }
 326
 327
 328 static gboolean vte_keyrelease_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
 329 {
 330         if (ui_is_keyval_enter_or_return(event->keyval) ||
 331                 ((event->keyval == GDK_c) && (event->state & GDK_CONTROL_MASK)))
 332         {
 333                 /* assume any text on the prompt has been executed when pressing Enter/Return */
 334                 clean = TRUE;
 335         }
 336         return FALSE;
 337 }
 338
 339
 340 static gboolean vte_keypress_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
 341 {
 342         if (vc->enable_bash_keys)
 343                 return FALSE;   /* Ctrl-[CD] will be handled by the VTE itself */
 344
 345         if (event->type != GDK_KEY_RELEASE)
 346                 return FALSE;
 347
 348         if ((event->keyval == GDK_c ||
 349                 event->keyval == GDK_d ||
 350                 event->keyval == GDK_C ||
 351                 event->keyval == GDK_D) &&
 352                 event->state & GDK_CONTROL_MASK &&
 353                 ! (event->state & GDK_SHIFT_MASK) && ! (event->state & GDK_MOD1_MASK))
 354         {
 355                 vte_restart(widget);
 356                 return TRUE;
 357         }
 358         return FALSE;
 359 }
 360
 361
 362 static void vte_commit_cb(VteTerminal *vte, gchar *arg1, guint arg2, gpointer user_data)
 363 {
 364         clean = FALSE;
 365 }
 366
 367
 368 static void vte_start(GtkWidget *widget)
 369 {
 370         gchar **env;
 371         gchar **argv;
 372
 373         /* split the shell command line, so arguments will work too */
 374         argv = g_strsplit(vc->shell, " ", -1);
 375
 376         if (argv != NULL)
 377         {
 378                 env = vte_get_child_environment();
 379                 pid = vf->vte_terminal_fork_command(VTE_TERMINAL(widget), argv[0], argv, env,
 380                                                                                         vte_info.dir, TRUE, TRUE, TRUE);
 381                 g_strfreev(env);
 382                 g_strfreev(argv);
 383         }
 384         else
 385                 pid = 0; /* use 0 as invalid pid */
 386
 387         clean = TRUE;
 388 }
 389
 390
 391 static void vte_restart(GtkWidget *widget)
 392 {
 393         vte_get_working_directory(); /* try to keep the working directory when restarting the VTE */
 394         if (pid > 0)
 395         {
 396                 kill(pid, SIGINT);
 397                 pid = 0;
 398         }
 399         vf->vte_terminal_reset(VTE_TERMINAL(widget), TRUE, TRUE);
 400         clean = TRUE;
 401 }
 402
 403
 404 static gboolean vte_button_pressed(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
 405 {
 406         if (event->button == 3)
 407         {
 408                 gtk_widget_grab_focus(vc->vte);
 409                 gtk_menu_popup(GTK_MENU(vc->menu), NULL, NULL, NULL, NULL, event->button, event->time);
 410         }
 411         else if (event->button == 2)
 412         {
 413                 gtk_widget_grab_focus(widget);
 414         }
 415         return FALSE;
 416 }
 417
 418
 419 static void vte_set_cursor_blink_mode(void)
 420 {
 421         if (vf->vte_terminal_set_cursor_blink_mode != NULL)
 422                 /* vte >= 0.17.1 */
 423                 vf->vte_terminal_set_cursor_blink_mode(VTE_TERMINAL(vc->vte),
 424                         (vc->cursor_blinks) ? VTE_CURSOR_BLINK_ON : VTE_CURSOR_BLINK_OFF);
 425         else
 426                 /* vte < 0.17.1 */
 427                 vf->vte_terminal_set_cursor_blinks(VTE_TERMINAL(vc->vte), vc->cursor_blinks);
 428 }
 429
 430
 431 static gboolean vte_register_symbols(GModule *mod)
 432 {
 433         #define BIND_SYMBOL(field) \
 434                 g_module_symbol(mod, #field, (void*)&vf->field)
 435         #define BIND_REQUIRED_SYMBOL(field) \
 436                 G_STMT_START { \
 437                         if (! BIND_SYMBOL(field)) \
 438                         { \
 439                                 g_critical(_("invalid VTE library \"%s\": missing symbol \"%s\""), \
 440                                                 g_module_name(mod), #field); \
 441                                 return FALSE; \
 442                         } \
 443                 } G_STMT_END
 444
 445         BIND_REQUIRED_SYMBOL(vte_terminal_new);
 446         BIND_REQUIRED_SYMBOL(vte_terminal_set_size);
 447         BIND_REQUIRED_SYMBOL(vte_terminal_fork_command);
 448         BIND_REQUIRED_SYMBOL(vte_terminal_set_word_chars);
 449         BIND_REQUIRED_SYMBOL(vte_terminal_set_mouse_autohide);
 450         BIND_REQUIRED_SYMBOL(vte_terminal_reset);
 451         BIND_REQUIRED_SYMBOL(vte_terminal_get_type);
 452         BIND_REQUIRED_SYMBOL(vte_terminal_set_scroll_on_output);
 453         BIND_REQUIRED_SYMBOL(vte_terminal_set_scroll_on_keystroke);
 454         BIND_REQUIRED_SYMBOL(vte_terminal_set_font_from_string);
 455         BIND_REQUIRED_SYMBOL(vte_terminal_set_scrollback_lines);
 456         BIND_REQUIRED_SYMBOL(vte_terminal_get_has_selection);
 457         BIND_REQUIRED_SYMBOL(vte_terminal_copy_clipboard);
 458         BIND_REQUIRED_SYMBOL(vte_terminal_paste_clipboard);
 459         BIND_REQUIRED_SYMBOL(vte_terminal_set_emulation);
 460         BIND_REQUIRED_SYMBOL(vte_terminal_set_color_foreground);
 461         BIND_REQUIRED_SYMBOL(vte_terminal_set_color_bold);
 462         BIND_REQUIRED_SYMBOL(vte_terminal_set_color_background);
 463         BIND_REQUIRED_SYMBOL(vte_terminal_set_background_image_file);
 464         BIND_REQUIRED_SYMBOL(vte_terminal_feed_child);
 465         BIND_REQUIRED_SYMBOL(vte_terminal_im_append_menuitems);
 466         if (! BIND_SYMBOL(vte_terminal_set_cursor_blink_mode))
 467                 /* vte_terminal_set_cursor_blink_mode() is only available since 0.17.1, so if we don't find
 468                  * this symbol, we are probably on an older version and use the old API instead */
 469                 BIND_REQUIRED_SYMBOL(vte_terminal_set_cursor_blinks);
 470         BIND_REQUIRED_SYMBOL(vte_terminal_select_all);
 471         BIND_REQUIRED_SYMBOL(vte_terminal_set_audible_bell);
 472
 473         #undef BIND_REQUIRED_SYMBOL
 474         #undef BIND_SYMBOL
 475
 476         return TRUE;
 477 }
 478
 479
 480 void vte_apply_user_settings(void)
 481 {
 482         if (! ui_prefs.msgwindow_visible)
 483                 return;
 484
 485         vf->vte_terminal_set_scrollback_lines(VTE_TERMINAL(vc->vte), vc->scrollback_lines);
 486         vf->vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(vc->vte), vc->scroll_on_key);
 487         vf->vte_terminal_set_scroll_on_output(VTE_TERMINAL(vc->vte), vc->scroll_on_out);
 488         vf->vte_terminal_set_emulation(VTE_TERMINAL(vc->vte), vc->emulation);
 489         vf->vte_terminal_set_font_from_string(VTE_TERMINAL(vc->vte), vc->font);
 490         vf->vte_terminal_set_color_foreground(VTE_TERMINAL(vc->vte), &vc->colour_fore);
 491         vf->vte_terminal_set_color_bold(VTE_TERMINAL(vc->vte), &vc->colour_fore);
 492         vf->vte_terminal_set_color_background(VTE_TERMINAL(vc->vte), &vc->colour_back);
 493         vf->vte_terminal_set_background_image_file(VTE_TERMINAL(vc->vte), vc->image);
 494         vf->vte_terminal_set_audible_bell(VTE_TERMINAL(vc->vte), prefs.beep_on_errors);
 495         vte_set_cursor_blink_mode();
 496
 497         override_menu_key();
 498 }
 499
 500
 501 static void vte_popup_menu_clicked(GtkMenuItem *menuitem, gpointer user_data)
 502 {
 503         switch (GPOINTER_TO_INT(user_data))
 504         {
 505                 case POPUP_COPY:
 506                 {
 507                         if (vf->vte_terminal_get_has_selection(VTE_TERMINAL(vc->vte)))
 508                                 vf->vte_terminal_copy_clipboard(VTE_TERMINAL(vc->vte));
 509                         break;
 510                 }
 511                 case POPUP_PASTE:
 512                 {
 513                         vf->vte_terminal_paste_clipboard(VTE_TERMINAL(vc->vte));
 514                         break;
 515                 }
 516                 case POPUP_SELECTALL:
 517                 {
 518                         vte_select_all();
 519                         break;
 520                 }
 521                 case POPUP_CHANGEPATH:
 522                 {
 523                         GeanyDocument *doc = document_get_current();
 524                         if (doc != NULL)
 525                                 vte_cwd(doc->file_name, TRUE);
 526                         break;
 527                 }
 528                 case POPUP_RESTARTTERMINAL:
 529                 {
 530                         vte_restart(vc->vte);
 531                         break;
 532                 }
 533                 case POPUP_PREFERENCES:
 534                 {
 535                         GtkWidget *notebook, *tab_page;
 536
 537                         prefs_show_dialog();
 538
 539                         notebook = ui_lookup_widget(ui_widgets.prefs_dialog, "notebook2");
 540                         tab_page = ui_lookup_widget(ui_widgets.prefs_dialog, "frame_term");
 541
 542                         gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook),
 543                                 gtk_notebook_page_num(GTK_NOTEBOOK(notebook), GTK_WIDGET(tab_page)));
 544
 545                         break;
 546                 }
 547         }
 548 }
 549
 550
 551 static GtkWidget *vte_create_popup_menu(void)
 552 {
 553         GtkWidget *menu, *item;
 554         GtkAccelGroup *accel_group;
 555
 556         menu = gtk_menu_new();
 557
 558         accel_group = gtk_accel_group_new();
 559         gtk_window_add_accel_group(GTK_WINDOW(main_widgets.window), accel_group);
 560
 561         item = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, NULL);
 562         gtk_widget_add_accelerator(item, "activate", accel_group,
 563                 GDK_c, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
 564         gtk_widget_show(item);
 565         gtk_container_add(GTK_CONTAINER(menu), item);
 566         g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_COPY));
 567
 568         item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, NULL);
 569         gtk_widget_add_accelerator(item, "activate", accel_group,
 570                 GDK_v, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
 571         gtk_widget_show(item);
 572         gtk_container_add(GTK_CONTAINER(menu), item);
 573         g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_PASTE));
 574
 575         item = gtk_separator_menu_item_new();
 576         gtk_widget_show(item);
 577         gtk_container_add(GTK_CONTAINER(menu), item);
 578
 579         item = gtk_image_menu_item_new_from_stock(GTK_STOCK_SELECT_ALL, NULL);
 580         gtk_widget_show(item);
 581         gtk_container_add(GTK_CONTAINER(menu), item);
 582         g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_SELECTALL));
 583
 584         item = gtk_separator_menu_item_new();
 585         gtk_widget_show(item);
 586         gtk_container_add(GTK_CONTAINER(menu), item);
 587
 588         item = gtk_image_menu_item_new_with_mnemonic(_("_Set Path From Document"));
 589         gtk_widget_show(item);
 590         gtk_container_add(GTK_CONTAINER(menu), item);
 591         g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_CHANGEPATH));
 592
 593         item = gtk_image_menu_item_new_with_mnemonic(_("_Restart Terminal"));
 594         gtk_widget_show(item);
 595         gtk_container_add(GTK_CONTAINER(menu), item);
 596         g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_RESTARTTERMINAL));
 597
 598         item = gtk_separator_menu_item_new();
 599         gtk_widget_show(item);
 600         gtk_container_add(GTK_CONTAINER(menu), item);
 601
 602         item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, NULL);
 603         gtk_widget_show(item);
 604         gtk_container_add(GTK_CONTAINER(menu), item);
 605         g_signal_connect(item, "activate", G_CALLBACK(vte_popup_menu_clicked), GINT_TO_POINTER(POPUP_PREFERENCES));
 606
 607         msgwin_menu_add_common_items(GTK_MENU(menu));
 608
 609         item = gtk_separator_menu_item_new();
 610         gtk_widget_show(item);
 611         gtk_container_add(GTK_CONTAINER(menu), item);
 612
 613         /* the IM submenu should always be the last item to be consistent with other GTK popup menus */
 614         vc->im_submenu = gtk_menu_new();
 615
 616         item = gtk_image_menu_item_new_with_mnemonic(_("_Input Methods"));
 617         gtk_widget_show(item);
 618         gtk_container_add(GTK_CONTAINER(menu), item);
 619
 620         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), vc->im_submenu);
 621         /* submenu populated after vte realized */
 622         return menu;
 623 }
 624
 625
 626 /* If the command could be executed, TRUE is returned, FALSE otherwise (i.e. there was some text
 627  * on the prompt). */
 628 gboolean vte_send_cmd(const gchar *cmd)
 629 {
 630         if (clean)
 631         {
 632                 vf->vte_terminal_feed_child(VTE_TERMINAL(vc->vte), cmd, strlen(cmd));
 633                 clean = TRUE; /* vte_terminal_feed_child() also marks the vte as not clean */
 634                 return TRUE;
 635         }
 636         else
 637                 return FALSE;
 638 }
 639
 640
 641 /* Taken from Terminal by os-cillation: terminal_screen_get_working_directory, thanks.
 642  * Determines the working directory using various OS-specific mechanisms and stores the determined
 643  * directory in vte_info.dir. Note: vte_info.dir contains the real path. */
 644 const gchar *vte_get_working_directory(void)
 645 {
 646         gchar  buffer[4096 + 1];
 647         gchar *file;
 648         gchar *cwd;
 649         gint   length;
 650
 651         if (pid > 0)
 652         {
 653                 file = g_strdup_printf("/proc/%d/cwd", pid);
 654                 length = readlink(file, buffer, sizeof(buffer));
 655
 656                 if (length > 0 && *buffer == '/')
 657                 {
 658                         buffer[length] = '\0';
 659                         g_free(vte_info.dir);
 660                         vte_info.dir = g_strdup(buffer);
 661                 }
 662                 else if (length == 0)
 663                 {
 664                         cwd = g_get_current_dir();
 665                         if (cwd != NULL)
 666                         {
 667                                 if (chdir(file) == 0)
 668                                 {
 669                                         g_free(vte_info.dir);
 670                                         vte_info.dir = g_get_current_dir();
 671                                         if (chdir(cwd) != 0)
 672                                                 geany_debug("%s: %s", G_STRFUNC, g_strerror(errno));
 673                                 }
 674                                 g_free(cwd);
 675                         }
 676                 }
 677                 g_free(file);
 678         }
 679
 680         return vte_info.dir;
 681 }
 682
 683
 684 /* Changes the current working directory of the VTE to the path of the given filename.
 685  * filename is expected to be in UTF-8 encoding.
 686  * filename can also be a path, then it is used directly.
 687  * If force is set to TRUE, it will always change the cwd
 688  */
 689 void vte_cwd(const gchar *filename, gboolean force)
 690 {
 691         if (vte_info.have_vte && (vc->follow_path || force) &&
 692                 filename != NULL && g_path_is_absolute(filename))
 693         {
 694                 gchar *path;
 695
 696                 if (g_file_test(filename, G_FILE_TEST_IS_DIR))
 697                         path = g_strdup(filename);
 698                 else
 699                         path = g_path_get_dirname(filename);
 700
 701                 vte_get_working_directory(); /* refresh vte_info.dir */
 702                 if (! utils_str_equal(path, vte_info.dir))
 703                 {
 704                         /* use g_shell_quote to avoid problems with spaces, '!' or something else in path */
 705                         gchar *quoted_path = g_shell_quote(path);
 706                         gchar *cmd = g_strconcat(vc->send_cmd_prefix, "cd ", quoted_path, "\n", NULL);
 707                         if (! vte_send_cmd(cmd))
 708                         {
 709                                 ui_set_statusbar(FALSE,
 710                 _("Could not change the directory in the VTE because it probably contains a command."));
 711                                 geany_debug(
 712                 "Could not change the directory in the VTE because it probably contains a command.");
 713                         }
 714                         g_free(quoted_path);
 715                         g_free(cmd);
 716                 }
 717                 g_free(path);
 718         }
 719 }
 720
 721
 722 static void vte_drag_data_received(GtkWidget *widget, GdkDragContext *drag_context,
 723                                                                    gint x, gint y, GtkSelectionData *data, guint info, guint ltime)
 724 {
 725         if (info == TARGET_TEXT_PLAIN)
 726         {
 727                 if (gtk_selection_data_get_format(data) == 8 && gtk_selection_data_get_length(data) > 0)
 728                         vf->vte_terminal_feed_child(VTE_TERMINAL(widget),
 729                                 (const gchar*) gtk_selection_data_get_data(data),
 730                                 gtk_selection_data_get_length(data));
 731         }
 732         else
 733         {
 734                 gchar *text = (gchar*) gtk_selection_data_get_text(data);
 735                 if (!EMPTY(text))
 736                         vf->vte_terminal_feed_child(VTE_TERMINAL(widget), text, strlen(text));
 737                 g_free(text);
 738         }
 739         gtk_drag_finish(drag_context, TRUE, FALSE, ltime);
 740 }
 741
 742
 743 static void on_check_run_in_vte_toggled(GtkToggleButton *togglebutton, GtkWidget *user_data)
 744 {
 745         g_return_if_fail(GTK_IS_WIDGET(user_data));
 746         gtk_widget_set_sensitive(user_data, gtk_toggle_button_get_active(togglebutton));
 747 }
 748
 749
 750 static void on_term_font_set(GtkFontButton *widget, gpointer user_data)
 751 {
 752         const gchar *fontbtn = gtk_font_button_get_font_name(widget);
 753
 754         if (! utils_str_equal(fontbtn, vc->font))
 755         {
 756                 SETPTR(vc->font, g_strdup(gtk_font_button_get_font_name(widget)));
 757                 vte_apply_user_settings();
 758         }
 759 }
 760
 761
 762 static void on_term_fg_color_set(GtkColorButton *widget, gpointer user_data)
 763 {
 764         gtk_color_button_get_color(widget, &vc->colour_fore);
 765 }
 766
 767
 768 static void on_term_bg_color_set(GtkColorButton *widget, gpointer user_data)
 769 {
 770         gtk_color_button_get_color(widget, &vc->colour_back);
 771 }
 772
 773
 774 void vte_append_preferences_tab(void)
 775 {
 776         if (vte_info.have_vte)
 777         {
 778                 GtkWidget *frame_term, *button_shell, *entry_shell;
 779                 GtkWidget *check_run_in_vte, *check_skip_script;
 780                 GtkWidget *font_button, *fg_color_button, *bg_color_button;
 781                 GtkWidget *entry_image, *button_image;
 782
 783                 button_shell = GTK_WIDGET(ui_lookup_widget(ui_widgets.prefs_dialog, "button_term_shell"));
 784                 entry_shell = GTK_WIDGET(ui_lookup_widget(ui_widgets.prefs_dialog, "entry_shell"));
 785                 ui_setup_open_button_callback(button_shell, NULL,
 786                         GTK_FILE_CHOOSER_ACTION_OPEN, GTK_ENTRY(entry_shell));
 787
 788                 button_image = GTK_WIDGET(ui_lookup_widget(ui_widgets.prefs_dialog, "button_term_image"));
 789                 entry_image = GTK_WIDGET(ui_lookup_widget(ui_widgets.prefs_dialog, "entry_image"));
 790                 ui_setup_open_button_callback(button_image, NULL,
 791                         GTK_FILE_CHOOSER_ACTION_OPEN, GTK_ENTRY(entry_image));
 792
 793                 check_skip_script = GTK_WIDGET(ui_lookup_widget(ui_widgets.prefs_dialog, "check_skip_script"));
 794                 gtk_widget_set_sensitive(check_skip_script, vc->run_in_vte);
 795
 796                 check_run_in_vte = GTK_WIDGET(ui_lookup_widget(ui_widgets.prefs_dialog, "check_run_in_vte"));
 797                 g_signal_connect(G_OBJECT(check_run_in_vte), "toggled",
 798                         G_CALLBACK(on_check_run_in_vte_toggled), check_skip_script);
 799
 800                 font_button = ui_lookup_widget(ui_widgets.prefs_dialog, "font_term");
 801                 g_signal_connect(font_button, "font-set",  G_CALLBACK(on_term_font_set), NULL);
 802
 803                 fg_color_button = ui_lookup_widget(ui_widgets.prefs_dialog, "color_fore");
 804                 g_signal_connect(fg_color_button, "color-set", G_CALLBACK(on_term_fg_color_set), NULL);
 805
 806                 bg_color_button = ui_lookup_widget(ui_widgets.prefs_dialog, "color_back");
 807                 g_signal_connect(bg_color_button, "color-set", G_CALLBACK(on_term_bg_color_set), NULL);
 808
 809                 frame_term = ui_lookup_widget(ui_widgets.prefs_dialog, "frame_term");
 810                 gtk_widget_show_all(frame_term);
 811         }
 812 }
 813
 814
 815 void vte_select_all(void)
 816 {
 817         if (vf->vte_terminal_select_all != NULL)
 818                 vf->vte_terminal_select_all(VTE_TERMINAL(vc->vte));
 819 }
 820
 821
 822 void vte_send_selection_to_vte(void)
 823 {
 824         GeanyDocument *doc;
 825         gchar *text;
 826         gsize len;
 827
 828         doc = document_get_current();
 829         g_return_if_fail(doc != NULL);
 830
 831         if (sci_has_selection(doc->editor->sci))
 832         {
 833                 text = sci_get_selection_contents(doc->editor->sci);
 834         }
 835         else
 836         {       /* Get the current line */
 837                 gint line_num = sci_get_current_line(doc->editor->sci);
 838                 text = sci_get_line(doc->editor->sci, line_num);
 839         }
 840
 841         len = strlen(text);
 842
 843         if (vc->send_selection_unsafe)
 844         {       /* Explicitly append a trailing newline character to get the command executed,
 845                    this is disabled by default as it could cause all sorts of damage. */
 846                 if (text[len-1] != '\n' && text[len-1] != '\r')
 847                 {
 848                         SETPTR(text, g_strconcat(text, "\n", NULL));
 849                         len++;
 850                 }
 851         }
 852         else
 853         {       /* Make sure there is no newline character at the end to prevent unwanted execution */
 854                 while (text[len-1] == '\n' || text[len-1] == '\r')
 855                 {
 856                         text[len-1] = '\0';
 857                         len--;
 858                 }
 859         }
 860
 861         vf->vte_terminal_feed_child(VTE_TERMINAL(vc->vte), text, len);
 862
 863         /* show the VTE */
 864         gtk_notebook_set_current_page(GTK_NOTEBOOK(msgwindow.notebook), MSG_VTE);
 865         gtk_widget_grab_focus(vc->vte);
 866         msgwin_show_hide(TRUE);
 867
 868         g_free(text);
 869 }
 870
 871
 872 #endif