/**** Vertical scrollbar constructor ****/ int clip_GTK_VSCROLLBARNEW(ClipMachine * ClipMachineMemory) { ClipVar *cv = _clip_spar(ClipMachineMemory, 1); C_widget *cadj = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2)); GtkAdjustment *adj; GtkWidget *wid = NULL; C_widget *cwid; CHECKOPT(1, MAP_type_of_ClipVarType); CHECKOPT2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType); CHECKCWIDOPT(cadj, GTK_IS_ADJUSTMENT); adj = cadj ? GTK_ADJUSTMENT(cadj->widget) : NULL; wid = gtk_vscrollbar_new(adj); if (!wid) goto err; cwid = _register_widget(ClipMachineMemory, wid, cv); _clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj); return 0; err: return 1; }
void pVerticalScroller::constructor() { gtkWidget = gtk_vscrollbar_new(0); g_signal_connect(G_OBJECT(gtkWidget), "value-changed", G_CALLBACK(VerticalScroller_change), (gpointer)&verticalScroller); setLength(verticalScroller.state.length); setPosition(verticalScroller.state.position); }
/* Create a scrolled text area that displays a "message" */ static GtkWidget *create_help_text (void) { GtkWidget *table; /* Create a table to hold the text widget and scrollbars */ table = gtk_table_new (1, 16, FALSE); /* Put a text widget in the upper left hand corner. Note the use of * GTK_SHRINK in the y direction */ text = gtk_text_new (NULL, NULL); gtk_table_attach (GTK_TABLE (table), text, 0, 14, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0); gtk_widget_set_usize(GTK_WIDGET(text), 100, 50); gtk_widget_show (text); /* And a VScrollbar in the upper right */ vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj); gtk_table_attach (GTK_TABLE (table), vscrollbar, 15, 16, 0, 1, GTK_FILL, GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0); gtk_widget_show (vscrollbar); /* Add a handler to put a message in the text widget when it is realized */ gtk_signal_connect (GTK_OBJECT (text), "realize", GTK_SIGNAL_FUNC (help_realize_text), NULL); gtk_text_set_word_wrap(GTK_TEXT(text), TRUE); return(table); }
void gScrollBar::resize(int w, int h) { GtkAdjustment* adj; GType type; gControl::resize(w, h); type = (w < h) ? GTK_TYPE_VSCROLLBAR : GTK_TYPE_HSCROLLBAR; if (type != G_OBJECT_TYPE(widget)) { adj = gtk_range_get_adjustment(GTK_RANGE(widget)); g_object_ref(adj); g_object_ref(widget); gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(widget)), widget); gtk_widget_destroy(widget); g_object_unref(widget); if (type == GTK_TYPE_VSCROLLBAR) widget = gtk_vscrollbar_new(adj); else widget = gtk_hscrollbar_new(adj); gtk_container_add(GTK_CONTAINER(border), widget); gtk_widget_show(widget); widgetSignals(); g_signal_connect(G_OBJECT(widget), "value-changed", G_CALLBACK(cb_change), (gpointer)this); g_object_unref(adj); init(); } }
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 main(int argc, char *argv[]) { gtk_init(&argc, &argv); GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL); g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL); GtkWidget *table = gtk_table_new(2, 2, FALSE); gtk_container_add(GTK_CONTAINER(window), table); GtkWidget *layout = gtk_layout_new(NULL, NULL); gtk_layout_set_size(GTK_LAYOUT(layout), 2000, 800); gtk_table_attach(GTK_TABLE(table), layout, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); GtkAdjustment *vadjustment = gtk_layout_get_vadjustment(GTK_LAYOUT(layout)); GtkAdjustment *hadjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(layout)); GtkWidget *vscrollbar = gtk_vscrollbar_new(vadjustment); gtk_table_attach(GTK_TABLE(table), vscrollbar, 1, 2, 0, 1, GTK_SHRINK, GTK_FILL | GTK_EXPAND, 0, 0); GtkWidget *hscrollbar = gtk_hscrollbar_new(hadjustment); gtk_table_attach(GTK_TABLE(table), hscrollbar, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 0); gtk_widget_show_all(window); gtk_main(); return 0; }
Scrollbar::Scrollbar(bool horizontal) { XOJ_INIT_TYPE(Scrollbar); #ifdef ENABLE_OS if(horizontal) { this->scrollbar = os_scrollbar_new(GTK_ORIENTATION_HORIZONTAL, NULL); } else { this->scrollbar = os_scrollbar_new(GTK_ORIENTATION_VERTICAL, NULL); } #else if (horizontal) { this->scrollbar = gtk_hscrollbar_new(NULL); } else { this->scrollbar = gtk_vscrollbar_new(NULL); } #endif g_object_ref(this->scrollbar); this->listener = NULL; this->adj = gtk_range_get_adjustment(GTK_RANGE(this->scrollbar)); gtk_adjustment_set_step_increment(this->adj, 20); this->value = 50; this->setMax(100); this->setValue(this->value); g_signal_connect(this->adj, "value-changed", G_CALLBACK(scrolled), this); }
void test_scroll (void) { GtkScrollbar *scbar_v = (GtkScrollbar*) gtk_vscrollbar_new (NULL); uzbl.gui.bar_v = gtk_range_get_adjustment((GtkRange*) scbar_v); gtk_adjustment_set_lower(uzbl.gui.bar_v, 0); gtk_adjustment_set_upper(uzbl.gui.bar_v, 100); gtk_adjustment_set_page_size(uzbl.gui.bar_v, 5); /* scroll vertical end should scroll it to upper - page_size */ parse_cmd_line("scroll vertical end", NULL); g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 95); /* scroll vertical begin should scroll it to lower */ parse_cmd_line("scroll vertical begin", NULL); g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 0); /* scroll vertical can scroll by pixels */ parse_cmd_line("scroll vertical 15", NULL); g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 15); parse_cmd_line("scroll vertical -10", NULL); g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 5); /* scroll vertical can scroll by a percentage of the page size */ parse_cmd_line("scroll vertical 100%", NULL); g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 10); parse_cmd_line("scroll vertical 150%", NULL); g_assert_cmpfloat(gtk_adjustment_get_value(uzbl.gui.bar_v), ==, 17.5); /* scroll_horz behaves basically the same way. */ }
void pHexEdit::constructor() { gtkWidget = gtk_hbox_new(false, 0); container = gtk_scrolled_window_new(0, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(container), GTK_POLICY_NEVER, GTK_POLICY_NEVER); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(container), GTK_SHADOW_ETCHED_IN); subWidget = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(subWidget), false); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(subWidget), GTK_WRAP_NONE); gtk_container_add(GTK_CONTAINER(container), subWidget); g_signal_connect(G_OBJECT(subWidget), "key-press-event", G_CALLBACK(HexEdit_keyPress), (gpointer)&hexEdit); scrollBar = gtk_vscrollbar_new((GtkAdjustment*)0); gtk_range_set_range(GTK_RANGE(scrollBar), 0, 255); gtk_range_set_increments(GTK_RANGE(scrollBar), 1, 16); gtk_widget_set_sensitive(scrollBar, false); g_signal_connect(G_OBJECT(scrollBar), "change-value", G_CALLBACK(HexEdit_scroll), (gpointer)&hexEdit); gtk_box_pack_start(GTK_BOX(gtkWidget), container, true, true, 0); gtk_box_pack_start(GTK_BOX(gtkWidget), scrollBar, false, false, 1); textBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(subWidget)); textCursor = gtk_text_buffer_get_mark(textBuffer, "insert"); gtk_widget_show(scrollBar); gtk_widget_show(subWidget); gtk_widget_show(container); }
static int create_disassembly( GtkBox *parent, gtkui_font font ) { size_t i; GtkWidget *scrollbar; gchar *disassembly_titles[] = { "Address", "Instruction" }; /* A box to hold the disassembly listing and the scrollbar */ disassembly_box = gtk_hbox_new( FALSE, 0 ); gtk_box_pack_start_defaults( parent, disassembly_box ); /* The disassembly CList itself */ disassembly = gtk_clist_new_with_titles( 2, disassembly_titles ); gtkui_set_font( disassembly, font ); gtk_clist_column_titles_passive( GTK_CLIST( disassembly ) ); for( i = 0; i < 2; i++ ) gtk_clist_set_column_auto_resize( GTK_CLIST( disassembly ), i, TRUE ); gtk_box_pack_start_defaults( GTK_BOX( disassembly_box ), disassembly ); /* The disassembly scrollbar */ disassembly_scrollbar_adjustment = gtk_adjustment_new( 0, 0x0000, 0xffff, 0.5, 20, 20 ); gtk_signal_connect( GTK_OBJECT( disassembly_scrollbar_adjustment ), "value-changed", GTK_SIGNAL_FUNC( move_disassembly ), NULL ); scrollbar = gtk_vscrollbar_new( GTK_ADJUSTMENT( disassembly_scrollbar_adjustment ) ); gtk_box_pack_start( GTK_BOX( disassembly_box ), scrollbar, FALSE, FALSE, 0 ); gtkui_scroll_connect( GTK_CLIST( disassembly ), GTK_ADJUSTMENT( disassembly_scrollbar_adjustment ) ); return 0; }
static void _ddisplay_setup_scrollbars (DDisplay *ddisp, GtkWidget *table, int width, int height) { /* The adjustment datums */ ddisp->hsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, width, 1, (width-1)/4, width-1)); ddisp->vsbdata = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, height, 1, (height-1)/4, height-1)); ddisp->hsb = gtk_hscrollbar_new (ddisp->hsbdata); #if GTK_CHECK_VERSION(2,18,0) gtk_widget_set_can_focus (ddisp->hsb, FALSE); #else GTK_WIDGET_UNSET_FLAGS (ddisp->hsb, GTK_CAN_FOCUS); #endif ddisp->vsb = gtk_vscrollbar_new (ddisp->vsbdata); #if GTK_CHECK_VERSION(2,18,0) gtk_widget_set_can_focus (ddisp->vsb, FALSE); #else GTK_WIDGET_UNSET_FLAGS (ddisp->vsb, GTK_CAN_FOCUS); #endif /* set up the scrollbar observers */ g_signal_connect (G_OBJECT (ddisp->hsbdata), "value_changed", G_CALLBACK(ddisplay_hsb_update), ddisp); g_signal_connect (G_OBJECT (ddisp->vsbdata), "value_changed", G_CALLBACK(ddisplay_vsb_update), ddisp); /* harder to change position in the table, but we did not do it for years ;) */ gtk_table_attach (GTK_TABLE (table), ddisp->hsb, 0, 2, 2, 3, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach (GTK_TABLE (table), ddisp->vsb, 2, 3, 0, 2, GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (ddisp->hsb); gtk_widget_show (ddisp->vsb); }
GtkWidget * gtk_scrollbar_new( GtkOrientation orientation, GtkAdjustment *adjustment ) { return ( orientation == GTK_ORIENTATION_HORIZONTAL )? gtk_hscrollbar_new( adjustment ) : gtk_vscrollbar_new( adjustment ); }
static void populate_table (widget_data_t *data) { GtkWidget *table = data->widget; GtkWidget *drawing_area, *w; drawing_area = gtk_drawing_area_new(); gtk_widget_show(drawing_area); data->drawing_area = drawing_area; gtk_table_attach (GTK_TABLE (table), drawing_area, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0); data->hadjustment = GTK_ADJUSTMENT(gtk_adjustment_new (0.0, 0.0, 100.0, 10.0, 100.0, 100.0)); w = gtk_hscrollbar_new (data->hadjustment); gtk_table_attach (GTK_TABLE (table), w, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL, 0, 0); gtk_widget_show (w); data->hscrollbar = w; data->vadjustment = GTK_ADJUSTMENT(gtk_adjustment_new (0.0, 0.0, 100.0, 10.0, 100.0, 100.0)); w = gtk_vscrollbar_new (data->vadjustment); gtk_table_attach (GTK_TABLE (table), w, 1, 2, 0, 1, GTK_FILL, GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0); gtk_widget_show (w); data->vscrollbar = w; gtk_signal_connect(GTK_OBJECT(drawing_area), "expose_event", (GtkSignalFunc)expose_event, NULL); gtk_signal_connect(GTK_OBJECT(drawing_area), "motion_notify_event", (GtkSignalFunc)motion_notify_event, NULL); gtk_signal_connect(GTK_OBJECT(drawing_area), "button_press_event", (GtkSignalFunc)button_press_event, NULL); gtk_signal_connect(GTK_OBJECT(drawing_area), "button_release_event", (GtkSignalFunc)button_release_event, NULL); gtk_widget_set_events(drawing_area, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); gtk_signal_connect(GTK_OBJECT(data->hadjustment), "value-changed", (GtkSignalFunc)adjustment_value_changed, data); gtk_signal_connect(GTK_OBJECT(data->vadjustment), "value-changed", (GtkSignalFunc)adjustment_value_changed, data); gtk_signal_connect(GTK_OBJECT(data->hadjustment), "changed", (GtkSignalFunc)adjustment_changed, data); gtk_signal_connect(GTK_OBJECT(data->vadjustment), "changed", (GtkSignalFunc)adjustment_changed, data); gtk_signal_connect(GTK_OBJECT(data->drawing_area), "size-allocate", (GtkSignalFunc)size_changed, data); }
GtkWidget* RenderThemeGtk::gtkVScrollbar() const { if (m_gtkVScrollbar) return m_gtkVScrollbar; m_gtkVScrollbar = gtk_vscrollbar_new(0); setupWidgetAndAddToContainer(m_gtkVScrollbar, gtkContainer()); return m_gtkVScrollbar; }
int main( int argc,char *argv[] ) { GtkWidget *window; GtkWidget *vbox; GtkWidget *entry; GtkWidget *vscrollbar; GtkWidget *text; GtkWidget *table; GtkWidget *check; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Demo_Entry_Text"); g_signal_connect (G_OBJECT (window), "destroy",G_CALLBACK (gtk_main_quit), NULL); g_signal_connect_swapped (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_widget_destroy), G_OBJECT (window)); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); entry = gtk_entry_new (); gtk_entry_set_max_length (GTK_ENTRY (entry), 30); gtk_entry_set_text(GTK_ENTRY (entry), "hello"); gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0); check = gtk_check_button_new_with_label ("Visible"); gtk_box_pack_start (GTK_BOX (vbox), check, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (check), "toggled", G_CALLBACK (entry_toggle_visibility), (gpointer) entry); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE); table = gtk_table_new (2, 2, FALSE); gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0); text = gtk_text_new (NULL, NULL); gtk_text_set_editable (GTK_TEXT (text), TRUE); gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj); gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1, GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0); check = gtk_check_button_new_with_label ("Editable"); gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (check), "toggled", G_CALLBACK (text_toggle_editable), text); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE); gtk_widget_show_all(window); gtk_main(); return 0; }
void open_rawlog (struct server *serv) { GtkWidget *hbox, *vscrollbar, *vbox; char tbuf[256]; if (serv->gui->rawlog_window) { mg_bring_tofront (serv->gui->rawlog_window); return; } snprintf (tbuf, sizeof tbuf, _(DISPLAY_NAME": Raw Log (%s)"), serv->servername); serv->gui->rawlog_window = mg_create_generic_tab ("RawLog", tbuf, FALSE, TRUE, close_rawlog, serv, 640, 320, &vbox, serv); gtkutil_destroy_on_esc (serv->gui->rawlog_window); hbox = gtk_hbox_new (FALSE, 2); gtk_container_add (GTK_CONTAINER (vbox), hbox); gtk_container_set_border_width (GTK_CONTAINER (hbox), 4); gtk_widget_show (hbox); serv->gui->rawlog_textlist = gtk_xtext_new (colors, 0); gtk_xtext_set_tint (GTK_XTEXT (serv->gui->rawlog_textlist), prefs.hex_text_tint_red, prefs.hex_text_tint_green, prefs.hex_text_tint_blue); gtk_xtext_set_background (GTK_XTEXT (serv->gui->rawlog_textlist), channelwin_pix, prefs.hex_text_transparent); gtk_container_add (GTK_CONTAINER (hbox), serv->gui->rawlog_textlist); gtk_xtext_set_font (GTK_XTEXT (serv->gui->rawlog_textlist), prefs.hex_text_font); GTK_XTEXT (serv->gui->rawlog_textlist)->ignore_hidden = 1; gtk_widget_show (serv->gui->rawlog_textlist); vscrollbar = gtk_vscrollbar_new (GTK_XTEXT (serv->gui->rawlog_textlist)->adj); gtk_box_pack_start (GTK_BOX (hbox), vscrollbar, FALSE, FALSE, 0); show_and_unfocus (vscrollbar); hbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_SPREAD); gtk_box_pack_end (GTK_BOX (vbox), hbox, 0, 0, 0); gtk_widget_show (hbox); gtkutil_button (hbox, GTK_STOCK_CLEAR, NULL, rawlog_clearbutton, serv, _("Clear Raw Log")); gtkutil_button (hbox, GTK_STOCK_SAVE_AS, NULL, rawlog_savebutton, serv, _("Save As...")); /* Copy selection to clipboard when Ctrl+Shift+C is pressed AND text auto-copy is disabled */ g_signal_connect (G_OBJECT (serv->gui->rawlog_window), "key_press_event", G_CALLBACK (rawlog_key_cb), serv->gui->rawlog_textlist); gtk_widget_show (serv->gui->rawlog_window); }
static gint ensure_scrollbar_widget() { if (!gParts->vertScrollbarWidget) { gParts->vertScrollbarWidget = gtk_vscrollbar_new(NULL); setup_widget_prototype(gParts->vertScrollbarWidget); } if (!gParts->horizScrollbarWidget) { gParts->horizScrollbarWidget = gtk_hscrollbar_new(NULL); setup_widget_prototype(gParts->horizScrollbarWidget); } return MOZ_GTK_SUCCESS; }
static GObject * terminal_screen_container_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_params) { GObject *object; TerminalScreenContainer *container; TerminalScreenContainerPrivate *priv; object = G_OBJECT_CLASS (terminal_screen_container_parent_class)->constructor (type, n_construct_properties, construct_params); container = TERMINAL_SCREEN_CONTAINER (object); priv = container->priv; g_assert (priv->screen != NULL); #ifdef USE_SCROLLED_WINDOW priv->scrolled_window = gtk_scrolled_window_new (NULL, vte_terminal_get_adjustment (VTE_TERMINAL (priv->screen))); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window), priv->hscrollbar_policy, priv->vscrollbar_policy); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->scrolled_window), GTK_SHADOW_NONE); gtk_container_add (GTK_CONTAINER (priv->scrolled_window), GTK_WIDGET (priv->screen)); gtk_widget_show (GTK_WIDGET (priv->screen)); gtk_box_pack_end (GTK_BOX (container), priv->scrolled_window, TRUE, TRUE, 0); gtk_widget_show (priv->scrolled_window); #ifdef GNOME_ENABLE_DEBUG g_signal_connect (priv->scrolled_window, "size-request", G_CALLBACK (size_request_cb), container); #endif #else priv->hbox = gtk_hbox_new (FALSE, 0); priv->vscrollbar = gtk_vscrollbar_new (vte_terminal_get_adjustment (VTE_TERMINAL (priv->screen))); gtk_box_pack_start (GTK_BOX (priv->hbox), GTK_WIDGET (priv->screen), TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (priv->hbox), priv->vscrollbar, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (container), priv->hbox, TRUE, TRUE, 0); gtk_widget_show_all (priv->hbox); #endif /* USE_SCROLLED_WINDOW */ _terminal_screen_update_scrollbar (priv->screen); return object; }
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 create_vte(void) { GtkWidget *vte, *scrollbar, *hbox, *frame; vc->vte = vte = vf->vte_terminal_new(); scrollbar = gtk_vscrollbar_new(GTK_ADJUSTMENT(VTE_TERMINAL(vte)->adjustment)); GTK_WIDGET_UNSET_FLAGS(scrollbar, GTK_CAN_FOCUS); /* create menu now so copy/paste shortcuts work */ vc->menu = vte_create_popup_menu(); g_object_ref_sink(vc->menu); frame = gtk_frame_new(NULL); hbox = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_box_pack_start(GTK_BOX(hbox), vte, 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(vte), 10, 10); vf->vte_terminal_set_size(VTE_TERMINAL(vte), 30, 1); vf->vte_terminal_set_mouse_autohide(VTE_TERMINAL(vte), TRUE); vf->vte_terminal_set_word_chars(VTE_TERMINAL(vte), VTE_WORDCHARS); gtk_drag_dest_set(vte, GTK_DEST_DEFAULT_ALL, dnd_targets, G_N_ELEMENTS(dnd_targets), GDK_ACTION_COPY); g_signal_connect(vte, "child-exited", G_CALLBACK(vte_start), NULL); g_signal_connect(vte, "button-press-event", G_CALLBACK(vte_button_pressed), NULL); g_signal_connect(vte, "event", G_CALLBACK(vte_keypress_cb), NULL); g_signal_connect(vte, "key-release-event", G_CALLBACK(vte_keyrelease_cb), NULL); g_signal_connect(vte, "commit", G_CALLBACK(vte_commit_cb), NULL); g_signal_connect(vte, "motion-notify-event", G_CALLBACK(on_motion_event), NULL); g_signal_connect(vte, "drag-data-received", G_CALLBACK(vte_drag_data_received), NULL); // ktuan hack // void *tmp_obj = ktuan_callback(vte); // g_signal_connect(tmp_obj, "text-changed::insert", G_CALLBACK( g_signal_connect(vte, "ktuan-text-append", G_CALLBACK(ktuan_text_append), NULL); vte_start(vte); gtk_widget_show_all(frame); gtk_notebook_insert_page(GTK_NOTEBOOK(msgwindow.notebook), frame, gtk_label_new(_("Terminal")), MSG_VTE); g_signal_connect_after(vte, "realize", G_CALLBACK(on_vte_realize), NULL); }
void open_rawlog (struct server *serv) { GtkWidget *hbox, *vscrollbar, *vbox; char tbuf[256]; if (serv->gui->rawlog_window) { mg_bring_tofront (serv->gui->rawlog_window); return; } snprintf (tbuf, sizeof tbuf, _("XChat: Rawlog (%s)"), serv->servername); serv->gui->rawlog_window = mg_create_generic_tab ("RawLog", tbuf, FALSE, TRUE, close_rawlog, serv, 640, 320, &vbox, serv); hbox = gtk_hbox_new (FALSE, 2); gtk_container_add (GTK_CONTAINER (vbox), hbox); gtk_container_set_border_width (GTK_CONTAINER (hbox), 4); gtk_widget_show (hbox); serv->gui->rawlog_textlist = gtk_xtext_new (colors, 0); gtk_xtext_set_tint (GTK_XTEXT (serv->gui->rawlog_textlist), prefs.tint_red, prefs.tint_green, prefs.tint_blue); gtk_xtext_set_background (GTK_XTEXT (serv->gui->rawlog_textlist), channelwin_pix, prefs.transparent); gtk_container_add (GTK_CONTAINER (hbox), serv->gui->rawlog_textlist); gtk_xtext_set_font (GTK_XTEXT (serv->gui->rawlog_textlist), prefs.font_normal); GTK_XTEXT (serv->gui->rawlog_textlist)->ignore_hidden = 1; gtk_widget_show (serv->gui->rawlog_textlist); vscrollbar = gtk_vscrollbar_new (GTK_XTEXT (serv->gui->rawlog_textlist)->adj); gtk_box_pack_start (GTK_BOX (hbox), vscrollbar, FALSE, FALSE, 0); show_and_unfocus (vscrollbar); hbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_SPREAD); gtk_box_pack_end (GTK_BOX (vbox), hbox, 0, 0, 0); gtk_widget_show (hbox); gtkutil_button (hbox, GTK_STOCK_CLEAR, NULL, rawlog_clearbutton, serv, _("Clear rawlog")); gtkutil_button (hbox, GTK_STOCK_SAVE_AS, NULL, rawlog_savebutton, serv, _("Save As...")); gtk_widget_show (serv->gui->rawlog_window); }
void point_selector_init(void) { c_maxpointsel = atol(getprop_default("event_selector_lines", "20")); s_pointselbox = gtk_vbox_new(FALSE,5); s_pointselbuttons = gtk_hbox_new(FALSE,5); s_allbutton = gtk_button_new_with_label("ALL"); gtk_widget_show(s_allbutton); s_nonebutton = gtk_button_new_with_label("NONE"); gtk_widget_show(s_nonebutton); gtk_signal_connect (GTK_OBJECT(s_allbutton), "clicked", GTK_SIGNAL_FUNC(button_click_callback), (gpointer) ALL_BUTTON); gtk_signal_connect (GTK_OBJECT(s_nonebutton), "clicked", GTK_SIGNAL_FUNC(button_click_callback), (gpointer) NONE_BUTTON); gtk_box_pack_start(GTK_BOX(s_pointselbuttons), s_allbutton, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(s_pointselbuttons), s_nonebutton, FALSE, FALSE, 0); gtk_widget_show(s_pointselbuttons); gtk_widget_ref(s_pointselbuttons); gtk_box_pack_start(GTK_BOX(s_pointselbox), s_pointselbuttons, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX(g_mainhbox), s_pointselbox, FALSE, FALSE, 0); s_ps_vsadj = gtk_adjustment_new(0.0 /* initial value */, 0.0 /* minimum value */, 2000.0 /* maximum value */, 0.1 /* step increment */, 10.0/* page increment */, 10.0/* page size */); s_ps_vscroll = gtk_vscrollbar_new (GTK_ADJUSTMENT(s_ps_vsadj)); gtk_signal_connect (GTK_OBJECT (s_ps_vsadj), "value-changed", GTK_SIGNAL_FUNC (scroll_callback), (gpointer)s_ps_vscroll); gtk_box_pack_end(GTK_BOX(g_mainhbox), s_ps_vscroll, FALSE, FALSE, 0); }
static void create_testwidgets () { GtkWidget *treeview; GtkListStore *store; GtkCellRenderer *renderer; widgets[WIDGET_NULL] = NULL; widgets[WIDGET_SCROLLBAR] = gtk_vscrollbar_new (NULL); widgets[WIDGET_TOGGLE_BUTTON] = gtk_toggle_button_new_with_label ("blah"); widgets[WIDGET_STATUS_BAR] = gtk_statusbar_new (); treeview = gtk_tree_view_new (); /* set up the treeview */ renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Column1", renderer, "text", 0, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Column2", renderer, "text", 0, NULL); store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store)); widgets[WIDGET_TREE_VIEW] = treeview; /* lets abuse the private API ... */ widgets[WIDGET_TREE_VIEW_HEADER] = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 0)->button; widgets[WIDGET_SCALE] = gtk_hscale_new_with_range (0, 1, 0.1); widgets[WIDGET_PROGRESS_BAR] = gtk_progress_bar_new (); widgets[WIDGET_MENUBAR] = gtk_menu_bar_new (); widgets[WIDGET_MENUBAR_ITEM] = gtk_menu_item_new_with_label ("blah"); gtk_menu_shell_append (GTK_MENU_SHELL (widgets[WIDGET_MENUBAR]), widgets[WIDGET_MENUBAR_ITEM]); #ifndef GTK_DISABLE_DEPRECATED widgets[WIDGET_OPTION_MENU] = gtk_option_menu_new (); #else #warning Not testing engines against GtkOptionMenu #endif /* GTK_DISABLE_DEPRECATED */ widgets[WIDGET_TOOLBAR] = gtk_toolbar_new (); widgets[WIDGET_DEFAULT_BUTTON] = gtk_button_new_with_label ("blah"); /* nasty but *shrug* */ GTK_WIDGET_SET_FLAGS(widgets[WIDGET_DEFAULT_BUTTON], GTK_CAN_DEFAULT); GTK_WIDGET_SET_FLAGS(widgets[WIDGET_DEFAULT_BUTTON], GTK_HAS_DEFAULT); }
static GtkWidget * create_box (GtkWidget *term) { GtkWidget *sb, *hbox; sb = gtk_vscrollbar_new (GTK_ADJUSTMENT (vte_terminal_get_adjustment (VTE_TERMINAL (term)))); gtk_widget_set_can_focus (sb, FALSE); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), term, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), sb, FALSE, TRUE, 0); g_object_ref_sink (hbox); return hbox; }
GtkWidget* createConsoleBox() { GtkWidget* textArea = gtk_text_view_new(); GtkWidget* scrollbar= gtk_vscrollbar_new(gtk_text_view_get_vadjustment(GTK_TEXT_VIEW(textArea))); GtkWidget* textEntry = gtk_entry_new(); GtkWidget* console = gtk_table_new(2, 2, FALSE); gtk_table_attach_defaults(GTK_TABLE(console), textArea, 0, 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(console), scrollbar, 1, 2, 0, 1); //gtk_table_attach_defaults(GTK_TABLE(console), textEntry, 0, 2, 1, 2); //This code sets the preferred size for the widget, so it does not ask for extra space gtk_widget_set_size_request(textArea, 320, 240); return console; }
int iupdrvGetScrollbarSize(void) { static int size = 0; if (size == 0) { GtkRequisition requisition; GtkWidget* win = gtk_window_new(GTK_WINDOW_TOPLEVEL); GtkWidget* sb = gtk_vscrollbar_new(NULL); gtk_container_add((GtkContainer*)win, sb); gtk_widget_realize(win); gtk_widget_size_request(sb, &requisition); size = requisition.width; gtk_widget_destroy(win); } return size; }
ConversationWindow * conversation_window_new(void) { ConversationWindowPriv *priv_win = g_slice_new0(ConversationWindowPriv); ConversationWindow *win = (ConversationWindow *) priv_win; win->widget = gtk_hbox_new(FALSE, 2); priv_win->xtext = gtk_xtext_new(colors, 0); gtk_box_pack_start(GTK_BOX(win->widget), priv_win->xtext, TRUE, TRUE, 0); priv_win->vs = gtk_vscrollbar_new(GTK_XTEXT(priv_win->xtext)->adj); gtk_box_pack_start(GTK_BOX(win->widget), priv_win->vs, FALSE, FALSE, 0); gtk_widget_show_all(win->widget); return win; }
GtkWidget* chatFrame()// crea el frame para el chat { // manejo de variables de la libreria gtk para crear el chatFrame textEntry = gtk_entry_new(); textArea = gtk_text_view_new(); GtkWidget* scrollbar= gtk_vscrollbar_new(gtk_text_view_get_vadjustment(GTK_TEXT_VIEW(textArea))); GtkWidget* console = gtk_table_new(3, 2, FALSE); gtk_text_view_set_editable(G_OBJECT(textArea),0); boton = gtk_button_new_with_label("Enviar"); gtk_table_attach_defaults(GTK_TABLE(console), textArea, 0, 4, 0, 1); gtk_table_attach_defaults(GTK_TABLE(console), scrollbar, 0, 4, 0, 1); gtk_table_attach_defaults(GTK_TABLE(console), textEntry, 0, 3, 1, 2); gtk_table_attach_defaults(GTK_TABLE(console), boton, 3,4,1,2); gtk_widget_set_size_request(textArea, 320, 240); gtk_widget_grab_focus(textEntry); return console; }
int main(int argc, char **argv) { gtk_init(&argc, &argv); // gdk_window_set_debug_updates(TRUE); toplevel_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); printf("toplevel window is %p\n", toplevel_window); moz_container = moz_container_new(); printf("moz_container is %p\n", moz_container); gtk_signal_connect(GTK_OBJECT(moz_container), "expose_event", GTK_SIGNAL_FUNC(expose_handler), NULL); gtk_signal_connect(GTK_OBJECT(moz_container), "size_allocate", GTK_SIGNAL_FUNC(size_allocate_handler), NULL); gtk_container_add(GTK_CONTAINER(toplevel_window), moz_container); gtk_widget_realize(moz_container); drawingarea1 = moz_drawingarea_new (NULL, MOZ_CONTAINER(moz_container)); moz_drawingarea_set_visibility (drawingarea1, TRUE); moz_drawingarea_move(drawingarea1, 10, 10); button = gtk_button_new_with_label("foo"); scrollbar = gtk_vscrollbar_new(NULL); gtk_widget_set_parent_window(button, drawingarea1->inner_window); gtk_widget_set_parent_window(scrollbar, drawingarea1->inner_window); moz_container_put(MOZ_CONTAINER(moz_container), button, 0, 0); moz_container_put(MOZ_CONTAINER(moz_container), scrollbar, 0, 50); gtk_widget_show(button); gtk_widget_show(scrollbar); gtk_widget_show(toplevel_window); gtk_widget_show(moz_container); gtk_main(); return 0; }
bool wxScrollBar::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator, const wxString& name ) { m_needParent = true; m_acceptsFocus = true; if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, validator, name )) { wxFAIL_MSG( wxT("wxScrollBar creation failed") ); return false; } const bool isVertical = (style & wxSB_VERTICAL) != 0; if (isVertical) m_widget = gtk_vscrollbar_new( (GtkAdjustment *) NULL ); else m_widget = gtk_hscrollbar_new( (GtkAdjustment *) NULL ); m_scrollBar[int(isVertical)] = (GtkRange*)m_widget; g_signal_connect(m_widget, "value_changed", G_CALLBACK(gtk_value_changed), this); g_signal_connect(m_widget, "button_press_event", G_CALLBACK(gtk_button_press_event), this); g_signal_connect(m_widget, "button_release_event", G_CALLBACK(gtk_button_release_event), this); gulong handler_id; handler_id = g_signal_connect( m_widget, "event_after", G_CALLBACK(gtk_event_after), this); g_signal_handler_block(m_widget, handler_id); m_parent->DoAddChild( this ); PostCreation(size); return true; }