static VALUE
tbtn_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE label, use_underline;
GtkWidget *widget;
if (rb_scan_args(argc, argv, "02", &label, &use_underline) > 0) {
if (TYPE(label) == T_STRING){
if (NIL_P(use_underline) || RVAL2CBOOL(use_underline)){
widget = gtk_toggle_button_new_with_mnemonic(RVAL2CSTR(label));
} else {
widget = gtk_toggle_button_new_with_label(RVAL2CSTR(label));
}
} else if (TYPE(label) == T_SYMBOL){
widget = gtk_toggle_button_new_with_label(rb_id2name(SYM2ID(label)));
gtk_button_set_use_stock(GTK_BUTTON(widget), TRUE);
} else {
rb_raise(rb_eArgError, "invalid argument %s (expect Symbol(Gtk::Stock constants) or String)",
rb_class2name(CLASS_OF(label)));
}
} else {
widget = gtk_toggle_button_new();
}
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
void lr_gtk_test(int argc, char** argv)
{
GtkWidget *window;
GtkWidget *box;
GtkWidget *led1Button, *led2Button;
gtk_init( &argc, &argv );
window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
g_signal_connect( G_OBJECT( window ), "destroy", G_CALLBACK( gtk_main_quit ), NULL );
gtk_container_set_border_width(GTK_CONTAINER (window), 10);
box = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), box);
led1Button = gtk_toggle_button_new_with_label("LED1");
led2Button = gtk_toggle_button_new_with_label("LED2");
gtk_container_add(GTK_CONTAINER(box), led1Button);
gtk_container_add(GTK_CONTAINER(box), led2Button);
g_signal_connect(led1Button, "clicked", G_CALLBACK(led_button_clicked), (gpointer)1);
g_signal_connect(led2Button, "clicked", G_CALLBACK(led_button_clicked), (gpointer)2);
gtk_widget_show(box);
gtk_widget_show(led1Button);
gtk_widget_show(led2Button);
gtk_widget_show(window);
gtk_main ();
}
/**
* To understand how to setup this function you must understand:
*
* gimp_table_attach_aligned
*
* To understand that you will find information in only one spot:
*
* c:\gimp-2.6.11\libgimpwidgets\gimpwidgets.c on or about line number 1118
* which states:
*
**
* gimp_table_attach_aligned:
* @table: The #GtkTable the widgets will be attached to.
* @column: The column to start with.
* @row: The row to attach the widgets.
* @label_text: The text for the #GtkLabel which will be attached left of
* the widget.
* @xalign: The horizontal alignment of the #GtkLabel.
* @yalign: The vertival alignment of the #GtkLabel.
* @widget: The #GtkWidget to attach right of the label.
* @colspan: The number of columns the widget will use.
* @left_align: %TRUE if the widget should be left-aligned.
*
* Note that the @label_text can be %NULL and that the widget will be
* attached starting at (@column + 1) in this case, too.
*
* Returns: The created #GtkLabel.
**
* GtkWidget *
* gimp_table_attach_aligned (GtkTable *table,
* gint column,
* gint row,
* const gchar *label_text,
* gfloat xalign,
* gfloat yalign,
* GtkWidget *widget,
* gint colspan,
* gboolean left_align);
*
*/
static GtkWidget *CreateToggleButton(GtkWidget *table, gint row, GCallback *function, const gchar *szName, gint32 nVal)
{
GtkWidget *btn = NULL;
if (nVal == 1)
{
btn = gtk_toggle_button_new_with_label("Yes");
}
else
{
btn = gtk_toggle_button_new_with_label("No");
}
if (btn != NULL)
{
gtk_signal_connect(GTK_OBJECT(btn), "clicked",
GTK_SIGNAL_FUNC(function), 0);
gimp_table_attach_aligned(GTK_TABLE(table), 0, row, szName, 0, 0.5,
btn, 1, 0);
gtk_widget_show(btn);
if (nVal == 1)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn), TRUE);
}
}
return btn;
}
static GtkWidget *create_play_record_page(){
GtkWidget *vbox=gtk_table_new(2,2,FALSE);
GtkWidget *labelRecord=gtk_label_new(_("Press the record button and say some words"));
GtkWidget *labelPlay=gtk_label_new(_("Listen to your record voice"));
GtkWidget *rec_button=gtk_toggle_button_new_with_label("Record");
GtkWidget *play_button=gtk_toggle_button_new_with_label("Play");
GtkWidget *image;
image=gtk_image_new_from_stock(GTK_STOCK_MEDIA_RECORD,GTK_ICON_SIZE_MENU);
gtk_button_set_image(GTK_BUTTON(rec_button),image);
image=gtk_image_new_from_stock(GTK_STOCK_MEDIA_PLAY,GTK_ICON_SIZE_MENU);
gtk_button_set_image(GTK_BUTTON(play_button),image);
gtk_widget_set_sensitive(play_button,FALSE);
gtk_table_attach_defaults(GTK_TABLE(vbox), labelRecord, 0, 1, 0, 1);
gtk_table_attach(GTK_TABLE(vbox), rec_button, 1, 2, 0, 1, GTK_SHRINK, GTK_SHRINK, 0,0);
gtk_table_attach_defaults(GTK_TABLE(vbox), labelPlay, 0, 1, 1, 2);
gtk_table_attach(GTK_TABLE(vbox), play_button, 1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0,0);
gtk_widget_show_all(vbox);
set_widget_to_assistant("rec_button",rec_button);
set_widget_to_assistant("play_button",play_button);
g_signal_connect(G_OBJECT(rec_button),"toggled",(GCallback)linphone_gtk_start_record_sound,vbox);
g_signal_connect(G_OBJECT(play_button),"toggled",(GCallback)linphone_gtk_start_play_record_sound,vbox);
return vbox;
}
static void
create_box_window (void)
{
GtkWidget *window;
GtkWidget *box1, *box2, *box3;
GtkWidget *toggle;
GtkWidget *colorbox;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Boxes");
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (box1),
gtk_label_new ("VBox 1 Top"));
gtk_box_pack_start (GTK_BOX (box1),
box2);
gtk_box_pack_end (GTK_BOX (box1),
gtk_label_new ("VBox 1 Bottom"));
gtk_box_pack_start (GTK_BOX (box2),
gtk_label_new ("HBox 2 Left"));
gtk_box_pack_start (GTK_BOX (box2),
box3);
gtk_box_pack_end (GTK_BOX (box2),
gtk_label_new ("HBox 2 Right"));
gtk_box_pack_start (GTK_BOX (box3),
gtk_label_new ("VBox 3 Top"));
gtk_box_pack_end (GTK_BOX (box3),
gtk_label_new ("VBox 3 Bottom"));
colorbox = gtk_frame_new (NULL);
toggle = gtk_toggle_button_new_with_label ("H Expand");
gtk_widget_set_halign (toggle, GTK_ALIGN_CENTER);
gtk_widget_set_valign (toggle, GTK_ALIGN_CENTER);
g_object_set (toggle, "margin", 5, NULL);
g_signal_connect (G_OBJECT (toggle), "toggled",
G_CALLBACK (on_toggle_hexpand), NULL);
gtk_container_add (GTK_CONTAINER (colorbox), toggle);
gtk_box_pack_start (GTK_BOX (box3), colorbox);
colorbox = gtk_frame_new (NULL);
toggle = gtk_toggle_button_new_with_label ("V Expand");
gtk_widget_set_halign (toggle, GTK_ALIGN_CENTER);
gtk_widget_set_valign (toggle, GTK_ALIGN_CENTER);
g_object_set (toggle, "margin", 5, NULL);
g_signal_connect (G_OBJECT (toggle), "toggled",
G_CALLBACK (on_toggle_vexpand), NULL);
gtk_container_add (GTK_CONTAINER (colorbox), toggle);
gtk_box_pack_start (GTK_BOX (box3), colorbox);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (window);
}
static void
initialise_test( void )
{
GtkWidget *w;
GtkBox *box;
test_status.percent = 50;
test_status.minutes = 180;
test_status.present = TRUE;
test_status.on_ac_power = FALSE;
test_status.charging = FALSE;
box = GTK_BOX( gtk_vbox_new( 5, FALSE ) );
gtk_box_pack_start( box, gtk_label_new( "percent" ), TRUE, TRUE, 0);
w = gtk_spin_button_new_with_range( -1.0, 100.0, 1 );
gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), 50.0 );
g_signal_connect( G_OBJECT( w ), "value-changed",
G_CALLBACK( test_update_integer ), &test_status.percent );
gtk_box_pack_start( box, w, TRUE, TRUE, 0 );
gtk_box_pack_start( box, gtk_label_new( "minutes" ), TRUE, TRUE, 0);
w = gtk_spin_button_new_with_range( -1.0, 1000.0, 1 );
gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), 180.0 );
g_signal_connect( G_OBJECT( w ), "value-changed",
G_CALLBACK( test_update_integer ), &test_status.minutes );
gtk_box_pack_start( box, w, TRUE, TRUE, 0);
w = gtk_toggle_button_new_with_label( "on_ac_power" );
g_signal_connect( G_OBJECT( w ), "toggled",
G_CALLBACK( test_update_boolean ),
&test_status.on_ac_power );
gtk_box_pack_start( box, w, TRUE, TRUE, 0);
w = gtk_toggle_button_new_with_label( "charging" );
g_signal_connect( G_OBJECT( w ), "toggled",
G_CALLBACK( test_update_boolean ), &test_status.charging );
gtk_box_pack_start( box, w, TRUE, TRUE, 0);
w = gtk_toggle_button_new_with_label( "present" );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), TRUE );
g_signal_connect( G_OBJECT( w ), "toggled",
G_CALLBACK( test_update_boolean ), &test_status.present );
gtk_box_pack_start( box, w, TRUE, TRUE, 0);
w = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_container_add( GTK_CONTAINER( w ), GTK_WIDGET( box ) );
gtk_widget_show_all( w );
}
static void *
cv_tabs_add (chanview *cv, chan *ch, char *name, GtkTreeIter *parent)
{
GtkWidget *but;
but = gtk_toggle_button_new_with_label (name);
gtk_widget_set_name (but, "hextor-tab");
g_object_set_data (G_OBJECT (but), "c", ch);
/* used to trap right-clicks */
g_signal_connect (G_OBJECT (but), "button_press_event",
G_CALLBACK (tab_click_cb), ch);
/* avoid prelights */
g_signal_connect (G_OBJECT (but), "enter_notify_event",
G_CALLBACK (tab_ignore_cb), NULL);
g_signal_connect (G_OBJECT (but), "leave_notify_event",
G_CALLBACK (tab_ignore_cb), NULL);
g_signal_connect (G_OBJECT (but), "pressed",
G_CALLBACK (tab_pressed_cb), ch);
/* for keyboard */
g_signal_connect (G_OBJECT (but), "toggled",
G_CALLBACK (tab_toggled_cb), ch);
g_object_set_data (G_OBJECT (but), "u", ch->userdata);
tab_add_real (cv, but, ch);
return but;
}
GtkWidget *
new_layer(GtkWidget *canvas)
{
gchar label[10];
nlayers++;
buttons = (GtkWidget **)g_realloc(buttons, nlayers * sizeof(GtkWidget *));
plots = (GtkWidget **)g_realloc(plots, nlayers * sizeof(GtkWidget *));
sprintf(label, "%d", nlayers);
buttons[nlayers-1] = gtk_toggle_button_new_with_label(label);
/* gtk_button_set_relief(GTK_BUTTON(buttons[nlayers-1]), GTK_RELIEF_NONE);
*/
gtk_widget_set_usize(buttons[nlayers-1], 20, 20);
gtk_fixed_put(GTK_FIXED(canvas), buttons[nlayers-1], (nlayers-1)*20, 0);
gtk_widget_show(buttons[nlayers-1]);
gtk_signal_connect(GTK_OBJECT(buttons[nlayers-1]), "toggled",
(GtkSignalFunc) activate_plot, canvas);
plots[nlayers-1] = gtk_plot_new_with_size(NULL, .5, .5);
gtk_widget_show(plots[nlayers-1]);
activate_plot(buttons[nlayers-1],canvas);
return plots[nlayers-1];
}
static GtkWidget *_lib_history_create_button(dt_lib_module_t *self, int num, const char *label,
gboolean enabled, gboolean selected)
{
/* create label */
GtkWidget *widget = NULL;
gchar numlabel[256];
if(num == -1)
g_snprintf(numlabel, sizeof(numlabel), "%d - %s", num + 1, label);
else
{
if(enabled)
g_snprintf(numlabel, sizeof(numlabel), "%d - %s", num + 1, label);
else
g_snprintf(numlabel, sizeof(numlabel), "%d - %s (%s)", num + 1, label, _("off"));
}
/* create toggle button */
widget = gtk_toggle_button_new_with_label(numlabel);
gtk_widget_set_halign(gtk_bin_get_child(GTK_BIN(widget)), GTK_ALIGN_START);
g_object_set_data(G_OBJECT(widget), "history_number", GINT_TO_POINTER(num + 1));
g_object_set_data(G_OBJECT(widget), "label", (gpointer)label);
if(selected) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
/* set callback when clicked */
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(_lib_history_button_clicked_callback), self);
/* associate the history number */
g_object_set_data(G_OBJECT(widget), "history-number", GINT_TO_POINTER(num + 1));
return widget;
}
static GtkWidget *
togglebutton_new(GladeXML *xml, GladeWidgetInfo *info)
{
GtkWidget *button;
GList *tmp;
char *string = NULL;
gboolean active = FALSE;
for (tmp = info->attributes; tmp; tmp = tmp->next) {
GladeAttribute *attr = tmp->data;
if (!strcmp(attr->name, "label"))
string = attr->value;
else if (!strcmp(attr->name, "active"))
active = attr->value[0] == 'T';
}
if (string != NULL) {
guint key;
button = gtk_toggle_button_new_with_label("");
key = gtk_label_parse_uline(GTK_LABEL(GTK_BIN(button)->child),
string[0] ? _(string) : "");
if (key)
gtk_widget_add_accelerator(button, "clicked",
glade_xml_ensure_accel(xml),
key, GDK_MOD1_MASK, 0);
} else
button = gtk_toggle_button_new();
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), active);
return button;
}
GtkWidget *
new_layer(GtkWidget *canvas)
{
gchar label[10];
GtkRequisition req;
gint size;
nlayers++;
buttons = (GtkWidget **)g_realloc(buttons, nlayers * sizeof(GtkWidget *));
plots = (GtkWidget **)g_realloc(plots, nlayers * sizeof(GtkWidget *));
sprintf(label, "%d", nlayers);
buttons[nlayers-1] = gtk_toggle_button_new_with_label(label);
/* gtk_button_set_relief(GTK_BUTTON(buttons[nlayers-1]), GTK_RELIEF_NONE);
*/
gtk_widget_size_request(buttons[nlayers-1], &req);
size = MAX(req.width,req.height);
gtk_widget_set_size_request(buttons[nlayers-1], size, size);
gtk_fixed_put(GTK_FIXED(canvas), buttons[nlayers-1], (nlayers-1)*20, 0);
gtk_widget_show(buttons[nlayers-1]);
g_signal_connect(GTK_OBJECT(buttons[nlayers-1]), "toggled",
(void *) activate_plot, canvas);
plots[nlayers-1] = gtk_plot_new_with_size(NULL, .5, .25);
gtk_widget_show(plots[nlayers-1]);
activate_plot(buttons[nlayers-1],canvas);
return plots[nlayers-1];
}
GtkWidget *
new_layer(GtkWidget *canvas, GtkType type)
{
gchar label[10];
GtkRequisition req;
gint size;
nlayers++;
buttons = (GtkWidget **)g_realloc(buttons, nlayers * sizeof(GtkWidget *));
plots = (GtkWidget **)g_realloc(plots, nlayers * sizeof(GtkWidget *));
sprintf(label, "%d", nlayers);
buttons[nlayers-1] = gtk_toggle_button_new_with_label(label);
/* gtk_button_set_relief(GTK_BUTTON(buttons[nlayers-1]), GTK_RELIEF_NONE);
*/
gtk_widget_size_request(buttons[nlayers-1], &req);
size = MAX(req.width,req.height);
gtk_widget_set_usize(buttons[nlayers-1], size, size);
gtk_fixed_put(GTK_FIXED(canvas), buttons[nlayers-1], (nlayers-1)*size, 0);
gtk_widget_show(buttons[nlayers-1]);
if(type == GTK_TYPE_PLOT3D)
plots[nlayers-1] = gtk_plot3d_new_with_size(NULL, .50, .50);
else
plots[nlayers-1] = gtk_plot_new_with_size(NULL, .40, .40);
gtk_widget_show(plots[nlayers-1]);
return plots[nlayers-1];
}
GtkWidget *gtk_toggle_button_new_with_label_color(const gchar *label, gint width, gint height, GdkColor *clrSel)
{
GtkWidget *cmd = gtk_toggle_button_new_with_label(label);
gtk_widget_set_size_request(cmd, width, height);
gtk_widget_modify_bg(cmd, GTK_STATE_ACTIVE, clrSel);
return cmd;
}
bool wxToggleButton::Create(wxWindow *parent, wxWindowID id,
const wxString &label, const wxPoint &pos,
const wxSize &size, long style,
const wxValidator& validator,
const wxString &name)
{
m_needParent = true;
m_acceptsFocus = true;
m_blockEvent = false;
if (!PreCreation(parent, pos, size) ||
!CreateBase(parent, id, pos, size, style, validator, name )) {
wxFAIL_MSG(wxT("wxToggleButton creation failed"));
return false;
}
wxControl::SetLabel(label);
// Create the gtk widget.
m_widget = gtk_toggle_button_new_with_label( wxGTK_CONV( m_label ) );
gtk_signal_connect(GTK_OBJECT(m_widget), "clicked",
GTK_SIGNAL_FUNC(gtk_togglebutton_clicked_callback),
(gpointer *)this);
m_parent->DoAddChild(this);
PostCreation(size);
return true;
}
static void
create_grid_window (void)
{
GtkWidget *window;
GtkWidget *grid;
GtkWidget *toggle;
GtkWidget *colorbox;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Grid");
grid = gtk_grid_new ();
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Top"), 1, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Bottom"), 1, 3, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Left"), 0, 1, 1, 2);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Right"), 2, 1, 1, 2);
colorbox = gtk_frame_new (NULL);
toggle = gtk_toggle_button_new_with_label ("H Expand");
gtk_widget_set_halign (toggle, GTK_ALIGN_CENTER);
gtk_widget_set_valign (toggle, GTK_ALIGN_CENTER);
g_object_set (toggle, "margin", 5, NULL);
g_signal_connect (G_OBJECT (toggle), "toggled",
G_CALLBACK (on_toggle_hexpand), NULL);
gtk_container_add (GTK_CONTAINER (colorbox), toggle);
gtk_grid_attach (GTK_GRID (grid), colorbox, 1, 1, 1, 1);
colorbox = gtk_frame_new (NULL);
toggle = gtk_toggle_button_new_with_label ("V Expand");
gtk_widget_set_halign (toggle, GTK_ALIGN_CENTER);
gtk_widget_set_valign (toggle, GTK_ALIGN_CENTER);
g_object_set (toggle, "margin", 5, NULL);
g_signal_connect (G_OBJECT (toggle), "toggled",
G_CALLBACK (on_toggle_vexpand), NULL);
gtk_container_add (GTK_CONTAINER (colorbox), toggle);
gtk_grid_attach (GTK_GRID (grid), colorbox, 1, 2, 1, 1);
gtk_container_add (GTK_CONTAINER (window), grid);
gtk_widget_show (window);
}
static WIDGET *
boolprop_get_widget(BoolProperty *prop, PropDialog *dialog)
{
GtkWidget *ret = gtk_toggle_button_new_with_label(_("No"));
g_signal_connect(G_OBJECT(ret), "toggled",
G_CALLBACK (bool_toggled), NULL);
prophandler_connect(&prop->common, G_OBJECT(ret), "toggled");
return ret;
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *box;
GtkWidget *footer;
GtkWidget *button;
GtkWidget *content;
GtkCssProvider *provider;
gtk_init (NULL, NULL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_style_context_add_class (gtk_widget_get_style_context (window), "main");
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (provider, css, -1, NULL);
gtk_style_context_add_provider_for_screen (gtk_widget_get_screen (window),
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
change_header (NULL, window);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box);
footer = gtk_header_bar_new ();
button = gtk_button_new_with_label ("Title");
g_signal_connect (button, "clicked", G_CALLBACK (change_title), footer);
gtk_header_bar_pack_start (GTK_HEADER_BAR (footer), button);
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (footer), gtk_check_button_new_with_label ("Middle"));
button = gtk_toggle_button_new_with_label ("Custom");
g_signal_connect (button, "clicked", G_CALLBACK (change_header), window);
gtk_header_bar_pack_start (GTK_HEADER_BAR (footer), button);
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (footer), gtk_check_button_new_with_label ("Middle"));
button = gtk_button_new_with_label ("Subtitle");
g_signal_connect (button, "clicked", G_CALLBACK (change_subtitle), NULL);
gtk_header_bar_pack_end (GTK_HEADER_BAR (footer), button);
button = gtk_button_new_with_label ("Fullscreen");
gtk_header_bar_pack_end (GTK_HEADER_BAR (footer), button);
g_signal_connect (button, "clicked", G_CALLBACK (toggle_fullscreen), window);
gtk_box_pack_end (GTK_BOX (box), footer, FALSE, FALSE, 0);
content = gtk_image_new_from_icon_name ("start-here-symbolic", GTK_ICON_SIZE_DIALOG);
gtk_image_set_pixel_size (GTK_IMAGE (content), 512);
gtk_box_pack_start (GTK_BOX (box), content, FALSE, TRUE, 0);
gtk_widget_show_all (window);
gtk_main ();
gtk_widget_destroy (window);
return 0;
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_snapshots_t *d = (dt_lib_snapshots_t *)g_malloc0(sizeof(dt_lib_snapshots_t));
self->data = (void *)d;
/* initialize snapshot storages */
d->size = 4;
d->snapshot = (dt_lib_snapshot_t *)g_malloc0_n(d->size, sizeof(dt_lib_snapshot_t));
d->vp_xpointer = 0.5;
d->vp_ypointer = 0.5;
d->vertical = TRUE;
/* initialize ui containers */
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
d->snapshots_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
/* create take snapshot button */
GtkWidget *button = gtk_button_new_with_label(_("take snapshot"));
d->take_button = button;
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_lib_snapshots_add_button_clicked_callback), self);
gtk_widget_set_tooltip_text(button, _("take snapshot to compare with another image "
"or the same image at another stage of development"));
/*
* initialize snapshots
*/
char wdname[32] = { 0 };
char localtmpdir[PATH_MAX] = { 0 };
dt_loc_get_tmp_dir(localtmpdir, sizeof(localtmpdir));
for(int k = 0; k < d->size; k++)
{
/* create snapshot button */
d->snapshot[k].button = gtk_toggle_button_new_with_label(wdname);
gtk_widget_set_halign(gtk_bin_get_child(GTK_BIN(d->snapshot[k].button)), GTK_ALIGN_START);
g_signal_connect(G_OBJECT(d->snapshot[k].button), "clicked", G_CALLBACK(_lib_snapshots_toggled_callback),
self);
/* assign snapshot number to widget */
g_object_set_data(G_OBJECT(d->snapshot[k].button), "snapshot", GINT_TO_POINTER(k + 1));
/* setup filename for snapshot */
snprintf(d->snapshot[k].filename, sizeof(d->snapshot[k].filename), "%s/dt_snapshot_%d.png", localtmpdir,
k);
/* add button to snapshot box */
gtk_box_pack_start(GTK_BOX(d->snapshots_box), d->snapshot[k].button, TRUE, TRUE, 0);
/* prevent widget to show on external show all */
gtk_widget_set_no_show_all(d->snapshot[k].button, TRUE);
}
/* add snapshot box and take snapshot button to widget ui*/
gtk_box_pack_start(GTK_BOX(self->widget), d->snapshots_box, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), button, TRUE, TRUE, 0);
}
static void
create_file_entry(void)
{
TestGnomeApp *app;
GtkWidget *entry;
GtkWidget *l1,*l2;
GtkWidget *but;
GtkWidget *box;
app = create_newwin(TRUE,"testGNOME","File Entry");
box = gtk_vbox_new(FALSE,5);
entry = gnome_file_entry_new("Foo","Bar");
gtk_box_pack_start(GTK_BOX(box),entry,FALSE,FALSE,0);
l1 = gtk_label_new("File name: ");
gtk_box_pack_start(GTK_BOX(box),l1,FALSE,FALSE,0);
l2 = gtk_label_new("File name(if exists only): ");
gtk_box_pack_start(GTK_BOX(box),l2,FALSE,FALSE,0);
but = gtk_button_new_with_label("Update file labels");
g_object_set_data(G_OBJECT(but),"l1",l1);
g_object_set_data(G_OBJECT(but),"l2",l2);
g_signal_connect(but,"clicked",
G_CALLBACK(file_entry_update_files),
entry);
gtk_box_pack_start(GTK_BOX(box),but,FALSE,FALSE,0);
but = gtk_toggle_button_new_with_label("Make browse dialog modal");
g_signal_connect(but,"toggled",
G_CALLBACK(file_entry_modal_toggle),
entry);
gtk_box_pack_start(GTK_BOX(box),but,FALSE,FALSE,0);
but = gtk_toggle_button_new_with_label("Directory only picker");
g_signal_connect(but,"toggled",
G_CALLBACK(file_entry_directory_toggle),
entry);
gtk_box_pack_start(GTK_BOX(box),but,FALSE,FALSE,0);
bonobo_window_set_contents (BONOBO_WINDOW(app->app), box);
gtk_widget_show_all(app->app);
}
extern void GTKShowMatchEquityTable( const unsigned int nMatchTo, const int anScore[ 2 ] )
{
/* FIXME: Widget should update after 'Invert' or 'Load ...' */
int i;
char sz[ 50 ];
GtkWidget *pwDialog = GTKCreateDialog( _("GNU Backgammon - Match equity table"),
DT_INFO, NULL, DIALOG_FLAG_MODAL, NULL, NULL );
GtkWidget *pwNotebook = gtk_notebook_new ();
GtkWidget *pwLoad = gtk_button_new_with_label(_("Load table..."));
GtkWidget *pwInvertButton =
gtk_toggle_button_new_with_label(_("Invert table"));
metwidget mw;
mw.nMatchTo = nMatchTo;
mw.anAway[ 0 ] = (nMatchTo - (unsigned)anScore[ 0 ]) - 1;
mw.anAway[ 1 ] = (nMatchTo - (unsigned)anScore[ 1 ]) - 1;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pwInvertButton),
fInvertMET);
gtk_container_set_border_width( GTK_CONTAINER( pwNotebook ), 4 );
gtk_container_add( GTK_CONTAINER( DialogArea( pwDialog, DA_MAIN ) ),
pwNotebook );
gtk_container_add( GTK_CONTAINER( DialogArea( pwDialog, DA_BUTTONS ) ),
pwInvertButton );
gtk_container_add( GTK_CONTAINER( DialogArea( pwDialog, DA_BUTTONS ) ),
pwLoad );
mw.pwPreCrawford = GTKWriteMET ( (unsigned)mw.nMatchTo, (unsigned)mw.nMatchTo, mw.anAway[ 0 ], mw.anAway[ 1 ] );
gtk_notebook_append_page ( GTK_NOTEBOOK ( pwNotebook ),
mw.pwPreCrawford,
gtk_label_new ( _("Pre-Crawford") ) );
for ( i = 0; i < 2; i++ ) {
sprintf ( sz, _("Post-Crawford for player %s"), ap[ i ].szName );
mw.apwPostCrawford[ i ] = GTKWriteMET ( nMatchTo , 1, mw.anAway[ i ], mw.anAway[ !i ] );
gtk_notebook_append_page ( GTK_NOTEBOOK ( pwNotebook ),
mw.apwPostCrawford[ i ],
gtk_label_new ( sz ) );
}
gtk_window_set_default_size( GTK_WINDOW( pwDialog ), 500, 300 );
g_signal_connect( G_OBJECT( pwInvertButton ), "toggled",
G_CALLBACK( invertMETlocal ), &mw );
g_signal_connect( G_OBJECT( pwLoad ), "clicked",
G_CALLBACK ( loadMET ), &mw );
UpdateAllTables ( &mw );
GTKRunDialog(pwDialog);
}
GtkWidget *
do_popover (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
GtkWidget *popover, *box, *widget;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 24);
gtk_container_set_border_width (GTK_CONTAINER (box), 24);
gtk_container_add (GTK_CONTAINER (window), box);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
widget = gtk_toggle_button_new_with_label ("Button");
popover = create_popover (widget,
gtk_label_new ("This popover does not grab input"),
GTK_POS_TOP);
gtk_popover_set_modal (GTK_POPOVER (popover), FALSE);
g_signal_connect (widget, "toggled",
G_CALLBACK (toggle_changed_cb), popover);
gtk_container_add (GTK_CONTAINER (box), widget);
widget = gtk_entry_new ();
popover = create_complex_popover (widget, GTK_POS_TOP);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget),
GTK_ENTRY_ICON_PRIMARY, "edit-find");
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (widget),
GTK_ENTRY_ICON_SECONDARY, "edit-clear");
g_signal_connect (widget, "icon-press",
G_CALLBACK (entry_icon_press_cb), popover);
g_signal_connect (widget, "size-allocate",
G_CALLBACK (entry_size_allocate_cb), popover);
gtk_container_add (GTK_CONTAINER (box), widget);
widget = gtk_calendar_new ();
g_signal_connect (widget, "day-selected",
G_CALLBACK (day_selected_cb), NULL);
gtk_container_add (GTK_CONTAINER (box), widget);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
static int
toggle_setup(struct gtk_common_data *mdata,
const struct sol_flow_node_options *options)
{
mdata->widget = gtk_toggle_button_new_with_label(" ");
g_signal_connect(mdata->widget, "toggled",
G_CALLBACK(on_toggle_changed), mdata);
g_object_set(mdata->widget, "halign", GTK_ALIGN_CENTER, NULL);
return 0;
}
static GtkWidget *viewer_button(GtkWidget *box, char *label)
{
GtkWidget *button;
if ( label[0] == '+' )
button = gtk_toggle_button_new_with_label(label+1);
else
button = gtk_button_new_with_label(label);
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
return button;
}
int
main (int argc, char **argv)
{
GtkWidget *window, *vbox, *frame, *swtch, *swtch2, *toggle, *vbox2;
gboolean is_active = FALSE;
gtk_init (&argc, &argv);
if (argc > 1)
is_active = atoi (argv[1]);
g_debug ("setting switch to '%d'", is_active);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 320, 240);
vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_container_add (GTK_CONTAINER (window), vbox);
frame = mx_gtk_frame_new ();
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 10);
gtk_frame_set_label (GTK_FRAME (frame), "Frame Title");
vbox2 = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 10);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
swtch = mx_gtk_light_switch_new ();
mx_gtk_light_switch_set_active (MX_GTK_LIGHT_SWITCH (swtch), is_active);
gtk_container_add (GTK_CONTAINER (vbox2), swtch);
swtch2 = mx_gtk_light_switch_new ();
gtk_widget_set_sensitive (swtch2, FALSE);
mx_gtk_light_switch_set_active (MX_GTK_LIGHT_SWITCH (swtch2), is_active);
gtk_container_add (GTK_CONTAINER (vbox2), swtch2);
frame = gtk_alignment_new (0, 0, 0, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (frame), 10, 10, 10, 10);
gtk_container_add (GTK_CONTAINER (vbox), frame);
toggle = gtk_toggle_button_new_with_label ("Toggle");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), is_active);
gtk_container_add (GTK_CONTAINER (frame), toggle);
g_signal_connect (toggle, "toggled", G_CALLBACK (_toggle_cb), swtch);
gtk_widget_show_all (window);
g_signal_connect (window, "delete-event", gtk_main_quit, NULL);
gtk_main ();
return 0;
}
static void
gcal_toolbar_set_event_mode (GcalToolbar *toolbar)
{
GcalToolbarPrivate *priv;
GtkStyleContext *context;
g_return_if_fail (GCAL_IS_TOOLBAR (toolbar));
priv = toolbar->priv;
/* back */
if (priv->back_button == NULL)
{
priv->back_button = gtk_button_new_with_label (_("Back"));
g_object_ref_sink (priv->back_button);
gtk_button_set_image (
GTK_BUTTON (priv->back_button),
gtk_image_new_from_icon_name ("go-previous-symbolic",
GTK_ICON_SIZE_MENU));
context = gtk_widget_get_style_context (priv->back_button);
gtk_style_context_add_class (context, "raised");
g_signal_connect (priv->back_button,
"clicked",
G_CALLBACK (gcal_toolbar_back_clicked),
toolbar);
}
gtk_container_add (GTK_CONTAINER (priv->left_item), priv->back_button);
gtk_widget_show_all (priv->back_button);
/* edit */
if (priv->edit_button == NULL)
{
priv->edit_button = gtk_toggle_button_new_with_label (_("Edit"));
g_object_ref_sink (priv->edit_button);
context = gtk_widget_get_style_context (priv->edit_button);
gtk_style_context_add_class (context, "raised");
g_signal_connect (priv->edit_button,
"toggled",
G_CALLBACK (gcal_toolbar_event_edited),
toolbar);
}
/* reset morphing edit_button */
gtk_button_set_label (GTK_BUTTON (priv->edit_button), _("Edit"));
g_signal_handlers_block_by_func (priv->edit_button, gcal_toolbar_event_edited, toolbar);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->edit_button), FALSE);
g_signal_handlers_unblock_by_func (priv->edit_button, gcal_toolbar_event_edited, toolbar);
gtk_container_add (GTK_CONTAINER (priv->right_item), priv->edit_button);
gtk_widget_show_all (priv->edit_button);
}
static void
open_control_window (void)
{
GtkWidget *window;
GtkWidget *box;
GtkWidget *toggle;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Controls");
g_signal_connect (window, "delete-event",
G_CALLBACK (gtk_main_quit), window);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box);
toggle =
gtk_toggle_button_new_with_label ("Containers have borders");
g_signal_connect (G_OBJECT (toggle),
"toggled", G_CALLBACK (on_toggle_border_widths),
NULL);
gtk_container_add (GTK_CONTAINER (box), toggle);
toggle =
gtk_toggle_button_new_with_label ("Set small size requests");
g_signal_connect (G_OBJECT (toggle),
"toggled", G_CALLBACK (on_set_small_size_requests),
NULL);
gtk_container_add (GTK_CONTAINER (box), toggle);
toggle =
gtk_toggle_button_new_with_label ("Set large size requests");
g_signal_connect (G_OBJECT (toggle),
"toggled", G_CALLBACK (on_set_large_size_requests),
NULL);
gtk_container_add (GTK_CONTAINER (box), toggle);
gtk_widget_show_all (window);
}
GtkWidget *filedump_new(const char *text, struct encdata *enc)
{
GtkWidget *dumpbox;
GtkWidget *hbox, *tmpwid, *entry;
/*dumpwin = gtk_dialog_new();
gtk_window_set_modal(GTK_WINDOW(dumpwin), TRUE);
gtk_window_set_title(GTK_WINDOW(dumpwin), "Record Stream");
gtk_container_set_border_width(GTK_CONTAINER(dumpwin), 7);
gtk_signal_connect(GTK_OBJECT(dumpwin), "destroy",
(GtkSignalFunc) gtk_widget_destroy, NULL);*/
dumpbox = gtk_vbox_new(FALSE, 4);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(dumpbox), hbox, FALSE, FALSE, 0);
if(!(strcmp(text, "Lame")))
tmpwid = gtk_label_new(_("Record Lame Stream"));
else
tmpwid = gtk_label_new(_("Record Ogg/Vorbis Stream"));
gtk_box_pack_start(GTK_BOX(hbox), tmpwid, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(dumpbox), hbox, FALSE, FALSE, 0);
tmpwid = gtk_label_new(_("Enter filename"));
gtk_box_pack_start(GTK_BOX(hbox), tmpwid, FALSE, FALSE, 0);
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(dumpbox), hbox, FALSE, FALSE, 0);
tmpwid=gtk_button_new_with_label(_("Browse..."));
gtk_signal_connect(GTK_OBJECT(tmpwid), "clicked",
(GtkSignalFunc) filedump_sel_file, entry);
gtk_box_pack_start(GTK_BOX(hbox), tmpwid, FALSE, FALSE, 0);
tmpwid = gtk_toggle_button_new_with_label(_("Record now!"));
/*if(mixer->fileout)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tmpwid), TRUE);*/
g_object_set_data(G_OBJECT(entry), "enc", (void *) enc);
g_signal_connect(G_OBJECT(tmpwid), "clicked",
G_CALLBACK(gcb_set_filedump), entry);
gtk_box_pack_start(GTK_BOX(hbox), tmpwid, FALSE, FALSE, 0);
gtk_widget_show_all(dumpbox);
return dumpbox;
}
/**
* create the table of buttons and set the signals
*
* \param
*
* \return the new table of buttons
* */
GtkWidget *gsb_form_config_create_buttons_table ( void )
{
GtkWidget *table;
gint current_element_number;
gint row, column;
/* the table is 3x6 buttons */
table = gtk_table_new ( 3, 6, FALSE );
/* the date, debit and credit are obligatory, so begin to number 4 */
current_element_number = 4;
for ( row=0 ; row<3 ; row++ )
for ( column=0 ; column<6 ; column++ )
{
gchar *string;
gchar *changed_string;
string = _(gsb_form_widget_get_name (current_element_number));
if ( string )
{
/* the max string in the button is 10 characters */
changed_string = limit_string ( string,
10 );
form_config_buttons[column + row*6] = gtk_toggle_button_new_with_label ( changed_string );
g_object_set_data ( G_OBJECT ( form_config_buttons[column + row*6] ),
"element_number",
GINT_TO_POINTER ( current_element_number));
g_signal_connect ( G_OBJECT ( form_config_buttons[column + row*6] ),
"toggled",
G_CALLBACK (gsb_form_config_toggle_element_button),
NULL );
gtk_table_attach_defaults ( GTK_TABLE ( table ),
form_config_buttons[column + row*6],
column, column+1,
row, row+1 );
/* set the tooltip with the real name */
string = g_strconcat ( " ", string, " ", NULL );
gtk_widget_set_tooltip_text ( GTK_WIDGET (form_config_buttons[column + row*6]),
string);
g_free (changed_string);
}
current_element_number++;
}
return table;
}
static void add_buttons (GtkWidget* mbox)
{
GtkWidget *hbox;
gRun = GTK_WIDGET(gtk_toggle_button_new_with_label (" Run "));
gtk_widget_set_usize (gRun, 60, 20);
gReset = GTK_WIDGET(gtk_button_new_with_label (" Reset "));
gtk_widget_set_usize (gReset, 60, 20);
hbox = gtk_hbox_new (TRUE, 10);
gtk_box_pack_start(GTK_BOX (hbox), gRun, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX (hbox), gReset, FALSE, FALSE,0);
add(mbox, hbox);
}
static void start_gui(GFile* usb_root) {
char* usb_root_path = g_file_get_path(usb_root);
time_t timer = time(NULL);
struct tm* timeinfo = localtime(&timer);
char rel_dir_name[20];
strftime(rel_dir_name, 20, "Aufnahme-%F", timeinfo);
char* recordings_dir_path = (char*) malloc((strlen(usb_root_path) + 21) * sizeof(char));
strcpy(recordings_dir_path, usb_root_path);
strcat(recordings_dir_path, "/");
strcat(recordings_dir_path, rel_dir_name);
g_free(usb_root_path);
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget* h_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget* record_button = gtk_toggle_button_new_with_label("Aufnahme starten");
GtkWidget* recordings_scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(recordings_scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
GtkWidget* recordings_frame = gtk_frame_new("Aufnahmen");
gtk_frame_set_shadow_type(GTK_FRAME(recordings_frame), GTK_SHADOW_ETCHED_IN);
gtk_frame_set_label_align(GTK_FRAME(recordings_frame), 0.5, 0.5);
GtkWidget* recordings_list_box = gtk_list_box_new();
GtkWidget* v_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
GtkWidget* delete_button = gtk_button_new_with_label("letzte Aufnahme löschen");
Data* data = (Data*) malloc(sizeof(Data));
data->recordings_dir_path = recordings_dir_path;
data->recordings_list_box = recordings_list_box;
data->index = -1;
data->recording_pid = 0;
data->playing_pid = 0;
data->currently_playing_song = NULL;
update_recordings_list(data);
g_signal_connect(GTK_TOGGLE_BUTTON(record_button), "toggled", G_CALLBACK(on_recording_button_toggled), data);
g_signal_connect(GTK_BUTTON(delete_button), "clicked", G_CALLBACK(on_delete_button_clicked), data);
gtk_box_pack_start(GTK_BOX(h_box), record_button, TRUE, TRUE, 10);
gtk_box_pack_start(GTK_BOX(h_box), v_box, FALSE, TRUE, 10);
gtk_container_add(GTK_CONTAINER(recordings_scrolled_window), recordings_frame);
gtk_box_pack_start(GTK_BOX(v_box), recordings_scrolled_window, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(v_box), delete_button, FALSE, TRUE, 10);
gtk_container_add(GTK_CONTAINER(recordings_frame), recordings_list_box);
gtk_container_add(GTK_CONTAINER(window), h_box);
data->right_box = v_box;
//gtk_window_set_title(GTK_WINDOW(window), "Christians Aufnehmer");
//gtk_window_fullscreen(GTK_WINDOW(window));
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(window);
}
