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