void gtkTermSetMPref(GtkWidget *term, gtkTermPref *pref, int i) { gpointer termPref; if((termPref = gtk_object_get_data(GTK_OBJECT(term), "mpref")) == NULL) { gtk_object_set_data(GTK_OBJECT(term), "mpref", GINT_TO_POINTER(-1)); termPref = GINT_TO_POINTER(-1); } if(GPOINTER_TO_INT(termPref) != i) { if(i == -1) { vte_terminal_set_audible_bell(VTE_TERMINAL(term), pref->beep); vte_terminal_set_cursor_blinks(VTE_TERMINAL(term), pref->blink); vte_terminal_set_colors(VTE_TERMINAL(term), &pref->fore[0], &pref->back[0], pref->colors, 16); vte_terminal_set_scroll_on_output(VTE_TERMINAL(term), pref->scrollOnOutput); vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(term), pref->scrollOnKeyStroke); vte_terminal_set_word_chars (VTE_TERMINAL(term), pref->worldClass); } else { vte_terminal_set_audible_bell(VTE_TERMINAL(term), pref->mpref[i]->beep); vte_terminal_set_cursor_blinks(VTE_TERMINAL(term), pref->mpref[i]->blink); vte_terminal_set_colors(VTE_TERMINAL(term), &pref->mpref[i]->fore[0], &pref->mpref[i]->back[0], pref->mpref[i]->colors, 16); vte_terminal_set_scroll_on_output(VTE_TERMINAL(term), pref->mpref[i]->scrollOnOutput); vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(term), pref->mpref[i]->scrollOnKeyStroke); vte_terminal_set_word_chars (VTE_TERMINAL(term), pref->mpref[i]->worldClass); } gtk_object_set_data(GTK_OBJECT(term), "mpref", GINT_TO_POINTER(i)); } }
PUSS_EXPORT void* puss_plugin_create(Puss* app) { PussVConsole* self; GtkWindow* window; GModule* module; bindtextdomain(TEXT_DOMAIN, app->get_locale_path()); bind_textdomain_codeset(TEXT_DOMAIN, "UTF-8"); window = puss_get_main_window(app); module = (GModule*)g_object_get_data(G_OBJECT(window), LIBVTE_KEEP_KEY); if( !module ) { module = g_module_open("libvte", G_MODULE_BIND_LAZY); if( !module ) { g_printerr("warning(puss_vconsole) : keep libvte failed! reload plugin will cause error!\n"); } else { g_object_set_data_full(G_OBJECT(window), LIBVTE_KEEP_KEY, module, (GDestroyNotify)g_module_close); } } self = g_new0(PussVConsole, 1); self->app = app; self->vte = vte_terminal_new(); { GtkWidget* hbox = gtk_hbox_new(FALSE, 4); GtkWidget* sbar = gtk_vscrollbar_new( vte_terminal_get_adjustment(VTE_TERMINAL(self->vte)) ); gtk_box_pack_start(GTK_BOX(hbox), self->vte, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), sbar, FALSE, FALSE, 0); g_signal_connect(self->vte, "child-exited", G_CALLBACK(on_quit), self); vte_terminal_fork_command( VTE_TERMINAL(self->vte) , 0, 0 , 0, 0 , FALSE , FALSE , FALSE ); vte_terminal_set_size(VTE_TERMINAL(self->vte), vte_terminal_get_column_count(VTE_TERMINAL(self->vte)), 5); vte_terminal_set_audible_bell(VTE_TERMINAL(self->vte), FALSE); gtk_widget_set_size_request(self->vte, 200, 50); gtk_widget_show_all(hbox); self->panel = hbox; app->panel_append(self->panel, gtk_label_new(_("Terminal")), "puss_vconsole_plugin_panel", PUSS_PANEL_POS_BOTTOM); } return self; }
static void hotssh_tab_init (HotSshTab *self) { HotSshTabPrivate *priv = hotssh_tab_get_instance_private (self); priv->settings = g_settings_new ("org.gnome.hotssh"); gtk_widget_init_template (GTK_WIDGET (self)); gtk_notebook_set_show_tabs ((GtkNotebook*)self, FALSE); g_signal_connect (priv->create_and_connect_button, "clicked", G_CALLBACK (on_create_and_connect), self); g_signal_connect (priv->add_new_connection_button, "clicked", G_CALLBACK (on_add_new_connection), self); g_signal_connect (priv->connect_cancel_button, "clicked", G_CALLBACK (on_connect_cancel), self); g_signal_connect (priv->error_disconnect, "clicked", G_CALLBACK (on_connect_cancel), self); g_signal_connect (priv->auth_cancel_button, "clicked", G_CALLBACK (on_connect_cancel), self); g_signal_connect (priv->approve_hostkey_button, "clicked", G_CALLBACK (on_approve_hostkey_clicked), self); g_signal_connect (priv->disapprove_hostkey_button, "clicked", G_CALLBACK (on_connect_cancel), self); g_signal_connect_swapped (priv->password_entry, "activate", G_CALLBACK (submit_password), self); g_signal_connect_swapped (priv->password_submit, "clicked", G_CALLBACK (submit_password), self); g_signal_connect (priv->connections_treeview, "row-activated", G_CALLBACK (on_connection_row_activated), self); priv->password_interaction = hotssh_password_interaction_new ((GtkEntry*)priv->password_entry); priv->terminal = vte_terminal_new (); g_signal_connect (priv->terminal, "realize", G_CALLBACK (on_vte_realize), self); vte_terminal_set_audible_bell ((VteTerminal*)priv->terminal, FALSE); /* Audible bell is a terrible idea */ g_signal_connect ((GObject*)priv->terminal, "size-allocate", G_CALLBACK (on_terminal_size_allocate), self); g_signal_connect ((GObject*)priv->terminal, "commit", G_CALLBACK (on_terminal_commit), self); gtk_box_pack_start ((GtkBox*)priv->terminal_box, priv->terminal, TRUE, TRUE, 0); gtk_range_set_adjustment ((GtkRange*)priv->terminal_vscrollbar, gtk_scrollable_get_vadjustment ((GtkScrollable*)priv->terminal)); gtk_widget_show_all (priv->terminal_box); g_queue_init (&priv->write_queue); { gs_unref_object HotSshHostDB *hostdb = hotssh_hostdb_get_instance (); gs_unref_object GtkTreeModel *hostdb_model = hotssh_hostdb_get_model (hostdb); priv->host_completion = gtk_entry_completion_new (); gtk_entry_completion_set_match_func (priv->host_completion, host_entry_match, self, NULL); gtk_entry_completion_set_model (priv->host_completion, hostdb_model); gtk_entry_completion_set_text_column (priv->host_completion, 0); gtk_entry_completion_set_inline_completion (priv->host_completion, TRUE); gtk_entry_set_completion ((GtkEntry*)priv->host_entry, priv->host_completion); } }
static void vte_config(VteTerminal* vte) { GRegex* regex = g_regex_new(url_regex, G_REGEX_CASELESS, G_REGEX_MATCH_NOTEMPTY, NULL); vte_terminal_search_set_gregex(vte, regex, G_REGEX_MATCH_NOTEMPTY); vte_terminal_search_set_wrap_around (vte, TINYTERM_SEARCH_WRAP_AROUND); vte_terminal_set_audible_bell (vte, TINYTERM_AUDIBLE_BELL); vte_terminal_set_cursor_shape (vte, TINYTERM_CURSOR_SHAPE); vte_terminal_set_cursor_blink_mode (vte, TINYTERM_CURSOR_BLINK); vte_terminal_set_word_char_exceptions (vte, TINYTERM_WORD_CHARS); vte_terminal_set_scrollback_lines (vte, TINYTERM_SCROLLBACK_LINES); PangoFontDescription *font = pango_font_description_from_string(TINYTERM_FONT); vte_terminal_set_font(vte, font); GdkRGBA color_fg, color_bg; GdkRGBA color_palette[16]; gdk_rgba_parse(&color_fg, TINYTERM_COLOR_FOREGROUND); gdk_rgba_parse(&color_bg, TINYTERM_COLOR_BACKGROUND); gdk_rgba_parse(&color_palette[0], TINYTERM_COLOR00); gdk_rgba_parse(&color_palette[1], TINYTERM_COLOR01); gdk_rgba_parse(&color_palette[2], TINYTERM_COLOR02); gdk_rgba_parse(&color_palette[3], TINYTERM_COLOR03); gdk_rgba_parse(&color_palette[4], TINYTERM_COLOR04); gdk_rgba_parse(&color_palette[5], TINYTERM_COLOR05); gdk_rgba_parse(&color_palette[6], TINYTERM_COLOR06); gdk_rgba_parse(&color_palette[7], TINYTERM_COLOR07); gdk_rgba_parse(&color_palette[8], TINYTERM_COLOR08); gdk_rgba_parse(&color_palette[9], TINYTERM_COLOR09); gdk_rgba_parse(&color_palette[10], TINYTERM_COLOR0A); gdk_rgba_parse(&color_palette[11], TINYTERM_COLOR0B); gdk_rgba_parse(&color_palette[12], TINYTERM_COLOR0C); gdk_rgba_parse(&color_palette[13], TINYTERM_COLOR0D); gdk_rgba_parse(&color_palette[14], TINYTERM_COLOR0E); gdk_rgba_parse(&color_palette[15], TINYTERM_COLOR0F); vte_terminal_set_colors(vte, &color_fg, &color_bg, &color_palette, 16); }
GtkWidget* build_term(void) { if (!popupmenu) build_popupmenu(); GtkWidget* term = vte_terminal_new(); vte_terminal_fork_command(VTE_TERMINAL(term), conf_get_shell(), NULL, NULL, "", TRUE, TRUE, TRUE); if (conf_get_bg_image() != NULL) vte_terminal_set_background_image_file(VTE_TERMINAL(term), conf_get_bg_image()); GdkColor fore, back; fore = conf_get_fg(); back = conf_get_bg(); GdkColor *palette = conf_get_color_palette(); if (palette == NULL) vte_terminal_set_colors(VTE_TERMINAL(term), &fore, &back, NULL, 0); else vte_terminal_set_colors(VTE_TERMINAL(term), &fore, &back, palette, 16); vte_terminal_set_background_tint_color(VTE_TERMINAL(term), &back); vte_terminal_set_allow_bold(VTE_TERMINAL(term), conf_get_allow_bold()); vte_terminal_set_scroll_on_output(VTE_TERMINAL(term), conf_get_scroll_on_output()); vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(term), TRUE); vte_terminal_set_font_from_string(VTE_TERMINAL(term), conf_get_font()); vte_terminal_set_scrollback_lines(VTE_TERMINAL(term), conf_get_lines()); vte_terminal_set_backspace_binding(VTE_TERMINAL(term), VTE_ERASE_ASCII_DELETE); vte_terminal_set_audible_bell (VTE_TERMINAL(term), conf_get_bell()); vte_terminal_set_cursor_blink_mode(VTE_TERMINAL(term), conf_get_cursor_blink()); vte_terminal_set_cursor_shape(VTE_TERMINAL(term), conf_get_cursor_shape()); term_connect_signals(term); return term; }
static void configure_term_widget (VteTerminal *vtterm, GVariantDict *options) { /* Pick default settings from the settings... */ dg_lmem gchar *opt_font = NULL; dg_lmem gchar *opt_theme = NULL; dg_lmem gchar *opt_fgcolor = NULL; dg_lmem gchar *opt_bgcolor = NULL; gboolean opt_bold; guint opt_scroll; DwtSettings *settings = dwt_settings_get_instance (); g_object_get (settings, "font", &opt_font, "theme", &opt_theme, "allow-bold", &opt_bold, "scrollback", &opt_scroll, "foreground-color", &opt_fgcolor, "background-color", &opt_bgcolor, NULL); /* * This ensures that properties are updated for the terminal whenever they * change in the configuration files. * * TODO: For now this is done only for those properties which cannot be * overriden using command line flags. */ static const struct { const gchar *setting_name; const gchar *property_name; GBindingFlags bind_flags; } property_bind_map[] = { { "mouse-autohide", "pointer-autohide", G_BINDING_SYNC_CREATE }, { "audible-bell", "audible-bell", G_BINDING_SYNC_CREATE }, }; for (guint i = 0; i < G_N_ELEMENTS (property_bind_map); i++) { g_object_bind_property (settings, property_bind_map[i].setting_name, G_OBJECT (vtterm), property_bind_map[i].property_name, property_bind_map[i].bind_flags); } /* ...and allow command line options to override them. */ if (options) { dg_lmem gchar *cmd_font = NULL; g_variant_dict_lookup (options, "font", "s", &cmd_font); if (cmd_font) SWAP (gchar*, cmd_font, opt_font); dg_lmem gchar *cmd_theme = NULL; g_variant_dict_lookup (options, "theme", "s", &cmd_theme); if (cmd_theme) SWAP (gchar*, cmd_theme, opt_theme); g_variant_dict_lookup (options, "allow-bold", "b", &opt_bold); g_variant_dict_lookup (options, "scrollback", "u", &opt_scroll); } PangoFontDescription *fontd = pango_font_description_from_string (opt_font); if (fontd) { if (!pango_font_description_get_family (fontd)) pango_font_description_set_family_static (fontd, "monospace"); if (!pango_font_description_get_size (fontd)) pango_font_description_set_size (fontd, 12 * PANGO_SCALE); vte_terminal_set_font (vtterm, fontd); pango_font_description_free (fontd); fontd = NULL; } const Theme *theme = &themes[1]; if (opt_theme) { theme = find_theme (opt_theme); if (!theme) { g_printerr ("No such theme '%s', using default (linux)\n", opt_theme); theme = &themes[1]; } } GdkRGBA fgcolor, bgcolor; if (!(opt_fgcolor && gdk_rgba_parse (&fgcolor, opt_fgcolor))) fgcolor = theme->fg; if (!(opt_bgcolor && gdk_rgba_parse (&bgcolor, opt_bgcolor))) bgcolor = theme->bg; vte_terminal_set_rewrap_on_resize (vtterm, TRUE); vte_terminal_set_scroll_on_keystroke (vtterm, TRUE); vte_terminal_set_audible_bell (vtterm, FALSE); vte_terminal_set_scroll_on_output (vtterm, FALSE); vte_terminal_set_allow_bold (vtterm, opt_bold); vte_terminal_set_scrollback_lines (vtterm, opt_scroll); vte_terminal_set_cursor_blink_mode (vtterm, VTE_CURSOR_BLINK_OFF); vte_terminal_set_cursor_shape (vtterm, VTE_CURSOR_SHAPE_BLOCK); vte_terminal_set_colors (vtterm, &fgcolor, &bgcolor, theme->colors, G_N_ELEMENTS (theme->colors)); const GRegexCompileFlags regex_compile_flags = G_REGEX_CASELESS | G_REGEX_OPTIMIZE | G_REGEX_MULTILINE; gint match_tag = vte_terminal_match_add_gregex (vtterm, g_regex_new (uri_regexp, regex_compile_flags, G_REGEX_MATCH_NOTEMPTY, NULL), G_REGEX_MATCH_NOTEMPTY); vte_terminal_match_set_cursor_type (vtterm, match_tag, GDK_HAND2); }
void terminal::setup_terminal() { if ( m_terminal && m_configuration ) { GError *error = NULL; vte_terminal_set_scrollback_lines(m_terminal, m_configuration->get_scrollback_lines()); vte_terminal_set_allow_bold(m_terminal, m_configuration->get_allow_bold()); vte_terminal_set_audible_bell(m_terminal, m_configuration->get_audible_bell()); vte_terminal_set_scroll_on_keystroke(m_terminal, m_configuration->get_scroll_on_keystroke()); vte_terminal_set_scroll_on_output(m_terminal, m_configuration->get_scroll_on_output()); vte_terminal_set_rewrap_on_resize(m_terminal, m_configuration->get_rewrap_on_resize()); vte_terminal_set_mouse_autohide(m_terminal, m_configuration->get_autohide_mouse()); if ( ! vte_terminal_set_encoding(m_terminal, m_configuration->get_encoding().c_str(), &error) ) { sterm::common::warning("sterm::terminal", "failed to set terminal encoding to '%s'", m_configuration->get_encoding().c_str()); sterm::common::debug("sterm::terminal", "VteTerminal error message: %s", error->message); } std::string word_chars = m_configuration->get_word_chars(); if ( ! word_chars.empty() ) vte_terminal_set_word_char_exceptions(m_terminal, word_chars.c_str()); else vte_terminal_set_word_char_exceptions(m_terminal, NULL); vte_terminal_set_cursor_blink_mode(m_terminal, m_configuration->get_cursor_blink_mode()); vte_terminal_set_cursor_shape(m_terminal, m_configuration->get_cursor_shape()); PangoFontDescription *font = NULL; if ( m_configuration->copy_font_description(&font) ) { vte_terminal_set_font(m_terminal, font); pango_font_description_free(font); } else { vte_terminal_set_font(m_terminal, NULL); } std::vector<GdkRGBA> color_palette = m_configuration->get_color_palette(); color foreground = m_configuration->get_foreground_color(); color background = m_configuration->get_background_color(); color bold_color = m_configuration->get_bold_color(); color cursor_color = m_configuration->get_cursor_color(); color highlight_bg = m_configuration->get_highlight_bg_color(); color highlight_fg = m_configuration->get_highlight_fg_color(); if ( color_palette.size() == PALETTE_SIZE ) vte_terminal_set_colors(m_terminal, NULL, NULL, color_palette.data(), PALETTE_SIZE); else vte_terminal_set_default_colors(m_terminal); if ( foreground.set ) vte_terminal_set_color_foreground(m_terminal, &(foreground.value)); if ( background.set ) vte_terminal_set_color_background(m_terminal, &(background.value)); if ( bold_color.set ) vte_terminal_set_color_bold(m_terminal, &(bold_color.value)); else vte_terminal_set_color_bold(m_terminal, NULL); if ( cursor_color.set ) vte_terminal_set_color_cursor(m_terminal, &(cursor_color.value)); else vte_terminal_set_color_cursor(m_terminal, NULL); if ( highlight_bg.set ) vte_terminal_set_color_highlight(m_terminal, &(highlight_bg.value)); else vte_terminal_set_color_highlight(m_terminal, NULL); if ( highlight_fg.set ) vte_terminal_set_color_highlight_foreground(m_terminal, &(highlight_fg.value)); else vte_terminal_set_color_highlight_foreground(m_terminal, NULL); } }
void termit_tab_set_audible_bell(struct TermitTab* pTab, gboolean audible_bell) { pTab->audible_bell = audible_bell; vte_terminal_set_audible_bell(VTE_TERMINAL(pTab->vte), audible_bell); }
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; }
static VALUE rg_set_audible_bell(VALUE self, VALUE is_audible) { vte_terminal_set_audible_bell(_SELF(self), RVAL2CBOOL(is_audible)); return self; }
/** * tilda_term_config_defaults () * * Read and set all of the defaults for this terminal from the current configuration. * * Success: return 0 * Failure: return non-zero */ static gint tilda_term_config_defaults (tilda_term *tt) { DEBUG_FUNCTION ("tilda_term_config_defaults"); DEBUG_ASSERT (tt != NULL); gdouble transparency_level = 0.0; GdkRGBA fg, bg, cc; gchar* word_chars; gint i; gint cursor_shape; /** Colors & Palette **/ bg.red = GUINT16_TO_FLOAT(config_getint ("back_red")); bg.green = GUINT16_TO_FLOAT(config_getint ("back_green")); bg.blue = GUINT16_TO_FLOAT(config_getint ("back_blue")); bg.alpha = 1.0; fg.red = GUINT16_TO_FLOAT(config_getint ("text_red")); fg.green = GUINT16_TO_FLOAT(config_getint ("text_green")); fg.blue = GUINT16_TO_FLOAT(config_getint ("text_blue")); fg.alpha = 1.0; cc.red = GUINT16_TO_FLOAT(config_getint ("cursor_red")); cc.green = GUINT16_TO_FLOAT(config_getint ("cursor_green")); cc.blue = GUINT16_TO_FLOAT(config_getint ("cursor_blue")); cc.alpha = 1.0; for(i = 0;i < TERMINAL_PALETTE_SIZE; i++) { current_palette[i].red = GUINT16_TO_FLOAT(config_getnint ("palette", i*3)); current_palette[i].green = GUINT16_TO_FLOAT(config_getnint ("palette", i*3+1)); current_palette[i].blue = GUINT16_TO_FLOAT(config_getnint ("palette", i*3+2)); current_palette[i].alpha = 1.0; } vte_terminal_set_colors_rgba (VTE_TERMINAL(tt->vte_term), &fg, &bg, current_palette, TERMINAL_PALETTE_SIZE); /** Bells **/ vte_terminal_set_audible_bell (VTE_TERMINAL(tt->vte_term), config_getbool ("bell")); vte_terminal_set_visible_bell (VTE_TERMINAL(tt->vte_term), config_getbool ("bell")); /** Cursor **/ vte_terminal_set_cursor_blink_mode (VTE_TERMINAL(tt->vte_term), (config_getbool ("blinks"))?VTE_CURSOR_BLINK_ON:VTE_CURSOR_BLINK_OFF); vte_terminal_set_color_cursor_rgba (VTE_TERMINAL(tt->vte_term), &cc); cursor_shape = config_getint("cursor_shape"); if (cursor_shape < 0 || cursor_shape > 2) { config_setint("cursor_shape", 0); cursor_shape = 0; } vte_terminal_set_cursor_shape(VTE_TERMINAL(tt->vte_term), (VteTerminalCursorShape)cursor_shape); /** Scrolling **/ vte_terminal_set_scroll_background (VTE_TERMINAL(tt->vte_term), config_getbool ("scroll_background")); vte_terminal_set_scroll_on_output (VTE_TERMINAL(tt->vte_term), config_getbool ("scroll_on_output")); vte_terminal_set_scroll_on_keystroke (VTE_TERMINAL(tt->vte_term), config_getbool ("scroll_on_key")); /** Mouse **/ vte_terminal_set_mouse_autohide (VTE_TERMINAL(tt->vte_term), FALSE); /* TODO: make this configurable */ /** Text Properties **/ vte_terminal_set_allow_bold (VTE_TERMINAL(tt->vte_term), config_getbool ("bold")); gtk_widget_set_double_buffered (tt->vte_term, config_getbool("double_buffer")); PangoFontDescription *description = pango_font_description_from_string (config_getstr ("font")); vte_terminal_set_font (VTE_TERMINAL (tt->vte_term), description); /** Scrollback **/ vte_terminal_set_scrollback_lines (VTE_TERMINAL(tt->vte_term), config_getbool("scroll_history_infinite") ? -1 : config_getint ("lines")); /** Keys **/ switch (config_getint ("backspace_key")) { case ASCII_DELETE: vte_terminal_set_backspace_binding (VTE_TERMINAL(tt->vte_term), VTE_ERASE_ASCII_DELETE); break; case DELETE_SEQUENCE: vte_terminal_set_backspace_binding (VTE_TERMINAL(tt->vte_term), VTE_ERASE_DELETE_SEQUENCE); break; case ASCII_BACKSPACE: vte_terminal_set_backspace_binding (VTE_TERMINAL(tt->vte_term), VTE_ERASE_ASCII_BACKSPACE); break; case AUTO: default: vte_terminal_set_backspace_binding (VTE_TERMINAL(tt->vte_term), VTE_ERASE_AUTO); break; } switch (config_getint ("delete_key")) { case ASCII_DELETE: vte_terminal_set_delete_binding (VTE_TERMINAL(tt->vte_term), VTE_ERASE_ASCII_DELETE); break; case DELETE_SEQUENCE: vte_terminal_set_delete_binding (VTE_TERMINAL(tt->vte_term), VTE_ERASE_DELETE_SEQUENCE); break; case ASCII_BACKSPACE: vte_terminal_set_delete_binding (VTE_TERMINAL(tt->vte_term), VTE_ERASE_ASCII_BACKSPACE); break; case AUTO: default: vte_terminal_set_delete_binding (VTE_TERMINAL(tt->vte_term), VTE_ERASE_AUTO); break; } /** Word chars **/ word_chars = config_getstr ("word_chars"); if (NULL == word_chars || '\0' == *word_chars) { word_chars = DEFAULT_WORD_CHARS; } vte_terminal_set_word_chars (VTE_TERMINAL(tt->vte_term), word_chars); /** Background **/ if (config_getbool ("use_image")) vte_terminal_set_background_image_file (VTE_TERMINAL(tt->vte_term), config_getstr ("image")); else vte_terminal_set_background_image_file (VTE_TERMINAL(tt->vte_term), NULL); transparency_level = ((gdouble) config_getint ("transparency"))/100; if (config_getbool ("enable_transparency") && transparency_level > 0) { vte_terminal_set_background_saturation (VTE_TERMINAL (tt->vte_term), transparency_level); vte_terminal_set_opacity (VTE_TERMINAL (tt->vte_term), (1.0 - transparency_level) * 0xffff); vte_terminal_set_background_transparent (VTE_TERMINAL(tt->vte_term), !tt->tw->have_argb_visual); } return 0; }
static VALUE term_set_audible_bell(VALUE self, VALUE is_audible) { vte_terminal_set_audible_bell(RVAL2TERM(self), RVAL2CBOOL(is_audible)); return Qnil; }
/* 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); }
void apply_new_win_data_to_page (struct Window *win_data_orig, struct Window *win_data, struct Page *page_data) { #ifdef DETAIL g_debug("! Launch apply_new_win_data_to_page() with win_data_orig = %p, win_data = %p, page_data = %p", win_data_orig, win_data, page_data); #endif #ifdef SAFEMODE if ((win_data_orig==NULL) || (win_data==NULL) || (page_data==NULL) || (page_data->vte==NULL)) return; #endif // if (win_data_orig->use_rgba != win_data->use_rgba) // init_rgba(win_data); #ifdef ENABLE_RGBA set_window_opacity (NULL, 0, win_data->window_opacity, win_data); #endif init_monitor_cmdline_datas(win_data, page_data); if (win_data_orig->enable_hyperlink != win_data->enable_hyperlink) set_hyprelink(win_data, page_data); // ---- the color used in vte ---- // gboolean update_color = FALSE; if (compare_color(&(win_data_orig->cursor_color), &(win_data->cursor_color)) || (win_data_orig->have_custom_color != win_data->have_custom_color) || (win_data_orig->use_custom_theme != win_data->use_custom_theme) || (win_data_orig->color_brightness != win_data->color_brightness)) update_color = TRUE; gint i; if (! update_color && (win_data->use_custom_theme)) { for (i=0; i<COLOR; i++) if (compare_color(&(win_data_orig->color[i]), &(win_data->color[i]))) update_color = TRUE; } if (update_color) set_vte_color(page_data->vte, use_default_vte_theme(win_data), win_data->cursor_color, win_data->color, FALSE); // ---- tabs on notebook ---- // if (win_data_orig->tabs_bar_position != win_data->tabs_bar_position) { if (win_data->tabs_bar_position) gtk_notebook_set_tab_pos(GTK_NOTEBOOK(win_data->notebook), GTK_POS_BOTTOM); else gtk_notebook_set_tab_pos(GTK_NOTEBOOK(win_data->notebook), GTK_POS_TOP); } // the fill_tabs_bar may not always work, so we should call set_fill_tabs_bar() every time. // if (win_data_orig->fill_tabs_bar != win_data->fill_tabs_bar) set_fill_tabs_bar(GTK_NOTEBOOK(win_data->notebook), win_data->fill_tabs_bar, page_data); if (win_data_orig->page_width != win_data->page_width) set_page_width(win_data, page_data); // g_debug("ORI: %d", win_data_orig->page_shows_current_cmdline || // win_data_orig->page_shows_current_dir || // win_data_orig->page_shows_window_title); // g_debug("NEW: %d", win_data->page_shows_current_cmdline || // win_data->page_shows_current_dir || // win_data->page_shows_window_title); if ((proc_exist) && ((page_data->page_update_method != PAGE_METHOD_NORMAL) || (win_data->page_shows_current_cmdline || win_data->page_shows_current_dir || win_data->page_shows_window_title))) { // FIXME: Is it necessary? if (page_data->page_update_method == PAGE_METHOD_WINDOW_TITLE) page_data->window_title_updated = 1; page_data->page_update_method = PAGE_METHOD_REFRESH; } // g_debug("page_data->page_update_method = %d", page_data->page_update_method); if (win_data->page_shows_window_title != win_data_orig->page_shows_window_title) add_remove_window_title_changed_signal(page_data); if (win_data->check_root_privileges != win_data_orig->check_root_privileges) { if (win_data->check_root_privileges) page_data->is_root = check_is_root(page_data->displayed_tpgid); else page_data->is_root = FALSE; // g_debug("apply_new_win_data_to_page(): page_data->is_root = %d", page_data->is_root); } if (page_data->is_bold) { if (page_data->vte == win_data->current_vte) { if (win_data->bold_current_page_name == FALSE) { page_data->is_bold = page_data->should_be_bold; if (win_data->bold_action_page_name == FALSE) page_data->is_bold = FALSE; } } else { if (win_data->bold_action_page_name == FALSE) page_data->is_bold = FALSE; } } else { if (page_data->vte == win_data->current_vte) page_data->is_bold = win_data->bold_current_page_name; else if (win_data->bold_action_page_name == TRUE) page_data->is_bold = page_data->should_be_bold; } if ((win_data_orig->window_title_shows_current_page != win_data->window_title_shows_current_page) || (win_data_orig->window_title_append_package_name != win_data->window_title_append_package_name)) { check_and_update_window_title(win_data, page_data->custom_window_title, page_data->page_no+1, page_data->custom_page_name, page_data->page_name); // g_debug("FINAL: New window title = %s", gtk_window_get_title(GTK_WINDOW(win_data->window))); } get_and_update_page_name(page_data, FALSE); if ((win_data_orig->show_close_button_on_tab != win_data->show_close_button_on_tab) || (win_data_orig->show_close_button_on_all_tabs != win_data->show_close_button_on_all_tabs)) show_close_button_on_tab(win_data, page_data); // ---- font ---- // if (win_data_orig->font_anti_alias != win_data->font_anti_alias) vte_terminal_set_font_from_string_full (VTE_TERMINAL(page_data->vte), page_data->font_name, win_data->font_anti_alias); // ---- other settings for init a vte ---- // if (compare_strings(win_data_orig->word_chars, win_data->word_chars, TRUE)) vte_terminal_set_word_chars(VTE_TERMINAL(page_data->vte), win_data->word_chars); if (win_data_orig->show_scroll_bar != win_data->show_scroll_bar) // hide_scroll_bar(win_data, page_data); show_and_hide_scroll_bar(page_data, check_show_or_hide_scroll_bar(win_data)); if (win_data_orig->scroll_bar_position != win_data->scroll_bar_position) { g_object_ref(page_data->vte); gtk_container_remove (GTK_CONTAINER(page_data->hbox), page_data->vte); g_object_ref(page_data->scroll_bar); gtk_container_remove (GTK_CONTAINER(page_data->hbox), page_data->scroll_bar); pack_vte_and_scroll_bar_to_hbox(win_data, page_data); g_object_unref(page_data->vte); g_object_unref(page_data->scroll_bar); } if (compare_color(&(win_data_orig->color[0]), &(win_data->color[0])) || (win_data_orig->transparent_background != win_data->transparent_background) || (win_data_orig->background_saturation != win_data->background_saturation) || (win_data_orig->scroll_background != win_data->scroll_background) || compare_strings (win_data_orig->background_image, win_data->background_image, TRUE)) set_background_saturation (NULL, 0, win_data->background_saturation, page_data->vte); if (win_data_orig->scrollback_lines != win_data->scrollback_lines) vte_terminal_set_scrollback_lines (VTE_TERMINAL(page_data->vte), win_data->scrollback_lines); if (win_data_orig->cursor_blinks != win_data->cursor_blinks) set_cursor_blink(win_data, page_data); if (win_data_orig->allow_bold_text != win_data->allow_bold_text) vte_terminal_set_allow_bold(VTE_TERMINAL(page_data->vte), win_data->allow_bold_text); if (win_data_orig->audible_bell != win_data->audible_bell) vte_terminal_set_audible_bell (VTE_TERMINAL(page_data->vte), win_data->audible_bell); if (win_data_orig->visible_bell != win_data->visible_bell) vte_terminal_set_visible_bell (VTE_TERMINAL(page_data->vte), win_data->visible_bell); #ifdef ENABLE_BEEP_SINGAL if (win_data_orig->urgent_bell != win_data->urgent_bell) set_vte_urgent_bell(win_data, page_data); #endif if (win_data_orig->erase_binding != win_data->erase_binding) vte_terminal_set_backspace_binding (VTE_TERMINAL(page_data->vte), win_data->erase_binding); #ifdef ENABLE_CURSOR_SHAPE if (win_data_orig->cursor_shape != win_data->cursor_shape) vte_terminal_set_cursor_shape(VTE_TERMINAL(page_data->vte), win_data->cursor_shape); #endif if (compare_strings(win_data_orig->emulate_term, win_data->emulate_term, TRUE)) vte_terminal_set_emulation (VTE_TERMINAL(page_data->vte), win_data->emulate_term); }
// to init a new page void init_new_page(struct Window *win_data, struct Page *page_data, glong column, glong row) { #ifdef DETAIL g_debug("! Launch init_new_page() with win_data = %p, page_data = %p, " " column = %ld, row = %ld", win_data, page_data, column, row); #endif #ifdef SAFEMODE if ((win_data==NULL) || (page_data==NULL) || (page_data->vte==NULL)) return; #endif // g_debug("Get win_data = %d when initing new page!", win_data); #ifdef SAFEMODE if (page_data->font_name) { #endif // set font // g_debug("Set Font AA = %d", win_data->font_anti_alias); vte_terminal_set_font_from_string_full (VTE_TERMINAL(page_data->vte), page_data->font_name, win_data->font_anti_alias); #ifdef SAFEMODE } #endif //g_debug("Got font size from %s: %d", font_name, pango_font_description_get_size ( // pango_font_description_from_string(font_name))/PANGO_SCALE); // set terminal size // g_debug("Set the vte size to: %dx%d", column, row); #ifdef SAFEMODE if (page_data->vte) #endif vte_terminal_set_size(VTE_TERMINAL(page_data->vte), column, row); #ifdef GEOMETRY # ifdef USE_GTK2_GEOMETRY_METHOD g_debug("@ init_new_page(for %p, vte = %p): Set win_data->keep_vte_size to %d, and column = %ld, row = %ld", win_data->window, page_data->vte, win_data->keep_vte_size, column, row); # else g_debug("@ init_new_page(for %p, vte = %p): Set column = %ld, row = %ld", win_data->window, page_data->vte, column, row); # endif #endif set_vte_color(page_data->vte, use_default_vte_theme(win_data), win_data->cursor_color, win_data->color, FALSE); // set transparent set_background_saturation(NULL, 0, win_data->background_saturation, page_data->vte); // other settings vte_terminal_set_word_chars(VTE_TERMINAL(page_data->vte), win_data->word_chars); vte_terminal_set_scrollback_lines(VTE_TERMINAL(page_data->vte), win_data->scrollback_lines); // some fixed parameter vte_terminal_set_scroll_on_output(VTE_TERMINAL(page_data->vte), FALSE); vte_terminal_set_scroll_on_keystroke(VTE_TERMINAL(page_data->vte), TRUE); // vte_terminal_set_backspace_binding (VTE_TERMINAL(page_data->vte), VTE_ERASE_ASCII_DELETE); // vte_terminal_set_delete_binding (VTE_TERMINAL(page_data->vte), VTE_ERASE_ASCII_DELETE); // vte_terminal_set_emulation (VTE_TERMINAL(page_data->vte), "xterm"); #ifdef ENABLE_FIND_STRING vte_terminal_search_set_wrap_around (VTE_TERMINAL(page_data->vte), TRUE); #endif set_hyprelink(win_data, page_data); set_cursor_blink(win_data, page_data); vte_terminal_set_allow_bold(VTE_TERMINAL(page_data->vte), win_data->allow_bold_text); vte_terminal_set_audible_bell (VTE_TERMINAL(page_data->vte), win_data->audible_bell); vte_terminal_set_visible_bell (VTE_TERMINAL(page_data->vte), win_data->visible_bell); // g_debug("init_new_page(): call set_vte_urgent_bell()"); #ifdef ENABLE_BEEP_SINGAL set_vte_urgent_bell(win_data, page_data); #endif vte_terminal_set_backspace_binding (VTE_TERMINAL(page_data->vte), win_data->erase_binding); #ifdef ENABLE_CURSOR_SHAPE vte_terminal_set_cursor_shape(VTE_TERMINAL(page_data->vte), win_data->cursor_shape); #endif vte_terminal_set_emulation (VTE_TERMINAL(page_data->vte), win_data->emulate_term); }
static void terminal_set_preferences (VteTerminal *term, GSettings* settings, TerminalPlugin *term_plugin) { char *text; int value; gboolean setting; GdkColor color[2]; GdkColor* foreground; GdkColor* background; gchar *profile; g_return_if_fail (settings != NULL); #if 0 /* Update the currently available list of terminal profiles */ setting = g_settings_get_boolean (settings, PREFS_TERMINAL_PROFILE_USE_DEFAULT); if (setting) { // TODO: Get from GSettings instead of GConf /* Use the currently selected profile in gnome-terminal */ text = gconf_client_get_string (client, GCONF_DEFAULT_PROFILE, NULL); } else { /* Otherwise use the user selected profile */ text = g_settings_get_string (settings, PREFS_TERMINAL_PROFILE); } if (!text || (*text == '\0')) text = g_strdup ("Default"); profile = text; vte_terminal_set_mouse_autohide (term, TRUE); /* Set terminal font either using the desktop wide font or g-t one. */ setting = g_settings_get_boolean (GCONF_USE_SYSTEM_FONT); if (setting) { text = gconf_client_get_string (client, GCONF_MONOSPACE_FONT, NULL); if (!text) text = GET_PROFILE_STRING (GCONF_VTE_TERMINAL_FONT); } else { text = GET_PROFILE_STRING (GCONF_VTE_TERMINAL_FONT); } if (text) vte_terminal_set_font_from_string (term, text); g_free (text); setting = GET_PROFILE_BOOL (GCONF_CURSOR_BLINK); vte_terminal_set_cursor_blink_mode ((term), setting ? VTE_CURSOR_BLINK_ON : VTE_CURSOR_BLINK_OFF); setting = GET_PROFILE_BOOL (GCONF_SILENT_BELL); vte_terminal_set_audible_bell (term, !setting); value = GET_PROFILE_INT (GCONF_SCROLLBACK_LINES); vte_terminal_set_scrollback_lines (term, (value == 0) ? 500 : value); setting = GET_PROFILE_BOOL (GCONF_SCROLL_ON_KEYSTROKE); vte_terminal_set_scroll_on_keystroke (term, setting); setting = GET_PROFILE_BOOL (GCONF_SCROLL_ON_OUTPUT); vte_terminal_set_scroll_on_output (term, TRUE); text = GET_PROFILE_STRING (GCONF_WORD_CHARS); if (text) vte_terminal_set_word_chars (term, text); g_free (text); text = GET_PROFILE_STRING (GCONF_BACKSPACE_BINDING); if (text) { if (!strcmp (text, "ascii-del")) vte_terminal_set_backspace_binding (term, VTE_ERASE_ASCII_DELETE); else if (!strcmp (text, "escape-sequence")) vte_terminal_set_backspace_binding (term, VTE_ERASE_DELETE_SEQUENCE); else if (!strcmp (text, "control-h")) vte_terminal_set_backspace_binding (term, VTE_ERASE_ASCII_BACKSPACE); else vte_terminal_set_backspace_binding (term, VTE_ERASE_AUTO); g_free (text); } text = GET_PROFILE_STRING (GCONF_DELETE_BINDING); if (text) { if (!strcmp (text, "ascii-del")) vte_terminal_set_delete_binding (term, VTE_ERASE_ASCII_DELETE); else if (!strcmp (text, "escape-sequence")) vte_terminal_set_delete_binding (term, VTE_ERASE_DELETE_SEQUENCE); else if (!strcmp (text, "control-h")) vte_terminal_set_delete_binding (term, VTE_ERASE_ASCII_BACKSPACE); else vte_terminal_set_delete_binding (term, VTE_ERASE_AUTO); g_free (text); } /* Set fore- and background colors. */ text = GET_PROFILE_STRING (GCONF_BACKGROUND_COLOR); if (text) { gdk_color_parse (text, &color[0]); g_free (text); } background = text ? &color[0] : NULL; text = GET_PROFILE_STRING (GCONF_FOREGROUND_COLOR); if (text) { gdk_color_parse (text, &color[1]); g_free (text); } foreground = text ? &color[1] : NULL; /* vte_terminal_set_colors works even if the terminal widget is not realized * which is not the case with vte_terminal_set_color_foreground and * vte_terminal_set_color_background */ vte_terminal_set_colors (term, foreground, background, NULL, 0); /* vte_terminal is not working depending on update_records setting at least * on FreeBSD */ term_plugin->lastlog = GET_PROFILE_BOOL (GCONF_LOGIN_SHELL); term_plugin->update_records = GET_PROFILE_BOOL_DEFAULT (GCONF_UPDATE_RECORDS, TRUE); g_free (profile); g_object_unref (client); #endif }