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);
}
