console_t *uimon_window_open(void) { GtkWidget *scrollbar, *horizontal_container; if (fixed.window == NULL) { fixed.window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(fixed.window), "VICE monitor"); gtk_window_set_position(GTK_WINDOW(fixed.window), GTK_WIN_POS_CENTER); gtk_widget_set_app_paintable(fixed.window, TRUE); gtk_window_set_deletable(GTK_WINDOW(fixed.window), TRUE); fixed.term = vte_terminal_new(); vte_terminal_set_scrollback_lines (VTE_TERMINAL(fixed.term), 1000); vte_terminal_set_scroll_on_output (VTE_TERMINAL(fixed.term), TRUE); scrollbar = gtk_vscrollbar_new(vte_terminal_get_adjustment (VTE_TERMINAL(fixed.term))); horizontal_container = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(fixed.window), horizontal_container); gtk_container_add(GTK_CONTAINER(horizontal_container), fixed.term); gtk_container_add(GTK_CONTAINER(horizontal_container), scrollbar); g_signal_connect(G_OBJECT(fixed.window), "delete-event", G_CALLBACK(close_window), &fixed.input_buffer); g_signal_connect(G_OBJECT(fixed.term), "key-press-event", G_CALLBACK(key_press_event), &fixed.input_buffer); g_signal_connect(G_OBJECT(fixed.term), "button-press-event", G_CALLBACK(button_press_event), &fixed.input_buffer); vte_console.console_xres = vte_terminal_get_column_count(VTE_TERMINAL(fixed.term)); vte_console.console_yres = vte_terminal_get_row_count(VTE_TERMINAL(fixed.term)); vte_console.console_can_stay_open = 1; } return uimon_window_resume(); }
int getColumns(struct console_private_s *t) { if(t->term) { return vte_terminal_get_column_count(VTE_TERMINAL(t->term)); } return 80; }
static void resize_window(GtkWidget *widget, guint width, guint height, gpointer data) { VteTerminal *terminal; if ((GTK_IS_WINDOW(data)) && (width >= 2) && (height >= 2)) { gint owidth, oheight, char_width, char_height, column_count, row_count; GtkBorder *inner_border; terminal = VTE_TERMINAL(widget); gtk_window_get_size(GTK_WINDOW(data), &owidth, &oheight); /* Take into account border overhead. */ char_width = vte_terminal_get_char_width (terminal); char_height = vte_terminal_get_char_height (terminal); column_count = vte_terminal_get_column_count (terminal); row_count = vte_terminal_get_row_count (terminal); gtk_widget_style_get (widget, "inner-border", &inner_border, NULL); owidth -= char_width * column_count; oheight -= char_height * row_count; if (inner_border != NULL) { owidth -= inner_border->left + inner_border->right; oheight -= inner_border->top + inner_border->bottom; } gtk_window_resize(GTK_WINDOW(data), width + owidth, height + oheight); gtk_border_free (inner_border); } }
static void get_terminal_size_in_chars(VteTerminal *terminal, glong *width, glong *height) { *width = vte_terminal_get_column_count(terminal); *height = vte_terminal_get_row_count(terminal); }
void term_set_font(GtkWidget *win, VteTerminal *term, size_t index) { PangoFontDescription *font_desc = NULL; glong width, height; if (index >= sizeof fonts / sizeof fonts[0]) { fprintf(stderr, __NAME__": Warning: Invalid font index\n"); return; } width = vte_terminal_get_column_count(term); height = vte_terminal_get_row_count(term); font_desc = pango_font_description_from_string(fonts[index]); vte_terminal_set_font(term, font_desc); pango_font_description_free(font_desc); vte_terminal_set_font_scale(term, 1); term_set_size(win, term, width, height); if (win != NULL) vte_terminal_set_geometry_hints_for_window(VTE_TERMINAL(term), GTK_WINDOW(win)); }
static void adjust_font_size(GtkWidget *widget, gpointer data, gdouble factor) { VteTerminal *terminal; gdouble scale; glong char_width, char_height; gint columns, rows, owidth, oheight; /* Read the screen dimensions in cells. */ terminal = VTE_TERMINAL(widget); columns = vte_terminal_get_column_count(terminal); rows = vte_terminal_get_row_count(terminal); /* Take into account padding and border overhead. */ gtk_window_get_size(GTK_WINDOW(data), &owidth, &oheight); char_width = vte_terminal_get_char_width (terminal); char_height = vte_terminal_get_char_height (terminal); owidth -= char_width * columns; oheight -= char_height * rows; scale = vte_terminal_get_font_scale(terminal); vte_terminal_set_font_scale(terminal, scale * factor); /* This above call will have changed the char size! */ char_width = vte_terminal_get_char_width (terminal); char_height = vte_terminal_get_char_height (terminal); gtk_window_resize(GTK_WINDOW(data), columns * char_width + owidth, rows * char_height + oheight); }
static void resize_window(GtkWidget *widget, guint width, guint height, gpointer data) { VteTerminal *terminal; if ((GTK_IS_WINDOW(data)) && (width >= 2) && (height >= 2)) { gint owidth, oheight, char_width, char_height, column_count, row_count; GtkBorder padding; terminal = VTE_TERMINAL(widget); gtk_window_get_size(GTK_WINDOW(data), &owidth, &oheight); /* Take into account border overhead. */ char_width = vte_terminal_get_char_width (terminal); char_height = vte_terminal_get_char_height (terminal); column_count = vte_terminal_get_column_count (terminal); row_count = vte_terminal_get_row_count (terminal); gtk_style_context_get_padding(gtk_widget_get_style_context(widget), gtk_widget_get_state_flags(widget), &padding); owidth -= char_width * column_count + padding.left + padding.right; oheight -= char_height * row_count + padding.top + padding.bottom; gtk_window_resize(GTK_WINDOW(data), width + owidth, height + oheight); } }
static void mud_subwindow_set_size_force_grid (MudSubwindow *window, VteTerminal *screen, gboolean even_if_mapped, int force_grid_width, int force_grid_height) { /* TODO: Missing get_padding in new VTE; maybe we can just use vte_terminal_set_size? */ #if 0 #warning Reimplement mud_subwindow size forcing /* Owen's hack from gnome-terminal */ GtkWidget *widget; GtkWidget *app; GtkRequisition toplevel_request; GtkRequisition widget_request; int w, h; int char_width; int char_height; int grid_width; int grid_height; int xpad; int ypad; g_return_if_fail(MUD_IS_SUBWINDOW(window)); /* be sure our geometry is up-to-date */ mud_subwindow_update_geometry (window); widget = GTK_WIDGET (screen); app = window->priv->window; gtk_widget_size_request (app, &toplevel_request); gtk_widget_size_request (widget, &widget_request); w = toplevel_request.width - widget_request.width; h = toplevel_request.height - widget_request.height; char_width = vte_terminal_get_char_width (screen); char_height = vte_terminal_get_char_height (screen); grid_width = vte_terminal_get_column_count (screen); grid_height = vte_terminal_get_row_count (screen); if (force_grid_width >= 0) grid_width = force_grid_width; if (force_grid_height >= 0) grid_height = force_grid_height; vte_terminal_get_padding (VTE_TERMINAL (screen), &xpad, &ypad); w += xpad * 2 + char_width * grid_width; h += ypad * 2 + char_height * grid_height; if (even_if_mapped && gtk_widget_get_mapped (app)) { gtk_window_resize (GTK_WINDOW (app), w, h); } }
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; }
void term_set_font_scale(GtkWidget *win, VteTerminal *term, gdouble mult) { gdouble s; glong width, height; width = vte_terminal_get_column_count(term); height = vte_terminal_get_row_count(term); s = vte_terminal_get_font_scale(term); s *= mult; vte_terminal_set_font_scale(term, s); term_set_size(win, term, width, height); vte_terminal_set_geometry_hints_for_window(VTE_TERMINAL(term), GTK_WINDOW(win)); }
static void mud_subwindow_size_allocate_cb(GtkWidget *widget, GtkAllocation *allocation, MudSubwindow *self) { if(gtk_widget_get_mapped(self->priv->window)) { if(self->priv->width != allocation->width || self->priv->height != allocation->height) { self->priv->width = vte_terminal_get_column_count (VTE_TERMINAL (self->priv->terminal)); self->priv->height = vte_terminal_get_row_count (VTE_TERMINAL(self->priv->terminal)); g_signal_emit(self, mud_subwindow_signal[RESIZED], 0, self->priv->width, self->priv->height); } } }
static gboolean idle_send_pty_size_request (gpointer user_data) { HotSshTab *self = user_data; HotSshTabPrivate *priv = hotssh_tab_get_instance_private (self); guint width = vte_terminal_get_column_count ((VteTerminal*)priv->terminal); guint height = vte_terminal_get_row_count ((VteTerminal*)priv->terminal); priv->queued_pty_size_id = 0; g_assert (priv->connection); if (gssh_connection_get_state (priv->connection) == GSSH_CONNECTION_STATE_CONNECTED) { priv->need_pty_size_request = FALSE; priv->sent_pty_size_request = TRUE; gssh_channel_request_pty_size_async (priv->channel, width, height, priv->cancellable, on_pty_size_complete, self); } return FALSE; }
static void adjust_font_size (GtkWidget *widget, gpointer data, gint howmuch) { DEBUG_FUNCTION ("adjust_font_size"); DEBUG_ASSERT (widget != NULL); DEBUG_ASSERT (data != NULL); VteTerminal *terminal; PangoFontDescription *desired; gint newsize; gint columns, rows, owidth, oheight; /* Read the screen dimensions in cells. */ terminal = VTE_TERMINAL(widget); columns = vte_terminal_get_column_count (terminal); rows = vte_terminal_get_row_count (terminal); /* Take into account padding and border overhead. */ gtk_window_get_size(GTK_WINDOW(data), &owidth, &oheight); owidth -= vte_terminal_get_char_width (terminal) * columns; oheight -= vte_terminal_get_char_height (terminal) * rows; /* Calculate the new font size. */ desired = pango_font_description_copy (vte_terminal_get_font(terminal)); newsize = pango_font_description_get_size (desired) / PANGO_SCALE; newsize += howmuch; pango_font_description_set_size (desired, CLAMP(newsize, 4, 144) * PANGO_SCALE); /* Change the font, then resize the window so that we have the same * number of rows and columns. */ vte_terminal_set_font (terminal, desired); /*gtk_window_resize (GTK_WINDOW(data), columns * terminal->char_width + owidth, rows * terminal->char_height + oheight);*/ pango_font_description_free (desired); }
void reset_vte_size(GtkWidget *vte, gchar *new_font_name, Font_Reset_Type type) { #ifdef DETAIL g_debug("! Launch reset_vte_size() with vte = %p, new_font_name = %s, type = %d", vte, new_font_name, type); #endif #ifdef SAFEMODE if ((vte==NULL) || (new_font_name==NULL)) return; #endif // type 0, RESET_CURRENT_TAB_FONT: change current page's font // type 1, RESET_ALL_TO_CURRENT_TAB: apply current column & row to every vte // type 2, RESET_ALL_TO_DEFAULT: apply default column & row to every vte // type 3, RESET_ALL_TO_SYSTEM: apply system column & row to every vte struct Page *page_data = (struct Page *)g_object_get_data(G_OBJECT(vte), "Page_Data"); #ifdef SAFEMODE if (page_data==NULL) return; #endif struct Window *win_data = (struct Window *)g_object_get_data(G_OBJECT(page_data->window), "Win_Data"); #ifdef SAFEMODE if (win_data==NULL) return; #endif // g_debug("Get win_data = %d when reset vte size!", win_data); switch (type) { case RESET_CURRENT_TAB_FONT: // We need to apply a new font to a single vte. // so that we should insure that this won't change the size of window. // g_debug("Trying to apply font %s to vte", current_font_name); vte_terminal_set_font_from_string_full( VTE_TERMINAL(vte), new_font_name, win_data->font_anti_alias); // g_debug("reset_vte_size(): call window_resizable() with run_once = %d", win_data->update_hints); // g_debug("reset_vte_size(): launch update_window_hint()!"); update_window_hint(win_data, page_data); break; case RESET_ALL_TO_CURRENT_TAB: // increase/decrease window size & font size for every vte // g_debug("Trying to apply font %s to every vte", current_font_name); // struct Page *page_data = (struct Page *)g_object_get_data(G_OBJECT(current_vte), "Page_Data"); apply_font_to_every_vte( page_data->window, new_font_name, vte_terminal_get_column_count(VTE_TERMINAL(win_data->current_vte)), vte_terminal_get_row_count(VTE_TERMINAL(win_data->current_vte))); break; case RESET_ALL_TO_DEFAULT: // reset window size & font size for every vte // g_debug("Trying to apply font %s to every vte", current_font_name); apply_font_to_every_vte(page_data->window, new_font_name, win_data->default_column, win_data->default_row); break; case RESET_ALL_TO_SYSTEM: // reset window size & font size for every vte // g_debug("Trying to apply font %s to every vte", current_font_name); apply_font_to_every_vte(page_data->window, new_font_name, SYSTEM_COLUMN, SYSTEM_ROW); break; default: #ifdef FATAL print_switch_out_of_range_error_dialog("reset_vte_size", "type", type); #endif break; } }
static VALUE rg_column_count(VALUE self) { return LONG2NUM(vte_terminal_get_column_count(_SELF(self))); }
static VALUE term_get_column_count(VALUE self) { return LONG2NUM(vte_terminal_get_column_count(RVAL2TERM(self))); }