void apply_font_to_every_vte(GtkWidget *window, gchar *new_font_name, glong column, glong row)
{
#ifdef DETAIL
g_debug("! Launch apply_font_to_every_vte() with window = %p, new_font_name = %s,"
" column = %ld, row = %ld", window, new_font_name, column, row);
#endif
#ifdef SAFEMODE
if ((window==NULL) || (new_font_name==NULL) || (column<1) || (row<1)) return;
#endif
struct Window *win_data = (struct Window *)g_object_get_data(G_OBJECT(window), "Win_Data");
// g_debug("Get win_data = %d when apply font to every vte!", win_data);
#ifdef SAFEMODE
if (win_data==NULL) return;
#endif
struct Page *page_data = NULL;
gint i;
// g_debug("Trying to apply every vte to %dx%d!", column, row);
// g_debug("Trying to apply font %s to every vte!", new_font_name);
for (i=0; i<gtk_notebook_get_n_pages(GTK_NOTEBOOK(win_data->notebook)); i++)
{
page_data = get_page_data_from_nth_page(win_data, i);
#ifdef SAFEMODE
if (page_data==NULL) continue;
#endif
// g_debug("The default font for %d page is: %s (%s)", i, page_data->font_name, new_font_name);
vte_terminal_set_font_from_string_full(VTE_TERMINAL(page_data->vte),
new_font_name,
win_data->font_anti_alias);
vte_terminal_set_size(VTE_TERMINAL(page_data->vte), column, row);
g_free(page_data->font_name);
page_data->font_name = g_strdup(new_font_name);
// g_debug("The new font for %d page is: %s (%s)", i, page_data->font_name, new_font_name);
}
// g_debug("* Set hints to HINTS_FONT_BASE!, win_data->window_status = %d", win_data->window_status);
win_data->hints_type = HINTS_FONT_BASE;
// win_data->keep_vte_size |= 0x30;
// g_debug("window_resizable in apply_font_to_every_vte!");
// window_resizable(window, page_data->vte, 2, 1);
// g_debug("apply_font_to_every_vte(): launch keep_window_size()!");
// Don't need to call keep_gtk2_window_size() when fullscreen
switch (win_data->window_status)
{
#ifdef USE_GTK2_GEOMETRY_METHOD
case FULLSCREEN_NORMAL:
case FULLSCREEN_UNFS_OK:
# ifdef GEOMETRY
g_debug("@ apply_font_to_every_vte(): Call keep_gtk2_window_size() with keep_vte_size = %x",
win_data->keep_vte_size);
# endif
keep_gtk2_window_size (win_data, page_data->vte, 0x380);
#endif
#ifdef USE_GTK3_GEOMETRY_METHOD
case WINDOW_NORMAL:
case WINDOW_APPLY_PROFILE_NORMAL:
# ifdef GEOMETRY
fprintf(stderr, "\033[1;%dm!! apply_font_to_every_vte(win_data %p): Calling keep_gtk3_window_size() with hints_type = %d\n",
ANSI_COLOR_MAGENTA, win_data, win_data->hints_type);
# endif
window_resizable(win_data->window, win_data->current_vte, win_data->hints_type);
if (win_data->window_status==WINDOW_NORMAL)
win_data->resize_type = GEOMETRY_AUTOMATIC;
else
win_data->resize_type = GEOMETRY_CUSTOM;
win_data->geometry_width = column;
win_data->geometry_height = row;
keep_gtk3_window_size(win_data, TRUE);
#endif
break;
default:
break;
}
}
/*
* init debug related GUI (watch tree view)
* arguments:
*/
void debug_init()
{
/* create watch page */
wtree = wtree_init(on_watch_expanded_callback,
on_watch_dragged_callback,
on_watch_key_pressed_callback,
on_watch_changed,
on_watch_button_pressed_callback);
wmodel = gtk_tree_view_get_model(GTK_TREE_VIEW(wtree));
wstore = GTK_TREE_STORE(wmodel);
tab_watch = gtk_scrolled_window_new(
gtk_tree_view_get_hadjustment(GTK_TREE_VIEW(wtree)),
gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(wtree))
);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab_watch),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(tab_watch), wtree);
/* create autos page */
atree = atree_init(on_watch_expanded_callback, on_watch_button_pressed_callback);
tab_autos = gtk_scrolled_window_new(
gtk_tree_view_get_hadjustment(GTK_TREE_VIEW(atree)),
gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(atree))
);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab_autos),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(tab_autos), atree);
/* create stack trace page */
stree = stree_init(editor_open_position, on_select_frame);
tab_call_stack = gtk_scrolled_window_new(
gtk_tree_view_get_hadjustment(GTK_TREE_VIEW(stree )),
gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(stree ))
);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab_call_stack),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(tab_call_stack), stree);
/* create debug terminal page */
terminal = vte_terminal_new();
/* create PTY */
openpty(&pty_master, &pty_slave, NULL,
NULL,
NULL);
grantpt(pty_master);
unlockpt(pty_master);
vte_terminal_set_pty(VTE_TERMINAL(terminal), pty_master);
GtkWidget *scrollbar = gtk_vscrollbar_new(GTK_ADJUSTMENT(VTE_TERMINAL(terminal)->adjustment));
GTK_WIDGET_UNSET_FLAGS(scrollbar, GTK_CAN_FOCUS);
tab_terminal = gtk_frame_new(NULL);
gtk_frame_set_shadow_type (GTK_FRAME(tab_terminal), GTK_SHADOW_NONE);
GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(tab_terminal), hbox);
gtk_box_pack_start(GTK_BOX(hbox), terminal, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, FALSE, 0);
/* set the default widget size first to prevent VTE expanding too much,
* sometimes causing the hscrollbar to be too big or out of view. */
gtk_widget_set_size_request(GTK_WIDGET(terminal), 10, 10);
vte_terminal_set_size(VTE_TERMINAL(terminal), 30, 1);
/* set terminal font. */
GKeyFile *config = g_key_file_new();
gchar *configfile = g_strconcat(geany_data->app->configdir, G_DIR_SEPARATOR_S, "geany.conf", NULL);
g_key_file_load_from_file(config, configfile, G_KEY_FILE_NONE, NULL);
gchar *font = utils_get_setting_string(config, "VTE", "font", "Monospace 10");
vte_terminal_set_font_from_string (VTE_TERMINAL(terminal), font);
/* debug messages page */
tab_messages = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab_messages),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
hadj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(tab_messages));
vadj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(tab_messages));
debugger_messages_textview = gtk_text_view_new();
gtk_text_view_set_editable (GTK_TEXT_VIEW (debugger_messages_textview), FALSE);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(tab_messages), debugger_messages_textview);
/* create tex tags */
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(debugger_messages_textview));
gtk_text_buffer_create_tag(buffer, "black", "foreground", "#000000", NULL);
gtk_text_buffer_create_tag(buffer, "grey", "foreground", "#AAAAAA", NULL);
gtk_text_buffer_create_tag(buffer, "red", "foreground", "#FF0000", NULL);
gtk_text_buffer_create_tag(buffer, "green", "foreground", "#00FF00", NULL);
gtk_text_buffer_create_tag(buffer, "blue", "foreground", "#0000FF", NULL);
gtk_text_buffer_create_tag(buffer, "yellow", "foreground", "#FFFF00", NULL);
gtk_text_buffer_create_tag(buffer, "brown", "foreground", "#BB8915", NULL);
gtk_text_buffer_create_tag(buffer, "rose", "foreground", "#BA92B7", NULL);
}
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->hints_type);
// g_debug("reset_vte_size(): launch update_window_hint()!");
# ifdef GEOMETRY
fprintf(stderr, "\033[1;37m!! reset_vte_size(): call update_window_hint()\033[0m\n");
# endif
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");
#ifdef USE_GTK2_GEOMETRY_METHOD
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)));
#endif
#ifdef USE_GTK3_GEOMETRY_METHOD
apply_font_to_every_vte( page_data->window, new_font_name, win_data->geometry_width, win_data->geometry_height);
#endif
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;
}
}
/*
* called when debugger exits
*/
static void on_debugger_exited (int code)
{
/* remove marker for current instruction if was set */
if (stack)
{
remove_stack_markers();
g_list_foreach(stack, (GFunc)frame_free, NULL);
g_list_free(stack);
stack = NULL;
}
/* clear watch page */
clear_watch_values(GTK_TREE_VIEW(wtree));
/* clear autos page */
gtk_tree_store_clear(GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(atree))));
/* clear stack trace tree */
stree_clear();
/* clear debug terminal */
vte_terminal_reset(VTE_TERMINAL(terminal), TRUE, TRUE);
/* clear debug messages window */
GtkTextIter start, end;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(debugger_messages_textview));
gtk_text_buffer_get_bounds(buffer, &start, &end);
gtk_text_buffer_delete(buffer, &start, &end);
/* enable target page */
tpage_set_readonly(FALSE);
/* remove breaks readonly if current module doesn't support run-time breaks operation */
if (!(active_module->features & MF_ASYNC_BREAKS))
bptree_set_readonly(FALSE);
/* set files that was readonly during debug writable */
GList *iter = read_only_pages;
while (iter)
{
GeanyDocument *doc = document_find_by_real_path((const gchar*)iter->data);
if (doc)
scintilla_send_message(doc->editor->sci, SCI_SETREADONLY, 0, 0);
/* free file name */
g_free(iter->data);
iter = iter->next;
}
g_list_free(read_only_pages);
read_only_pages = NULL;
/* clear and destroy calltips cache */
g_hash_table_destroy(calltips);
calltips = NULL;
/* enable widgets */
enable_sensitive_widgets(TRUE);
/* update buttons panel state */
btnpanel_set_debug_state(DBS_IDLE);
/* update debug state */
debug_state = DBS_IDLE;
}
void set_data(struct v *p){
vte_terminal_set_color_background(VTE_TERMINAL(p-> vte), &bcolor);
vte_terminal_set_color_foreground(VTE_TERMINAL(p-> vte), &fcolor);
}
int main(int argc, char **argv){
GtkWidget *box_buttons;
GtkWidget* button_new;
GtkWidget* button_rem;
GtkWidget* button_switch;
GtkWidget* button_settings;
gtk_init(&argc, &argv);
window_main = gtk_window_new(GTK_WINDOW_TOPLEVEL);
box_main = gtk_vbox_new (FALSE, 0);
box_buttons = gtk_hbox_new (FALSE, 0);
box_vte = gtk_vbox_new (FALSE, 0);
button_new = gtk_button_new_with_label ("new terminal");
button_rem = gtk_button_new_with_label ("remove terminal");
button_switch = gtk_button_new_with_label ("switch >>");
button_settings = gtk_button_new_with_label ("settings");
list = (struct v*)malloc(sizeof(struct v));
list -> next = list;
list -> prev = list;
st = list;
st -> vte = vte_terminal_new();
vte_terminal_fork_command(VTE_TERMINAL(st -> vte), "bash",
NULL, NULL, ".", FALSE, FALSE, FALSE);
vte_terminal_set_size(VTE_TERMINAL(st -> vte), 80,20);
gtk_signal_connect (GTK_OBJECT (button_new), "clicked",
GTK_SIGNAL_FUNC (add_vte), NULL);
gtk_box_pack_start (GTK_BOX (box_buttons), button_new, TRUE, FALSE, 5);
gtk_widget_show (button_new);
gtk_signal_connect (GTK_OBJECT (button_rem), "clicked",
GTK_SIGNAL_FUNC (remove_vte), NULL);
gtk_box_pack_start (GTK_BOX (box_buttons), button_rem, TRUE, FALSE, 5);
gtk_widget_show (button_rem);
gtk_signal_connect (GTK_OBJECT (button_switch), "clicked",
GTK_SIGNAL_FUNC (switch_vte), NULL);
gtk_box_pack_start (GTK_BOX (box_buttons), button_switch, TRUE, FALSE, 5);
gtk_widget_show (button_switch);
gtk_signal_connect (GTK_OBJECT (button_settings), "clicked",
GTK_SIGNAL_FUNC (settings), NULL);
gtk_box_pack_start (GTK_BOX (box_buttons), button_settings, TRUE, FALSE, 5);
gtk_widget_show (button_settings);
gtk_box_pack_start (GTK_BOX (box_vte), st -> vte, FALSE, TRUE, 5);
gtk_widget_show (st -> vte);
gtk_box_pack_start(GTK_BOX (box_main), box_buttons, FALSE, TRUE, 5);
gtk_box_pack_start(GTK_BOX (box_main), box_vte, FALSE, TRUE, 5);
gtk_container_add(GTK_CONTAINER (window_main), box_main);
gtk_widget_show(box_main);
gtk_widget_show(box_buttons);
gtk_widget_show(box_vte);
gtk_widget_show(window_main);
read_config();
gtk_main();
return 0;
}
void vte_select_all(void)
{
if (vf->vte_terminal_select_all != NULL)
vf->vte_terminal_select_all(VTE_TERMINAL(vc->vte));
}
static GObject *
mud_subwindow_constructor (GType gtype,
guint n_properties,
GObjectConstructParam *properties)
{
GtkWidget *term_box;
MudWindow *app;
GtkWidget *main_window;
MudSubwindow *self;
GObject *obj;
MudSubwindowClass *klass;
GObjectClass *parent_class;
GtkBuilder *builder;
/* Chain up to parent constructor */
klass = MUD_SUBWINDOW_CLASS( g_type_class_peek(MUD_TYPE_SUBWINDOW) );
parent_class = G_OBJECT_CLASS( g_type_class_peek_parent(klass) );
obj = parent_class->constructor(gtype, n_properties, properties);
self = MUD_SUBWINDOW(obj);
if(!self->priv->parent_view)
{
g_printf("ERROR: Tried to instantiate MudSubwindow without passing parent view\n");
g_error("Tried to instantiate MudSubwindow without passing parent view");
}
if(!self->priv->title)
{
g_printf("ERROR: Tried to instantiate MudSubwindow without passing title\n");
g_error("Tried to instantiate MudSubwindow without passing title.");
}
if(!self->priv->identifier)
{
g_printf("ERROR: Tried to instantiate MudSubwindow without passing identifier\n");
g_error("Tried to instantiate MudSubwindow without passing identifier.");
}
if(self->priv->width == 0 || self->priv->height == 0)
{
g_printf("ERROR: Tried to instantiate MudSubwindow without passing valid width/height\n");
g_error("Tried to instantiate MudSubwindow without passing valid width/height.");
}
self->priv->old_width = self->priv->width;
self->priv->old_height = self->priv->height;
self->priv->initial_width = self->priv->width;
self->priv->initial_height = self->priv->height;
/* start glading */
builder = gtk_builder_new_from_resource ("/org/gnome/MUD/main.ui");
self->priv->window = GTK_WIDGET(gtk_builder_get_object(builder, "subwindow"));
g_object_unref(builder);
gtk_window_set_type_hint(GTK_WINDOW(self->priv->window),
GDK_WINDOW_TYPE_HINT_UTILITY);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(self->priv->window), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(self->priv->window), TRUE);
g_object_get(self->priv->parent_view, "window", &app, NULL);
g_object_get(app, "window", &main_window, NULL);
gtk_window_set_transient_for(GTK_WINDOW(self->priv->window),
GTK_WINDOW(main_window));
self->priv->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
self->priv->entry = gtk_entry_new();
gtk_widget_hide(self->priv->entry);
self->priv->terminal = vte_terminal_new();
self->priv->scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (self->priv->terminal)));
term_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
vte_terminal_set_encoding(VTE_TERMINAL(self->priv->terminal),
"ISO-8859-1", NULL); /* TODO: This is deprecated; if keeping, at least add error handling? */
/* TODO: set_emulation doesn't exist anymore. We don't really care, but does it affect TTYPE queries? */
/* vte_terminal_set_emulation(VTE_TERMINAL(self->priv->terminal), "xterm"); */
vte_terminal_set_cursor_shape(VTE_TERMINAL(self->priv->terminal),
VTE_CURSOR_SHAPE_UNDERLINE);
vte_terminal_set_cursor_blink_mode(VTE_TERMINAL(self->priv->terminal),
VTE_CURSOR_BLINK_OFF);
vte_terminal_set_size(VTE_TERMINAL(self->priv->terminal),
self->priv->initial_width,
self->priv->initial_height);
gtk_box_pack_start(GTK_BOX(term_box),
self->priv->terminal,
TRUE,
TRUE,
0);
gtk_box_pack_end(GTK_BOX(term_box),
self->priv->scrollbar,
FALSE,
FALSE,
0);
gtk_box_pack_start(GTK_BOX(self->priv->vbox), term_box, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(self->priv->vbox), self->priv->entry, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(self->priv->window), self->priv->vbox);
gtk_window_set_title(GTK_WINDOW(self->priv->window), self->priv->title);
gtk_widget_show(term_box);
gtk_widget_show(self->priv->vbox);
if(self->priv->scroll)
gtk_widget_show(self->priv->scrollbar);
gtk_widget_show(self->priv->terminal);
gtk_widget_show(self->priv->window);
gtk_window_get_size(GTK_WINDOW(self->priv->window),
&self->priv->pixel_width,
&self->priv->pixel_height);
return obj;
}
