void mssh_terminal_start_session(MSSHTerminal *terminal, char **env) { GError *error = NULL; char *args[5]; char *fullhost; char *host = NULL; char *port = NULL; fullhost = strdup(terminal->hostname); host = strtok(fullhost, ":"); port = strtok(NULL, ""); if (!port) port = "22"; args[0] = strdup("ssh"); args[1] = host; args[2] = "-p"; args[3] = port; args[4] = NULL; vte_terminal_fork_command_full(VTE_TERMINAL(terminal), VTE_PTY_NO_LASTLOG|VTE_PTY_NO_UTMP|VTE_PTY_NO_WTMP, NULL, /* working dir */ args, env, G_SPAWN_SEARCH_PATH, NULL, /* child_setup */ NULL, /* child_setup_data */ NULL, /* *child_pid */ &error); free(args[0]); }
static void term_fork_command(VteTerminal *term, char *cmd) { #if VTE_CHECK_VERSION(0,25,0) char **argv = NULL; g_shell_parse_argv(cmd, NULL, &argv, NULL); vte_terminal_fork_command_full(term, VTE_PTY_DEFAULT, "", argv, NULL, G_SPAWN_CHILD_INHERITS_STDIN|G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, NULL); #else vte_terminal_fork_command(term, cmd, NULL, NULL, "", TRUE, TRUE, TRUE); #endif }
static VALUE rg_fork_command(int argc, VALUE *argv, VALUE self) { VALUE options, rb_pty_flags, rb_working_directory, rb_command_argv, rb_envv, rb_spawn_flags; int pty_flags, spawn_flags; char *working_directory; char **command_argv; char **envv; GPid child_pid; gboolean result; GError *error = NULL; rb_scan_args(argc, argv, "01", &options); rbg_scan_options(options, "pty_flags", &rb_pty_flags, "working_directory", &rb_working_directory, "argv", &rb_command_argv, "envv", &rb_envv, "spawn_flags", &rb_spawn_flags, NULL); pty_flags = NIL_P(rb_pty_flags) ? VTE_PTY_DEFAULT : RVAL2VTEPTYFLAGS(rb_pty_flags); working_directory = RVAL2CSTR_ACCEPT_NIL(rb_working_directory); command_argv = rval2cstrary(NIL_P(rb_command_argv) ? fork_command_default_argv() : rb_command_argv); envv = rval2cstrary(rb_envv); spawn_flags = NIL_P(rb_spawn_flags) ? G_SPAWN_CHILD_INHERITS_STDIN | G_SPAWN_SEARCH_PATH : NUM2INT(rb_spawn_flags); result = vte_terminal_fork_command_full(_SELF(self), pty_flags, working_directory, command_argv, envv, spawn_flags, NULL, NULL, &child_pid, &error); free_cstrary(command_argv); free_cstrary(envv); if (error) RAISE_GERROR(error); return INT2NUM(child_pid); }
GtkWidget* create_horst_window(void) { GtkWidget *horst_window, *horst_term; char *envs[2]; char *params[] = {horstpath}; envs[0] = strdup(environments); envs[1] = NULL; VtePtyFlags pty_flags = 0; GSpawnFlags spawn_flags = 0; char horst_title[24]; params[0] = strdup(horstpath); params[1] = strdup("-c"); params[2] = strdup("192.168.1.125"); params[3] = NULL; /* params[0] = strdup(horstpath); params[1] = strdup("-i"); params[2] = strdup(wificards[chan_detail]); params[3] = NULL; */ horst_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); sprintf(horst_title, "channel %d signal details", horst_chans[chan_detail]); gtk_window_set_title (GTK_WINDOW(horst_window), strdup(horst_title)); gtk_container_set_border_width(GTK_CONTAINER(horst_window), 0); horst_term = vte_terminal_new(); gtk_container_add(GTK_CONTAINER(horst_window), horst_term); vte_terminal_set_size(VTE_TERMINAL(horst_term), 100, 50); gtk_widget_show(horst_term); gtk_widget_set_visible (GTK_WIDGET(horst_term), TRUE); vte_terminal_fork_command_full (VTE_TERMINAL(horst_term), pty_flags, kislogdir , params, envs, spawn_flags, NULL, NULL, NULL, NULL); vte_terminal_set_scrollback_lines(VTE_TERMINAL(horst_term), 1024); gtk_widget_grab_focus(horst_term); g_signal_connect(G_OBJECT(horst_window), "destroy", G_CALLBACK(horst_delete), horst_window); return horst_window; }
static void activate (GtkApplication* app, gpointer user_data) { GtkWidget *window; GtkWidget *bases, *keyLength, *errorBits, *errorTolerance, *playButton, *mode, *peerIp, *eveRate, *eveStrategy, *channelNoise, *genBias; GtkWidget *windowBox, *optionGrid, *playGrid, *playBox; GtkWidget *baseLabel, *keyLengthLabel, *errorBitsLabel, *errorToleranceLabel, *peerIpLabel, *eveRateLabel, *eveStrategyLabel, *channelNoiseLabel, *genBiasLabel; GtkWidget *tty1; GtkWidget *tty2; window = gtk_application_window_new (app); gtk_window_set_title (GTK_WINDOW (window), "Quantum Network Simulator"); gtk_window_set_default_size (GTK_WINDOW (window), 1280, 720); windowBox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL); gtk_container_add(GTK_CONTAINER(window), windowBox); playBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); gtk_container_add(GTK_CONTAINER(windowBox), playBox); optionGrid = gtk_grid_new (); gtk_container_add(GTK_CONTAINER(playBox), optionGrid); playGrid = gtk_grid_new (); gtk_grid_set_column_spacing(GTK_GRID(playGrid), 20); gtk_container_add(GTK_CONTAINER(playBox), playGrid); mode = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Superposition Tutorial"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Measurement Tutorial"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Classic BB84 Tutorial"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Polybase BB84 Tutorial"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Bias BB84 Tutorial"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(mode), "Freestyle BB84"); gtk_grid_attach(GTK_GRID( optionGrid ), mode, 0, 0, 2, 1); baseLabel = gtk_label_new("Number of bases"); bases = gtk_entry_new (); gtk_grid_attach(GTK_GRID( optionGrid ), baseLabel , 0, 1, 1, 1); gtk_grid_attach(GTK_GRID( optionGrid ), bases , 1, 1, 1, 1); keyLengthLabel = gtk_label_new("Key Length"); keyLength = gtk_entry_new (); gtk_grid_attach(GTK_GRID( optionGrid ), keyLengthLabel , 0, 2, 1, 1); gtk_grid_attach(GTK_GRID( optionGrid ), keyLength, 1, 2, 1, 1); errorBitsLabel = gtk_label_new("Number of error detection bits"); errorBits = gtk_entry_new (); gtk_grid_attach(GTK_GRID( optionGrid ), errorBitsLabel , 0, 3, 1, 1); gtk_grid_attach(GTK_GRID( optionGrid ), errorBits , 1, 3, 1, 1); errorToleranceLabel = gtk_label_new("Number of error bits to tolerate"); errorTolerance = gtk_entry_new (); gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 0, 4, 1, 1); gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 1, 4, 1, 1); errorToleranceLabel = gtk_label_new("Peer IP"); errorTolerance = gtk_entry_new (); gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 0, 1, 1); gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 0, 1, 1); errorToleranceLabel = gtk_label_new("Eve Eavesdrop Rate"); errorTolerance = gtk_entry_new (); gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 1, 1, 1); gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 1, 1, 1); errorToleranceLabel = gtk_label_new("Eve Eavesdrop Strategy"); errorTolerance = gtk_entry_new (); gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 2, 1, 1); gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 2, 1, 1); errorToleranceLabel = gtk_label_new("Generator Bias"); errorTolerance = gtk_entry_new (); gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 3, 1, 1); gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 3, 1, 1); errorToleranceLabel = gtk_label_new("Channel Noise"); errorTolerance = gtk_entry_new (); gtk_grid_attach(GTK_GRID( optionGrid ), errorToleranceLabel , 2, 4, 1, 1); gtk_grid_attach(GTK_GRID( optionGrid ), errorTolerance , 3, 4, 1, 1); playButton = gtk_button_new_with_label("PLAY QUANTUM ALGORITHM"); g_signal_connect (playButton, "clicked", G_CALLBACK(playAlgorithm), playButton); // g_signal_connect_swapped (playButton, "clicked", G_CALLBACK(gtk_widget_destroy), window); gtk_grid_attach(GTK_GRID( optionGrid ), playButton, 0, 5, 4, 1); char *startTerm[2] = {0,0}; startTerm[0] = vte_get_user_shell(); GPid pidTerm; tty1 = vte_terminal_new(); vte_terminal_fork_command_full(VTE_TERMINAL(tty1), VTE_PTY_DEFAULT, NULL, //"/tmp", startTerm, NULL, (GSpawnFlags)(G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH), NULL, NULL, NULL, NULL ); gtk_widget_set_size_request(tty1, 600, 400); gtk_grid_attach(GTK_GRID (playGrid ), tty1, 0, 6, 4, 15); gtk_widget_set_sensitive(tty1, FALSE); tty2 = vte_terminal_new(); vte_terminal_fork_command_full(VTE_TERMINAL(tty2), VTE_PTY_DEFAULT, NULL, //"/tmp", startTerm, NULL, (GSpawnFlags)(G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH), NULL, NULL, NULL, NULL ); gtk_widget_set_size_request(tty2, 600, 400); gtk_grid_attach(GTK_GRID (playGrid ), tty2, 4, 6, 4, 15); gtk_widget_set_sensitive(tty2, FALSE); g_object_set_data(G_OBJECT(playButton), "tty1", VTE_TERMINAL(tty1)); g_object_set_data(G_OBJECT(playButton), "tty2", VTE_TERMINAL(tty2)); g_object_set_data(G_OBJECT(playButton), "in_mode", GTK_COMBO_BOX_TEXT(mode)); g_object_set_data(G_OBJECT(playButton), "in_bases", GTK_ENTRY(bases)); g_object_set_data(G_OBJECT(playButton), "in_keyLength", GTK_ENTRY(keyLength)); g_object_set_data(G_OBJECT(playButton), "in_errorBits", GTK_ENTRY(errorBits)); g_object_set_data(G_OBJECT(playButton), "in_errorTolerance", GTK_ENTRY(errorTolerance)); gtk_widget_show_all (window); }
void termit_append_tab_with_details(const struct TabInfo* ti) { struct TermitTab* pTab = g_malloc0(sizeof(struct TermitTab)); termit_style_copy(&pTab->style, &configs.style); if (ti->name) { pTab->tab_name = gtk_label_new(ti->name); pTab->custom_tab_name = TRUE; } else { gchar* label_text = g_strdup_printf("%s %d", configs.default_tab_name, termit.tab_max_number++); pTab->tab_name = gtk_label_new(label_text); g_free(label_text); pTab->custom_tab_name = FALSE; } pTab->encoding = (ti->encoding) ? g_strdup(ti->encoding) : g_strdup(configs.default_encoding); pTab->bksp_binding = ti->bksp_binding; pTab->delete_binding = ti->delete_binding; pTab->hbox = gtk_hbox_new(FALSE, 0); pTab->vte = vte_terminal_new(); vte_terminal_set_scrollback_lines(VTE_TERMINAL(pTab->vte), configs.scrollback_lines); if (configs.default_word_chars) vte_terminal_set_word_chars(VTE_TERMINAL(pTab->vte), configs.default_word_chars); vte_terminal_set_mouse_autohide(VTE_TERMINAL(pTab->vte), TRUE); vte_terminal_set_backspace_binding(VTE_TERMINAL(pTab->vte), pTab->bksp_binding); vte_terminal_set_delete_binding(VTE_TERMINAL(pTab->vte), pTab->delete_binding); #ifdef TERMIT_ENABLE_SEARCH vte_terminal_search_set_wrap_around(VTE_TERMINAL(pTab->vte), TRUE); #endif // TERMIT_ENABLE_SEARCH /* parse command */ gchar **cmd_argv; GError *cmd_err = NULL; gchar *cmd_path = NULL; gchar *cmd_file = NULL; pTab->command = (ti->command) ? g_strdup(ti->command) : g_strdup(configs.default_command); if (!g_shell_parse_argv(pTab->command, NULL, &cmd_argv, &cmd_err)) { ERROR("%s", _("Cannot parse command. Creating tab with shell")); g_error_free(cmd_err); } else { cmd_path = g_find_program_in_path(cmd_argv[0]); cmd_file = g_path_get_basename(cmd_argv[0]); } TRACE("command=%s cmd_path=%s cmd_file=%s", pTab->command, cmd_path, cmd_file); if (cmd_path && cmd_file) { g_free(cmd_argv[0]); cmd_argv[0] = g_strdup(cmd_path); #if VTE_CHECK_VERSION(0, 26, 0) > 0 if (vte_terminal_fork_command_full(VTE_TERMINAL(pTab->vte), VTE_PTY_DEFAULT, ti->working_dir, cmd_argv, NULL, 0, NULL, NULL, &pTab->pid, &cmd_err) != TRUE) { ERROR("failed to open tab: %s", cmd_err->message); g_error_free(cmd_err); } #else pTab->pid = vte_terminal_fork_command(VTE_TERMINAL(pTab->vte), cmd_path, cmd_argv, NULL, ti->working_dir, TRUE, TRUE, TRUE); #endif // version >= 0.26 } else { g_free(pTab->command); pTab->command = g_strdup(configs.default_command); gchar* argv[] = {pTab->command, NULL}; TRACE("defaults: cmd=%s working_dir=%s", pTab->command, ti->working_dir); /* default tab */ #if VTE_CHECK_VERSION(0, 26, 0) > 0 if (vte_terminal_fork_command_full(VTE_TERMINAL(pTab->vte), VTE_PTY_DEFAULT, ti->working_dir, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, &pTab->pid, &cmd_err) != TRUE) { ERROR("failed to open tab: %s", cmd_err->message); g_error_free(cmd_err); } #else pTab->pid = vte_terminal_fork_command(VTE_TERMINAL(pTab->vte), pTab->command, NULL, NULL, ti->working_dir, TRUE, TRUE, TRUE); #endif // version >= 0.26 } g_strfreev(cmd_argv); g_free(cmd_path); g_free(cmd_file); g_signal_connect(G_OBJECT(pTab->vte), "beep", G_CALLBACK(termit_on_beep), pTab); g_signal_connect(G_OBJECT(pTab->vte), "focus-in-event", G_CALLBACK(termit_on_focus), pTab); g_signal_connect(G_OBJECT(pTab->vte), "window-title-changed", G_CALLBACK(termit_on_tab_title_changed), NULL); g_signal_connect(G_OBJECT(pTab->vte), "child-exited", G_CALLBACK(termit_on_child_exited), NULL); // g_signal_connect(G_OBJECT(pTab->vte), "eof", G_CALLBACK(termit_eof), NULL); g_signal_connect_swapped(G_OBJECT(pTab->vte), "button-press-event", G_CALLBACK(termit_on_popup), NULL); vte_terminal_set_encoding(VTE_TERMINAL(pTab->vte), pTab->encoding); pTab->matches = g_array_new(FALSE, TRUE, sizeof(struct Match)); termit_tab_add_matches(pTab, configs.matches); termit_tab_set_transparency(pTab, pTab->style.transparency); vte_terminal_set_font(VTE_TERMINAL(pTab->vte), pTab->style.font); gint index = gtk_notebook_append_page(GTK_NOTEBOOK(termit.notebook), pTab->hbox, pTab->tab_name); if (index == -1) { ERROR("%s", _("Cannot create a new tab")); return; } if (configs.fill_tabbar) { GValue val = {}; g_value_init(&val, G_TYPE_BOOLEAN); g_value_set_boolean(&val, TRUE); gtk_container_child_set_property(GTK_CONTAINER(termit.notebook), pTab->hbox, "tab-expand", &val); gtk_container_child_set_property(GTK_CONTAINER(termit.notebook), pTab->hbox, "tab-fill", &val); } termit_tab_set_audible_bell(pTab, configs.audible_bell); termit_tab_set_visible_bell(pTab, configs.visible_bell); pTab->scrollbar = gtk_vscrollbar_new(vte_terminal_get_adjustment(VTE_TERMINAL(pTab->vte))); gtk_box_pack_start(GTK_BOX(pTab->hbox), pTab->vte, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(pTab->hbox), pTab->scrollbar, FALSE, FALSE, 0); GtkWidget* tabWidget = gtk_notebook_get_nth_page(GTK_NOTEBOOK(termit.notebook), index); if (!tabWidget) { ERROR("tabWidget is NULL"); return; } g_object_set_data(G_OBJECT(tabWidget), TERMIT_TAB_DATA, pTab); if (index == 0) { // there is no "switch-page" signal on the first page termit_set_statusbar_message(index); } pTab->scrollbar_is_shown = configs.show_scrollbar; gtk_widget_show_all(termit.notebook); if (pTab->style.image_file == NULL) { vte_terminal_set_background_image(VTE_TERMINAL(pTab->vte), NULL); } else { vte_terminal_set_background_image_file(VTE_TERMINAL(pTab->vte), pTab->style.image_file); } termit_tab_apply_colors(pTab); gtk_notebook_set_current_page(GTK_NOTEBOOK(termit.notebook), index); gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(termit.notebook), pTab->hbox, TRUE); gtk_window_set_focus(GTK_WINDOW(termit.main_window), pTab->vte); termit_check_single_tab(); termit_hide_scrollbars(); }
int main(int argc, char **argv) { GdkScreen *screen; GdkColormap *colormap; GtkWidget *window, *widget,*hbox = NULL, *scrollbar, *scrolled_window = NULL; VteTerminal *terminal; char *env_add[] = { #ifdef VTE_DEBUG (char *) "FOO=BAR", (char *) "BOO=BIZ", #endif NULL}; const char *background = NULL; gboolean transparent = FALSE, audible = TRUE, blink = TRUE, debug = FALSE, dingus = FALSE, dbuffer = TRUE, console = FALSE, scroll = FALSE, keep = FALSE, icon_title = FALSE, shell = TRUE, highlight_set = FALSE, cursor_set = FALSE, reverse = FALSE, use_geometry_hints = TRUE, antialias = TRUE, use_scrolled_window = FALSE, show_object_notifications = FALSE; char *geometry = NULL; gint lines = 100; const char *message = "Launching interactive shell...\r\n"; const char *font = NULL; const char *termcap = NULL; const char *command = NULL; const char *working_directory = NULL; const char *output_file = NULL; char *pty_flags_string = NULL; char *cursor_shape_string = NULL; char *scrollbar_policy_string = NULL; GdkColor fore, back, tint, highlight, cursor; const GOptionEntry options[]={ { "antialias", 'A', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &antialias, "Disable the use of anti-aliasing", NULL }, { "background", 'B', 0, G_OPTION_ARG_FILENAME, &background, "Specify a background image", NULL }, { "console", 'C', 0, G_OPTION_ARG_NONE, &console, "Watch /dev/console", NULL }, { "dingus", 'D', 0, G_OPTION_ARG_NONE, &dingus, "Highlight URLs inside the terminal", NULL }, { "shell", 'S', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &shell, "Disable spawning a shell inside the terminal", NULL }, { "transparent", 'T', 0, G_OPTION_ARG_NONE, &transparent, "Enable the use of a transparent background", NULL }, { "double-buffer", '2', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &dbuffer, "Disable double-buffering", NULL }, { "audible", 'a', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &audible, "Use visible, instead of audible, terminal bell", NULL }, { "blink", 'b', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &blink, "Disable the blinking cursor", NULL }, { "command", 'c', 0, G_OPTION_ARG_STRING, &command, "Execute a command in the terminal", NULL }, { "debug", 'd', 0, G_OPTION_ARG_NONE, &debug, "Enable various debugging checks", NULL }, { "font", 'f', 0, G_OPTION_ARG_STRING, &font, "Specify a font to use", NULL }, { "geometry", 'g', 0, G_OPTION_ARG_STRING, &geometry, "Set the size (in characters) and position", "GEOMETRY" }, { "highlight", 'h', 0, G_OPTION_ARG_NONE, &highlight_set, "Enable the cursor highlighting", NULL }, { "icon-title", 'i', 0, G_OPTION_ARG_NONE, &icon_title, "Enable the setting of the icon title", NULL }, { "keep", 'k', 0, G_OPTION_ARG_NONE, &keep, "Live on after the window closes", NULL }, { "scrollback-lines", 'n', 0, G_OPTION_ARG_INT, &lines, "Specify the number of scrollback-lines", NULL }, { "color-cursor", 'r', 0, G_OPTION_ARG_NONE, &cursor_set, "Enable a colored cursor", NULL }, { "cursor-shape", 0, 0, G_OPTION_ARG_STRING, &cursor_shape_string, "Set cursor shape (block|underline|ibeam)", NULL }, { "scroll-background", 's', 0, G_OPTION_ARG_NONE, &scroll, "Enable a scrolling background", NULL }, { "termcap", 't', 0, G_OPTION_ARG_STRING, &termcap, "Specify the terminal emulation to use", NULL }, { "working-directory", 'w', 0, G_OPTION_ARG_FILENAME, &working_directory, "Specify the initial working directory of the terminal", NULL }, { "reverse", 0, 0, G_OPTION_ARG_NONE, &reverse, "Reverse foreground/background colors", NULL }, { "no-geometry-hints", 'G', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &use_geometry_hints, "Allow the terminal to be resized to any dimension, not constrained to fit to an integer multiple of characters", NULL }, { "scrolled-window", 'W', 0, G_OPTION_ARG_NONE, &use_scrolled_window, "Use a GtkScrolledWindow as terminal container", NULL }, { "scrollbar-policy", 'P', 0, G_OPTION_ARG_STRING, &scrollbar_policy_string, "Set the policy for the vertical scroolbar in the scrolled window (always|auto|never; default:always)", NULL }, { "object-notifications", 'N', 0, G_OPTION_ARG_NONE, &show_object_notifications, "Print VteTerminal object notifications", NULL }, { "output-file", 0, 0, G_OPTION_ARG_STRING, &output_file, "Save terminal contents to file at exit", NULL }, { "pty-flags", 0, 0, G_OPTION_ARG_STRING, &pty_flags_string, "PTY flags set from default|no-utmp|no-wtmp|no-lastlog|no-helper|no-fallback", NULL }, { NULL } }; GOptionContext *context; GError *error = NULL; VteTerminalCursorShape cursor_shape = VTE_CURSOR_SHAPE_BLOCK; GtkPolicyType scrollbar_policy = GTK_POLICY_ALWAYS; VtePtyFlags pty_flags = VTE_PTY_DEFAULT; /* Have to do this early. */ if (getenv("VTE_PROFILE_MEMORY")) { if (atol(getenv("VTE_PROFILE_MEMORY")) != 0) { g_mem_set_vtable(glib_mem_profiler_table); } } context = g_option_context_new (" - test VTE terminal emulation"); g_option_context_add_main_entries (context, options, NULL); g_option_context_add_group (context, gtk_get_option_group (TRUE)); g_option_context_parse (context, &argc, &argv, &error); g_option_context_free (context); if (error != NULL) { g_printerr ("Failed to parse command line arguments: %s\n", error->message); g_error_free (error); return 1; } if (cursor_shape_string) { cursor_shape = parse_enum(VTE_TYPE_TERMINAL_CURSOR_SHAPE, cursor_shape_string); g_free(cursor_shape_string); } if (scrollbar_policy_string) { scrollbar_policy = parse_enum(GTK_TYPE_POLICY_TYPE, scrollbar_policy_string); g_free(scrollbar_policy_string); } if (pty_flags_string) { pty_flags |= parse_flags(VTE_TYPE_PTY_FLAGS, pty_flags_string); g_free(pty_flags_string); } if (!reverse) { back.red = back.green = back.blue = 0xffff; fore.red = fore.green = fore.blue = 0x0000; } else { back.red = back.green = back.blue = 0x0000; fore.red = fore.green = fore.blue = 0xffff; } highlight.red = highlight.green = highlight.blue = 0xc000; cursor.red = 0xffff; cursor.green = cursor.blue = 0x8000; tint.red = tint.green = tint.blue = 0; tint = back; gdk_window_set_debug_updates(debug); /* Create a window to hold the scrolling shell, and hook its * delete event to the quit function.. */ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_set_resize_mode(GTK_CONTAINER(window), GTK_RESIZE_IMMEDIATE); /* Set ARGB colormap */ screen = gtk_widget_get_screen (window); colormap = gdk_screen_get_rgba_colormap (screen); if (colormap) gtk_widget_set_colormap(window, colormap); if (use_scrolled_window) { scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_NEVER, scrollbar_policy); gtk_container_add(GTK_CONTAINER(window), scrolled_window); } else { /* Create a box to hold everything. */ hbox = gtk_hbox_new(0, FALSE); gtk_container_add(GTK_CONTAINER(window), hbox); } /* Create the terminal widget and add it to the scrolling shell. */ widget = vte_terminal_new(); terminal = VTE_TERMINAL (widget); if (!dbuffer) { gtk_widget_set_double_buffered(widget, dbuffer); } g_signal_connect(terminal, "child-exited", G_CALLBACK(child_exit_cb), NULL); if (show_object_notifications) g_signal_connect(terminal, "notify", G_CALLBACK(terminal_notify_cb), NULL); if (use_scrolled_window) { gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(terminal)); } else { gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0); } /* Connect to the "char_size_changed" signal to set geometry hints * whenever the font used by the terminal is changed. */ if (use_geometry_hints) { char_size_changed(widget, 0, 0, window); g_signal_connect(widget, "char-size-changed", G_CALLBACK(char_size_changed), window); g_signal_connect(widget, "realize", G_CALLBACK(char_size_realized), window); } /* Connect to the "window_title_changed" signal to set the main * window's title. */ g_signal_connect(widget, "window-title-changed", G_CALLBACK(window_title_changed), window); if (icon_title) { g_signal_connect(widget, "icon-title-changed", G_CALLBACK(icon_title_changed), window); } /* Connect to the "status-line-changed" signal. */ g_signal_connect(widget, "status-line-changed", G_CALLBACK(status_line_changed), widget); /* Connect to the "button-press" event. */ g_signal_connect(widget, "button-press-event", G_CALLBACK(button_pressed), widget); /* Connect to application request signals. */ g_signal_connect(widget, "iconify-window", G_CALLBACK(iconify_window), window); g_signal_connect(widget, "deiconify-window", G_CALLBACK(deiconify_window), window); g_signal_connect(widget, "raise-window", G_CALLBACK(raise_window), window); g_signal_connect(widget, "lower-window", G_CALLBACK(lower_window), window); g_signal_connect(widget, "maximize-window", G_CALLBACK(maximize_window), window); g_signal_connect(widget, "restore-window", G_CALLBACK(restore_window), window); g_signal_connect(widget, "refresh-window", G_CALLBACK(refresh_window), window); g_signal_connect(widget, "resize-window", G_CALLBACK(resize_window), window); g_signal_connect(widget, "move-window", G_CALLBACK(move_window), window); /* Connect to font tweakage. */ g_signal_connect(widget, "increase-font-size", G_CALLBACK(increase_font_size), window); g_signal_connect(widget, "decrease-font-size", G_CALLBACK(decrease_font_size), window); if (!use_scrolled_window) { /* Create the scrollbar for the widget. */ scrollbar = gtk_vscrollbar_new(terminal->adjustment); gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, FALSE, 0); } /* Set some defaults. */ vte_terminal_set_audible_bell(terminal, audible); vte_terminal_set_visible_bell(terminal, !audible); vte_terminal_set_cursor_blink_mode(terminal, blink ? VTE_CURSOR_BLINK_SYSTEM : VTE_CURSOR_BLINK_OFF); vte_terminal_set_scroll_background(terminal, scroll); vte_terminal_set_scroll_on_output(terminal, FALSE); vte_terminal_set_scroll_on_keystroke(terminal, TRUE); vte_terminal_set_scrollback_lines(terminal, lines); vte_terminal_set_mouse_autohide(terminal, TRUE); if (background != NULL) { vte_terminal_set_background_image_file(terminal, background); } if (transparent) { vte_terminal_set_background_transparent(terminal, TRUE); } vte_terminal_set_background_tint_color(terminal, &tint); vte_terminal_set_colors(terminal, &fore, &back, NULL, 0); vte_terminal_set_opacity(terminal, 0xdddd); if (highlight_set) { vte_terminal_set_color_highlight(terminal, &highlight); } if (cursor_set) { vte_terminal_set_color_cursor(terminal, &cursor); } if (termcap != NULL) { vte_terminal_set_emulation(terminal, termcap); } vte_terminal_set_cursor_shape(terminal, cursor_shape); /* Set the default font. */ vte_terminal_set_font_from_string_full(terminal, font, antialias ? VTE_ANTI_ALIAS_USE_DEFAULT : VTE_ANTI_ALIAS_FORCE_DISABLE); /* Match "abcdefg". */ if (dingus) { int id; GRegex *regex; regex = g_regex_new (DINGUS1, 0, 0, NULL); id = vte_terminal_match_add_gregex(terminal, regex, 0); g_regex_unref (regex); vte_terminal_match_set_cursor_type(terminal, id, GDK_GUMBY); regex = g_regex_new (DINGUS2, 0, 0, NULL); id = vte_terminal_match_add_gregex(terminal, regex, 0); g_regex_unref (regex); vte_terminal_match_set_cursor_type(terminal, id, GDK_HAND1); } if (console) { /* Open a "console" connection. */ int consolefd = -1, yes = 1, watch; GIOChannel *channel; consolefd = open("/dev/console", O_RDONLY | O_NOCTTY); if (consolefd != -1) { /* Assume failure. */ console = FALSE; #ifdef TIOCCONS if (ioctl(consolefd, TIOCCONS, &yes) != -1) { /* Set up a listener. */ channel = g_io_channel_unix_new(consolefd); watch = g_io_add_watch(channel, G_IO_IN, read_and_feed, widget); g_signal_connect(widget, "eof", G_CALLBACK(disconnect_watch), GINT_TO_POINTER(watch)); g_signal_connect(widget, "child-exited", G_CALLBACK(disconnect_watch), GINT_TO_POINTER(watch)); g_signal_connect(widget, "realize", G_CALLBACK(take_xconsole_ownership), NULL); #ifdef VTE_DEBUG vte_terminal_feed(terminal, "Console log for ...\r\n", -1); #endif /* Record success. */ console = TRUE; } #endif } else { /* Bail back to normal mode. */ g_warning(_("Could not open console.\n")); close(consolefd); console = FALSE; } } if (!console) { if (shell) { GError *err = NULL; char **command_argv = NULL; int command_argc; GPid pid = -1; _VTE_DEBUG_IF(VTE_DEBUG_MISC) vte_terminal_feed(terminal, message, -1); if (command == NULL) command = "/bin/sh"; // FIXMEchpe if (command != NULL) { if (!g_shell_parse_argv(command, &command_argc, &command_argv, &err) || !vte_terminal_fork_command_full(terminal, pty_flags, NULL, command_argv, env_add, G_SPAWN_SEARCH_PATH, NULL, NULL, &pid, &err)) { g_warning("Failed to fork: %s\n", err->message); g_error_free(err); } else { g_print("Fork succeeded, PID %d\n", pid); } } g_strfreev(command_argv); #ifdef VTE_DEBUG if (command == NULL) { vte_terminal_feed_child(terminal, "pwd\n", -1); } #endif } else { long i; i = vte_terminal_forkpty(terminal, env_add, working_directory, TRUE, TRUE, TRUE); switch (i) { case -1: /* abnormal */ g_warning("Error in vte_terminal_forkpty(): %s", strerror(errno)); break; case 0: /* child */ for (i = 0; ; i++) { switch (i % 3) { case 0: case 1: g_print("%ld\n", i); break; case 2: g_printerr("%ld\n", i); break; } sleep(1); } _exit(0); break; default: g_print("Child PID is %ld (mine is %ld).\n", (long) i, (long) getpid()); /* normal */ break; } } } g_object_set_data (G_OBJECT (widget), "output_file", (gpointer) output_file); /* Go for it! */ g_signal_connect(widget, "child-exited", G_CALLBACK(child_exited), window); g_signal_connect(window, "delete-event", G_CALLBACK(delete_event), widget); add_weak_pointer(G_OBJECT(widget), &widget); add_weak_pointer(G_OBJECT(window), &window); gtk_widget_realize(widget); if (geometry) { if (!gtk_window_parse_geometry (GTK_WINDOW(window), geometry)) { g_warning (_("Could not parse the geometry spec passed to --geometry")); } } gtk_widget_show_all(window); gtk_main(); g_assert(widget == NULL); g_assert(window == NULL); if (keep) { while (TRUE) { sleep(60); } } return 0; }
/* Fork a shell into the VTE Terminal * * @param tt the tilda_term to fork into * * SUCCESS: return 0 * FAILURE: return non-zero */ static gint start_shell (struct tilda_term_ *tt, gboolean ignore_custom_command, const char* working_dir) { DEBUG_FUNCTION ("start_shell"); DEBUG_ASSERT (tt != NULL); gint ret; gint argc; gchar **argv; GError *error = NULL; gchar *default_command; if (working_dir == NULL || config_getbool ("inherit_working_dir") == FALSE) { working_dir = config_getstr ("working_dir"); } if (config_getbool ("run_command") && !ignore_custom_command) { ret = g_shell_parse_argv (config_getstr ("command"), &argc, &argv, &error); /* Check for error */ if (ret == FALSE) { g_printerr (_("Problem parsing custom command: %s\n"), error->message); g_printerr (_("Launching default shell instead\n")); g_error_free (error); goto launch_default_shell; } char **envv = malloc(2*sizeof(void *)); envv[0] = getenv("PATH"); envv[1] = NULL; ret = vte_terminal_fork_command_full (VTE_TERMINAL (tt->vte_term), VTE_PTY_DEFAULT, /* VtePtyFlags pty_flags */ working_dir, /* const char *working_directory */ argv, /* char **argv */ envv, /* char **envv */ G_SPAWN_SEARCH_PATH, /* GSpawnFlags spawn_flags */ NULL, /* GSpawnChildSetupFunc child_setup */ NULL, /* gpointer child_setup_data */ &tt->pid, /* GPid *child_pid */ NULL /* GError **error */ ); g_strfreev (argv); g_free (envv); /* Check for error */ if (ret == FALSE) { g_printerr (_("Unable to launch custom command: %s\n"), config_getstr ("command")); g_printerr (_("Launching default shell instead\n")); goto launch_default_shell; } return 0; /* SUCCESS: the early way out */ } launch_default_shell: /* If we have dropped to the default shell before, then this time, we * do not spawn a new shell, but instead close the current shell. This will * cause the current tab to close. */ if (tt->dropped_to_default_shell) { gint index = gtk_notebook_page_num (GTK_NOTEBOOK(tt->tw->notebook), tt->hbox); tilda_window_close_tab (tt->tw, index, FALSE); return 0; } if (ignore_custom_command) { tt->dropped_to_default_shell = TRUE; } /* No custom command, get it from the environment */ default_command = (gchar *) g_getenv ("SHELL"); /* Check for error */ if (default_command == NULL) default_command = "/bin/sh"; /* We need to create a NULL terminated list of arguments. * The first item is the command to execute in the shell, in this * case there are no further arguments being passed. */ GSpawnFlags flags = 0; gchar* argv1 = NULL; if(config_getbool("command_login_shell")) { argv1 = g_strdup_printf("-%s", default_command); argv = malloc(3 * sizeof(void *)); argv[0] = default_command; argv[1] = argv1; argv[2] = NULL; /* This is needed so that argv[1] becomes the argv[0] of the new process. Otherwise * glib just duplicates argv[0] when it executes the command and it is not possible * to modify the argv[0] that the new command sees. */ flags |= G_SPAWN_FILE_AND_ARGV_ZERO; } else { argv = malloc(1 * sizeof(void *)); argv[0] = default_command; argv[1] = NULL; } ret = vte_terminal_fork_command_full (VTE_TERMINAL (tt->vte_term), VTE_PTY_DEFAULT, /* VtePtyFlags pty_flags */ working_dir, /* const char *working_directory */ argv, /* char **argv */ NULL, /* char **envv */ flags, /* GSpawnFlags spawn_flags */ NULL, /* GSpawnChildSetupFunc child_setup */ NULL, /* gpointer child_setup_data */ &tt->pid, /* GPid *child_pid */ NULL /* GError **error */ ); g_free(argv1); g_free (argv); if (ret == -1) { g_printerr (_("Unable to launch default shell: %s\n"), default_command); return ret; } return 0; }
/* Fork a shell into the VTE Terminal * * @param tt the tilda_term to fork into * * SUCCESS: return 0 * FAILURE: return non-zero */ static gint start_shell (struct tilda_term_ *tt) { DEBUG_FUNCTION ("start_shell"); DEBUG_ASSERT (tt != NULL); gint ret; gint argc; gchar **argv; GError *error = NULL; gchar *default_command; if (config_getbool ("run_command")) { ret = g_shell_parse_argv (config_getstr ("command"), &argc, &argv, &error); /* Check for error */ if (ret == FALSE) { g_printerr (_("Problem parsing custom command: %s\n"), error->message); g_printerr (_("Launching default shell instead\n")); g_error_free (error); goto launch_default_shell; } char **envv = malloc(2*sizeof(void *)); envv[0] = getenv("PATH"); envv[1] = NULL; ret = vte_terminal_fork_command_full (VTE_TERMINAL (tt->vte_term), VTE_PTY_DEFAULT, /* VtePtyFlags pty_flags */ config_getstr ("working_dir"), /* const char *working_directory */ argv, /* char **argv */ envv, /* char **envv */ G_SPAWN_SEARCH_PATH, /* GSpawnFlags spawn_flags */ NULL, /* GSpawnChildSetupFunc child_setup */ NULL, /* gpointer child_setup_data */ NULL, /* GPid *child_pid */ NULL /* GError **error */ ); g_strfreev (argv); g_free (envv); /* Check for error */ if (ret == -1) { g_printerr (_("Unable to launch custom command: %s\n"), config_getstr ("command")); g_printerr (_("Launching default shell instead\n")); goto launch_default_shell; } return 0; /* SUCCESS: the early way out */ } launch_default_shell: /* No custom command, get it from the environment */ default_command = (gchar *) g_getenv ("SHELL"); /* Check for error */ if (default_command == NULL) default_command = "/bin/sh"; /* We need to create a NULL terminated list of arguments. * The first item is the command to execute in the shell, in this * case there are no further arguments being passed. */ argv = malloc(2 * sizeof(void *)); argv[0] = default_command; argv[1] = NULL; ret = vte_terminal_fork_command_full (VTE_TERMINAL (tt->vte_term), VTE_PTY_DEFAULT, /* VtePtyFlags pty_flags */ config_getstr ("working_dir"), /* const char *working_directory */ argv, /* char **argv */ NULL, /* char **envv */ 0, /* GSpawnFlags spawn_flags */ NULL, /* GSpawnChildSetupFunc child_setup */ NULL, /* gpointer child_setup_data */ NULL, /* GPid *child_pid */ NULL /* GError **error */ ); g_free (argv); if (ret == -1) { g_printerr (_("Unable to launch default shell: %s\n"), default_command); return ret; } return 0; }
/* create a new tab */ static void tab_new(struct window *w) { term *t; int tmp; char **args = 0; const gchar *shell = g_getenv("SHELL"); if (!shell) { shell = "sh"; } g_shell_parse_argv(shell, 0, &args, 0); t = g_new0(term, 1); t->label = gtk_label_new(""); t->w = w; t->vte = vte_terminal_new(); int index = gtk_notebook_append_page(GTK_NOTEBOOK(w->notebook), t->vte, t->label); gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(w->notebook), t->vte, TRUE); if (index == 0) { gtk_notebook_set_show_tabs(GTK_NOTEBOOK(w->notebook), FALSE); vte_terminal_fork_command_full(VTE_TERMINAL(t->vte), VTE_PTY_DEFAULT, NULL, args, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, t->pid, NULL); tab_geometry_hints(t); } else { struct term *previous = get_nth_term(w, gtk_notebook_get_current_page(GTK_NOTEBOOK(w->notebook))); vte_terminal_fork_command_full(VTE_TERMINAL(t->vte), VTE_PTY_DEFAULT, tab_get_cwd(previous), args, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, t->pid, NULL); gtk_notebook_set_show_tabs(GTK_NOTEBOOK(w->notebook), TRUE); } g_object_set_qdata_full(G_OBJECT(gtk_notebook_get_nth_page( (GtkNotebook*)w->notebook, index)), term_data_id, t, NULL); g_signal_connect(G_OBJECT(t->vte), "child-exited", G_CALLBACK(tab_close), w); g_signal_connect(G_OBJECT(t->vte), "window-title-changed", G_CALLBACK(tab_title), t); g_signal_connect(G_OBJECT(t->vte), "button-press-event", G_CALLBACK(event_button), NULL); vte_terminal_set_allow_bold(VTE_TERMINAL(t->vte), config->allow_bold); vte_terminal_set_audible_bell(VTE_TERMINAL(t->vte), config->audible_bell); vte_terminal_set_background_transparent(VTE_TERMINAL(t->vte), config->bg_transparent); vte_terminal_set_background_saturation(VTE_TERMINAL(t->vte), config->bg_saturation); vte_terminal_set_background_image_file(VTE_TERMINAL(t->vte), config->bg_image); vte_terminal_set_font_from_string(VTE_TERMINAL(t->vte), config->font); vte_terminal_set_mouse_autohide(VTE_TERMINAL(t->vte), config->autohide_mouse); vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(t->vte), config->scroll_on_keystroke); vte_terminal_set_scroll_on_output(VTE_TERMINAL(t->vte), config->scroll_on_output); vte_terminal_set_scrollback_lines(VTE_TERMINAL(t->vte), config->num_scrollback_lines); vte_terminal_set_visible_bell(VTE_TERMINAL(t->vte), config->visible_bell); vte_terminal_set_word_chars(VTE_TERMINAL(t->vte), config->word_chars); vte_terminal_set_colors(VTE_TERMINAL(t->vte), &config->foreground, &config->background, config->colour_palette, DEFAULT_PALETTE_SIZE); tmp = vte_terminal_match_add_gregex( VTE_TERMINAL(t->vte), g_regex_new(config->url_regex, G_REGEX_CASELESS, G_REGEX_MATCH_NOTEMPTY, NULL), 0); vte_terminal_match_set_cursor_type(VTE_TERMINAL(t->vte), tmp, GDK_HAND2); gtk_widget_show_all(w->notebook); gtk_notebook_set_current_page(GTK_NOTEBOOK(w->notebook), index); gtk_widget_grab_focus(t->vte); }