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 #include "geany.h"
  27
  28 #ifdef HAVE_VTE
  29
  30 /* include stdlib.h AND unistd.h, because on GNU/Linux pid_t seems to be
  31  * in stdlib.h, on FreeBSD in unistd.h, sys/types.h is needed for C89 */
  32 #include <stdlib.h>
  33 #include <sys/types.h>
  34 #include <unistd.h>
  35
  36 #include <gdk/gdkkeysyms.h>
  37 #include <signal.h>
  38 #include <string.h>
  39 #include <errno.h>
  40
  41 #include "vte.h"
  42 #include "support.h"
  43 #include "prefs.h"
  44 #include "ui_utils.h"
  45 #include "utils.h"
  46 #include "document.h"
  47 #include "msgwindow.h"
  48 #include "callbacks.h"
  49 #include "geanywraplabel.h"
  50 #include "editor.h"
  51 #include "sciwrappers.h"
  52 #include "gtkcompat.h"
  53
  54
  55 VteInfo vte_info;
  56 VteConfig *vc;
  57
  58 static pid_t pid = 0;
  59 static gboolean clean = TRUE;
  60 static GModule *module = NULL;
  61 static struct VteFunctions *vf;
  62 static gchar *gtk_menu_key_accel = NULL;
  63
  64 /* use vte wordchars to select paths */
  65 static const gchar VTE_WORDCHARS[] = "-A-Za-z0-9,./?%&#:_";
  66
  67
  68 /* Incomplete VteTerminal struct from vte/vte.h. */
  69 typedef struct _VteTerminal VteTerminal;
  70 struct _VteTerminal
  71 {
  72         GtkWidget widget;
  73         GtkAdjustment *adjustment;
  74 };
  75
  76 #define VTE_TERMINAL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), VTE_TYPE_TERMINAL, VteTerminal))
  77 #define VTE_TYPE_TERMINAL (vf->vte_terminal_get_type())
  78
  79 typedef enum {
  80         VTE_CURSOR_BLINK_SYSTEM,
  81         VTE_CURSOR_BLINK_ON,
  82         VTE_CURSOR_BLINK_OFF
  83 } VteTerminalCursorBlinkMode;
  84
  85
  86 /* Holds function pointers we need to access the VTE API. */
  87 struct VteFunctions
  88 {
  89         GtkWidget* (*vte_terminal_new) (void);
  90         pid_t (*vte_terminal_fork_command) (VteTerminal *terminal, const char *command, char **argv,
  91                                                                                 char **envv, const char *directory, gboolean lastlog,
  92                                                                                 gboolean utmp, gboolean wtmp);
  93         void (*vte_terminal_set_size) (VteTerminal *terminal, glong columns, glong rows);
  94         void (*vte_terminal_set_word_chars) (VteTerminal *terminal, const char *spec);
  95         void (*vte_terminal_set_mouse_autohide) (VteTerminal *terminal, gboolean setting);
  96         void (*vte_terminal_reset) (VteTerminal *terminal, gboolean full, gboolean clear_history);
  97         GType (*vte_terminal_get_type) (void);
  98         void (*vte_terminal_set_scroll_on_output) (VteTerminal *terminal, gboolean scroll);
  99         void (*vte_terminal_set_scroll_on_keystroke) (VteTerminal *terminal, gboolean scroll);
 100         void (*vte_terminal_set_font_from_string) (VteTerminal *terminal, const char *name);
 101         void (*vte_terminal_set_scrollback_lines) (VteTerminal *terminal, glong lines);
 102         gboolean (*vte_terminal_get_has_selection) (VteTerminal *terminal);
 103         void (*vte_terminal_copy_clipboard) (VteTerminal *terminal);
 104         void (*vte_terminal_paste_clipboard) (VteTerminal *terminal);
 105         void (*vte_terminal_set_emulation) (VteTerminal *terminal, const gchar *emulation);
 106         void (*vte_terminal_set_color_foreground) (VteTerminal *terminal, const GdkColor *foreground);
 107         void (*vte_terminal_set_color_bold) (VteTerminal *terminal, const GdkColor *foreground);
 108         void (*vte_terminal_set_color_background) (VteTerminal *terminal, const GdkColor *background);
 109         void (*vte_terminal_feed_child) (VteTerminal *terminal, const char *data, glong length);
 110         void (*vte_terminal_im_append_menuitems) (VteTerminal *terminal, GtkMenuShell *menushell);
 111         void (*vte_terminal_set_cursor_blink_mode) (VteTerminal *terminal,
 112                                                                                                 VteTerminalCursorBlinkMode mode);
 113         void (*vte_terminal_set_cursor_blinks) (VteTerminal *terminal, gboolean blink);
 114         void (*vte_terminal_select_all) (VteTerminal *terminal);
 115         void (*vte_terminal_set_audible_bell) (VteTerminal *terminal, gboolean is_audible);
 116         void (*vte_terminal_set_background_image_file) (VteTerminal *terminal, const char *path);
 117 };
 118
 119
 120 static void create_vte(void);
 121 static void vte_start(GtkWidget *widget);
 122 static void vte_restart(GtkWidget *widget);
 123 static gboolean vte_button_pressed(GtkWidget *widget, GdkEventButton *event, gpointer user_data);
 124 static gboolean vte_keyrelease_cb(GtkWidget *widget, GdkEventKey *event, gpointer data);
 125 static gboolean vte_keypress_cb(GtkWidget *widget, GdkEventKey *event, gpointer data);
 126 static gboolean vte_register_symbols(GModule *module);
 127 static void vte_popup_menu_clicked(GtkMenuItem *menuitem, gpointer user_data);
 128 static GtkWidget *vte_create_popup_menu(void);
 129 static void vte_commit_cb(VteTerminal *vte, gchar *arg1, guint arg2, gpointer user_data);
 130 static void vte_drag_data_received(GtkWidget *widget, GdkDragContext *drag_context,
 131                                                                    gint x, gint y, GtkSelectionData *data, guint info, guint ltime);
 132
 133
 134 enum
 135 {
 136         POPUP_COPY,
 137         POPUP_PASTE,
 138         POPUP_SELECTALL,
 139         POPUP_CHANGEPATH,
 140         POPUP_RESTARTTERMINAL,
 141         POPUP_PREFERENCES,
 142         TARGET_UTF8_STRING = 0,
 143         TARGET_TEXT,
 144         TARGET_COMPOUND_TEXT,
 145         TARGET_STRING,
 146         TARGET_TEXT_PLAIN
 147 };
 148
 149 static const GtkTargetEntry dnd_targets[] =
 150 {
 151   { "UTF8_STRING", 0, TARGET_UTF8_STRING },
 152   { "TEXT", 0, TARGET_TEXT },
 153   { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
 154   { "STRING", 0, TARGET_STRING },
 155   { "text/plain", 0, TARGET_TEXT_PLAIN },
 156 };
 157
 158
 159 static gchar **vte_get_child_environment(void)
 160 {
 161         const gchar *exclude_vars[] = {"COLUMNS", "LINES", "TERM", NULL};
 162
 163         return utils_copy_environment(exclude_vars, "TERM", "xterm", NULL);
 164 }
 165
 166
 167 static void override_menu_key(void)
 168 {
 169         if (gtk_menu_key_accel == NULL) /* for restoring the default value */
 170                 g_object_get(G_OBJECT(gtk_settings_get_default()),
 171                         "gtk-menu-bar-accel", &gtk_menu_key_accel, NULL);
 172
 173         if (vc->ignore_menu_bar_accel)
 174                 gtk_settings_set_string_property(gtk_settings_get_default(),
 175                         "gtk-menu-bar-accel", "<Shift><Control><Mod1><Mod2><Mod3><Mod4><Mod5>F10", "Geany");
 176         else
 177                 gtk_settings_set_string_property(gtk_settings_get_default(),
 178                         "gtk-menu-bar-accel", gtk_menu_key_accel, "Geany");
 179 }
 180
 181
 182 void vte_init(void)
 183 {
 184         if (vte_info.have_vte == FALSE)
 185         {       /* vte_info.have_vte can be false even if VTE is compiled in, think of command line option */
 186                 geany_debug("Disabling terminal support");
 187                 return;
 188         }
 189
 190         if (!EMPTY(vte_info.lib_vte))
 191         {
 192                 module = g_module_open(vte_info.lib_vte, G_MODULE_BIND_LAZY);
 193         }
 194 #ifdef VTE_MODULE_PATH
 195         else
 196         {
 197                 module = g_module_open(VTE_MODULE_PATH, G_MODULE_BIND_LAZY);
 198         }
 199 #endif
 200
 201         if (module == NULL)
 202         {
 203                 gint i;
 204                 const gchar *sonames[] = {
 205 #if GTK_CHECK_VERSION(3, 0, 0)
 206                         "libvte2_90.so", "libvte2_90.so.9",
 207 #else
 208                         "libvte.so", "libvte.so.4", "libvte.so.8", "libvte.so.9",
 209 #endif
 210                         NULL
 211                 };
 212
 213                 for (i = 0; sonames[i] != NULL && module == NULL; i++)
 214                 {
 215                         module = g_module_open(sonames[i], G_MODULE_BIND_LAZY);
 216                 }
 217         }
 218
 219         if (module == NULL)
 220         {
 221                 vte_info.have_vte = FALSE;
 222                 geany_debug("Could not load libvte.so, embedded terminal support disabled");
 223                 return;
 224         }
 225         else
 226         {
 227                 vf = g_new0(struct VteFunctions, 1);
 228                 if (vte_register_symbols(module))
 229                         vte_info.have_vte = TRUE;
 230                 else
 231                 {
 232                         vte_info.have_vte = FALSE;
 233                         g_free(vf);
 234                         /* FIXME: is closing the module safe? see vte_close() and test on FreeBSD */
 235                         /*g_module_close(module);*/
 236                         module = NULL;
 237                         return;
 238                 }
 239         }
 240
 241         create_vte();
 242
 243         /* setup the F10 menu override (so it works before the widget is first realised). */
 244         override_menu_key();
 245 }
 246
 247
 248 static void on_vte_realize(void)
 249 {
 250         /* the vte widget has to be realised before color changes take effect */
 251         vte_apply_user_settings();
 252
 253         vf->vte_terminal_im_append_menuitems(VTE_TERMINAL(vc->vte), GTK_MENU_SHELL(vc->im_submenu));
 254 }
 255
 256
 257 static void create_vte(void)
 258 {
 259         GtkWidget *vte, *scrollbar, *hbox, *frame;
 260
 261         vc->vte = vte = vf->vte_terminal_new();
 262         scrollbar = gtk_vscrollbar_new(GTK_ADJUSTMENT(VTE_TERMINAL(vte)->adjustment));
 263         gtk_widget_set_can_focus(scrollbar, FALSE);
 264
 265         /* create menu now so copy/paste shortcuts work */
 266         vc->menu = vte_create_popup_menu();
 267         g_object_ref_sink(vc->menu);
 268
 269         frame = gtk_frame_new(NULL);
 270
 271         hbox = gtk_hbox_new(FALSE, 0);
 272         gtk_container_add(GTK_CONTAINER(frame), hbox);
 273         gtk_box_pack_start(GTK_BOX(hbox), vte, TRUE, TRUE, 0);
 274         gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, FALSE, 0);
 275
 276         /* set the default widget size first to prevent VTE expanding too much,
 277          * sometimes causing the hscrollbar to be too big or out of view. */
 278         gtk_widget_set_size_request(GTK_WIDGET(vte), 10, 10);
 279         vf->vte_terminal_set_size(VTE_TERMINAL(vte), 30, 1);
 280
 281         vf->vte_terminal_set_mouse_autohide(VTE_TERMINAL(vte), TRUE);
 282         vf->vte_terminal_set_word_chars(VTE_TERMINAL(vte), VTE_WORDCHARS);
 283
 284         gtk_drag_dest_set(vte, GTK_DEST_DEFAULT_ALL,
 285                 dnd_targets, G_N_ELEMENTS(dnd_targets), GDK_ACTION_COPY);
 286
 287         g_signal_connect(vte, "child-exited", G_CALLBACK(vte_start), NULL);
 288         g_signal_connect(vte, "button-press-event", G_CALLBACK(vte_button_pressed), NULL);
 289         g_signal_connect(vte, "event", G_CALLBACK(vte_keypress_cb), NULL);
 290         g_signal_connect(vte, "key-release-event", G_CALLBACK(vte_keyrelease_cb), NULL);
 291         g_signal_connect(vte, "commit", G_CALLBACK(vte_commit_cb), NULL);
 292         g_signal_connect(vte, "motion-notify-event", G_CALLBACK(on_motion_event), NULL);
 293         g_signal_connect(vte, "drag-data-received", G_CALLBACK(vte_drag_data_received), NULL);
 294
 295         vte_start(vte);
 296
 297         gtk_widget_show_all(frame);
 298         gtk_notebook_insert_page(GTK_NOTEBOOK(msgwindow.notebook), frame, gtk_label_new(_("Terminal")), MSG_VTE);
 299
 300         g_signal_connect_after(vte, "realize", G_CALLBACK(on_vte_realize), NULL);
 301 }
 302
 303
 304 void vte_close(void)
 305 {
 306         g_free(vf);
 307         /* free the vte widget before unloading vte module
 308          * this prevents a segfault on X close window if the message window is hidden */
 309         gtk_widget_destroy(vc->vte);
 310         gtk_widget_destroy(vc->menu);
 311         g_object_unref(vc->menu);
 312         g_free(vc->emulation);
 313         g_free(vc->shell);
 314         g_free(vc->image);
 315         g_free(vc->font);
 316         g_free(vc->colour_back);
 317         g_free(vc->colour_fore);
 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 G_MODULE_EXPORT 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 G_MODULE_EXPORT 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 G_MODULE_EXPORT void on_term_fg_color_set(GtkColorButton *widget, gpointer user_data)
 763 {
 764         g_free(vc->colour_fore);
 765         vc->colour_fore = g_new0(GdkColor, 1);
 766         gtk_color_button_get_color(widget, vc->colour_fore);
 767 }
 768
 769
 770 G_MODULE_EXPORT void on_term_bg_color_set(GtkColorButton *widget, gpointer user_data)
 771 {
 772         g_free(vc->colour_back);
 773         vc->colour_back = g_new0(GdkColor, 1);
 774         gtk_color_button_get_color(widget, vc->colour_back);
 775 }
 776
 777
 778 void vte_append_preferences_tab(void)
 779 {
 780         if (vte_info.have_vte)
 781         {
 782                 GtkWidget *frame_term, *button_shell, *entry_shell;
 783                 GtkWidget *check_run_in_vte, *check_skip_script;
 784                 GtkWidget *font_button, *fg_color_button, *bg_color_button;
 785                 GtkWidget *entry_image, *button_image;
 786
 787                 button_shell = GTK_WIDGET(ui_lookup_widget(ui_widgets.prefs_dialog, "button_term_shell"));
 788                 entry_shell = GTK_WIDGET(ui_lookup_widget(ui_widgets.prefs_dialog, "entry_shell"));
 789                 ui_setup_open_button_callback(button_shell, NULL,
 790                         GTK_FILE_CHOOSER_ACTION_OPEN, GTK_ENTRY(entry_shell));
 791
 792                 button_image = GTK_WIDGET(ui_lookup_widget(ui_widgets.prefs_dialog, "button_term_image"));
 793                 entry_image = GTK_WIDGET(ui_lookup_widget(ui_widgets.prefs_dialog, "entry_image"));
 794                 ui_setup_open_button_callback(button_image, NULL,
 795                         GTK_FILE_CHOOSER_ACTION_OPEN, GTK_ENTRY(entry_image));
 796
 797                 check_skip_script = GTK_WIDGET(ui_lookup_widget(ui_widgets.prefs_dialog, "check_skip_script"));
 798                 gtk_widget_set_sensitive(check_skip_script, vc->run_in_vte);
 799
 800                 check_run_in_vte = GTK_WIDGET(ui_lookup_widget(ui_widgets.prefs_dialog, "check_run_in_vte"));
 801                 g_signal_connect(G_OBJECT(check_run_in_vte), "toggled",
 802                         G_CALLBACK(on_check_run_in_vte_toggled), check_skip_script);
 803
 804                 font_button = ui_lookup_widget(ui_widgets.prefs_dialog, "font_term");
 805                 g_signal_connect(font_button, "font-set",  G_CALLBACK(on_term_font_set), NULL);
 806
 807                 fg_color_button = ui_lookup_widget(ui_widgets.prefs_dialog, "color_fore");
 808                 g_signal_connect(fg_color_button, "color-set", G_CALLBACK(on_term_fg_color_set), NULL);
 809
 810                 bg_color_button = ui_lookup_widget(ui_widgets.prefs_dialog, "color_back");
 811                 g_signal_connect(bg_color_button, "color-set", G_CALLBACK(on_term_bg_color_set), NULL);
 812
 813                 frame_term = ui_lookup_widget(ui_widgets.prefs_dialog, "frame_term");
 814                 gtk_widget_show_all(frame_term);
 815         }
 816 }
 817
 818
 819 void vte_select_all(void)
 820 {
 821         if (vf->vte_terminal_select_all != NULL)
 822                 vf->vte_terminal_select_all(VTE_TERMINAL(vc->vte));
 823 }
 824
 825
 826 void vte_send_selection_to_vte(void)
 827 {
 828         GeanyDocument *doc;
 829         gchar *text;
 830         gsize len;
 831
 832         doc = document_get_current();
 833         g_return_if_fail(doc != NULL);
 834
 835         if (sci_has_selection(doc->editor->sci))
 836         {
 837                 text = sci_get_selection_contents(doc->editor->sci);
 838         }
 839         else
 840         {       /* Get the current line */
 841                 gint line_num = sci_get_current_line(doc->editor->sci);
 842                 text = sci_get_line(doc->editor->sci, line_num);
 843         }
 844
 845         len = strlen(text);
 846
 847         if (vc->send_selection_unsafe)
 848         {       /* Explicitly append a trailing newline character to get the command executed,
 849                    this is disabled by default as it could cause all sorts of damage. */
 850                 if (text[len-1] != '\n' && text[len-1] != '\r')
 851                 {
 852                         SETPTR(text, g_strconcat(text, "\n", NULL));
 853                         len++;
 854                 }
 855         }
 856         else
 857         {       /* Make sure there is no newline character at the end to prevent unwanted execution */
 858                 while (text[len-1] == '\n' || text[len-1] == '\r')
 859                 {
 860                         text[len-1] = '\0';
 861                         len--;
 862                 }
 863         }
 864
 865         vf->vte_terminal_feed_child(VTE_TERMINAL(vc->vte), text, len);
 866
 867         /* show the VTE */
 868         gtk_notebook_set_current_page(GTK_NOTEBOOK(msgwindow.notebook), MSG_VTE);
 869         gtk_widget_grab_focus(vc->vte);
 870         msgwin_show_hide(TRUE);
 871
 872         g_free(text);
 873 }
 874
 875
 876 #endif