/**** 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;
}
