void switch_vte(){
if (c > 1){
vte_terminal_set_size(VTE_TERMINAL(st-> vte), 80, 5);
st = st -> next;
vte_terminal_set_size(VTE_TERMINAL(st-> vte), 80, 20);
}
}
static void
ide_terminal_size_allocate (GtkWidget *widget,
GtkAllocation *alloc)
{
IdeTerminal *self = (IdeTerminal *)widget;
glong width;
glong height;
glong columns;
glong rows;
GTK_WIDGET_CLASS (ide_terminal_parent_class)->size_allocate (widget, alloc);
if ((alloc->width == 0) || (alloc->height == 0))
return;
width = vte_terminal_get_char_width (VTE_TERMINAL (self));
height = vte_terminal_get_char_height (VTE_TERMINAL (self));
if ((width == 0) || (height == 0))
return;
columns = alloc->width / width;
rows = alloc->height / height;
if ((columns < 2) || (rows < 2))
return;
vte_terminal_set_size (VTE_TERMINAL (self), columns, rows);
}
static void
size_allocate_cb (VteTerminal *terminal,
GtkAllocation *alloc,
GbTerminalView *self)
{
glong width;
glong height;
glong columns;
glong rows;
g_assert (VTE_IS_TERMINAL (terminal));
g_assert (alloc != NULL);
g_assert (GB_IS_TERMINAL_VIEW (self));
if ((alloc->width == 0) || (alloc->height == 0))
return;
width = vte_terminal_get_char_width (terminal);
height = vte_terminal_get_char_height (terminal);
if ((width == 0) || (height == 0))
return;
columns = alloc->width / width;
rows = alloc->height / height;
if ((columns < 2) || (rows < 2))
return;
vte_terminal_set_size (terminal, columns, rows);
}
static GtkWidget *
create_terminal (TerminalPlugin *term_plugin)
{
GtkWidget *term;
/* Create new terminal. */
term = vte_terminal_new ();
gtk_widget_set_size_request (GTK_WIDGET (term), 10, 10);
vte_terminal_set_size (VTE_TERMINAL (term), 50, 1);
g_signal_connect (G_OBJECT (term), "focus-in-event",
G_CALLBACK (terminal_focus_cb), term_plugin);
g_signal_connect (G_OBJECT (term), "button-press-event",
G_CALLBACK (terminal_click_cb), term_plugin);
#if OLD_VTE == 1
g_signal_connect (G_OBJECT (term), "realize",
G_CALLBACK (terminal_realize_cb), term_plugin);
g_signal_connect (G_OBJECT (term), "unrealize",
G_CALLBACK (terminal_unrealize_cb), term_plugin);
#endif
return term;
}
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 remove_vte(){
if (c > 1){
if(list == st) list = list -> prev;
gtk_container_remove (GTK_CONTAINER (box_vte), st -> vte);
struct v *r = st;
st = st -> next;
st -> prev = (st -> prev) -> prev;
(st -> prev) -> next = st;
vte_terminal_set_size(VTE_TERMINAL(st-> vte), 80, 20);
c--;
gtk_window_resize (GTK_WINDOW(window_main), 20, 20);
free(r);
}
}
void add_vte(){
struct v *temp = (struct v *)malloc(sizeof(struct v));
temp-> vte = vte_terminal_new();
vte_terminal_fork_command(VTE_TERMINAL(temp-> vte), "bash"
, NULL, NULL, ".", FALSE, FALSE, FALSE);
vte_terminal_set_size(VTE_TERMINAL(temp-> vte), 80, 5);
gtk_box_pack_start (GTK_BOX (box_vte), temp-> vte, FALSE, TRUE, 5);
gtk_widget_show (temp-> vte);
set_data(temp);
temp -> next = list -> next;
(list -> next) -> prev = temp;
list -> next = temp;
temp -> prev = list;
list = list -> next;
c++;
}
static void
mud_subwindow_constructed(GObject *object)
{
MudSubwindow *self = MUD_SUBWINDOW(object);
mud_subwindow_reread_profile(self);
vte_terminal_set_size(VTE_TERMINAL(self->priv->terminal),
self->priv->initial_width,
self->priv->initial_height);
mud_subwindow_set_size_force_grid(self,
VTE_TERMINAL(self->priv->terminal),
TRUE,
self->priv->initial_width,
self->priv->initial_height);
g_signal_connect(self->priv->window,
"delete-event",
G_CALLBACK(mud_subwindow_delete_event_cb),
self);
g_signal_connect(self->priv->window,
"configure-event",
G_CALLBACK(mud_subwindow_configure_event_cb),
self);
g_signal_connect(self->priv->window,
"size-allocate",
G_CALLBACK(mud_subwindow_size_allocate_cb),
self);
g_signal_connect(self->priv->entry,
"key_press_event",
G_CALLBACK(mud_subwindow_entry_keypress_cb),
self);
g_signal_connect(self->priv->terminal,
"focus-in-event",
G_CALLBACK(mud_subwindow_focus_in_cb),
self);
}
/* Public Methods */
void
mud_subwindow_set_size(MudSubwindow *self,
guint width,
guint height)
{
g_return_if_fail(MUD_IS_SUBWINDOW(self));
self->priv->width = width;
self->priv->height = height;
vte_terminal_set_size(VTE_TERMINAL(self->priv->terminal),
self->priv->width,
self->priv->height);
mud_subwindow_set_size_force_grid(self,
VTE_TERMINAL(self->priv->terminal),
TRUE,
self->priv->width,
self->priv->height);
}
void
term_set_size(GtkWidget *win, VteTerminal *term, glong width, glong height)
{
GtkRequisition natural;
/* This resizes the window to the exact size of the child widget.
* This works even if the child uses padding or other cosmetic
* attributes, and we don't need to know anything about it. */
if (width > 0 && height > 0)
{
vte_terminal_set_size(term, width, height);
/* win might be NULL when called from term_set_font(). */
if (win != NULL)
{
gtk_widget_get_preferred_size(GTK_WIDGET(term), NULL, &natural);
gtk_window_resize(GTK_WINDOW(win), natural.width, natural.height);
}
}
}
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 int window_create_show()
{
char *tmp;
// window
m_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
tmp = get_res_path(ICON_APP);
gtk_window_set_icon_from_file(GTK_WINDOW(m_window), tmp, NULL);
free(tmp);
gtk_window_set_title(GTK_WINDOW(m_window), "jnXssh");
gtk_window_maximize(GTK_WINDOW(m_window));
gtk_widget_set_events(m_window, GDK_BUTTON_PRESS_MASK|GDK_KEY_PRESS_MASK);
g_signal_connect(G_OBJECT(m_window), "key-press-event", G_CALLBACK(on_window_key_press), NULL);
g_signal_connect(G_OBJECT(m_window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
// vbox
GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(m_window), vbox);
// notebook
GtkWidget *notebook = page_get_notebook();
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
// pty + vte
GtkWidget *vte = vte_terminal_new();
gtk_box_pack_start(GTK_BOX(vbox), vte, FALSE, FALSE, 1);
vte_terminal_set_size((VteTerminal*)vte, 1, 1);
VtePty *pty = vte_pty_new(VTE_PTY_DEFAULT, NULL);
vte_terminal_set_pty_object((VteTerminal*)vte, pty);
pthread_t tid;
pthread_create(&tid, NULL, proc_allvte, pty);
gtk_widget_show_all(m_window);
return 0;
}
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
#ifdef USE_GTK3_GEOMETRY_METHOD
save_current_vte_geometry(win_data, page_data->vte);
#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);
#ifdef USE_GTK3_GEOMETRY_METHOD
page_data->column = column;
page_data->row = row;
# ifdef GEOMETRY
g_debug("@ apply_font_to_every_vte (for %p): Trying set the geometry to %ld x %ld",
window, column, row);
# endif
#endif
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 FALSE!");
win_data->update_hints = 1;
// 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()!");
#ifdef USE_GTK2_GEOMETRY_METHOD
# ifdef GEOMETRY
g_debug("@ apply_font_to_every_vte(): Call keep_gtk2_window_size() with win_data->unfullscreen = %d",
win_data->unfullscreen);
# endif
// Don't need to call keep_gtk2_window_size() when fullscreen
switch (win_data->unfullscreen)
{
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);
break;
default:
break;
}
#endif
#ifdef USE_GTK3_GEOMETRY_METHOD
win_data->keep_vte_size += 2;
# ifdef GEOMETRY
g_debug("@ apply_font_to_every_vte(for %p): Set win_data->keep_vte_size to %d",
win_data->window, win_data->keep_vte_size);
# endif
#endif
}
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;
}
static VALUE
rg_set_size(VALUE self, VALUE columns, VALUE rows)
{
vte_terminal_set_size(_SELF(self), NUM2LONG(columns), NUM2LONG(rows));
return self;
}
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);
fake_vte_terminal_set_font_from_string( 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()!");
#ifdef USE_GTK2_GEOMETRY_METHOD
// Don't need to call keep_gtk2_window_size() when fullscreen
switch (win_data->window_status)
{
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 = 0x%X",
win_data->keep_vte_size);
# endif
keep_gtk2_window_size (win_data, page_data->vte, GEOMETRY_CHANGING_FONT);
break;
default:
break;
}
#endif
}
static VALUE
term_set_size(VALUE self, VALUE columns, VALUE rows)
{
vte_terminal_set_size(RVAL2TERM(self), NUM2LONG(columns), NUM2LONG(rows));
return Qnil;
}
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;
}
}
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;
}
/*
* 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);
}
// 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);
}
