void tablewizard_dialog(Tbfwin *bfwin) {
GtkWidget *dgtable;
Thtml_diag *dg;
dg = html_diag_new(bfwin,_("Table Wizard"));
dgtable = gtk_table_new(4, 5, 0);
gtk_table_set_row_spacings(GTK_TABLE(dgtable), 6);
gtk_table_set_col_spacings(GTK_TABLE(dgtable), 12);
gtk_box_pack_start(GTK_BOX(dg->vbox), dgtable, FALSE, FALSE, 0);
dg->spin[1] = spinbut_with_value("1", 1, 100, 1.0, 5.0);
bf_mnemonic_label_tad_with_alignment(_("Number of _rows:"), dg->spin[1], 0, 0.5, dgtable, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(dgtable), dg->spin[1], 1, 5, 0, 1);
dg->spin[2] = spinbut_with_value("1", 1, 100, 1.0, 5.0);
bf_mnemonic_label_tad_with_alignment(_("Number of colu_mns:"), dg->spin[2], 0, 0.5, dgtable, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(dgtable), dg->spin[2], 1, 5, 1, 2);
dg->check[1] = gtk_check_button_new();
bf_mnemonic_label_tad_with_alignment(_("Table rows on one _line:"), dg->check[1], 0, 0.5, dgtable, 0, 1, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(dgtable), dg->check[1], 1, 2, 2, 3);
dg->check[2] = gtk_check_button_new();
bf_mnemonic_label_tad_with_alignment(_("_Indent table code:"), dg->check[2], 0, 0.5, dgtable, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(dgtable), dg->check[2], 1, 5, 3, 4);
html_diag_finish(dg, G_CALLBACK(table_wizard_ok_lcb));
}
/**
@brief add a check button for a current permission
@param table the table to which the button will be added
@param left index of column to left of attach-position in @a table
@param right index of column to right of attach-position in @a table
@param top index or row above attach-position in @a table
@param bottom index of row below attach-position in @a table
@param label label to add to the button, or NULL
@param state state of the button
@param i buttons-array index of added button
@param rt pointer to dialog data struct
@return
*/
static void _e2_permissions_dialog_add_chmod_button (
GtkWidget *table,
gint left, gint right, gint top, gint bottom,
gint i,
gchar *label,
gint state,
E2_PermsDldRuntime *rt)
{
if (label == NULL)
{ //align the button reasonably
GtkWidget *aligner = gtk_alignment_new (0.1, 0.5, 0, 0 );
GtkWidget *check_button = gtk_check_button_new ();
gtk_container_add (GTK_CONTAINER (aligner), check_button);
#ifdef USE_GTK3_2
gtk_grid_attach (GTK_GRID(table), aligner, left, top, right-left, bottom-top);
#else
gtk_table_attach (GTK_TABLE (table), aligner,
left, right, top, bottom,
GTK_FILL, //GtkAttachOptions xoptions
GTK_FILL, //GtkAttachOptions yoptions
0, //xpadding
0 //ypadding
);
#endif
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), state);
rt->chmod_buttons[i] = check_button;
}
else //there is a label
rt->chmod_buttons[i] = e2_button_add_toggle_to_table (table,
label, state, NULL, NULL, left, right, top, bottom);
//prevent changes if relevant
if (!rt->permission)
gtk_widget_set_sensitive (rt->chmod_buttons[i], FALSE);
}
static GtkWidget *gl_create_water_plane (gl_preview_struct *gl_preview) {
GtkWidget *vbox, *scale;
// 1. Create Vbox for water control
vbox = gtk_vbox_new(FALSE,0);
gtk_widget_show(GTK_WIDGET(vbox));
if ((!gl_preview->use_water) || (!gl_preview->water_level))
// Nothing to do if pointers are NULL
return vbox;
// 2. Pack water label + check button on/off + scale in Vbox
define_label_in_box("Water", vbox, FALSE, TRUE, 0);
gl_preview->if_water_chkbox = gtk_check_button_new ();
gtk_widget_show (gl_preview->if_water_chkbox);
gtk_box_pack_start (GTK_BOX(vbox), align_widget(gl_preview->if_water_chkbox,ALIGN_CENTER, ALIGN_CENTER), FALSE, FALSE, DEF_PAD*0.5);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gl_preview->if_water_chkbox), *gl_preview->use_water);
gl_preview->adj_water_level = gtk_adjustment_new (*gl_preview->water_level, 0.0, 1.1, 0.01, 0.1, 0.1);
g_signal_connect (G_OBJECT(gl_preview->adj_water_level), "value_changed",
GTK_SIGNAL_FUNC(gfloat_adj_callb), gl_preview->water_level);
g_signal_connect (G_OBJECT(gl_preview->adj_water_level), "value_changed",
GTK_SIGNAL_FUNC(gl_area_redraw), gl_preview);
scale = define_scale_in_box (gl_preview->adj_water_level, vbox, 2, DEF_PAD*0.5);
gtk_range_set_inverted (GTK_RANGE(scale), TRUE);
g_signal_connect (G_OBJECT(gl_preview->if_water_chkbox), "toggled", GTK_SIGNAL_FUNC(sensitive_if_true), scale);
g_signal_connect (G_OBJECT(gl_preview->if_water_chkbox), "toggled",
GTK_SIGNAL_FUNC(toggle_check_button_callb), gl_preview->use_water);
g_signal_connect (G_OBJECT(gl_preview->if_water_chkbox), "toggled", GTK_SIGNAL_FUNC(gl_area_redraw), gl_preview);
return vbox;
}
void
stpui_create_scale_entry(option_t *opt,
GtkTable *table,
gint column,
gint row,
const gchar *text,
gint scale_usize,
gint spinbutton_usize,
gfloat value,
gfloat lower,
gfloat upper,
gfloat step_increment,
gfloat page_increment,
guint digits,
gboolean constrain,
gfloat unconstrained_lower,
gfloat unconstrained_upper,
const gchar *tooltip,
gboolean is_optional)
{
opt->checkbox = gtk_check_button_new();
gtk_table_attach(GTK_TABLE(table), opt->checkbox,
column, column + 1, row, row + 1,
GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
opt->info.flt.adjustment =
stpui_scale_entry_new(table, column, row, text, scale_usize,
spinbutton_usize, value, lower, upper,
step_increment, page_increment, digits, constrain,
unconstrained_lower, unconstrained_upper, tooltip);
}
void framewizard_dialog(Tbfwin *bfwin) {
GtkWidget *dgtable, *frame, *vbox, *label;
Thtml_diag *dg;
gint i;
dg = html_diag_new(bfwin,_("Frame Wizard"));
dgtable = gtk_table_new(4, 12, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(dgtable), 6);
gtk_table_set_col_spacings(GTK_TABLE(dgtable), 12);
frame = gtk_aspect_frame_new(NULL, 0, 0.5, 0, TRUE);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
gtk_box_pack_start(GTK_BOX(dg->vbox), frame, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), dgtable);
dg->entry[12] = entry_with_text(NULL, 256);
bf_mnemonic_label_tad_with_alignment(_("_Title:"), dg->entry[12], 0, 0.5, dgtable, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(dgtable), dg->entry[12], 1, 12, 0, 1);
dg->check[0] = gtk_check_button_new();
bf_mnemonic_label_tad_with_alignment(_("Use _DTD:"), dg->check[0], 0, 0.5, dgtable, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(dgtable), dg->check[0], 1, 2, 1, 2);
label = gtk_label_new(_("Orientation:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach_defaults(GTK_TABLE(dgtable), label, 0, 1, 2, 3);
dg->radio[1] = radiobut_with_value(_("_Horizontal"), 0, NULL);
dg->radio[2] = radiobut_with_value(_("_Vertical"), 0, GTK_RADIO_BUTTON(dg->radio[1]));
gtk_table_attach_defaults(GTK_TABLE(dgtable), dg->radio[1], 1, 2, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(dgtable), dg->radio[2], 2, 3, 2, 3);
dg->spin[1] = spinbut_with_value("2", 1, MAX_FRAMES_IN_FRAMEWIZARD, 1.0, 2.0);
bf_mnemonic_label_tad_with_alignment(_("Number of _Frames:"), dg->spin[1], 0, 0.5, dgtable, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(dgtable), dg->spin[1], 1, 2, 3, 4);
g_signal_connect(G_OBJECT(dg->spin[1]), "changed", G_CALLBACK(frame_wizard_num_changed), dg);
frame = gtk_frame_new(_("Frame's"));
gtk_container_set_border_width(GTK_CONTAINER(frame), 6);
gtk_box_pack_start(GTK_BOX(dg->vbox), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);
gtk_container_add(GTK_CONTAINER(frame), vbox);
for (i = 0; i < MAX_FRAMES_IN_FRAMEWIZARD ; i++) {
GtkWidget *file_but;
/* since there are no clists in this dialog we can use it freely :) */
dg->clist[i] = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), dg->clist[i], FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(dg->clist[i]), gtk_label_new(_("Name:")), TRUE, TRUE, 0);
dg->combo[i] = boxed_combo_with_popdown(NULL, bfwin->session->targetlist, 1, dg->clist[i]);
gtk_box_pack_start(GTK_BOX(dg->clist[i]), gtk_label_new(_("Source:")), TRUE, TRUE, 0);
dg->combo[i+5] = boxed_combo_with_popdown(NULL, bfwin->session->urllist, 1, dg->clist[i]);
file_but = file_but_new(GTK_WIDGET(GTK_COMBO(dg->combo[i+5])->entry), 0, bfwin);
gtk_box_pack_start(GTK_BOX(dg->clist[i]), file_but, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(dg->clist[i]), gtk_label_new(_("Size:")), TRUE, TRUE, 0);
dg->entry[i] = boxed_entry_with_text(NULL, 100, dg->clist[i]);
}
html_diag_finish(dg, G_CALLBACK(frame_wizard_ok_lcb));
frame_wizard_num_changed(NULL, dg);
}
static regrow *make_regrow(GtkWidget *ww, GtkSignalFunc play_callback, GtkSignalFunc name_callback)
{
regrow *r;
r = (regrow *)CALLOC(1, sizeof(regrow));
/* assume "ww" is a vbox widget in this case */
r->rw = gtk_hbox_new(false, 0);
gtk_box_pack_start(GTK_BOX(ww), r->rw, false, false, 0);
gtk_widget_modify_bg(r->rw, GTK_STATE_NORMAL, ss->sgx->highlight_color);
gtk_widget_modify_base(r->rw, GTK_STATE_NORMAL, ss->sgx->highlight_color);
gtk_widget_show(r->rw);
r->pl = gtk_check_button_new();
gtk_box_pack_start(GTK_BOX(r->rw), r->pl, false, false, 2);
SG_SIGNAL_CONNECT(r->pl, "toggled", play_callback, r);
gtk_widget_show(r->pl);
r->nm = gtk_button_new_with_label("");
sg_left_justify_button(r->nm);
gtk_box_pack_start(GTK_BOX(r->rw), r->nm, true, true, 2);
SG_SIGNAL_CONNECT(r->nm, "clicked", name_callback, r);
SG_SIGNAL_CONNECT(r->nm, "enter_notify_event", regrow_mouse_enter_label, r);
SG_SIGNAL_CONNECT(r->nm, "leave_notify_event", regrow_mouse_leave_label, r);
set_user_data(G_OBJECT(r->nm), (gpointer)r);
gtk_widget_modify_bg(r->nm, GTK_STATE_NORMAL, ss->sgx->highlight_color);
gtk_widget_modify_base(r->nm, GTK_STATE_NORMAL, ss->sgx->highlight_color);
gtk_widget_show(r->nm);
return(r);
}
static GtkWidget*
remmina_file_editor_create_chooser(RemminaFileEditor* gfe, GtkWidget* table, gint row, gint col, const gchar* label,
const gchar* value, gint type)
{
GtkWidget* check;
GtkWidget* widget;
GtkWidget* hbox;
widget = gtk_label_new(label);
gtk_widget_show(widget);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), widget, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox);
gtk_table_attach_defaults(GTK_TABLE(table), hbox, col + 1, col + 2, row, row + 1);
check = gtk_check_button_new();
gtk_widget_show(check);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), (value && value[0] == '/'));
gtk_box_pack_start(GTK_BOX(hbox), check, FALSE, FALSE, 0);
widget = gtk_file_chooser_button_new(label, type);
gtk_widget_show(widget);
if (value)
{
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(widget), value);
}
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(remmina_file_editor_button_on_toggled), widget);
remmina_file_editor_button_on_toggled(GTK_TOGGLE_BUTTON(check), widget);
return widget;
}
static GtkWidget *
checkbutton_new (GladeXML *xml, GladeWidgetInfo *info)
{
GtkWidget *button;
GList *tmp;
char *string = NULL;
gboolean active = FALSE, draw_indicator = TRUE;
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';
else if (!strcmp(attr->name, "draw_indicator"))
draw_indicator = attr->value[0] == 'T';
}
if (string != NULL) {
guint key;
button = gtk_check_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_check_button_new();
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), active);
gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(button), draw_indicator);
return button;
}
GtkWidget *cd_screenshot_build_options_widget (void)
{
GtkWidget *pHBox;
const gchar *cTooltip;
GtkWidget *pBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, CAIRO_DOCK_GUI_MARGIN);
cTooltip = D_("in seconds.");
pHBox = _add_label_in_new_hbox (D_("Delay"), cTooltip, pBox);
GtkWidget *pScale;
GtkAdjustment *pAdjustment = gtk_adjustment_new (0,
0, // min
10, // max
1, // step
1, // step
0);
pScale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (pAdjustment));
gtk_scale_set_digits (GTK_SCALE (pScale), 0);
g_object_set (pScale, "width-request", 100, NULL);
gldi_dialog_set_widget_text_color (pScale);
gtk_box_pack_end (GTK_BOX (pHBox), pScale, FALSE, FALSE, _MARGIN);
g_object_set_data (G_OBJECT (pBox), "delay", pScale);
gtk_widget_set_tooltip_text (pScale, cTooltip);
cTooltip = D_("Grab the current window instead of the all screen");
pHBox = _add_label_in_new_hbox (D_("Grab the current window"), cTooltip, pBox);
GtkWidget *pCheckButton = gtk_check_button_new ();
gtk_box_pack_end (GTK_BOX (pHBox), pCheckButton, FALSE, FALSE, _MARGIN);
g_object_set_data (G_OBJECT (pBox), "current", pCheckButton);
gtk_widget_set_tooltip_text (pCheckButton, cTooltip);
cTooltip = D_("Let empty to use the default one.");
pHBox = _add_label_in_new_hbox (D_("File name"), cTooltip, pBox);
GtkWidget *pEntry = gtk_entry_new ();
gtk_box_pack_end (GTK_BOX (pHBox), pEntry, FALSE, FALSE, _MARGIN);
g_object_set_data (G_OBJECT (pBox), "name", pEntry);
gtk_widget_set_tooltip_text (pEntry, cTooltip);
cTooltip = D_("Let empty to use the default one.");
pHBox = _add_label_in_new_hbox (D_("Directory"), cTooltip, pBox);
pEntry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (pEntry), myConfig.cDirPath ? myConfig.cDirPath : g_getenv ("HOME"));
g_object_set_data (G_OBJECT (pBox), "dir", pEntry);
GtkWidget *pButtonFileChooser = gtk_button_new_from_icon_name (GLDI_ICON_NAME_OPEN, GTK_ICON_SIZE_BUTTON);
g_signal_connect (G_OBJECT (pButtonFileChooser),
"clicked",
G_CALLBACK (_cairo_dock_pick_a_file),
pEntry);
gtk_box_pack_end (GTK_BOX (pHBox), pButtonFileChooser, FALSE, FALSE, _MARGIN);
gtk_box_pack_end (GTK_BOX (pHBox), pEntry, FALSE, FALSE, _MARGIN);
gtk_widget_set_tooltip_text (pEntry, cTooltip);
return pBox;
}
static GtkWidget* main_window() {
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Cheeseburger Machine");
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
GtkWidget* listbox = gtk_list_box_new();
gtk_list_box_set_selection_mode(GTK_LIST_BOX(listbox), GTK_SELECTION_NONE);
gtk_container_add(GTK_CONTAINER(window), listbox);
// Re-use variables so we're not making row1, row2, and such.
GtkWidget *row, *box, *label;
// Checkbox
row = gtk_list_box_row_new();
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 100);
gtk_container_add(GTK_CONTAINER(row), box);
label = gtk_label_new("Check if you love cheeseburgers:");
GtkWidget* check = gtk_check_button_new();
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), check, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(listbox), row);
// Toggle Switch
row = gtk_list_box_row_new();
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 100);
gtk_container_add(GTK_CONTAINER(row), box);
label = gtk_label_new("Burger making machine`:");
GtkWidget* switcher = gtk_switch_new();
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), switcher, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(listbox), row);
return window;
}
static struct gopt *gopt_new_bool(struct gopt_job_view *gjv,
struct fio_option *o, unsigned int *val,
unsigned int idx)
{
struct gopt_bool *b;
GtkWidget *label;
int defstate = 0;
b = calloc(1, sizeof(*b));
b->gopt.box = gtk_hbox_new(FALSE, 3);
if (!o->lname)
label = gtk_label_new(o->name);
else
label = gtk_label_new(o->lname);
b->check = gtk_check_button_new();
gopt_mark_index(gjv, &b->gopt, idx, GOPT_BOOL);
if (o->def && !strcmp(o->def, "1"))
defstate = 1;
if (o->neg)
defstate = !defstate;
if (val)
gopt_bool_set_val(b, *val);
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(b->check), defstate);
b->gopt.sig_handler = g_signal_connect(G_OBJECT(b->check), "toggled", G_CALLBACK(gopt_bool_toggled), b);
g_signal_connect(G_OBJECT(b->check), "destroy", G_CALLBACK(gopt_bool_destroy), b);
gtk_box_pack_start(GTK_BOX(b->gopt.box), b->check, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(b->gopt.box), label, FALSE, FALSE, 0);
return &b->gopt;
}
bool wxCheckBox::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("wxCheckBox creation failed") );
return false;
}
wxASSERT_MSG( (style & wxCHK_ALLOW_3RD_STATE_FOR_USER) == 0 ||
(style & wxCHK_3STATE) != 0,
wxT("Using wxCHK_ALLOW_3RD_STATE_FOR_USER")
wxT(" style flag for a 2-state checkbox is useless") );
if ( style & wxALIGN_RIGHT )
{
// VZ: as I don't know a way to create a right aligned checkbox with
// GTK we will create a checkbox without label and a label at the
// left of it
m_widgetCheckbox = gtk_check_button_new();
m_widgetLabel = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(m_widgetLabel), 0.0, 0.5);
m_widget = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(m_widget), m_widgetLabel, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(m_widget), m_widgetCheckbox, FALSE, FALSE, 3);
gtk_widget_show( m_widgetLabel );
gtk_widget_show( m_widgetCheckbox );
}
else
{
m_widgetCheckbox = gtk_check_button_new_with_label("");
m_widgetLabel = GTK_BIN(m_widgetCheckbox)->child;
m_widget = m_widgetCheckbox;
}
SetLabel( label );
g_signal_connect (m_widgetCheckbox, "toggled",
G_CALLBACK (gtk_checkbox_toggled_callback), this);
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
/**
* vtable_dialog_new:
*
* Returns: a new #GtkWidget
*/
GtkWidget *
vtable_dialog_new (GtkWindow *parent, TConnection *tcnc)
{
VtableDialog *dlg;
g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL);
dlg = VTABLE_DIALOG (g_object_new (VTABLE_DIALOG_TYPE, NULL));
dlg->priv->tcnc = g_object_ref (tcnc);
if (parent)
gtk_window_set_transient_for (GTK_WINDOW (dlg), parent);
gtk_window_set_modal (GTK_WINDOW (dlg), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (dlg), SPACING * 2);
gtk_window_set_title (GTK_WINDOW (dlg), _("Define LDAP search as a virtual table"));
GtkWidget *dcontents;
GtkWidget *label, *entry, *grid, *button;
gchar *str;
dcontents = gtk_dialog_get_content_area (GTK_DIALOG (dlg));
label = gtk_label_new (NULL);
gtk_widget_set_halign (label, GTK_ALIGN_START);
str = g_markup_printf_escaped ("<b>%s:</b>\n<small>%s</small>",
_("Name of the virtual LDAP table to create"),
_("Everytime data is selected from the virtual table which will "
"be created, the LDAP search will be executed and data "
"returned as the contents of the table."));
gtk_label_set_markup (GTK_LABEL (label), str);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
g_free (str);
gtk_box_pack_start (GTK_BOX (dcontents), label, FALSE, FALSE, SPACING);
grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (grid), SPACING);
gtk_grid_set_row_spacing (GTK_GRID (grid), SPACING);
gtk_box_pack_start (GTK_BOX (dcontents), grid, FALSE, FALSE, SPACING);
label = gtk_label_new (_("Table name:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
entry = gtk_entry_new ();
gtk_grid_attach (GTK_GRID (grid), entry, 1, 0, 1, 1);
dlg->priv->tname_entry = entry;
label = gtk_label_new (_("Replace if exists:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
button = gtk_check_button_new ();
gtk_grid_attach (GTK_GRID (grid), button, 1, 1, 1, 1);
dlg->priv->tname_replace = button;
gtk_widget_show_all (dcontents);
gtk_dialog_add_buttons (GTK_DIALOG (dlg),
_("_Ok"), GTK_RESPONSE_OK,
_("_Cancel"), GTK_RESPONSE_CANCEL, NULL);
return (GtkWidget*) dlg;
}
GtkWidget* RenderThemeGtk::gtkCheckButton() const
{
if (m_gtkCheckButton)
return m_gtkCheckButton;
m_gtkCheckButton = gtk_check_button_new();
setupWidgetAndAddToContainer(m_gtkCheckButton, gtkContainer());
return m_gtkCheckButton;
}
bool wxCheckBox::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;
WXValidateStyle(&style);
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxCheckBox creation failed") );
return false;
}
if ( style & wxALIGN_RIGHT )
{
// VZ: as I don't know a way to create a right aligned checkbox with
// GTK we will create a checkbox without label and a label at the
// left of it
m_widgetCheckbox = gtk_check_button_new();
m_widgetLabel = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(m_widgetLabel), 0.0, 0.5);
m_widget = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(m_widget), m_widgetLabel, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(m_widget), m_widgetCheckbox, FALSE, FALSE, 3);
gtk_widget_show( m_widgetLabel );
gtk_widget_show( m_widgetCheckbox );
}
else
{
m_widgetCheckbox = gtk_check_button_new_with_label("");
m_widgetLabel = BUTTON_CHILD( m_widgetCheckbox );
m_widget = m_widgetCheckbox;
}
SetLabel( label );
gtk_signal_connect( GTK_OBJECT(m_widgetCheckbox),
"toggled",
GTK_SIGNAL_FUNC(gtk_checkbox_toggled_callback),
(gpointer *)this );
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
GtkWidget *
ggzpurple_preferences_get_frame(PurplePlugin *plugin) {
pTable = gtk_table_new(5,5,TRUE);
pLogin = gtk_entry_new();
pPassword = gtk_entry_new();
pCheckBox = gtk_check_button_new();
pServer = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(pPassword), FALSE);
gtk_entry_set_text(GTK_ENTRY(pLogin),purple_prefs_get_string("/plugins/gtk/ggzpurple/login"));
gtk_entry_set_text(GTK_ENTRY(pPassword),purple_prefs_get_string("/plugins/gtk/ggzpurple/password"));
gtk_entry_set_text(GTK_ENTRY(pServer),purple_prefs_get_string("/plugins/gtk/ggzpurple/server"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pCheckBox), purple_prefs_get_bool("/plugins/gtk/ggzpurple/guest"));
gtk_table_attach_defaults(GTK_TABLE(pTable),gtk_label_new("Identification en 'guest' :"),0,2,1,2);
gtk_table_attach_defaults(GTK_TABLE(pTable),gtk_label_new("Pseudo :"),0,2,2,3);
gtk_table_attach_defaults(GTK_TABLE(pTable),gtk_label_new("Pass :"******"Serveur :"),0,2,4,5);
gtk_table_attach_defaults(GTK_TABLE(pTable),pCheckBox,3,4,1,2);
gtk_table_attach_defaults(GTK_TABLE(pTable),pLogin,3,5,2,3);
gtk_table_attach_defaults(GTK_TABLE(pTable),pPassword,3,5,3,4);
gtk_table_attach_defaults(GTK_TABLE(pTable),pServer,3,5,4,5);
//purple_prefs_set_int(pref_url, int);
//purple_prefs_add_string(const char *name, const char *value);
//purple_prefs_add_bool(const char *name, gboolean value);
//purple_prefs_add_int(const char *name, int value);
//gboolean purple_prefs_get_bool(const char *name);
//int purple_prefs_get_int(const char *name);
//const char *purple_prefs_get_string(const char *name);
g_signal_connect(GTK_OBJECT(pLogin), "changed", G_CALLBACK(ggzpurple_entry_change_cb), "/plugins/gtk/ggzpurple/login");
g_signal_connect(GTK_OBJECT(pPassword), "changed", G_CALLBACK(ggzpurple_entry_change_cb), "/plugins/gtk/ggzpurple/password");
g_signal_connect(GTK_OBJECT(pServer), "changed", G_CALLBACK(ggzpurple_entry_change_cb), "/plugins/gtk/ggzpurple/server");
g_signal_connect(GTK_OBJECT(pCheckBox), "clicked", G_CALLBACK(ggzpurple_checkbox_change_cb), "/plugins/gtk/ggzpurple/guest");
gtk_widget_show_all(pTable);
return pTable;
}
bool wxCheckBox::Create(wxWindow *parent,
wxWindowID id,
const wxString &label,
const wxPoint &pos,
const wxSize &size,
long style,
const wxValidator& validator,
const wxString &name )
{
WXValidateStyle( &style );
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxCheckBox creation failed") );
return false;
}
if ( style & wxALIGN_RIGHT )
{
// VZ: as I don't know a way to create a right aligned checkbox with
// GTK we will create a checkbox without label and a label at the
// left of it
m_widgetCheckbox = gtk_check_button_new();
m_widgetLabel = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(m_widgetLabel), 0.0, 0.5);
m_widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(m_widget), m_widgetLabel, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(m_widget), m_widgetCheckbox, FALSE, FALSE, 3);
gtk_widget_show( m_widgetLabel );
gtk_widget_show( m_widgetCheckbox );
}
else
{
m_widgetCheckbox = gtk_check_button_new_with_label("");
m_widgetLabel = gtk_bin_get_child(GTK_BIN(m_widgetCheckbox));
m_widget = m_widgetCheckbox;
}
g_object_ref(m_widget);
SetLabel( label );
g_signal_connect (m_widgetCheckbox, "toggled",
G_CALLBACK (gtk_checkbox_toggled_callback), this);
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
static GtkWidget *
create_boolean_editor (RBObjectPropertyEditor *editor, const char *property, GParamSpec *pspec)
{
GtkWidget *control;
control = gtk_check_button_new ();
g_object_bind_property (editor->priv->object, property,
control, "active",
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
return control;
}
static void
build_ui (EPilotSettings *ps, ESourceList *source_list)
{
EPilotSettingsPrivate *priv;
GtkWidget *lbl;
priv = ps->priv;
gtk_table_resize (GTK_TABLE (ps), 2, 2);
gtk_container_set_border_width (GTK_CONTAINER (ps), 4);
gtk_table_set_col_spacings (GTK_TABLE (ps), 6);
lbl = gtk_label_new (_("Sync with:"));
gtk_misc_set_alignment (GTK_MISC (lbl), 0.0, 0.5);
priv->source = e_source_combo_box_new (source_list);
gtk_table_attach_defaults (GTK_TABLE (ps), lbl, 0, 1, 0, 1);
gtk_table_attach_defaults (GTK_TABLE (ps), priv->source, 1, 2, 0, 1);
gtk_widget_show (lbl);
gtk_widget_show (priv->source);
lbl = gtk_label_new (_("Sync Private Records:"));
gtk_misc_set_alignment (GTK_MISC (lbl), 0.0, 0.5);
priv->secret = gtk_check_button_new ();
gtk_table_attach_defaults (GTK_TABLE (ps), lbl, 0, 1, 1, 2);
gtk_table_attach_defaults (GTK_TABLE (ps), priv->secret, 1, 2, 1, 2);
gtk_widget_show (lbl);
gtk_widget_show (priv->secret);
#if 0
lbl = gtk_label_new (_("Sync Categories:"));
gtk_misc_set_alignment (GTK_MISC (lbl), 0.0, 0.5);
priv->cat = gtk_check_button_new ();
gtk_table_attach_defaults (GTK_TABLE (ps), lbl, 0, 1, 2, 3);
gtk_table_attach_defaults (GTK_TABLE (ps), priv->cat, 1, 2, 2, 3);
gtk_widget_show (lbl);
gtk_widget_show (priv->cat);
#endif
}
int module_init(Switch *self)
{
int j;
GtkWidget *main_box;
GtkWidget *button;
GtkWidget *button_box;
GtkWidget *select;
self->ext_state=0xFF;
main_box=gtk_vbox_new(FALSE, 0);
select=h_port_selector_new();
g_signal_connect(select, "port-select",
G_CALLBACK(port_select), self);
gtk_box_pack_start(GTK_BOX(main_box), select, FALSE, FALSE, 0);
/* buttons */
button_box=gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(main_box), button_box, FALSE, FALSE, 0);
for(j=0; j<8; j++) {
button=gtk_check_button_new();
g_signal_connect(button, "toggled",
G_CALLBACK(toggled), self);
gtk_box_pack_start(GTK_BOX(button_box), button, FALSE, FALSE, 0);
self->check_buttons[j]=button;
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON(self->check_buttons[j]), 1);
}
/* try to find empty port */
for(j=0; j<4; j++) {
if (alloc_bits(self, j, 0xFF) == 0){
printf("[switch:%d]\tusing port %d\n", *(int *)self, j);
self->port=j;
port_selector_set_port(PORT_SELECTOR(select), j);
break;
}
}
if (j == 4) {
fprintf(stderr, "[switch:%d]\tno empty port found\n", *(int *)self);
return -1;
}
gtk_widget_show_all(main_box);
self->window=gui_add(main_box, self, "switch panel");
return 0;
}
static GtkWidget *
make_delayed_switch (gboolean is_on,
gboolean is_sensitive)
{
GtkWidget *hbox;
GtkWidget *sw, *label, *spinner, *check;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
sw = gtk_switch_new ();
gtk_switch_set_active (GTK_SWITCH (sw), is_on);
gtk_box_pack_start (GTK_BOX (hbox), sw, FALSE, FALSE, 0);
gtk_widget_set_sensitive (sw, is_sensitive);
gtk_widget_show (sw);
g_signal_connect (sw, "state-set", G_CALLBACK (set_state), NULL);
spinner = gtk_spinner_new ();
gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, TRUE, 0);
gtk_widget_set_opacity (spinner, 0.0);
gtk_widget_show (spinner);
check = gtk_check_button_new ();
gtk_box_pack_end (GTK_BOX (hbox), check, FALSE, TRUE, 0);
gtk_widget_show (check);
g_object_bind_property (sw, "state",
check, "active",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
label = gtk_label_new (is_on ? "Enabled" : "Disabled");
gtk_box_pack_end (GTK_BOX (hbox), label, TRUE, TRUE, 0);
gtk_widget_show (label);
g_object_bind_property_full (sw, "active",
label, "label",
G_BINDING_DEFAULT,
boolean_to_text,
NULL,
NULL, NULL);
g_signal_connect (sw, "notify", G_CALLBACK (sw_delay_notify), spinner);
return hbox;
}
SHOES_CONTROL_REF shoes_native_check(VALUE self, shoes_canvas *canvas, shoes_place *place, VALUE attr, char *msg) {
SHOES_CONTROL_REF ref = gtk_check_button_new();
// set visual state before connecting signal
if (RTEST(ATTR(attr, checked))) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ref), TRUE);
}
if (!NIL_P(shoes_hash_get(attr, rb_intern("checked")))) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ref), shoes_hash_get(attr, rb_intern("checked")) == Qtrue);
}
if (!NIL_P(shoes_hash_get(attr, rb_intern("tooltip")))) {
gtk_widget_set_tooltip_text(GTK_WIDGET(ref), RSTRING_PTR(shoes_hash_get(attr, rb_intern("tooltip"))));
}
g_signal_connect(G_OBJECT(ref), "clicked",
G_CALLBACK(shoes_button_gtk_clicked),
(gpointer)self);
return ref;
}
static void roccat_single_cpi_selector_init(RoccatSingleCpiSelector *selector) {
RoccatSingleCpiSelectorPrivate *priv = ROCCAT_SINGLE_CPI_SELECTOR_GET_PRIVATE(selector);
GtkHBox *hbox;
selector->priv = priv;
hbox = GTK_HBOX(gtk_hbox_new(FALSE, 0));
gtk_container_add(GTK_CONTAINER(selector), GTK_WIDGET(hbox));
priv->radio = GTK_RADIO_BUTTON(gtk_radio_button_new(NULL));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->radio), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(priv->radio), "toggled", G_CALLBACK(click_radio_cb), selector);
priv->active = GTK_CHECK_BUTTON(gtk_check_button_new());
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->active), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(priv->active), "toggled", G_CALLBACK(toggle_active_cb), selector);
priv->scale = GAMINGGEAR_HSCALE(gaminggear_hscale_new_with_range(0, 1, 1));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->scale), TRUE, TRUE, 0);
}
void addLesson(gchar *title, gint flag, char dmon[], gchar *code, GtkWidget *eksam)
{
GtkWidget *hbox;
hbox = gtk_hbox_new (FALSE, 5);
/* DIDAKTIKES MONADES MATHIMATOS */
lessons[i].DM = atoi(dmon);
gtk_box_pack_end (GTK_BOX(hbox), gtk_label_new(dmon), FALSE, FALSE, 5);
/* BATHMOS */
lessons[i].entry = gtk_entry_new();
gtk_entry_set_width_chars (GTK_ENTRY(lessons[i].entry), 5);
gtk_entry_set_max_length (GTK_ENTRY(lessons[i].entry), 5);
gtk_entry_set_text (GTK_ENTRY(lessons[i].entry), "5");
gtk_box_pack_end (GTK_BOX(hbox), lessons[i].entry, FALSE, FALSE, 0);
/* CHECK BOX */
lessons[i].checkbtn = gtk_check_button_new();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(lessons[i].checkbtn), TRUE);
gtk_widget_show (lessons[i].checkbtn);
if (flag == 0) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(lessons[i].checkbtn), TRUE);
gtk_widget_set_sensitive (GTK_WIDGET(lessons[i].checkbtn), FALSE);
gtk_widget_hide (lessons[i].checkbtn);
}
gtk_box_pack_start (GTK_BOX(hbox), lessons[i].checkbtn, FALSE, FALSE, 0);
/* KODIKOS MATHIMATOS */
lessons[i].code = gtk_label_new(code);
gtk_box_pack_start (GTK_BOX(hbox), lessons[i].code, FALSE, FALSE, 0);
/* TITLOS MATHIMATOS */
lessons[i].title = gtk_label_new(title);
gtk_box_pack_start (GTK_BOX(hbox), lessons[i].title, FALSE, FALSE, 5);
g_signal_connect (G_OBJECT(lessons[i].checkbtn), "toggled", G_CALLBACK (checkbtnToggle), GINT_TO_POINTER(i));
gtk_box_pack_start (GTK_BOX(eksam), hbox, TRUE, FALSE, 0);
i++;
}
XWidget *XCheckBoxNew(XWidget *parent)
{
XWidget *chk;
chk=(XWidget*)malloc(sizeof(XWidget));
if(chk==NULL)
{
puts("ERRO ao criar widget");
exit(-2);
}
chk=AddWidget(chk);
chk->window=gtk_check_button_new();
gtk_widget_set_size_request(chk->window,50,30);
gtk_fixed_put(GTK_FIXED(parent->container),chk->window,10,10);
chk->type=CHECKBOX;
chk->parent=parent;
chk->size.x=10;
chk->size.y=10;
chk->size.width=50;
chk->size.height=30;
return (XWidget*)chk;
}
static GtkWidget *vf_marks_filter_init(ViewFile *vf)
{
GtkWidget *frame = gtk_frame_new(NULL);
GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
gint i;
for (i = 0; i < FILEDATA_MARKS_SIZE ; i++)
{
GtkWidget *check = gtk_check_button_new();
gtk_box_pack_start(GTK_BOX(hbox), check, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(check), "toggled",
G_CALLBACK(vf_marks_filter_toggle_cb), vf);
gtk_widget_show(check);
vf->filter_check[i] = check;
}
gtk_container_add(GTK_CONTAINER(frame), hbox);
gtk_widget_show(hbox);
return frame;
}
void
stpui_create_new_combo(option_t *option, GtkWidget *table,
int hpos, int vpos, gboolean is_optional)
{
GtkWidget *event_box = gtk_event_box_new();
GtkWidget *combo = gtk_combo_new();
option->checkbox = gtk_check_button_new();
gtk_table_attach(GTK_TABLE(table), option->checkbox,
hpos, hpos + 1, vpos, vpos + 1,
GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
option->info.list.combo = combo;
gtk_container_add(GTK_CONTAINER(event_box), combo);
gtk_widget_show(combo);
gtk_widget_show(event_box);
stpui_set_help_data(event_box, gettext(option->fast_desc->help));
stpui_table_attach_aligned
(GTK_TABLE(table), hpos + 1, vpos, gettext(option->fast_desc->text),
0.0, 0.5, event_box, 2, TRUE);
option->info.list.label = table_label(GTK_TABLE(table), hpos, vpos);
}
static gboolean main_button_area_draw(struct wcam_win *c, GtkWidget *box)
{
GtkWidget *buttonbox;
GtkWidget *button;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *image;
buttonbox = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(box), buttonbox, FALSE, FALSE, 0);
c->button_area = buttonbox;
/* control button */
image = gtk_image_new_from_file(SETTING_BUTTON_IMG);
label = gtk_label_new("显示控制项 ");
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start_defaults(GTK_BOX(hbox), image);
gtk_box_pack_start_defaults(GTK_BOX(hbox), label);
button = gtk_check_button_new();
gtk_container_add(GTK_CONTAINER(button), hbox);
c->control_area_button = button;
gtk_box_pack_start_defaults(GTK_BOX(buttonbox), button);
/* snapshot button */
image = gtk_image_new_from_file(SNAP_BUTTON_IMG);
label = gtk_label_new("快照");
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start_defaults(GTK_BOX(hbox), image);
gtk_box_pack_start_defaults(GTK_BOX(hbox), label);
button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(button), hbox);
gtk_box_pack_start_defaults(GTK_BOX(buttonbox), button);
return TRUE;
}
/**
@brief add check button with optional mmemonic label to @a table
@param table table to hold the button
@param label button label which may contain mnemonic, or NULL
@param state the intitial state of the button
@param callback callback function for "toggled" signal, or NULL
@param data data specified for the callback
@param left index of table column left of attachment-position
@param right index of table column right of attachment-position
@param top index of table row above attachment-position
@param bottom index of table row below attachment-position
@return the button widget
*/
GtkWidget *e2_button_add_toggle_to_table (
GtkWidget *table,
gchar *label,
gboolean state,
void (*callback)(/*GtkToggleButton*,gpointer*/),
gpointer data,
gint left, gint right, gint top, gint bottom)
{
GtkWidget *check_button;
check_button = (label == NULL) ? gtk_check_button_new () :
gtk_check_button_new_with_mnemonic (label);
if (state)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), TRUE);
if (callback != NULL)
g_signal_connect (G_OBJECT (check_button), "toggled",
G_CALLBACK (callback), data);
#ifdef USE_GTK3_2
gtk_grid_attach (GTK_GRID (table), check_button, left, top, right-left, bottom-top);
#else
gtk_table_attach_defaults (GTK_TABLE (table), check_button,
left, right, top, bottom);
#endif
return check_button;
}
static GObject *konepuremilitary_single_cpi_selector_constructor(GType gtype, guint n_properties, GObjectConstructParam *properties) {
KonepuremilitarySingleCpiSelectorPrivate *priv;
KonepuremilitarySingleCpiSelector *selector;
GObject *obj;
obj = G_OBJECT_CLASS(konepuremilitary_single_cpi_selector_parent_class)->constructor(gtype, n_properties, properties);
selector = KONEPUREMILITARY_SINGLE_CPI_SELECTOR(obj);
priv = selector->priv;
priv->radio = GTK_RADIO_BUTTON(gtk_radio_button_new(NULL));
gtk_box_pack_start(GTK_BOX(selector), GTK_WIDGET(priv->radio), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(priv->radio), "toggled", G_CALLBACK(click_radio_cb), selector);
priv->active = GTK_CHECK_BUTTON(gtk_check_button_new());
gtk_box_pack_start(GTK_BOX(selector), GTK_WIDGET(priv->active), FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(priv->active), "toggled", G_CALLBACK(toggle_active_cb), selector);
priv->scale = GAMINGGEAR_XY_SCALES(gaminggear_xy_scales_new(priv->min, priv->max, priv->step));
gtk_box_pack_start(GTK_BOX(selector), GTK_WIDGET(priv->scale), TRUE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(selector));
return obj;
}
