void cpanel_edgeedit_make (GGobiSession * gg) { modepaneld *panel; GtkWidget *vb, *radio1, *radio2, *w; GSList *group; // This should be in an init routine gboolean adding_edges = true; panel = (modepaneld *) g_malloc (sizeof (modepaneld)); gg->control_panels = g_list_append (gg->control_panels, (gpointer) panel); panel->name = g_strdup (ggobi_getIModeName (EDGEED)); panel->w = gtk_vbox_new (false, VBOX_SPACING); gtk_container_set_border_width (GTK_CONTAINER (panel->w), 5); /*-- Radio group in a box: add edges or points buttons --*/ vb = gtk_vbox_new (false, 1); gtk_container_set_border_width (GTK_CONTAINER (vb), 3); gtk_box_pack_start (GTK_BOX (panel->w), vb, false, false, 0); radio1 = gtk_radio_button_new_with_mnemonic (NULL, "Add _edges"); gtk_widget_set_name (radio1, "EDGEEDIT:add_edges_radio_button"); if (adding_edges) GTK_TOGGLE_BUTTON (radio1)->active = true; gtk_tooltips_set_tip (GTK_TOOLTIPS (gg->tips), radio1, "Add new edges using the mouse. The right or middle button opens a dialog window; the left button adds an edge using defaults.", NULL); g_signal_connect (G_OBJECT (radio1), "toggled", G_CALLBACK (add_edges_or_points_cb), gg); gtk_box_pack_start (GTK_BOX (vb), radio1, false, false, 0); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio1)); radio2 = gtk_radio_button_new_with_mnemonic (group, "Add _points"); gtk_widget_set_name (radio2, "EDGEEDIT:add_points_radio_button"); gtk_tooltips_set_tip (GTK_TOOLTIPS (gg->tips), radio2, "Add points using the mouse. The right or button opens a dialog window; the left button adds a point using defaults.", NULL); gtk_box_pack_start (GTK_BOX (vb), radio2, false, false, 0); w = gtk_label_new (tip_edges); gtk_label_set_line_wrap (GTK_LABEL (w), true); gtk_box_pack_start (GTK_BOX (vb), w, false, false, 0); gtk_widget_set_name (w, "EDGEEDIT:tip_label"); /*-- Undo --*/ /* not implemented btn = gtk_button_new_with_label ("Undo"); gtk_tooltips_set_tip (GTK_TOOLTIPS (gg->tips), btn, "Undo last action", NULL); gtk_box_pack_start (GTK_BOX (panel->w), btn, false, false, 1); g_signal_connect (G_OBJECT (btn), "clicked", G_CALLBACK (undo_last_cb), NULL); */ gtk_widget_show_all (panel->w); }
static GtkWidget* radio_option(GSList *g, GtkWidget **radio, GtkWidget **entry, const char *caption, const char *label, const char *initial) { GtkWidget *vbox; vbox = gtk_vbox_new(FALSE, 0); *radio = gtk_radio_button_new_with_mnemonic(g, caption); gtk_box_pack_start(GTK_BOX(vbox), *radio, FALSE, FALSE, 0); *entry = gtk_entry_new(); gtk_entry_set_activates_default(GTK_ENTRY(*entry), TRUE); g_signal_connect(G_OBJECT(*entry), "focus-in-event", G_CALLBACK(entry_focus_cb), *radio); if (initial) gtk_entry_set_text(GTK_ENTRY(*entry), initial); gtk_widget_set_size_request(*entry, 75, -1); g_signal_connect(G_OBJECT(*radio), "toggled", G_CALLBACK(select_toggled), *entry); g_signal_connect(G_OBJECT(*radio), "activate", G_CALLBACK(select_toggled), *entry); if (label) { GtkWidget *hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new(label), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), *entry, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); } else { gtk_box_pack_start(GTK_BOX(vbox), *entry, TRUE, TRUE, 0); } return vbox; }
GtkWidget* create_radio_button_in_table(GtkWidget *table, GSList *group, int row, int col, const char *text) { GtkWidget *button = gtk_radio_button_new_with_mnemonic(group, text); return add_widget_to_table(table, row, col, button); }
void ui_import_csv(void) { GtkWidget *dia_file_import; GtkWidget *vbox; GtkWidget *radio_comma, *radio_tab; import_ *import; import = malloc(sizeof(import_)); import->delimiter = ','; dia_file_import = gtk_file_chooser_dialog_new( "Import character separated file", GTK_WINDOW(win_main), GTK_FILE_CHOOSER_ACTION_OPEN, NULL); gtk_dialog_add_buttons( GTK_DIALOG(dia_file_import), GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); /* Build options widget */ radio_comma = gtk_radio_button_new_with_mnemonic(NULL, "_Comma separated"); radio_tab = gtk_radio_button_new_with_mnemonic_from_widget( GTK_RADIO_BUTTON(radio_comma), "_Tab separated"); g_signal_connect( radio_comma, "toggled", GTK_SIGNAL_FUNC(ui_import_delimiter_comma_cb), import); g_signal_connect( radio_tab, "toggled", GTK_SIGNAL_FUNC(ui_import_delimiter_tab_cb), import); vbox = gtk_vbox_new(FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox), radio_comma, FALSE, FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox), radio_tab, FALSE, FALSE, 3); gtk_widget_show_all(vbox); /* Prepare import dialog and show */ gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dia_file_import), vbox); if (gtk_dialog_run(GTK_DIALOG(dia_file_import)) == GTK_RESPONSE_ACCEPT) { list_clear(list); list = list_create(); import->filename = strdup(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dia_file_import))); list_import_csv(list, import->filename, import->delimiter); free(import->filename); } gtk_widget_destroy(dia_file_import); free(import); }
/** * gimp_enum_radio_box_new_with_range: * @minimum: the minimum enum value * @maximum: the maximum enum value * @enum_type: the #GType of an enum. * @callback: a callback to connect to the "toggled" signal of each * #GtkRadioButton that is created. * @callback_data: data to pass to the @callback. * @first_button: returns the first button in the created group. * * Just like gimp_enum_radio_box_new(), this function creates a group * of radio buttons, but additionally it supports limiting the range * of available enum values. * * Return value: a new #GtkVBox holding a group of #GtkRadioButtons. * * Since: GIMP 2.4 **/ GtkWidget * gimp_enum_radio_box_new_with_range (GType enum_type, gint minimum, gint maximum, GCallback callback, gpointer callback_data, GtkWidget **first_button) { GtkWidget *vbox; GtkWidget *button; GEnumClass *enum_class; GEnumValue *value; GSList *group = NULL; g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL); enum_class = g_type_class_ref (enum_type); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify) g_type_class_unref, enum_class); if (first_button) *first_button = NULL; for (value = enum_class->values; value->value_name; value++) { const gchar *desc; if (value->value < minimum || value->value > maximum) continue; desc = gimp_enum_value_get_desc (enum_class, value); button = gtk_radio_button_new_with_mnemonic (group, desc); if (first_button && *first_button == NULL) *first_button = button; group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (value->value)); if (callback) g_signal_connect (button, "toggled", callback, callback_data); } return vbox; }
GtkWidget * dialog_radio_button_in_table(GSList * group, const gchar * label, GtkWidget * table, guint left_attach, guint right_attach, guint top_attach, guint bottom_attach) { GtkWidget *button; button = gtk_radio_button_new_with_mnemonic(group, label); gtk_table_attach(GTK_TABLE(table), button, left_attach, right_attach, top_attach, bottom_attach, GTK_FILL, GTK_SHRINK, 0, 0); return button; }
GtkWidget* gtr_relocate_dialog_new( GtkWindow * parent, TrCore * core, GSList * torrent_ids ) { int row; GtkWidget * w; GtkWidget * d; GtkWidget * t; struct relocate_dialog_data * data; d = gtk_dialog_new_with_buttons( _( "Set Torrent Location" ), parent, GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, NULL ); gtk_dialog_set_default_response( GTK_DIALOG( d ), GTK_RESPONSE_CANCEL ); gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ), GTK_RESPONSE_APPLY, GTK_RESPONSE_CANCEL, -1 ); g_signal_connect( d, "response", G_CALLBACK( onResponse ), NULL ); row = 0; t = hig_workarea_create( ); hig_workarea_add_section_title( t, &row, _( "Location" ) ); if( previousLocation == NULL ) previousLocation = g_strdup( pref_string_get( TR_PREFS_KEY_DOWNLOAD_DIR ) ); w = gtk_file_chooser_button_new( _( "Set Torrent Location" ), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ); gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), previousLocation ); g_object_set_data( G_OBJECT( d ), "chooser", w ); hig_workarea_add_row( t, &row, _( "Torrent _location:" ), w, NULL ); w = gtk_radio_button_new_with_mnemonic( NULL, _( "_Move from the current folder" ) ); g_object_set_data( G_OBJECT( d ), "move_rb", w ); hig_workarea_add_wide_control( t, &row, w ); w = gtk_radio_button_new_with_mnemonic_from_widget( GTK_RADIO_BUTTON( w ), _( "Local data is _already there" ) ); hig_workarea_add_wide_control( t, &row, w ); hig_workarea_finish( t, &row ); gtk_widget_show_all( t ); gtk_box_pack_start( GTK_BOX( GTK_DIALOG( d )->vbox ), t, TRUE, TRUE, 0 ); data = g_new0( struct relocate_dialog_data, 1 ); data->core = core; data->torrent_ids = torrent_ids; data->chooser_dialog = d; g_object_set_data_full( G_OBJECT( d ), DATA_KEY, data, data_free ); return d; }
JNIEXPORT jlong JNICALL Java_org_gnome_gtk_GtkRadioButton_gtk_1radio_1button_1new_1with_1mnemonic ( JNIEnv* env, jclass cls, jlongArray _group, jstring _label ) { GtkWidget* result; jlong _result; GSList* group; const gchar* label; // convert parameter group if (_group == NULL) { group = NULL; } else { group = (GSList*) bindings_java_convert_jarray_to_gslist(env, _group); if (group == NULL) { return 0L; // Java Exception already thrown } } // convert parameter label label = (const gchar*) bindings_java_getString(env, _label); if (label == NULL) { return 0L; // Java Exception already thrown } // call function result = gtk_radio_button_new_with_mnemonic(group, label); // cleanup parameter group if (group != NULL) { g_slist_free(group); } // cleanup parameter label bindings_java_releaseString(label); // translate return value to JNI type _result = (jlong) result; // cleanup return value if (result != NULL) { bindings_java_memory_cleanup((GObject*)result, TRUE); } // and finally return _result; }
/** @brief add radio button with mmemonic label to @a box @param box widget to hold the button @param label button label which may contain mnemonic, or NULL if no label @param group the radio group, or NULL to start a group @param state the intitial state of the button @param exp TRUE to make the button expand with @a box @param pad padding between button and @a box @param callback callback function for "toggled" signal, or NULL @param data data specified for the callback @return the button widget */ GtkWidget *e2_button_add_radio (GtkWidget *box, gchar *label, GSList *group, gboolean state, gboolean exp, guint pad, void (*callback)(GtkToggleButton*,gpointer), gpointer data) { GtkWidget *radio_button = (label != NULL) ? gtk_radio_button_new_with_mnemonic (group, label): gtk_radio_button_new (group); if (state) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio_button), TRUE); if (callback != NULL) g_signal_connect (G_OBJECT (radio_button), "toggled", G_CALLBACK (callback), data); gtk_box_pack_start (GTK_BOX (box), radio_button, exp, TRUE, pad); return radio_button; }
static GtkWidget* sw_make_sg(char *name, GtkSizeGroup *sg) { SettingsWidget *sw = sw_lookup(name); switch (sw->type) { case SW_TOGGLE: sw->widget = gtk_check_button_new_with_mnemonic(_(sw->caption)); toggle_tie(sw); return sw->widget; case SW_RADIO: sw->widget = gtk_radio_button_new_with_mnemonic(NULL, _(sw->caption)); radio_tie(sw); return sw->widget; case SW_TEXT: sw->widget = gtk_entry_new(); text_tie(sw); return labelled_box_new_sg(_(sw->caption), sw->widget, sg); case SW_INTEGER: sw->widget = gtk_entry_new(); gtk_entry_set_width_chars(GTK_ENTRY(sw->widget), 4); integer_tie(sw); return labelled_box_new(_(sw->caption), sw->widget); case SW_SPIN_INTEGER: { gdouble default_value = *(gint*)sw->conf; GtkObject *adj = gtk_adjustment_new(default_value, /* client code should override these */ G_MINDOUBLE, G_MAXDOUBLE, 1.0, 1.0, 0); sw->widget = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 1, 1); } spin_integer_tie(sw); return labelled_box_new_expand(_(sw->caption), sw->widget, FALSE); case SW_COMBO: sw->widget = gtk_combo_new(); combo_tie(sw); return labelled_box_new(_(sw->caption), sw->widget); case SW_COMMAND: return command_make(sw); case SW_CUSTOM: if (sw->caption && sw->widget) return labelled_box_new(_(sw->caption), sw->widget); break; default: break; } return NULL; }
/** @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 @param group radio group, or NULL to start a group @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_radio_to_table ( GtkWidget *table, gchar *label, GSList *group, gboolean state, void (*callback)(/*GtkToggleButton*,gpointer*/), gpointer data, gint left, gint right, gint top, gint bottom) { GtkWidget *radio_button = gtk_radio_button_new_with_mnemonic (group, label); if (state) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio_button), TRUE); if (callback != NULL) g_signal_connect (G_OBJECT (radio_button), "toggled", G_CALLBACK (callback), data); #ifdef USE_GTK3_2 gtk_grid_attach (GTK_GRID (table), radio_button, left, top, right-left, bottom-top); #else gtk_table_attach_defaults (GTK_TABLE (table), radio_button, left, right, top, bottom); #endif return radio_button; }
int fe_dcc_open_recv_win (int passive) { GtkWidget *radio, *table, *vbox, *bbox, *view, *exp, *detailbox; GtkListStore *store; GSList *group; if (dccfwin.window) { if (!passive) mg_bring_tofront (dccfwin.window); return TRUE; } dccfwin.window = mg_create_generic_tab ("Transfers", _("conspire: Uploads and Downloads"), FALSE, TRUE, close_dcc_file_window, NULL, win_width, win_height, &vbox, 0); gtk_container_set_border_width (GTK_CONTAINER (dccfwin.window), 3); gtk_box_set_spacing (GTK_BOX (vbox), 3); store = gtk_list_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, GDK_TYPE_COLOR); view = gtkutil_treeview_new (vbox, GTK_TREE_MODEL (store), NULL, -1); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE); /* Up/Down Icon column */ gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), -1, NULL, gtk_cell_renderer_pixbuf_new (), "pixbuf", COL_TYPE, NULL); dcc_add_column (view, COL_STATUS, COL_COLOR, _("Status"), FALSE); dcc_add_column (view, COL_FILE, COL_COLOR, _("File"), FALSE); dcc_add_column (view, COL_SIZE, COL_COLOR, _("Size"), TRUE); dcc_add_column (view, COL_POS, COL_COLOR, _("Position"), TRUE); dcc_add_column (view, COL_PERC, COL_COLOR, "%", TRUE); dcc_add_column (view, COL_SPEED, COL_COLOR, "KB/s", TRUE); dcc_add_column (view, COL_ETA, COL_COLOR, _("ETA"), FALSE); dcc_add_column (view, COL_NICK, COL_COLOR, _("Nick"), FALSE); dccfwin.list = view; dccfwin.store = store; dccfwin.sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view)); view_mode = VIEW_BOTH; gtk_tree_selection_set_mode (dccfwin.sel, GTK_SELECTION_MULTIPLE); if (!prefs.windows_as_tabs) g_signal_connect (G_OBJECT (dccfwin.window), "configure_event", G_CALLBACK (dcc_configure_cb), 0); g_signal_connect (G_OBJECT (dccfwin.sel), "changed", G_CALLBACK (dcc_row_cb), NULL); /* double click */ g_signal_connect (G_OBJECT (view), "row-activated", G_CALLBACK (dcc_dclick_cb), NULL); table = gtk_table_new (1, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 16); gtk_box_pack_start (GTK_BOX (vbox), table, 0, 0, 0); radio = gtk_radio_button_new_with_mnemonic (NULL, _("Both")); g_signal_connect (G_OBJECT (radio), "toggled", G_CALLBACK (dcc_toggle), GINT_TO_POINTER (VIEW_BOTH)); gtk_table_attach (GTK_TABLE (table), radio, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); radio = gtk_radio_button_new_with_mnemonic (group, _("Uploads")); g_signal_connect (G_OBJECT (radio), "toggled", G_CALLBACK (dcc_toggle), GINT_TO_POINTER (VIEW_UPLOAD)); gtk_table_attach (GTK_TABLE (table), radio, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); radio = gtk_radio_button_new_with_mnemonic (group, _("Downloads")); g_signal_connect (G_OBJECT (radio), "toggled", G_CALLBACK (dcc_toggle), GINT_TO_POINTER (VIEW_DOWNLOAD)); gtk_table_attach (GTK_TABLE (table), radio, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0); exp = gtk_expander_new (_("Details")); gtk_table_attach (GTK_TABLE (table), exp, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); detailbox = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (detailbox), 6); gtk_table_set_row_spacings (GTK_TABLE (detailbox), 2); gtk_container_set_border_width (GTK_CONTAINER (detailbox), 6); g_signal_connect (G_OBJECT (exp), "activate", G_CALLBACK (dcc_exp_cb), detailbox); gtk_table_attach (GTK_TABLE (table), detailbox, 0, 4, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); dccfwin.file_label = dcc_detail_label (_("File:"), detailbox, 0); dccfwin.address_label = dcc_detail_label (_("Address:"), detailbox, 1); bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD); gtk_box_pack_end (GTK_BOX (vbox), bbox, FALSE, FALSE, 2); dccfwin.abort_button = gtkutil_button (bbox, GTK_STOCK_CANCEL, 0, abort_clicked, 0, _("Abort")); dccfwin.accept_button = gtkutil_button (bbox, GTK_STOCK_APPLY, 0, accept_clicked, 0, _("Accept")); dccfwin.resume_button = gtkutil_button (bbox, GTK_STOCK_REFRESH, 0, resume_clicked, 0, _("Resume")); dccfwin.open_button = gtkutil_button (bbox, 0, 0, browse_dcc_folder, 0, _("Open Folder...")); gtk_widget_set_sensitive (dccfwin.accept_button, FALSE); gtk_widget_set_sensitive (dccfwin.resume_button, FALSE); gtk_widget_set_sensitive (dccfwin.abort_button, FALSE); dcc_fill_window (3); gtk_widget_show_all (dccfwin.window); gtk_widget_hide (detailbox); return FALSE; }
static gboolean vpropagate_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *hbox; GtkWidget *frame; GtkWidget *table; GtkWidget *toggle_vbox; GtkWidget *button; GtkObject *adj; GSList *group = NULL; gint index = 0; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Value Propagate"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, VPROPAGATE_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (value_propagate_body), drawable); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* Propagate Mode */ frame = gimp_frame_new (_("Mode")); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); toggle_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_container_add (GTK_CONTAINER (frame), toggle_vbox); gtk_widget_show (toggle_vbox); for (index = 0; index < num_mode; index++) { button = gtk_radio_button_new_with_mnemonic (group, gettext (modes[index].name)); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_box_pack_start (GTK_BOX (toggle_vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (index)); g_signal_connect (button, "toggled", G_CALLBACK (gimp_radio_button_update), &vpvals.propagate_mode); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), index == vpvals.propagate_mode); } /* Parameter settings */ frame = gimp_frame_new (_("Propagate")); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (8, 3, FALSE); /* 4 raw, 2 columns(name and value) */ gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 2, 12); gtk_table_set_row_spacing (GTK_TABLE (table), 5, 12); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("Lower t_hreshold:"), SCALE_WIDTH, 4, vpvals.lower_limit, 0, 255, 1, 8, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &vpvals.lower_limit); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Upper threshold:"), SCALE_WIDTH, 4, vpvals.upper_limit, 0, 255, 1, 8, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &vpvals.upper_limit); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("_Propagating rate:"), SCALE_WIDTH, 4, vpvals.propagating_rate, 0, 1, 0.01, 0.1, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &vpvals.propagating_rate); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_table_add_toggle (table, _("To l_eft"), 0, 1, 4, G_CALLBACK (vpropagate_toggle_button_update), &direction_mask_vec[Right2Left]); gtk_table_add_toggle (table, _("To _right"), 2, 3, 4, G_CALLBACK (vpropagate_toggle_button_update), &direction_mask_vec[Left2Right]); gtk_table_add_toggle (table, _("To _top"), 1, 2, 3, G_CALLBACK (vpropagate_toggle_button_update), &direction_mask_vec[Bottom2Top]); gtk_table_add_toggle (table, _("To _bottom"), 1, 2, 5, G_CALLBACK (vpropagate_toggle_button_update), &direction_mask_vec[Top2Bottom]); if (gimp_drawable_has_alpha (drawable->drawable_id)) { GtkWidget *toggle; toggle = gtk_table_add_toggle (table, _("Propagating _alpha channel"), 0, 3, 6, G_CALLBACK (vpropagate_toggle_button_update), &propagate_alpha); if (gimp_layer_get_lock_alpha (drawable->drawable_id)) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), 0); gtk_widget_set_sensitive (toggle, FALSE); } gtk_table_add_toggle (table, _("Propagating value channel"), 0, 3, 7, G_CALLBACK (vpropagate_toggle_button_update), &propagate_value); } gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { gint i, result; for (i = result = 0; i < 4; i++) result |= (direction_mask_vec[i] ? 1 : 0) << i; vpvals.direction_mask = result; vpvals.propagating_channel = ((propagate_alpha ? PROPAGATING_ALPHA : 0) | (propagate_value ? PROPAGATING_VALUE : 0)); } gtk_widget_destroy (dialog); return run; }
GtkWidget* build_gui ( void ) { GtkWidget *window1; GtkWidget *vbox1; GtkWidget *vbox2; GtkWidget *table1; GtkWidget *label1; GtkWidget *label2; GtkWidget *label3; GtkWidget *label4; GtkWidget *radiobutton1; GSList *radiobutton1_group = NULL; GtkWidget *radiobutton2; GtkWidget *entry1; window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window1), "tracking antenna"); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (window1), vbox1); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0); table1 = gtk_table_new (4, 3, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox2), table1, TRUE, TRUE, 0); gtk_table_set_col_spacings (GTK_TABLE (table1), 5); label1 = gtk_label_new ("Azimuth"); gtk_widget_show (label1); gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5); label2 = gtk_label_new ("Elevation"); gtk_widget_show (label2); gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); label3 = gtk_label_new ("Id"); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label4 = gtk_label_new ("mode"); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); radiobutton1 = gtk_radio_button_new_with_mnemonic (NULL, "manual"); gtk_widget_show (radiobutton1); gtk_table_attach (GTK_TABLE (table1), radiobutton1, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton1), radiobutton1_group); radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton1)); radiobutton2 = gtk_radio_button_new_with_mnemonic (NULL, "tracking"); gtk_widget_show (radiobutton2); gtk_table_attach (GTK_TABLE (table1), radiobutton2, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton2), radiobutton1_group); radiobutton1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton2)); azim_scale = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (144.7, 0, 360, 1, 1, 1))); gtk_widget_show (azim_scale); gtk_table_attach (GTK_TABLE (table1), azim_scale, 1, 3, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_range_set_update_policy (GTK_RANGE (azim_scale), GTK_UPDATE_DELAYED); elev_scale = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (32.3, 0, 90, 1, 1, 1))); gtk_widget_show (elev_scale); gtk_table_attach (GTK_TABLE (table1), elev_scale, 1, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); entry1 = gtk_entry_new (); gtk_widget_show (entry1); gtk_table_attach (GTK_TABLE (table1), entry1, 1, 3, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect ((gpointer) radiobutton1, "toggled", G_CALLBACK (on_mode_changed), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (window1, window1, "window1"); GLADE_HOOKUP_OBJECT (window1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (window1, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT (window1, table1, "table1"); GLADE_HOOKUP_OBJECT (window1, label1, "label1"); GLADE_HOOKUP_OBJECT (window1, label2, "label2"); GLADE_HOOKUP_OBJECT (window1, label3, "label3"); GLADE_HOOKUP_OBJECT (window1, label4, "label4"); GLADE_HOOKUP_OBJECT (window1, radiobutton1, "radiobutton1"); GLADE_HOOKUP_OBJECT (window1, radiobutton2, "radiobutton2"); GLADE_HOOKUP_OBJECT (window1, entry1, "entry1"); return window1; }
int nsSetupTypeDlg::Show(int aDirection) { int err = OK; int numSetupTypes = 0; GtkWidget *radbtn; nsSetupType *currST = NULL; GtkWidget *frame = NULL; XI_VERIFY(gCtx); XI_VERIFY(gCtx->notebook); if (mWidgetsInit == FALSE) { // add a vbox as a page of the notebook mBox = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(mBox), 12); gtk_notebook_append_page(GTK_NOTEBOOK(gCtx->notebook), mBox, NULL); mPageNum = gtk_notebook_get_current_page(GTK_NOTEBOOK(gCtx->notebook)); // add the top text label GtkWidget *msg0 = gtk_label_new(mMsg0); gtk_misc_set_alignment(GTK_MISC(msg0), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(mBox), msg0, FALSE, FALSE, 12); // for each setup type, pack into the vbox: // an hbox containing: (this is to pad the radio button on the right) // the radio button with short description // a label with the long description numSetupTypes = GetNumSetupTypes(); currST = GetSetupTypeList(); for (int i = 0; i < numSetupTypes; ++i, currST = currST->GetNext()) { if (i == 0) { radbtn = gtk_radio_button_new_with_mnemonic(NULL, currST->GetDescShort()); mRadioGroup = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radbtn)); } else { radbtn = gtk_radio_button_new_with_mnemonic(mRadioGroup, currST->GetDescShort()); } GtkWidget *hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), radbtn, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(mBox), hbox, FALSE, FALSE, 6); GtkWidget *desc = gtk_label_new(currST->GetDescLong()); gtk_label_set_line_wrap(GTK_LABEL(desc), TRUE); gtk_misc_set_alignment(GTK_MISC(desc), 0.0, 0.5); // Pad the labels so that they line up with the radio button text gint ind_size, ind_spacing; gtk_widget_style_get(radbtn, "indicator_size", &ind_size, "indicator_spacing", &ind_spacing, NULL); gtk_misc_set_padding(GTK_MISC(desc), ind_size + ind_spacing * 3, 0); gtk_box_pack_start(GTK_BOX(mBox), desc, FALSE, FALSE, 6); } frame = gtk_frame_new(gCtx->Res("DEST_DIR")); gtk_box_pack_start(GTK_BOX(mBox), frame, FALSE, FALSE, 12); GtkWidget *frame_hbox = gtk_hbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(frame_hbox), 6); gtk_container_add(GTK_CONTAINER(frame), frame_hbox); if (!gCtx->opt->mDestination) { gCtx->opt->mDestination = (char*)malloc(MAXPATHLEN * sizeof(char)); getcwd(gCtx->opt->mDestination, MAXPATHLEN); } sFolder = gtk_label_new(gCtx->opt->mDestination); gtk_label_set_line_wrap(GTK_LABEL(sFolder), TRUE); gtk_misc_set_alignment(GTK_MISC(sFolder), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(frame_hbox), sFolder, TRUE, TRUE, 0); sBrowseBtn = gtk_button_new_with_label(gCtx->Res("BROWSE")); gtk_box_pack_start(GTK_BOX(frame_hbox), sBrowseBtn, FALSE, FALSE, 0); mWidgetsInit = TRUE; } else { gtk_notebook_set_page(GTK_NOTEBOOK(gCtx->notebook), mPageNum); } // <b>title</b>\0 char *titleBuf = new char[strlen(mTitle) + 9]; sprintf(titleBuf, "<b>%s</b>", mTitle); gtk_label_set_markup(GTK_LABEL(gCtx->header_title), titleBuf); gtk_label_set_text(GTK_LABEL(gCtx->header_subtitle), mSubTitle); delete[] titleBuf; gtk_widget_show_all(mBox); // signal connect the buttons // NOTE: back button disfunctional in this dlg since user accepted license gCtx->backID = gtk_signal_connect(GTK_OBJECT(gCtx->back), "clicked", GTK_SIGNAL_FUNC(nsSetupTypeDlg::Back), gCtx->sdlg); gCtx->nextID = gtk_signal_connect(GTK_OBJECT(gCtx->next), "clicked", GTK_SIGNAL_FUNC(nsSetupTypeDlg::Next), gCtx->sdlg); sBrowseBtnID = gtk_signal_connect(GTK_OBJECT(sBrowseBtn), "clicked", GTK_SIGNAL_FUNC(nsSetupTypeDlg::SelectFolder), NULL); if (aDirection == nsXInstallerDlg::FORWARD_MOVE) { // change the button titles back to Back/Next gtk_button_set_label(GTK_BUTTON(gCtx->next), GTK_STOCK_GO_FORWARD); gtk_button_set_label(GTK_BUTTON(gCtx->back), GTK_STOCK_GO_BACK); } // from install dlg if (aDirection == nsXInstallerDlg::BACKWARD_MOVE && // not custom setup type gCtx->opt->mSetupType != (gCtx->sdlg->GetNumSetupTypes() - 1)) { DUMP("Back from Install to Setup Type"); gtk_button_set_label(GTK_BUTTON(gCtx->next), GTK_STOCK_GO_FORWARD); } gtk_widget_set_sensitive(gCtx->back, FALSE); return err; }
int gnc_choose_radio_option_dialog(GtkWidget *parent, const char *title, const char *msg, const char *button_name, int default_value, GList *radio_list) { int radio_result = 0; /* initial selected value is first one */ GtkWidget *vbox; GtkWidget *main_vbox; GtkWidget *label; GtkWidget *radio_button; GtkWidget *dialog; GtkWidget *dvbox; GSList *group = NULL; GList *node; int i; main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3); gtk_box_set_homogeneous (GTK_BOX (main_vbox), FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 6); gtk_widget_show(main_vbox); label = gtk_label_new(msg); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); gtk_box_pack_start(GTK_BOX(main_vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3); gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE); gtk_container_set_border_width(GTK_CONTAINER(vbox), 6); gtk_container_add(GTK_CONTAINER(main_vbox), vbox); gtk_widget_show(vbox); for (node = radio_list, i = 0; node; node = node->next, i++) { radio_button = gtk_radio_button_new_with_mnemonic(group, node->data); group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio_button)); gtk_widget_set_halign (GTK_WIDGET(radio_button), GTK_ALIGN_START); if (i == default_value) /* default is first radio button */ { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio_button), TRUE); radio_result = default_value; } gtk_widget_show(radio_button); gtk_box_pack_start(GTK_BOX(vbox), radio_button, FALSE, FALSE, 0); g_object_set_data(G_OBJECT(radio_button), INDEX_LABEL, GINT_TO_POINTER(i)); g_signal_connect(radio_button, "clicked", G_CALLBACK(gnc_choose_radio_button_cb), &radio_result); } if (!button_name) button_name = _("_OK"); dialog = gtk_dialog_new_with_buttons (title, GTK_WINDOW(parent), GTK_DIALOG_DESTROY_WITH_PARENT, _("_Cancel"), GTK_RESPONSE_CANCEL, button_name, GTK_RESPONSE_OK, NULL); /* default to ok */ gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); dvbox = gtk_dialog_get_content_area (GTK_DIALOG(dialog)); gtk_box_pack_start(GTK_BOX(dvbox), main_vbox, TRUE, TRUE, 0); if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_OK) radio_result = -1; gtk_widget_destroy (dialog); return radio_result; }
GtkWidget * palette_import_dialog_new (GimpContext *context) { ImportDialog *dialog; GimpGradient *gradient; GtkWidget *button; GtkWidget *main_hbox; GtkWidget *frame; GtkWidget *vbox; GtkWidget *table; GtkWidget *abox; GtkSizeGroup *size_group; GSList *group = NULL; g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); gradient = gimp_context_get_gradient (context); dialog = g_slice_new0 (ImportDialog); dialog->import_type = GRADIENT_IMPORT; dialog->context = gimp_context_new (context->gimp, "Palette Import", context); dialog->dialog = gimp_dialog_new (_("Import a New Palette"), "gimp-palette-import", NULL, 0, gimp_standard_help_func, GIMP_HELP_PALETTE_IMPORT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); button = gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), _("_Import"), GTK_RESPONSE_OK); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_icon_name ("gtk-convert", GTK_ICON_SIZE_BUTTON)); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_object_set_data_full (G_OBJECT (dialog->dialog), "palette-import-dialog", dialog, (GDestroyNotify) palette_import_free); g_signal_connect (dialog->dialog, "response", G_CALLBACK (palette_import_response), dialog); gimp_dnd_viewable_dest_add (dialog->dialog, GIMP_TYPE_GRADIENT, import_dialog_drop_callback, dialog); gimp_dnd_viewable_dest_add (dialog->dialog, GIMP_TYPE_IMAGE, import_dialog_drop_callback, dialog); main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog->dialog))), main_hbox, TRUE, TRUE, 0); gtk_widget_show (main_hbox); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); /* The "Source" frame */ frame = gimp_frame_new (_("Select Source")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (5, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); dialog->gradient_radio = gtk_radio_button_new_with_mnemonic (group, _("_Gradient")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->gradient_radio)); gtk_table_attach (GTK_TABLE (table), dialog->gradient_radio, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->gradient_radio); g_signal_connect (dialog->gradient_radio, "toggled", G_CALLBACK (palette_import_grad_callback), dialog); dialog->image_radio = gtk_radio_button_new_with_mnemonic (group, _("I_mage")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->image_radio)); gtk_table_attach (GTK_TABLE (table), dialog->image_radio, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->image_radio); g_signal_connect (dialog->image_radio, "toggled", G_CALLBACK (palette_import_image_callback), dialog); gtk_widget_set_sensitive (dialog->image_radio, ! gimp_container_is_empty (context->gimp->images)); dialog->sample_merged_toggle = gtk_check_button_new_with_mnemonic (_("Sample _Merged")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->sample_merged_toggle), TRUE); gtk_table_attach (GTK_TABLE (table), dialog->sample_merged_toggle, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->sample_merged_toggle); g_signal_connect_swapped (dialog->sample_merged_toggle, "toggled", G_CALLBACK (palette_import_make_palette), dialog); dialog->selection_only_toggle = gtk_check_button_new_with_mnemonic (_("_Selected Pixels only")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->selection_only_toggle), FALSE); gtk_table_attach (GTK_TABLE (table), dialog->selection_only_toggle, 1, 2, 3, 4, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->selection_only_toggle); g_signal_connect_swapped (dialog->selection_only_toggle, "toggled", G_CALLBACK (palette_import_make_palette), dialog); dialog->file_radio = gtk_radio_button_new_with_mnemonic (group, _("Palette _file")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->image_radio)); gtk_table_attach (GTK_TABLE (table), dialog->file_radio, 0, 1, 4, 5, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->file_radio); g_signal_connect (dialog->file_radio, "toggled", G_CALLBACK (palette_import_file_callback), dialog); size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL); /* The gradient menu */ dialog->gradient_combo = gimp_container_combo_box_new (gimp_data_factory_get_container (context->gimp->gradient_factory), dialog->context, 24, 1); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, NULL, 0.0, 0.5, dialog->gradient_combo, 1, FALSE); gtk_size_group_add_widget (size_group, dialog->gradient_combo); /* The image menu */ dialog->image_combo = gimp_container_combo_box_new (context->gimp->images, dialog->context, 24, 1); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, NULL, 0.0, 0.5, dialog->image_combo, 1, FALSE); gtk_size_group_add_widget (size_group, dialog->image_combo); /* Palette file name entry */ dialog->file_chooser = gtk_file_chooser_button_new (_("Select Palette File"), GTK_FILE_CHOOSER_ACTION_OPEN); gimp_table_attach_aligned (GTK_TABLE (table), 0, 4, NULL, 0.0, 0.5, dialog->file_chooser, 1, FALSE); gtk_size_group_add_widget (size_group, dialog->file_chooser); g_object_unref (size_group); /* The "Import" frame */ frame = gimp_frame_new (_("Import Options")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (4, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); /* The source's name */ dialog->entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (dialog->entry), gradient ? gimp_object_get_name (gradient) : _("New import")); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("Palette _name:"), 0.0, 0.5, dialog->entry, 2, FALSE); /* The # of colors */ dialog->num_colors = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("N_umber of colors:"), -1, 5, 256, 2, 10000, 1, 10, 0, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect_swapped (dialog->num_colors, "value-changed", G_CALLBACK (palette_import_make_palette), dialog); /* The columns */ dialog->columns = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("C_olumns:"), -1, 5, 16, 0, 64, 1, 8, 0, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect (dialog->columns, "value-changed", G_CALLBACK (palette_import_columns_changed), dialog); /* The interval */ dialog->threshold = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 3, _("I_nterval:"), -1, 5, 1, 1, 128, 1, 8, 0, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect_swapped (dialog->threshold, "value-changed", G_CALLBACK (palette_import_make_palette), dialog); /* The "Preview" frame */ frame = gimp_frame_new (_("Preview")); gtk_box_pack_start (GTK_BOX (main_hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); abox = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); gtk_widget_show (abox); dialog->preview = gimp_view_new_full_by_types (dialog->context, GIMP_TYPE_VIEW, GIMP_TYPE_PALETTE, 192, 192, 1, TRUE, FALSE, FALSE); gtk_container_add (GTK_CONTAINER (abox), dialog->preview); gtk_widget_show (dialog->preview); dialog->no_colors_label = gtk_label_new (_("The selected source contains no colors.")); gtk_widget_set_size_request (dialog->no_colors_label, 194, -1); gtk_label_set_line_wrap (GTK_LABEL (dialog->no_colors_label), TRUE); gimp_label_set_attributes (GTK_LABEL (dialog->no_colors_label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_box_pack_start (GTK_BOX (vbox), dialog->no_colors_label, FALSE, FALSE, 0); gtk_widget_show (dialog->no_colors_label); /* keep the dialog up-to-date */ g_signal_connect (context->gimp->images, "add", G_CALLBACK (palette_import_image_add), dialog); g_signal_connect (context->gimp->images, "remove", G_CALLBACK (palette_import_image_remove), dialog); g_signal_connect (dialog->context, "gradient-changed", G_CALLBACK (palette_import_gradient_changed), dialog); g_signal_connect (dialog->context, "image-changed", G_CALLBACK (palette_import_image_changed), dialog); g_signal_connect (dialog->file_chooser, "selection-changed", G_CALLBACK (palette_import_filename_changed), dialog); palette_import_grad_callback (dialog->gradient_radio, dialog); return dialog->dialog; }
static void greeter_system_handler (GreeterItemInfo *info, gpointer user_data) { GtkWidget *w = NULL; GtkWidget *hbox = NULL; GtkWidget *main_vbox = NULL; GtkWidget *vbox = NULL; GtkWidget *cat_vbox = NULL; GtkWidget *group_radio = NULL; GtkWidget *halt_radio = NULL; GtkWidget *suspend_radio = NULL; GtkWidget *restart_radio = NULL; GtkWidget *config_radio = NULL; gchar *s; int ret; gint i; GSList *radio_group = NULL; static GtkTooltips *tooltips = NULL; /* should never be allowed by the UI */ if ( ! mdm_config_get_bool (MDM_KEY_SYSTEM_MENU) || ve_string_empty (g_getenv ("MDM_IS_LOCAL"))) return; dialog = gtk_dialog_new (); if (tooltips == NULL) tooltips = gtk_tooltips_new (); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); main_vbox = gtk_vbox_new (FALSE, 18); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 5); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox, FALSE, FALSE, 0); cat_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (main_vbox), cat_vbox, FALSE, FALSE, 0); s = g_strdup_printf ("<b>%s</b>", _("Choose an Action")); w = gtk_label_new (s); gtk_label_set_use_markup (GTK_LABEL (w), TRUE); g_free (s); gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (cat_vbox), w, FALSE, FALSE, 0); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (cat_vbox), hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), gtk_label_new (" "), FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); if (MdmHaltFound) { if (group_radio != NULL) radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio)); halt_radio = gtk_radio_button_new_with_mnemonic (radio_group, _("Shut _down the computer")); group_radio = halt_radio; gtk_tooltips_set_tip (tooltips, GTK_WIDGET (halt_radio), _("Shut Down your computer so that " "you may turn it off."), NULL); g_signal_connect (G_OBJECT(halt_radio), "button_press_event", G_CALLBACK(radio_button_press_event), NULL); gtk_box_pack_start (GTK_BOX (vbox), halt_radio, FALSE, FALSE, 4); gtk_widget_show (halt_radio); } if (MdmRebootFound) { if (group_radio != NULL) radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio)); restart_radio = gtk_radio_button_new_with_mnemonic (radio_group, _("_Restart the computer")); group_radio = restart_radio; gtk_tooltips_set_tip (tooltips, GTK_WIDGET (restart_radio), _("Restart your computer"), NULL); g_signal_connect (G_OBJECT(restart_radio), "button_press_event", G_CALLBACK(radio_button_press_event), NULL); gtk_box_pack_start (GTK_BOX (vbox), restart_radio, FALSE, FALSE, 4); gtk_widget_show (restart_radio); } if (MdmSuspendFound) { if (group_radio != NULL) radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio)); suspend_radio = gtk_radio_button_new_with_mnemonic (radio_group, _("Sus_pend the computer")); group_radio = suspend_radio; gtk_tooltips_set_tip (tooltips, GTK_WIDGET (suspend_radio), _("Suspend your computer"), NULL); g_signal_connect (G_OBJECT(suspend_radio), "button_press_event", G_CALLBACK(radio_button_press_event), NULL); gtk_box_pack_start (GTK_BOX (vbox), suspend_radio, FALSE, FALSE, 4); gtk_widget_show (suspend_radio); } /* * Disable Configuration if using accessibility (AddGtkModules) since * using it with accessibility causes a hang. */ if (mdm_config_get_bool (MDM_KEY_CONFIG_AVAILABLE) && !mdm_config_get_bool (MDM_KEY_ADD_GTK_MODULES) && bin_exists (mdm_config_get_string (MDM_KEY_CONFIGURATOR))) { if (group_radio != NULL) radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio)); config_radio = gtk_radio_button_new_with_mnemonic (radio_group, _("Confi_gure the login manager")); group_radio = config_radio; gtk_tooltips_set_tip (tooltips, GTK_WIDGET (config_radio), _("Configure MDM (this login manager). " "This will require the root password."), NULL); g_signal_connect (G_OBJECT(config_radio), "button_press_event", G_CALLBACK(radio_button_press_event), NULL); gtk_box_pack_start (GTK_BOX (vbox), config_radio, FALSE, FALSE, 4); gtk_widget_show (config_radio); } gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_widget_show_all (dialog); mdm_wm_center_window (GTK_WINDOW (dialog)); mdm_wm_no_login_focus_push (); ret = gtk_dialog_run (GTK_DIALOG (dialog)); mdm_wm_no_login_focus_pop (); if (ret != GTK_RESPONSE_OK) { gtk_widget_destroy (dialog); return; } if (halt_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (halt_radio))) greeter_halt_handler (); else if (restart_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (restart_radio))) greeter_restart_handler (); else if (suspend_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (suspend_radio))) greeter_suspend_handler (); else if (config_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (config_radio))) greeter_config_handler (); gtk_widget_destroy (dialog); }
GtkWidget *create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *notebook1; GtkWidget *table1; GtkWidget *radioCQ; GSList *radioCQ_group = NULL; GtkWidget *radioCBR; GtkWidget *radio2Pass; GtkWidget *entryCQ; GtkWidget *entryCBR; GtkWidget *entry2Pass; GtkWidget *label1; GtkWidget *table2; GtkWidget *label5; GtkWidget *label6; GtkWidget *label7; GtkObject *spinbuttonMaxIFrame_adj; GtkWidget *spinbuttonMaxIFrame; GtkWidget *label8; GtkObject *spinbuttonMinIFrame_adj; GtkWidget *spinbuttonMinIFrame; GtkWidget *optionME; GtkWidget *menu4; GtkWidget *_0___none1; GtkWidget *_1__very_low1; GtkWidget *_2__low1; GtkWidget *_3__medium1; GtkWidget *_4__high1; GtkWidget *_5__very_high1; GtkWidget *_6__ultra_high1; GtkWidget *optionQzer; GtkWidget *menu5; GtkWidget *h263_quantizer1; GtkWidget *mpeg_quantizer1; GtkWidget *label2; GtkWidget *table3; GtkWidget *label9; GtkWidget *label10; GtkWidget *label11; GtkWidget *label12; GtkObject *spinImin_adj; GtkWidget *spinImin; GtkObject *spinImax_adj; GtkWidget *spinImax; GtkObject *spinPmin_adj; GtkWidget *spinPmin; GtkObject *spinPmax_adj; GtkWidget *spinPmax; GtkWidget *label3; GtkWidget *label13; GtkWidget *label4; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), _("Xvid Encoder")); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); notebook1 = gtk_notebook_new (); gtk_widget_show (notebook1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), notebook1, TRUE, TRUE, 0); table1 = gtk_table_new (3, 2, FALSE); gtk_widget_show (table1); gtk_container_add (GTK_CONTAINER (notebook1), table1); radioCQ = gtk_radio_button_new_with_mnemonic (NULL, _("Constant Quantizer")); gtk_widget_show (radioCQ); gtk_table_attach (GTK_TABLE (table1), radioCQ, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioCQ), radioCQ_group); radioCQ_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioCQ)); radioCBR = gtk_radio_button_new_with_mnemonic (NULL, _("Constant Bitrate (kbps)")); gtk_widget_show (radioCBR); gtk_table_attach (GTK_TABLE (table1), radioCBR, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioCBR), radioCQ_group); radioCQ_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioCBR)); radio2Pass = gtk_radio_button_new_with_mnemonic (NULL, _("Dual pass (MBytes)")); gtk_widget_show (radio2Pass); gtk_table_attach (GTK_TABLE (table1), radio2Pass, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radio2Pass), radioCQ_group); radioCQ_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio2Pass)); entryCQ = gtk_entry_new (); gtk_widget_show (entryCQ); gtk_table_attach (GTK_TABLE (table1), entryCQ, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entryCBR = gtk_entry_new (); gtk_widget_show (entryCBR); gtk_table_attach (GTK_TABLE (table1), entryCBR, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry2Pass = gtk_entry_new (); gtk_widget_show (entry2Pass); gtk_table_attach (GTK_TABLE (table1), entry2Pass, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); label1 = gtk_label_new (_("Basic")); gtk_widget_show (label1); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 0), label1); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); table2 = gtk_table_new (4, 2, FALSE); gtk_widget_show (table2); gtk_container_add (GTK_CONTAINER (notebook1), table2); label5 = gtk_label_new (_("Motion Search")); gtk_widget_show (label5); gtk_table_attach (GTK_TABLE (table2), label5, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5); label6 = gtk_label_new (_("Quantization")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table2), label6, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); label7 = gtk_label_new (_("Max I frame interval ")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table2), label7, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); spinbuttonMaxIFrame_adj = gtk_adjustment_new (300, 0, 600, 1, 10, 10); spinbuttonMaxIFrame = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonMaxIFrame_adj), 1, 0); gtk_widget_show (spinbuttonMaxIFrame); gtk_table_attach (GTK_TABLE (table2), spinbuttonMaxIFrame, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonMaxIFrame), TRUE); label8 = gtk_label_new (_("Min I frame interval")); gtk_widget_show (label8); gtk_table_attach (GTK_TABLE (table2), label8, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5); spinbuttonMinIFrame_adj = gtk_adjustment_new (1, 0, 600, 1, 10, 10); spinbuttonMinIFrame = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonMinIFrame_adj), 1, 0); gtk_widget_show (spinbuttonMinIFrame); gtk_table_attach (GTK_TABLE (table2), spinbuttonMinIFrame, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonMinIFrame), TRUE); optionME = gtk_option_menu_new (); gtk_widget_show (optionME); gtk_table_attach (GTK_TABLE (table2), optionME, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); menu4 = gtk_menu_new (); _0___none1 = gtk_menu_item_new_with_mnemonic (_("0 - None")); gtk_widget_show (_0___none1); gtk_container_add (GTK_CONTAINER (menu4), _0___none1); _1__very_low1 = gtk_menu_item_new_with_mnemonic (_("1- Very low")); gtk_widget_show (_1__very_low1); gtk_container_add (GTK_CONTAINER (menu4), _1__very_low1); _2__low1 = gtk_menu_item_new_with_mnemonic (_("2- Low")); gtk_widget_show (_2__low1); gtk_container_add (GTK_CONTAINER (menu4), _2__low1); _3__medium1 = gtk_menu_item_new_with_mnemonic (_("3- Medium")); gtk_widget_show (_3__medium1); gtk_container_add (GTK_CONTAINER (menu4), _3__medium1); _4__high1 = gtk_menu_item_new_with_mnemonic (_("4- High")); gtk_widget_show (_4__high1); gtk_container_add (GTK_CONTAINER (menu4), _4__high1); _5__very_high1 = gtk_menu_item_new_with_mnemonic (_("5- Very High")); gtk_widget_show (_5__very_high1); gtk_container_add (GTK_CONTAINER (menu4), _5__very_high1); _6__ultra_high1 = gtk_menu_item_new_with_mnemonic (_("6- Ultra High")); gtk_widget_show (_6__ultra_high1); gtk_container_add (GTK_CONTAINER (menu4), _6__ultra_high1); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionME), menu4); optionQzer = gtk_option_menu_new (); gtk_widget_show (optionQzer); gtk_table_attach (GTK_TABLE (table2), optionQzer, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); menu5 = gtk_menu_new (); h263_quantizer1 = gtk_menu_item_new_with_mnemonic (_("H263 Quantizer")); gtk_widget_show (h263_quantizer1); gtk_container_add (GTK_CONTAINER (menu5), h263_quantizer1); mpeg_quantizer1 = gtk_menu_item_new_with_mnemonic (_("MPEG Quantizer")); gtk_widget_show (mpeg_quantizer1); gtk_container_add (GTK_CONTAINER (menu5), mpeg_quantizer1); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionQzer), menu5); label2 = gtk_label_new (_("Advanced")); gtk_widget_show (label2); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 1), label2); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); table3 = gtk_table_new (4, 2, FALSE); gtk_widget_show (table3); gtk_container_add (GTK_CONTAINER (notebook1), table3); label9 = gtk_label_new (_("Min I Frame Qzer")); gtk_widget_show (label9); gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5); label10 = gtk_label_new (_("Max I Frame Qzer")); gtk_widget_show (label10); gtk_table_attach (GTK_TABLE (table3), label10, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5); label11 = gtk_label_new (_("Min P Frame Qzer")); gtk_widget_show (label11); gtk_table_attach (GTK_TABLE (table3), label11, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label11), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label11), 0, 0.5); label12 = gtk_label_new (_("Max P Frame Qzer")); gtk_widget_show (label12); gtk_table_attach (GTK_TABLE (table3), label12, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label12), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5); spinImin_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10); spinImin = gtk_spin_button_new (GTK_ADJUSTMENT (spinImin_adj), 1, 0); gtk_widget_show (spinImin); gtk_table_attach (GTK_TABLE (table3), spinImin, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinImin), TRUE); spinImax_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10); spinImax = gtk_spin_button_new (GTK_ADJUSTMENT (spinImax_adj), 1, 0); gtk_widget_show (spinImax); gtk_table_attach (GTK_TABLE (table3), spinImax, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinImax), TRUE); spinPmin_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10); spinPmin = gtk_spin_button_new (GTK_ADJUSTMENT (spinPmin_adj), 1, 0); gtk_widget_show (spinPmin); gtk_table_attach (GTK_TABLE (table3), spinPmin, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinPmin), TRUE); spinPmax_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10); spinPmax = gtk_spin_button_new (GTK_ADJUSTMENT (spinPmax_adj), 1, 0); gtk_widget_show (spinPmax); gtk_table_attach (GTK_TABLE (table3), spinPmax, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinPmax), TRUE); label3 = gtk_label_new (_("Quantizer")); gtk_widget_show (label3); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 2), label3); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); label13 = gtk_label_new (_("Not Yet!")); gtk_widget_show (label13); gtk_container_add (GTK_CONTAINER (notebook1), label13); gtk_label_set_justify (GTK_LABEL (label13), GTK_JUSTIFY_LEFT); label4 = gtk_label_new (_("B Frames")); gtk_widget_show (label4); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 3), label4); gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, notebook1, "notebook1"); GLADE_HOOKUP_OBJECT (dialog1, table1, "table1"); GLADE_HOOKUP_OBJECT (dialog1, radioCQ, "radioCQ"); GLADE_HOOKUP_OBJECT (dialog1, radioCBR, "radioCBR"); GLADE_HOOKUP_OBJECT (dialog1, radio2Pass, "radio2Pass"); GLADE_HOOKUP_OBJECT (dialog1, entryCQ, "entryCQ"); GLADE_HOOKUP_OBJECT (dialog1, entryCBR, "entryCBR"); GLADE_HOOKUP_OBJECT (dialog1, entry2Pass, "entry2Pass"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, table2, "table2"); GLADE_HOOKUP_OBJECT (dialog1, label5, "label5"); GLADE_HOOKUP_OBJECT (dialog1, label6, "label6"); GLADE_HOOKUP_OBJECT (dialog1, label7, "label7"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonMaxIFrame, "spinbuttonMaxIFrame"); GLADE_HOOKUP_OBJECT (dialog1, label8, "label8"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonMinIFrame, "spinbuttonMinIFrame"); GLADE_HOOKUP_OBJECT (dialog1, optionME, "optionME"); GLADE_HOOKUP_OBJECT (dialog1, menu4, "menu4"); GLADE_HOOKUP_OBJECT (dialog1, _0___none1, "_0___none1"); GLADE_HOOKUP_OBJECT (dialog1, _1__very_low1, "_1__very_low1"); GLADE_HOOKUP_OBJECT (dialog1, _2__low1, "_2__low1"); GLADE_HOOKUP_OBJECT (dialog1, _3__medium1, "_3__medium1"); GLADE_HOOKUP_OBJECT (dialog1, _4__high1, "_4__high1"); GLADE_HOOKUP_OBJECT (dialog1, _5__very_high1, "_5__very_high1"); GLADE_HOOKUP_OBJECT (dialog1, _6__ultra_high1, "_6__ultra_high1"); GLADE_HOOKUP_OBJECT (dialog1, optionQzer, "optionQzer"); GLADE_HOOKUP_OBJECT (dialog1, menu5, "menu5"); GLADE_HOOKUP_OBJECT (dialog1, h263_quantizer1, "h263_quantizer1"); GLADE_HOOKUP_OBJECT (dialog1, mpeg_quantizer1, "mpeg_quantizer1"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, table3, "table3"); GLADE_HOOKUP_OBJECT (dialog1, label9, "label9"); GLADE_HOOKUP_OBJECT (dialog1, label10, "label10"); GLADE_HOOKUP_OBJECT (dialog1, label11, "label11"); GLADE_HOOKUP_OBJECT (dialog1, label12, "label12"); GLADE_HOOKUP_OBJECT (dialog1, spinImin, "spinImin"); GLADE_HOOKUP_OBJECT (dialog1, spinImax, "spinImax"); GLADE_HOOKUP_OBJECT (dialog1, spinPmin, "spinPmin"); GLADE_HOOKUP_OBJECT (dialog1, spinPmax, "spinPmax"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); GLADE_HOOKUP_OBJECT (dialog1, label13, "label13"); GLADE_HOOKUP_OBJECT (dialog1, label4, "label4"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
static void create_screenshot_frame (GtkWidget *outer_vbox, const gchar *frame_title) { GtkWidget *main_vbox, *vbox, *hbox; GtkWidget *align; GtkWidget *radio; GtkWidget *image; GtkWidget *spin; GtkWidget *label; GtkAdjustment *adjust; GSList *group; gchar *title; #if GTK_CHECK_VERSION (3, 0, 0) main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else main_vbox = gtk_vbox_new (FALSE, 6); #endif gtk_box_pack_start (GTK_BOX (outer_vbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); title = g_strconcat ("<b>", frame_title, "</b>", NULL); label = gtk_label_new (title); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_label_set_yalign (GTK_LABEL (label), 0.5); #else gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); #endif gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (title); #if GTK_CHECK_VERSION (3, 0, 0) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); #else hbox = gtk_hbox_new (FALSE, 12); #endif gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); align = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); gtk_widget_set_size_request (align, 48, -1); gtk_box_pack_start (GTK_BOX (hbox), align, FALSE, FALSE, 0); gtk_widget_show (align); image = gtk_image_new_from_stock (SCREENSHOOTER_ICON, GTK_ICON_SIZE_DIALOG); gtk_container_add (GTK_CONTAINER (align), image); gtk_widget_show (image); #if GTK_CHECK_VERSION (3, 0, 0) vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else vbox = gtk_vbox_new (FALSE, 6); #endif gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); /** Grab whole desktop **/ group = NULL; radio = gtk_radio_button_new_with_mnemonic (group, _("Grab the whole _desktop")); if (take_window_shot || take_area_shot) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), FALSE); g_signal_connect (radio, "toggled", G_CALLBACK (target_toggled_cb), GINT_TO_POINTER (TARGET_TOGGLE_DESKTOP)); gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); gtk_widget_show (radio); /** Grab current window **/ radio = gtk_radio_button_new_with_mnemonic (group, _("Grab the current _window")); if (take_window_shot) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE); g_signal_connect (radio, "toggled", G_CALLBACK (target_toggled_cb), GINT_TO_POINTER (TARGET_TOGGLE_WINDOW)); gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); gtk_widget_show (radio); /** Grab area of the desktop **/ radio = gtk_radio_button_new_with_mnemonic (group, _("Select _area to grab")); if (take_area_shot) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE); g_signal_connect (radio, "toggled", G_CALLBACK (target_toggled_cb), GINT_TO_POINTER (TARGET_TOGGLE_AREA)); gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0); gtk_widget_show (radio); /** Grab after delay **/ #if GTK_CHECK_VERSION (3, 0, 0) delay_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); #else delay_hbox = gtk_hbox_new (FALSE, 6); #endif gtk_widget_set_sensitive (delay_hbox, !take_area_shot); gtk_box_pack_start (GTK_BOX (vbox), delay_hbox, FALSE, FALSE, 0); gtk_widget_show (delay_hbox); /* translators: this is the first part of the "grab after a * delay of <spin button> seconds". */ label = gtk_label_new_with_mnemonic (_("Grab _after a delay of")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_label_set_yalign (GTK_LABEL (label), 0.5); #else gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); #endif gtk_box_pack_start (GTK_BOX (delay_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); adjust = GTK_ADJUSTMENT (gtk_adjustment_new ((gdouble) delay, 0.0, 99.0, 1.0, 1.0, 0.0)); spin = gtk_spin_button_new (adjust, 1.0, 0); g_signal_connect (spin, "value-changed", G_CALLBACK (delay_spin_value_changed_cb), NULL); gtk_box_pack_start (GTK_BOX (delay_hbox), spin, FALSE, FALSE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin); gtk_widget_show (spin); /* translators: this is the last part of the "grab after a * delay of <spin button> seconds". */ label = gtk_label_new (_("seconds")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_label_set_yalign (GTK_LABEL (label), 0.5); #else gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); #endif gtk_box_pack_end (GTK_BOX (delay_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); }
dialogo_propiedades_red_t * dialogo_propiedades_red_crear() { dialogo_propiedades_red_t * dialogo_propiedades_red = (dialogo_propiedades_red_t*)malloc(sizeof(dialogo_propiedades_red_t)); dialogo_propiedades_red->rbt_ordenes_group = NULL; dialogo_propiedades_red->dlg_propiedades_red = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialogo_propiedades_red->dlg_propiedades_red), "Propiedades de la red"); dialogo_propiedades_red->dialog_vbox1 = GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red)->vbox; gtk_widget_show (dialogo_propiedades_red->dialog_vbox1); dialogo_propiedades_red->vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (dialogo_propiedades_red->vbox1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->dialog_vbox1), dialogo_propiedades_red->vbox1, TRUE, TRUE, 0); dialogo_propiedades_red->label1 = gtk_label_new_with_mnemonic ("_Ruta del archivo:"); gtk_widget_show (dialogo_propiedades_red->label1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->label1, FALSE, FALSE, 0); dialogo_propiedades_red->hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (dialogo_propiedades_red->hbox1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->hbox1, TRUE, TRUE, 0); dialogo_propiedades_red->entry_ruta = gtk_entry_new (); gtk_widget_show (dialogo_propiedades_red->entry_ruta); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox1), dialogo_propiedades_red->entry_ruta, TRUE, TRUE, 0); dialogo_propiedades_red->button1 = gtk_button_new (); gtk_widget_show (dialogo_propiedades_red->button1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox1), dialogo_propiedades_red->button1, FALSE, FALSE, 0); dialogo_propiedades_red->alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (dialogo_propiedades_red->alignment1); gtk_container_add (GTK_CONTAINER (dialogo_propiedades_red->button1), dialogo_propiedades_red->alignment1); dialogo_propiedades_red->hbox2 = gtk_hbox_new (FALSE, 2); gtk_widget_show (dialogo_propiedades_red->hbox2); gtk_container_add (GTK_CONTAINER (dialogo_propiedades_red->alignment1), dialogo_propiedades_red->hbox2); dialogo_propiedades_red->image1 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON); gtk_widget_show (dialogo_propiedades_red->image1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox2), dialogo_propiedades_red->image1, FALSE, FALSE, 0); dialogo_propiedades_red->label4 = gtk_label_new_with_mnemonic ("_..."); gtk_widget_show (dialogo_propiedades_red->label4); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox2), dialogo_propiedades_red->label4, FALSE, FALSE, 0); dialogo_propiedades_red->hseparator1 = gtk_hseparator_new (); gtk_widget_show (dialogo_propiedades_red->hseparator1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->hseparator1, TRUE, TRUE, 0); dialogo_propiedades_red->frame1 = gtk_frame_new (NULL); gtk_widget_show (dialogo_propiedades_red->frame1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->frame1, TRUE, TRUE, 0); dialogo_propiedades_red->vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (dialogo_propiedades_red->vbox2); gtk_container_add (GTK_CONTAINER (dialogo_propiedades_red->frame1), dialogo_propiedades_red->vbox2); dialogo_propiedades_red->rbt_ordenes = gtk_radio_button_new_with_mnemonic (NULL, "\303\223_rdenes"); gtk_widget_show (dialogo_propiedades_red->rbt_ordenes); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox2), dialogo_propiedades_red->rbt_ordenes, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_ordenes), dialogo_propiedades_red->rbt_ordenes_group); dialogo_propiedades_red->rbt_ordenes_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_ordenes)); dialogo_propiedades_red->rbt_parametros = gtk_radio_button_new_with_mnemonic (NULL, "P_ar\303\241metros"); gtk_widget_show (dialogo_propiedades_red->rbt_parametros); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox2), dialogo_propiedades_red->rbt_parametros, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_parametros), dialogo_propiedades_red->rbt_ordenes_group); dialogo_propiedades_red->rbt_ordenes_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_parametros)); dialogo_propiedades_red->label3 = gtk_label_new ("M\303\263dulo"); gtk_widget_show (dialogo_propiedades_red->label3); gtk_frame_set_label_widget (GTK_FRAME (dialogo_propiedades_red->frame1), dialogo_propiedades_red->label3); dialogo_propiedades_red->dialog_action_area1 = GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red)->action_area; gtk_widget_show (dialogo_propiedades_red->dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialogo_propiedades_red->dialog_action_area1), GTK_BUTTONBOX_END); dialogo_propiedades_red->cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (dialogo_propiedades_red->cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red), dialogo_propiedades_red->cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (dialogo_propiedades_red->cancelbutton1, GTK_CAN_DEFAULT); dialogo_propiedades_red->okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (dialogo_propiedades_red->okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red), dialogo_propiedades_red->okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (dialogo_propiedades_red->okbutton1, GTK_CAN_DEFAULT); g_signal_connect((gpointer) dialogo_propiedades_red->button1, "clicked", G_CALLBACK(boton_abrir), dialogo_propiedades_red); return dialogo_propiedades_red; }
void mobile_connection_new (GtkWindow *parent, const char *detail, NMRemoteSettings *settings, PageNewConnectionResultFunc result_func, gpointer user_data) { NMAMobileWizard *wizard; WizardInfo *info; GtkWidget *dialog, *vbox, *gsm_radio, *cdma_radio, *label, *content, *alignment; GtkWidget *hbox, *image; gint response; NMAMobileWizardAccessMethod method; info = g_malloc0 (sizeof (WizardInfo)); info->result_func = result_func; info->settings = g_object_ref (settings); info->user_data = user_data; wizard = nma_mobile_wizard_new (parent, NULL, NM_DEVICE_MODEM_CAPABILITY_NONE, FALSE, new_connection_mobile_wizard_done, info); if (wizard) { nma_mobile_wizard_present (wizard); return; } /* Fall back to just asking for GSM vs. CDMA */ dialog = gtk_dialog_new_with_buttons (_("Select Mobile Broadband Provider Type"), parent, GTK_DIALOG_MODAL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_signal_connect (dialog, "delete-event", G_CALLBACK (cancel_dialog), NULL); gtk_window_set_icon_name (GTK_WINDOW (dialog), "nm-device-wwan"); content = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); alignment = gtk_alignment_new (0, 0, 0.5, 0.5); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12); gtk_box_pack_start (GTK_BOX (content), alignment, TRUE, FALSE, 6); #if GTK_CHECK_VERSION (3,1,6) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); #else hbox = gtk_hbox_new (FALSE, 6); #endif gtk_container_add (GTK_CONTAINER (alignment), hbox); image = gtk_image_new_from_icon_name ("nm-device-wwan", GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0); gtk_misc_set_padding (GTK_MISC (image), 0, 6); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 6); #if GTK_CHECK_VERSION (3,1,6) vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else vbox = gtk_vbox_new (FALSE, 6); #endif gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, FALSE, 0); label = gtk_label_new (_("Select the technology your mobile broadband provider uses. If you are unsure, ask your provider.")); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 12); gsm_radio = gtk_radio_button_new_with_mnemonic (NULL, _("My provider uses _GSM-based technology (i.e. GPRS, EDGE, UMTS, HSDPA)")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gsm_radio), TRUE); gtk_box_pack_start (GTK_BOX (vbox), gsm_radio, FALSE, FALSE, 6); /* Translators: CDMA has 'D' accelerator key; 'C' collides with 'Cancel' button. You may need to change it according to your language. */ cdma_radio = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (gsm_radio), _("My provider uses C_DMA-based technology (i.e. 1xRTT, EVDO)")); gtk_box_pack_start (GTK_BOX (vbox), cdma_radio, FALSE, FALSE, 6); gtk_widget_show_all (dialog); memset (&method, 0, sizeof (method)); response = gtk_dialog_run (GTK_DIALOG (dialog)); if (response == GTK_RESPONSE_OK) { if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (cdma_radio))) { method.devtype = NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO; method.provider_name = _("CDMA"); } else { method.devtype = NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS; method.provider_name = _("GSM"); } } gtk_widget_destroy (dialog); new_connection_mobile_wizard_done (NULL, (response != GTK_RESPONSE_OK), (response == GTK_RESPONSE_OK) ? &method : NULL, info); }
static gboolean shoot_dialog (GdkScreen **screen) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *notebook; GtkWidget *frame; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *button; GtkWidget *toggle; GtkWidget *spinner; GdkPixbuf *pixbuf; GSList *radio_group = NULL; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Screenshot"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("S_nap"), GTK_RESPONSE_OK); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); pixbuf = gdk_pixbuf_new_from_inline (-1, screenshot_icon, FALSE, NULL); if (pixbuf) { gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_pixbuf (pixbuf)); g_object_unref (pixbuf); } main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); /* Hints */ notebook = g_object_new (GTK_TYPE_NOTEBOOK, "show-border", FALSE, "show-tabs", FALSE, NULL); gtk_box_pack_end (GTK_BOX (main_vbox), notebook, FALSE, FALSE, 0); gtk_widget_show (notebook); shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_ROOT, _("After the delay, the screenshot is taken.")); shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_REGION, _("After the delay, drag your mouse to select " "the region for the screenshot.")); shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_WINDOW, _("At the end of the delay, click in a window " "to snap it.")); gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), shootvals.shoot_type); /* Area */ frame = gimp_frame_new (_("Area")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); /* single window */ button = gtk_radio_button_new_with_mnemonic (radio_group, _("Take a screenshot of " "a single _window")); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), shootvals.shoot_type == SHOOT_WINDOW); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (SHOOT_WINDOW)); g_signal_connect (button, "toggled", G_CALLBACK (shoot_radio_button_toggled), notebook); #ifdef HAVE_X11_XMU_WINUTIL_H hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); toggle = gtk_check_button_new_with_mnemonic (_("Include window _decoration")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), shootvals.decorate); gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 24); gtk_widget_show (toggle); g_object_set_data (G_OBJECT (button), "set_sensitive", toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &shootvals.decorate); #endif /* HAVE_X11_XMU_WINUTIL_H */ /* whole screen */ button = gtk_radio_button_new_with_mnemonic (radio_group, _("Take a screenshot of " "the entire _screen")); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), shootvals.shoot_type == SHOOT_ROOT); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (SHOOT_ROOT)); g_signal_connect (button, "toggled", G_CALLBACK (shoot_radio_button_toggled), notebook); /* dragged region */ button = gtk_radio_button_new_with_mnemonic (radio_group, _("Select a _region to grab")); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), shootvals.shoot_type == SHOOT_REGION); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (SHOOT_REGION)); g_signal_connect (button, "toggled", G_CALLBACK (shoot_radio_button_toggled), notebook); /* Delay */ frame = gimp_frame_new (_("Delay")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); spinner = gimp_spin_button_new (&adj, shootvals.select_delay, 0.0, 100.0, 1.0, 5.0, 0.0, 0, 0); gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0); gtk_widget_show (spinner); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &shootvals.select_delay); /* this is the unit label of a spinbutton */ label = gtk_label_new (_("seconds")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { /* get the screen on which we are running */ *screen = gtk_widget_get_screen (dialog); } gtk_widget_destroy (dialog); if (run) { /* A short timeout to give the server a chance to * redraw the area that was obscured by our dialog. */ g_timeout_add (100, shoot_quit_timeout, NULL); gtk_main (); } return run; }
BackupAssistant::BackupAssistant(int dummy) : AssistantBase(_("Backup"), _("backup")) // Backup assistant. { gtk_assistant_set_forward_page_func (GTK_ASSISTANT (assistant), GtkAssistantPageFunc (assistant_forward_function), gpointer(this), NULL); g_signal_connect (G_OBJECT (assistant), "apply", G_CALLBACK (on_assistant_apply_signal), gpointer(this)); g_signal_connect (G_OBJECT (assistant), "prepare", G_CALLBACK (on_assistant_prepare_signal), gpointer(this)); introduction (_("A backup helps keep your data safe")); // Configuration and initialization. extern Settings *settings; ustring project = settings->genconfig.project_get(); // Build the GUI for the task selector. vbox_select_type = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox_select_type); page_number_select_type = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_select_type); gtk_container_set_border_width (GTK_CONTAINER (vbox_select_type), 10); gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_select_type, _("What would you like to backup?")); gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_select_type, GTK_ASSISTANT_PAGE_CONTENT); gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_select_type, true); GSList *radiobutton_select_type_group = NULL; radiobutton_select_type_bible = gtk_radio_button_new_with_mnemonic (NULL, _("Bible")); gtk_widget_show (radiobutton_select_type_bible); gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_bible, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_bible), radiobutton_select_type_group); radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_bible)); radiobutton_select_type_notes = gtk_radio_button_new_with_mnemonic (NULL, _("Notes")); gtk_widget_show (radiobutton_select_type_notes); gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_notes, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_notes), radiobutton_select_type_group); radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_notes)); radiobutton_select_type_resource = gtk_radio_button_new_with_mnemonic (NULL, _("Resource")); gtk_widget_show (radiobutton_select_type_resource); gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_resource, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_resource), radiobutton_select_type_group); radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_resource)); radiobutton_select_type_everything = gtk_radio_button_new_with_mnemonic (NULL, _("Everything")); gtk_widget_show (radiobutton_select_type_everything); gtk_box_pack_start (GTK_BOX (vbox_select_type), radiobutton_select_type_everything, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_select_type_everything), radiobutton_select_type_group); radiobutton_select_type_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_select_type_everything)); Shortcuts shortcuts_select_type (0); shortcuts_select_type.button (radiobutton_select_type_bible); shortcuts_select_type.button (radiobutton_select_type_notes); shortcuts_select_type.button (radiobutton_select_type_resource); shortcuts_select_type.button (radiobutton_select_type_everything); shortcuts_select_type.consider_assistant(); shortcuts_select_type.process(); // Confirm or change Bible. vbox_bible_name = gtk_vbox_new (FALSE, 5); gtk_widget_show (vbox_bible_name); page_number_bible_name = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_bible_name); gtk_container_set_border_width (GTK_CONTAINER (vbox_bible_name), 10); gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_bible_name, _("Is this the right Bible?")); gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_bible_name, GTK_ASSISTANT_PAGE_CONTENT); gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_bible_name, true); label_bible_name = gtk_label_new (_("Bible name")); gtk_widget_show (label_bible_name); gtk_box_pack_start (GTK_BOX (vbox_bible_name), label_bible_name, FALSE, FALSE, 0); button_bible_name = gtk_button_new (); gtk_widget_show (button_bible_name); gtk_box_pack_start (GTK_BOX (vbox_bible_name), button_bible_name, FALSE, FALSE, 0); g_signal_connect ((gpointer) button_bible_name, "clicked", G_CALLBACK (on_button_bible_name_clicked), gpointer (this)); GtkWidget *alignment1; GtkWidget *hbox1; GtkWidget *image1; GtkWidget *label1; alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment1); gtk_container_add (GTK_CONTAINER (button_bible_name), alignment1); hbox1 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox1); gtk_container_add (GTK_CONTAINER (alignment1), hbox1); image1 = gtk_image_new_from_stock (_("gtk-open"), GTK_ICON_SIZE_BUTTON); gtk_widget_show (image1); gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, FALSE, 0); label1 = gtk_label_new_with_mnemonic (_("Choose another one")); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, FALSE, 0); Shortcuts shortcuts_bible_name (0); shortcuts_bible_name.label (label1); shortcuts_bible_name.consider_assistant(); shortcuts_bible_name.process(); // Confirm or change Resource. vbox_resource_name = gtk_vbox_new (FALSE, 5); gtk_widget_show (vbox_resource_name); page_number_resource_name = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_resource_name); gtk_container_set_border_width (GTK_CONTAINER (vbox_resource_name), 10); gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_resource_name, _("Is this the right Resource?")); gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_resource_name, GTK_ASSISTANT_PAGE_CONTENT); gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_resource_name, true); label_resource_name = gtk_label_new (_("Resource name")); gtk_widget_show (label_resource_name); gtk_box_pack_start (GTK_BOX (vbox_resource_name), label_resource_name, FALSE, FALSE, 0); button_resource_name = gtk_button_new (); gtk_widget_show (button_resource_name); gtk_box_pack_start (GTK_BOX (vbox_resource_name), button_resource_name, FALSE, FALSE, 0); g_signal_connect ((gpointer) button_resource_name, "clicked", G_CALLBACK (on_button_resource_name_clicked), gpointer (this)); alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment1); gtk_container_add (GTK_CONTAINER (button_resource_name), alignment1); hbox1 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox1); gtk_container_add (GTK_CONTAINER (alignment1), hbox1); image1 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image1); gtk_box_pack_start (GTK_BOX (hbox1), image1, FALSE, FALSE, 0); label1 = gtk_label_new_with_mnemonic (_("Choose another one")); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (hbox1), label1, FALSE, FALSE, 0); Shortcuts shortcuts_resource_name (0); shortcuts_resource_name.label (label1); shortcuts_resource_name.consider_assistant(); shortcuts_resource_name.process(); // Select file where to save to. vbox_file = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox_file); page_number_file = gtk_assistant_append_page (GTK_ASSISTANT (assistant), vbox_file); gtk_container_set_border_width (GTK_CONTAINER (vbox_file), 10); gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), vbox_file, _("Where would you like to save it?")); gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), vbox_file, GTK_ASSISTANT_PAGE_CONTENT); gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), vbox_file, false); button_file = gtk_button_new (); gtk_widget_show (button_file); gtk_box_pack_start (GTK_BOX (vbox_file), button_file, FALSE, FALSE, 0); GtkWidget *alignment2; GtkWidget *hbox2; GtkWidget *image2; alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment2); gtk_container_add (GTK_CONTAINER (button_file), alignment2); hbox2 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox2); gtk_container_add (GTK_CONTAINER (alignment2), hbox2); image2 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image2); gtk_box_pack_start (GTK_BOX (hbox2), image2, FALSE, FALSE, 0); label_file = gtk_label_new_with_mnemonic (""); gtk_widget_show (label_file); gtk_box_pack_start (GTK_BOX (hbox2), label_file, FALSE, FALSE, 0); g_signal_connect ((gpointer) button_file, "clicked", G_CALLBACK (on_button_file_clicked), gpointer(this)); // Build the confirmation stuff. label_confirm = gtk_label_new (_("Backup is about to be made")); gtk_widget_show (label_confirm); page_number_confirm = gtk_assistant_append_page (GTK_ASSISTANT (assistant), label_confirm); gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label_confirm, _("Backup is about to be made")); gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label_confirm, GTK_ASSISTANT_PAGE_CONFIRM); gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_confirm, true); label_progress = gtk_label_new (""); gtk_widget_show (label_progress); gtk_assistant_append_page (GTK_ASSISTANT (assistant), label_progress); gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label_progress, ""); gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label_progress, GTK_ASSISTANT_PAGE_PROGRESS); gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_progress, true); label_summary = gtk_label_new (_("Backup is done")); gtk_widget_show (label_summary); summary_page_number = gtk_assistant_append_page (GTK_ASSISTANT (assistant), label_summary); gtk_assistant_set_page_title (GTK_ASSISTANT (assistant), label_summary, _("The backup was completed successfully.")); gtk_assistant_set_page_type (GTK_ASSISTANT (assistant), label_summary, GTK_ASSISTANT_PAGE_SUMMARY); gtk_assistant_set_page_complete (GTK_ASSISTANT (assistant), label_summary, true); // Finish building assistant. gtk_widget_show_all (assistant); gtk_assistant_set_current_page (GTK_ASSISTANT (assistant), 0); }
void CUIHandler::ShowSettingsDlg(void) { GtkWidget* settingsDlg; GtkWidget* dialog_vbox1; GtkWidget* frame4; GtkWidget* alignment4; GtkWidget* vbox2; GtkWidget* radiobuttonBt; GtkWidget* hbox2; GtkWidget* radiobuttonInet; GtkWidget* label5; GtkWidget* inetPort; GtkWidget* label4; GtkWidget* dialog_action_area1; CUserSettings crtSettings = pSmartEngine->GetSettings(); settingsDlg = gtk_dialog_new_with_buttons("SmartCam Preferences", GTK_WINDOW(pSmartEngine->GetMainWindow()), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_window_set_type_hint(GTK_WINDOW (settingsDlg), GDK_WINDOW_TYPE_HINT_DIALOG); dialog_vbox1 = GTK_DIALOG (settingsDlg)->vbox; gtk_widget_show (dialog_vbox1); frame4 = gtk_frame_new (NULL); gtk_widget_show (frame4); gtk_box_pack_start (GTK_BOX (dialog_vbox1), frame4, TRUE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame4), GTK_SHADOW_IN); alignment4 = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment4); gtk_container_add (GTK_CONTAINER (frame4), alignment4); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment4), 10, 10, 12, 12); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_container_add (GTK_CONTAINER (alignment4), vbox2); radiobuttonBt = gtk_radio_button_new_with_mnemonic(NULL, "Bluetooth"); gtk_box_pack_start(GTK_BOX (vbox2), radiobuttonBt, FALSE, FALSE, 0); hbox2 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox2); gtk_box_pack_start(GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0); radiobuttonInet = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(radiobuttonBt), "TCP/IP (WiFi)"); gtk_box_pack_start(GTK_BOX (hbox2), radiobuttonInet, FALSE, FALSE, 0); label5 = gtk_label_new(" Port: "); gtk_box_pack_start(GTK_BOX(hbox2), label5, FALSE, FALSE, 0); inetPort = gtk_spin_button_new_with_range(1025, 65536, 1); gtk_box_pack_start(GTK_BOX(hbox2), inetPort, TRUE, TRUE, 0); label4 = gtk_label_new("Connection"); gtk_frame_set_label_widget(GTK_FRAME(frame4), label4); gtk_label_set_use_markup(GTK_LABEL(label4), TRUE); dialog_action_area1 = GTK_DIALOG(settingsDlg)->action_area; gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END); g_signal_connect(G_OBJECT(radiobuttonBt), "toggled", G_CALLBACK(OnRadiobuttonBluetooth), inetPort); if(crtSettings.connectionType == CONN_BLUETOOTH) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonBt), TRUE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonInet), FALSE); g_object_set(G_OBJECT(inetPort), "sensitive", FALSE, NULL); } else { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonBt), FALSE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonInet), TRUE); g_object_set(G_OBJECT(inetPort), "sensitive", TRUE, NULL); } gtk_spin_button_set_value(GTK_SPIN_BUTTON(inetPort), crtSettings.inetPort); gtk_widget_show_all(settingsDlg); if(gtk_dialog_run(GTK_DIALOG(settingsDlg)) == GTK_RESPONSE_OK) { CUserSettings newSettings = crtSettings; if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobuttonBt))) { newSettings.connectionType = CONN_BLUETOOTH; } else { newSettings.connectionType = CONN_INET; newSettings.inetPort = gtk_spin_button_get_value(GTK_SPIN_BUTTON(inetPort)); } pSmartEngine->SaveSettings(newSettings); } gtk_widget_destroy(settingsDlg); }
RevertDialog::RevertDialog(Reference * reference) { // Save variables. extern Settings *settings; project = settings->genconfig.project_get(); ProjectConfiguration *projectconfig = settings->projectconfig(project); language = projectconfig->language_get(); reference_chapter = reference->chapter_get(); revisionloaded = false; branch = 0; // Build dialog. Shortcuts shortcuts(0); revertdialog = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(revertdialog), _("Revert")); gtk_window_set_position(GTK_WINDOW(revertdialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_type_hint(GTK_WINDOW(revertdialog), GDK_WINDOW_TYPE_HINT_DIALOG); dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (revertdialog)); gtk_widget_show(dialog_vbox1); hbox1 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox1); gtk_box_pack_start(GTK_BOX(dialog_vbox1), hbox1, TRUE, TRUE, 0); vbox1 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox1); gtk_box_pack_start(GTK_BOX(hbox1), vbox1, TRUE, TRUE, 0); table1 = gtk_table_new(2, 2, FALSE); gtk_widget_show(table1); gtk_box_pack_start(GTK_BOX(vbox1), table1, FALSE, TRUE, 0); comboboxbook = gtk_combo_box_new_text(); gtk_widget_show(comboboxbook); gtk_table_attach(GTK_TABLE(table1), comboboxbook, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); comboboxchapter = gtk_combo_box_new_text(); gtk_widget_show(comboboxchapter); gtk_table_attach(GTK_TABLE(table1), comboboxchapter, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); labelbook = gtk_label_new(_("Book")); gtk_widget_show(labelbook); gtk_table_attach(GTK_TABLE(table1), labelbook, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment(GTK_MISC(labelbook), 0, 0.5); shortcuts.label(labelbook); gtk_label_set_mnemonic_widget(GTK_LABEL(labelbook), comboboxbook); labelchapter = gtk_label_new(_("Chapter")); gtk_widget_show(labelchapter); gtk_table_attach(GTK_TABLE(table1), labelchapter, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment(GTK_MISC(labelchapter), 0, 0.5); shortcuts.label(labelchapter); gtk_label_set_mnemonic_widget(GTK_LABEL(labelchapter), comboboxchapter); hseparator1 = gtk_hseparator_new(); gtk_widget_show(hseparator1); gtk_box_pack_start(GTK_BOX(vbox1), hseparator1, FALSE, TRUE, 0); labelrevisions = gtk_label_new(_("Revisions")); gtk_widget_show(labelrevisions); gtk_box_pack_start(GTK_BOX(vbox1), labelrevisions, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(labelrevisions), 0, 0.5); shortcuts.label(labelrevisions); scrolledwindowrevisions = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindowrevisions); gtk_box_pack_start(GTK_BOX(vbox1), scrolledwindowrevisions, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindowrevisions), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindowrevisions), GTK_SHADOW_IN); treeviewrevisions = gtk_tree_view_new(); gtk_widget_show(treeviewrevisions); gtk_container_add(GTK_CONTAINER(scrolledwindowrevisions), treeviewrevisions); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeviewrevisions), FALSE); gtk_label_set_mnemonic_widget(GTK_LABEL(labelrevisions), treeviewrevisions); // Create treeview related stuff. store = gtk_list_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(treeviewrevisions), GTK_TREE_MODEL(store)); g_object_unref(store); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeviewrevisions), column); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviewrevisions)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); vseparator1 = gtk_vseparator_new(); gtk_widget_show(vseparator1); gtk_box_pack_start(GTK_BOX(hbox1), vseparator1, FALSE, TRUE, 0); vbox2 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox2); gtk_box_pack_start(GTK_BOX(hbox1), vbox2, TRUE, TRUE, 0); GSList *radiobutton_current_group = NULL; radiobutton_current = gtk_radio_button_new_with_mnemonic (NULL, _("View current version")); gtk_widget_show (radiobutton_current); gtk_box_pack_start (GTK_BOX (vbox2), radiobutton_current, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_current), radiobutton_current_group); radiobutton_current_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_current)); shortcuts.button(radiobutton_current); radiobutton_previous = gtk_radio_button_new_with_mnemonic (NULL, _("View previous revision")); gtk_widget_show (radiobutton_previous); gtk_box_pack_start (GTK_BOX (vbox2), radiobutton_previous, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_previous), radiobutton_current_group); radiobutton_current_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_previous)); shortcuts.button(radiobutton_previous); radiobutton_changes = gtk_radio_button_new_with_mnemonic (NULL, _("View changes if reverting to previous revision")); gtk_widget_show (radiobutton_changes); gtk_box_pack_start (GTK_BOX (vbox2), radiobutton_changes, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_changes), radiobutton_current_group); radiobutton_current_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_changes)); shortcuts.button(radiobutton_changes); changes_gui = new DisplayChangesGui (vbox2); gtk_widget_set_size_request(changes_gui->textview, 450, 500); dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(revertdialog)); gtk_widget_show(dialog_action_area1); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END); new InDialogHelp(revertdialog, NULL, &shortcuts, "edit/revert"); cancelbutton1 = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_show(cancelbutton1); gtk_dialog_add_action_widget(GTK_DIALOG(revertdialog), cancelbutton1, GTK_RESPONSE_CANCEL); gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true); okbutton1 = gtk_button_new_from_stock("gtk-ok"); gtk_widget_show(okbutton1); gtk_dialog_add_action_widget(GTK_DIALOG(revertdialog), okbutton1, GTK_RESPONSE_OK); gtk_widget_set_can_default (GTK_WIDGET (okbutton1), true); shortcuts.stockbutton(cancelbutton1); shortcuts.stockbutton(okbutton1); shortcuts.process(); g_signal_connect((gpointer) comboboxbook, "changed", G_CALLBACK(on_comboboxbook_changed), gpointer(this)); g_signal_connect((gpointer) comboboxchapter, "changed", G_CALLBACK(on_comboboxchapter_changed), gpointer(this)); g_signal_connect((gpointer) treeviewrevisions, "row_activated", G_CALLBACK(on_treeviewrevisions_row_activated), gpointer(this)); g_signal_connect((gpointer) okbutton1, "clicked", G_CALLBACK(on_okbutton1_clicked), gpointer(this)); g_signal_connect ((gpointer) radiobutton_current, "toggled", G_CALLBACK (on_radiobutton_toggled), gpointer(this)); g_signal_connect ((gpointer) radiobutton_previous, "toggled", G_CALLBACK (on_radiobutton_toggled), gpointer(this)); g_signal_connect ((gpointer) radiobutton_changes, "toggled", G_CALLBACK (on_radiobutton_toggled), gpointer(this)); gtk_widget_grab_focus(okbutton1); gtk_widget_grab_default(okbutton1); // Load books. This also loads the chapters through the callback. vector < unsigned int >books = project_get_books(project); vector < ustring > localbooks; for (unsigned int i = 0; i < books.size(); i++) { localbooks.push_back(books_id_to_name(language, books[i])); } combobox_set_strings(comboboxbook, localbooks); combobox_set_string(comboboxbook, books_id_to_name(language, reference->book_get())); // By default view changes. gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radiobutton_changes), true); }
static void xpad_preferences_init (XpadPreferences *pref) { GtkWidget *hbox, *font_hbox, *vbox; const GdkColor *color; const gchar *fontname; GtkStyle *style; GtkWidget *label, *appearance_frame, *alignment, *appearance_vbox; GtkWidget *options_frame, *options_vbox, *global_vbox; gchar *text; GtkSizeGroup *size_group_labels = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); GtkRequisition req; pref->priv = XPAD_PREFERENCES_GET_PRIVATE (pref); text = g_strconcat ("<b>", _("Appearance"), "</b>", NULL); label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL, "label", text, "use-markup", TRUE, "xalign", 0.0, NULL)); g_free (text); appearance_vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX, "homogeneous", FALSE, "spacing", 18, NULL)); alignment = gtk_alignment_new (1, 1, 1, 1); g_object_set (G_OBJECT (alignment), "left-padding", 12, "top-padding", 12, "child", appearance_vbox, NULL); appearance_frame = GTK_WIDGET (g_object_new (GTK_TYPE_FRAME, "label-widget", label, "shadow-type", GTK_SHADOW_NONE, "child", alignment, NULL)); pref->priv->textbutton = gtk_color_button_new (); pref->priv->backbutton = gtk_color_button_new (); pref->priv->fontbutton = gtk_font_button_new (); pref->priv->antifontcheck = gtk_radio_button_new_with_mnemonic (NULL, _("Use font from theme")); pref->priv->fontcheck = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (pref->priv->antifontcheck), _("Use this font:")); pref->priv->anticolorcheck = gtk_radio_button_new_with_mnemonic (NULL, _("Use colors from theme")); pref->priv->colorcheck = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (pref->priv->anticolorcheck), _("Use these colors:")); font_hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (font_hbox), pref->priv->fontcheck, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (font_hbox), pref->priv->fontbutton, TRUE, TRUE, 0); pref->priv->colorbox = gtk_vbox_new (FALSE, 6); hbox = gtk_hbox_new (FALSE, 12); label = gtk_label_new_with_mnemonic (_("Background:")); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_size_group_add_widget (size_group_labels, label); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), pref->priv->backbutton, TRUE, TRUE, 0); g_object_set (G_OBJECT (pref->priv->colorbox), "child", hbox, NULL); hbox = gtk_hbox_new (FALSE, 12); label = gtk_label_new_with_mnemonic (_("Foreground:")); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_size_group_add_widget (size_group_labels, label); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), pref->priv->textbutton, TRUE, TRUE, 0); g_object_set (G_OBJECT (pref->priv->colorbox), "child", hbox, NULL); alignment = gtk_alignment_new (1, 1, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); gtk_container_add (GTK_CONTAINER (alignment), pref->priv->colorbox); pref->priv->editcheck = gtk_check_button_new_with_mnemonic (_("_Edit lock")); pref->priv->stickycheck = gtk_check_button_new_with_mnemonic (_("_Pads start on all workspaces")); pref->priv->confirmcheck = gtk_check_button_new_with_mnemonic (_("_Confirm pad deletion")); gtk_dialog_add_button (GTK_DIALOG (pref), "gtk-close", GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response (GTK_DIALOG (pref), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator (GTK_DIALOG (pref), FALSE); g_signal_connect (pref, "response", G_CALLBACK (xpad_preferences_response), NULL); gtk_window_set_title (GTK_WINDOW (pref), _("Xpad Preferences")); gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pref->priv->textbutton), FALSE); gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pref->priv->backbutton), xpad_app_get_translucent ()); gtk_color_button_set_title (GTK_COLOR_BUTTON (pref->priv->textbutton), _("Set Foreground Color")); gtk_color_button_set_title (GTK_COLOR_BUTTON (pref->priv->backbutton), _("Set Background Color")); gtk_font_button_set_title (GTK_FONT_BUTTON (pref->priv->fontbutton), _("Set Font")); /* Set current state */ style = gtk_widget_get_default_style (); color = xpad_settings_get_back_color (xpad_settings ()); if (color) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->colorcheck), TRUE); gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->backbutton), color); } else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->anticolorcheck), TRUE); gtk_widget_set_sensitive (pref->priv->colorbox, FALSE); gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->backbutton), &style->base[GTK_STATE_NORMAL]); } color = xpad_settings_get_text_color (xpad_settings ()); if (color) gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->textbutton), color); else gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->textbutton), &style->text[GTK_STATE_NORMAL]); fontname = xpad_settings_get_fontname (xpad_settings ()); if (fontname) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->fontcheck), TRUE); gtk_font_button_set_font_name (GTK_FONT_BUTTON (pref->priv->fontbutton), fontname); } else { gchar *str; gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->antifontcheck), TRUE); gtk_widget_set_sensitive (pref->priv->fontbutton, FALSE); str = pango_font_description_to_string (style->font_desc); gtk_font_button_set_font_name (GTK_FONT_BUTTON (pref->priv->fontbutton), str); g_free (str); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->editcheck), xpad_settings_get_edit_lock (xpad_settings ())); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->stickycheck), xpad_settings_get_sticky (xpad_settings ())); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->confirmcheck), xpad_settings_get_confirm_destroy (xpad_settings ())); vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), pref->priv->antifontcheck, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), font_hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (appearance_vbox), vbox, FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), pref->priv->anticolorcheck, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), pref->priv->colorcheck, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (appearance_vbox), vbox, FALSE, FALSE, 0); text = g_strconcat ("<b>", _("Options"), "</b>", NULL); label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL, "label", text, "use-markup", TRUE, "xalign", 0.0, NULL)); g_free (text); options_vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX, "homogeneous", FALSE, "spacing", 6, NULL)); alignment = gtk_alignment_new (1, 1, 1, 1); g_object_set (G_OBJECT (alignment), "left-padding", 12, "top-padding", 12, "child", options_vbox, NULL); options_frame = GTK_WIDGET (g_object_new (GTK_TYPE_FRAME, "label-widget", label, "shadow-type", GTK_SHADOW_NONE, "child", alignment, NULL)); gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->editcheck, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->stickycheck, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->confirmcheck, FALSE, FALSE, 0); global_vbox = g_object_new (GTK_TYPE_VBOX, "border-width", 6, "homogeneous", FALSE, "spacing", 18, "child", appearance_frame, "child", options_frame, NULL); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pref)->vbox), global_vbox, FALSE, FALSE, 0); pref->priv->editcheck_handler = g_signal_connect (pref->priv->editcheck, "toggled", G_CALLBACK (change_edit_check), pref); pref->priv->stickycheck_handler = g_signal_connect (pref->priv->stickycheck, "toggled", G_CALLBACK (change_sticky_check), pref); pref->priv->confirmcheck_handler = g_signal_connect (pref->priv->confirmcheck, "toggled", G_CALLBACK (change_confirm_check), pref); pref->priv->colorcheck_handler = g_signal_connect (pref->priv->colorcheck, "toggled", G_CALLBACK (change_color_check), pref); pref->priv->fontcheck_handler = g_signal_connect (pref->priv->fontcheck, "toggled", G_CALLBACK (change_font_check), pref); pref->priv->text_handler = g_signal_connect (pref->priv->textbutton, "color-set", G_CALLBACK (change_text_color), pref); pref->priv->back_handler = g_signal_connect (pref->priv->backbutton, "color-set", G_CALLBACK (change_back_color), pref); pref->priv->font_handler = g_signal_connect (pref->priv->fontbutton, "font-set", G_CALLBACK (change_font_face), pref); pref->priv->notify_font_handler = g_signal_connect_swapped (xpad_settings (), "notify::fontname", G_CALLBACK (notify_fontname), pref); pref->priv->notify_text_handler = g_signal_connect_swapped (xpad_settings (), "notify::text-color", G_CALLBACK (notify_text_color), pref); pref->priv->notify_back_handler = g_signal_connect_swapped (xpad_settings (), "notify::back-color", G_CALLBACK (notify_back_color), pref); pref->priv->notify_sticky_handler = g_signal_connect_swapped (xpad_settings (), "notify::sticky", G_CALLBACK (notify_sticky), pref); pref->priv->notify_edit_handler = g_signal_connect_swapped (xpad_settings (), "notify::edit-lock", G_CALLBACK (notify_edit), pref); pref->priv->notify_confirm_handler = g_signal_connect_swapped (xpad_settings (), "notify::confirm-destroy", G_CALLBACK (notify_confirm), pref); g_object_unref (size_group_labels); gtk_widget_show_all (GTK_DIALOG (pref)->vbox); /* Make window not so squished */ gtk_widget_size_request (GTK_WIDGET (pref), &req); g_object_set (G_OBJECT (pref), "default-width", (gint) (req.height * 0.8), NULL); }
void diaElemThreadCount::setMe(void *dialog, void *opaque, uint32_t line) { GtkWidget *label1; GtkWidget *hbox1; GtkWidget *radiobutton1; GSList *radiobutton_group = NULL; GtkWidget *radiobutton2; GtkWidget *hbox2; GtkWidget *radiobutton3; GtkObject *spinbutton1_adj; GtkWidget *spinbutton1; label1 = gtk_label_new_with_mnemonic (paramTitle); gtk_widget_show (label1); gtk_misc_set_alignment (GTK_MISC (label1), 0.0, 0.5); gtk_table_attach (GTK_TABLE (opaque), label1, 0, 1, line, line+1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); hbox1 = gtk_hbox_new (FALSE, 20); gtk_widget_show (hbox1); radiobutton1 = gtk_radio_button_new_with_mnemonic (NULL, QT_TR_NOOP("Disable")); gtk_widget_show (radiobutton1); gtk_box_pack_start (GTK_BOX (hbox1), radiobutton1, FALSE, FALSE, 0); radiobutton2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radiobutton1), QT_TR_NOOP("Auto-detect")); gtk_widget_show (radiobutton2); gtk_box_pack_start (GTK_BOX (hbox1), radiobutton2, FALSE, FALSE, 0); hbox2 = gtk_hbox_new (FALSE, 6); gtk_widget_show (hbox2); gtk_box_pack_start (GTK_BOX (hbox1), hbox2, FALSE, FALSE, 0); radiobutton3 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radiobutton1), QT_TR_NOOP("Custom")); gtk_widget_show (radiobutton3); gtk_box_pack_start (GTK_BOX (hbox2), radiobutton3, TRUE, TRUE, 0); spinbutton1_adj = gtk_adjustment_new (2, 2, 32, 1, 10, 0); spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 0); gtk_widget_show (spinbutton1); gtk_box_pack_start (GTK_BOX (hbox2), spinbutton1, TRUE, TRUE, 0); gtk_entry_set_activates_default (GTK_ENTRY(spinbutton1), TRUE); gtk_table_attach (GTK_TABLE (opaque), hbox1, 1, 2, line, line+1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect(GTK_OBJECT(radiobutton3), "toggled", GTK_SIGNAL_FUNC(customToggled), this); GtkWidget **w; w = new GtkWidget*[4]; w[0] = radiobutton1; w[1] = radiobutton2; w[2] = radiobutton3; w[3] = spinbutton1; myWidget = (void *)w; uint32_t val = *(uint32_t *)param; gtk_widget_set_sensitive(GTK_WIDGET(spinbutton1), val > 1); if (val == 0) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radiobutton2), TRUE); else if (val == 1) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radiobutton1), TRUE); else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radiobutton3), TRUE); gtk_spin_button_set_value (GTK_SPIN_BUTTON(spinbutton1), val); } }
static void on_insert_numbers_activate(G_GNUC_UNUSED GtkMenuItem *menuitem, G_GNUC_UNUSED gpointer gdata) { InsertNumbersDialog d; GtkWidget *vbox, *label, *upper, *space, *button; GtkGrid *grid; GtkComboBoxText *combo; const char *case_tip = _("For base 11 and above"); gchar *base_text; gint result; d.dialog = gtk_dialog_new_with_buttons(_("Insert Numbers"), GTK_WINDOW(geany->main_widgets->window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); vbox = ui_dialog_vbox_new(GTK_DIALOG(d.dialog)); gtk_box_set_spacing(GTK_BOX(vbox), 9); #if GTK_CHECK_VERSION(3, 0, 0) grid = GTK_GRID(gtk_grid_new()); #else grid = GTK_TABLE(gtk_table_new(3, 6, FALSE)); #endif gtk_grid_set_row_spacing(grid, 6); gtk_grid_set_column_spacing(grid, 6); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(grid), TRUE, TRUE, 0); label = gtk_label_new_with_mnemonic(_("_Start:")); gtk_grid_attach(grid, label, 0, 0, 1, 1); d.start = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1); set_entry(d.start, RANGE_LEN, label, RANGE_TOOLTIP); gtk_grid_attach(grid, d.start, 1, 0, 2, 1); label = gtk_label_new_with_mnemonic(_("S_tep:")); gtk_grid_attach(grid, label, 3, 0, 1, 1); d.step = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1); set_entry(d.step, RANGE_LEN, label, RANGE_TOOLTIP); gtk_grid_attach(grid, d.step, 4, 0, 2, 1); label = gtk_label_new_with_mnemonic(_("_Base:")); gtk_grid_attach(grid, label, 0, 1, 1, 1), combo = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new_with_entry()); d.base = gtk_bin_get_child(GTK_BIN(combo)); set_entry(d.base, 2, label, "2..36"); g_signal_connect(d.base, "insert-text", G_CALLBACK(on_base_insert_text), NULL); gtk_combo_box_text_append_text(combo, "2"); gtk_combo_box_text_append_text(combo, "8"); gtk_combo_box_text_append_text(combo, "10"); gtk_combo_box_text_append_text(combo, "16"); #if GTK_CHECK_VERSION(3, 0, 0) gtk_grid_attach(grid, GTK_WIDGET(combo), 1, 1, 2, 1); gtk_widget_set_hexpand(GTK_WIDGET(combo), TRUE); #else gtk_table_attach(grid, GTK_WIDGET(combo), 1, 3, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0); #endif label = gtk_label_new(_("Letters:")); gtk_widget_set_tooltip_text(label, case_tip); gtk_grid_attach(grid, label, 3, 1, 1, 1); upper = gtk_radio_button_new_with_mnemonic(NULL, _("_Upper")); gtk_widget_set_tooltip_text(upper, case_tip); gtk_grid_attach(grid, upper, 4, 1, 1, 1); d.lower = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(upper)); gtk_widget_set_tooltip_text(label, case_tip); label = gtk_label_new_with_mnemonic(_("_Lower")); gtk_widget_set_tooltip_text(label, case_tip); gtk_container_add(GTK_CONTAINER(d.lower), label); gtk_grid_attach(grid, d.lower, 5, 1, 1, 1); d.prefix = gtk_check_button_new_with_mnemonic(_("Base _prefix")); gtk_widget_set_tooltip_text(d.prefix, _("0 for octal, 0x for hex, + for positive decimal")); gtk_grid_attach(grid, d.prefix, 1, 2, 2, 1); label = gtk_label_new(_("Padding:")); gtk_grid_attach(grid, label, 3, 2, 1, 1); space = gtk_radio_button_new_with_mnemonic(NULL, _("Sp_ace")); gtk_grid_attach(grid, space, 4, 2, 1, 1); d.zero = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(space)); label = gtk_label_new_with_mnemonic(_("_Zero")); gtk_container_add(GTK_CONTAINER(d.zero), label); gtk_grid_attach(grid, d.zero, 5, 2, 1, 1); button = gtk_button_new_from_stock(GTK_STOCK_OK); g_signal_connect(button, "clicked", G_CALLBACK(on_insert_numbers_ok_clicked), &d); gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(d.dialog))), button, TRUE, TRUE, 0); #if GTK_CHECK_VERSION(2, 18, 0) gtk_widget_set_can_default(button, TRUE); #else GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); #endif gtk_widget_grab_default(button); gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.start), start_value); gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.step), step_value); base_text = g_strdup_printf("%d", base_value); gtk_entry_set_text(GTK_ENTRY(d.base), base_text); g_free(base_text); gtk_button_clicked(GTK_BUTTON(lower_case ? d.lower : upper)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d.prefix), base_prefix); gtk_button_clicked(GTK_BUTTON(pad_zeros ? d.zero : space)); gtk_widget_show_all(d.dialog); result = gtk_dialog_run(GTK_DIALOG(d.dialog)); if (result == GTK_RESPONSE_ACCEPT) { if (can_insert_numbers()) { if (end_line - start_line < 1000) { /* quick version */ gtk_widget_hide(d.dialog); insert_numbers(NULL); } else { gboolean cancel = FALSE; gtk_widget_set_sensitive(GTK_WIDGET(grid), FALSE); gtk_widget_set_sensitive(button, FALSE); update_display(); g_signal_connect(d.dialog, "response", G_CALLBACK(on_insert_numbers_response), &cancel); insert_numbers(&cancel); } } else plugin_beep(); /* reloaded or something */ } gtk_widget_destroy(d.dialog); }
void greeter_session_init (void) { GtkWidget *w = NULL; GtkWidget *hbox = NULL; GtkWidget *main_vbox = NULL; GtkWidget *vbox = NULL; GtkWidget *cat_vbox = NULL; GtkWidget *radio; GtkWidget *dialog; GtkWidget *button; GList *tmp; static GtkTooltips *tooltips = NULL; GtkRequisition req; char *s; int num = 1; char *label; greeter_set_session (NULL); session_dialog = dialog = gtk_dialog_new (); if (tooltips == NULL) tooltips = gtk_tooltips_new (); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); button = gtk_button_new_with_mnemonic (_("Change _Session")); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_show (button); gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, GTK_RESPONSE_OK); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 2); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); main_vbox = gtk_vbox_new (FALSE, 18); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 5); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox, FALSE, FALSE, 0); cat_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (main_vbox), cat_vbox, FALSE, FALSE, 0); s = g_strdup_printf ("<b>%s</b>", _("Sessions")); w = gtk_label_new (s); gtk_label_set_use_markup (GTK_LABEL (w), TRUE); g_free (s); gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (cat_vbox), w, FALSE, FALSE, 0); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (cat_vbox), hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), gtk_label_new (" "), FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 6); /* we will pack this later depending on size */ if (mdm_config_get_bool (MDM_KEY_SHOW_LAST_SESSION)) { greeter_set_session (LAST_SESSION); radio = gtk_radio_button_new_with_mnemonic (session_group, _("_Last session")); g_object_set_data (G_OBJECT (radio), SESSION_NAME, LAST_SESSION); session_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); gtk_tooltips_set_tip (tooltips, radio, _("Log in using the session that you have used " "last time you logged in"), NULL); gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0); gtk_widget_show (radio); } mdm_session_list_init (); for (tmp = sessions; tmp != NULL; tmp = tmp->next) { MdmSession *session; char *file; file = (char *) tmp->data; session = g_hash_table_lookup (sessnames, file); if (num < 10 && (strcmp (file, MDM_SESSION_FAILSAFE_GNOME) != 0) && (strcmp (file, MDM_SESSION_FAILSAFE_XTERM) != 0)) label = g_strdup_printf ("_%d. %s", num, session->name); else label = g_strdup (session->name); num++; radio = gtk_radio_button_new_with_mnemonic (session_group, label); g_free (label); g_object_set_data_full (G_OBJECT (radio), SESSION_NAME, file, (GDestroyNotify) g_free); session_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0); gtk_widget_show (radio); if (! ve_string_empty (session->comment)) gtk_tooltips_set_tip (tooltips, GTK_WIDGET (radio), session->comment, NULL); } gtk_widget_show_all (vbox); gtk_widget_size_request (vbox, &req); /* if too large */ if (req.height > 0.7 * mdm_wm_screen.height) { GtkWidget *sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (sw, req.width, 0.7 * mdm_wm_screen.height); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw), vbox); gtk_widget_show (sw); gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0); } else { gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); } }