static void
comments_add(JamView *view) {
GtkWidget *menu, *item;
static const char * items[] = {
N_("Default"),
N_("Don't Email"),
N_("Disable")
};
int i;
option_add(view);
view->comments = gtk_option_menu_new();
menu = gtk_menu_new();
for (i = 0; i < sizeof(items)/sizeof(char*); i++) {
item = gtk_menu_item_new_with_label(_(items[i]));
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
}
gtk_option_menu_set_menu(GTK_OPTION_MENU(view->comments), menu);
view->commentsbox = labelled_box_new(_("_Comments:"), view->comments);
gtk_box_pack_end(GTK_BOX(view->optionbar), view->commentsbox, FALSE, FALSE, 0);
gtk_widget_show_all(view->commentsbox);
}
/*
* Creates a new GtkWidget of class GtkOptionMenu, performing any specialized
* initialization needed for the widget to work correctly in this environment.
* If a dialog box is used to initialize the widget, return NULL from this
* function, and call data->callback with your new widget when it is done.
* If the widget needs a special destroy handler, add a signal here.
*/
GtkWidget *
gb_option_menu_new (GbWidgetNewData * data)
{
GtkWidget *new_widget;
new_widget = gtk_option_menu_new ();
return new_widget;
}
GtkWidget *
sp_fill_style_widget_new (void)
{
GtkWidget *spw, *vb, *psel, *hb, *l, *om, *m, *mi;
spw = sp_widget_new_global (INKSCAPE);
vb = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vb);
gtk_container_add (GTK_CONTAINER (spw), vb);
psel = sp_paint_selector_new ();
gtk_widget_show (psel);
gtk_box_pack_start (GTK_BOX (vb), psel, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (spw), "paint-selector", psel);
g_signal_connect (G_OBJECT (psel), "mode_changed", G_CALLBACK (sp_fill_style_widget_paint_mode_changed), spw);
g_signal_connect (G_OBJECT (psel), "dragged", G_CALLBACK (sp_fill_style_widget_paint_dragged), spw);
g_signal_connect (G_OBJECT (psel), "changed", G_CALLBACK (sp_fill_style_widget_paint_changed), spw);
hb = gtk_hbox_new (FALSE, 4);
gtk_widget_show (hb);
gtk_box_pack_start (GTK_BOX (vb), hb, FALSE, FALSE, 0);
l = gtk_label_new (_("Fill Rule"));
gtk_widget_show (l);
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (hb), l, TRUE, TRUE, 0);
om = gtk_option_menu_new ();
gtk_widget_show (om);
gtk_box_pack_start (GTK_BOX (hb), om, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (spw), "fill-rule", om);
/* 0 - nonzero 1 - evenodd */
m = gtk_menu_new ();
gtk_widget_show (m);
mi = gtk_menu_item_new_with_label (_("nonzero"));
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (m), mi);
g_object_set_data (G_OBJECT (mi), "fill-rule", (void *)"nonzero");
g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (sp_fill_style_widget_fill_rule_activate), spw);
mi = gtk_menu_item_new_with_label (_("evenodd"));
gtk_widget_show (mi);
gtk_menu_append (GTK_MENU (m), mi);
g_object_set_data (G_OBJECT (mi), "fill-rule", (void *)"evenodd");
g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (sp_fill_style_widget_fill_rule_activate), spw);
gtk_option_menu_set_menu (GTK_OPTION_MENU (om), m);
g_signal_connect (G_OBJECT (spw), "construct", G_CALLBACK (sp_fill_style_widget_construct), psel);
g_signal_connect (G_OBJECT (spw), "modify_selection", G_CALLBACK (sp_fill_style_widget_modify_selection), psel);
g_signal_connect (G_OBJECT (spw), "change_selection", G_CALLBACK (sp_fill_style_widget_change_selection), psel);
g_signal_connect (G_OBJECT (spw), "attr_changed", G_CALLBACK (sp_fill_style_widget_attr_changed), psel);
sp_fill_style_widget_update (SP_WIDGET (spw), SP_ACTIVE_DESKTOP ? SP_DT_SELECTION (SP_ACTIVE_DESKTOP) : NULL);
return spw;
}
static GtkWidget *create_lineend_menu(FileInfo *selected_fi)
{
GtkWidget *option_menu;
GtkWidget *menu;
GtkWidget *menu_item;
gint i;
option_menu = gtk_option_menu_new();
menu = gtk_menu_new();
for (i = 0; i <= 2; i++) {
menu_item = gtk_menu_item_new_with_label(lineend_str[i]);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
gtk_widget_show(menu_item); // <- required for width adjustment
}
gtk_option_menu_set_menu(GTK_OPTION_MENU(option_menu), menu);
g_signal_connect(G_OBJECT(option_menu), "changed",
G_CALLBACK(cb_select_lineend), selected_fi);
i = 0;
switch (selected_fi->lineend) {
case CR+LF:
i = 1;
break;
case CR:
i = 2;
}
gtk_option_menu_set_history(GTK_OPTION_MENU(option_menu), i);
return option_menu;
}
/* This creates a widget that lets you pick one item from a hardcoded list */
static GtkWidget *gtkhelp_oneof(
GtkSignalFunc callback, /* called whenever an item is selected */
char *(*namefunc)(int), /* called to generate names of items */
char *initial, /* initial value to show */
...) /* NULL-terminated list of hardcoded items */
{
GtkWidget *blist, *menu, *item;
va_list ap;
gint i, init;
char *value;
/* Create an empty menu widget */
menu = gtk_menu_new();
/* Also create the blist that the menu will go into */
blist = gtk_option_menu_new();
/* If there is a namefunc, then call it to get the first value */
va_start(ap, initial);
i = 0;
value = namefunc ? (*namefunc)(i) : NULL;
if (!value)
{
namefunc = NULL;
value = va_arg(ap, char *);
}
GtkWidget* ctk_drop_down_menu_new(guint flags)
{
GObject *object;
CtkDropDownMenu *d;
object = g_object_new(CTK_TYPE_DROP_DOWN_MENU, NULL);
d = CTK_DROP_DOWN_MENU(object);
d->flags = flags;
d->values = NULL;
d->num_entries = 0;
d->option_menu = gtk_option_menu_new();
d->menu = gtk_menu_new();
gtk_option_menu_set_menu(GTK_OPTION_MENU(d->option_menu), d->menu);
gtk_box_set_spacing(GTK_BOX(d), 0);
gtk_box_pack_start(GTK_BOX(d), d->option_menu, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(d->option_menu), "changed",
G_CALLBACK(changed), (gpointer) d);
return GTK_WIDGET(d);
} /* ctk_drop_down_menu_new() */
/*
* create_option_menu_simple:
* @ Create option menu widget. Return val will store to data.
*
* menu_items : Menu entries.
* def_val : Default value.
* data : Pointer to gint for store return value when a menuitem has been
* selected.
* Return : Option menu widget.
*/
GtkWidget *
create_option_menu_simple (const gchar **menu_items, gint def_val, gint *data)
{
GtkWidget *option_menu;
GtkWidget *menu_item;
GtkWidget *menu;
gint i;
option_menu = gtk_option_menu_new();
menu = gtk_menu_new();
for (i = 0; menu_items[i]; i++) {
menu_item = gtk_menu_item_new_with_label (_(menu_items[i]));
g_object_set_data (G_OBJECT (menu_item), "num", GINT_TO_POINTER(i));
g_signal_connect(G_OBJECT(menu_item), "activate",
G_CALLBACK(cb_get_data_from_menuitem),
data);
gtk_menu_append (GTK_MENU(menu), menu_item);
gtk_widget_show (menu_item);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
gtk_option_menu_set_history (GTK_OPTION_MENU (option_menu), def_val);
return option_menu;
}
GtkWidget *vsvks_vidnal(int *nomerstr)
{
int nomer=0;
GtkWidget *opt = gtk_option_menu_new();
GtkWidget *menu = gtk_menu_new();
GtkWidget *item;
item = gtk_menu_item_new_with_label (iceb_u_toutf(gettext("С НДС")));
gtk_signal_connect (GTK_OBJECT (item), "activate",GTK_SIGNAL_FUNC(iceb_get_menu), nomerstr);
gtk_object_set_user_data(GTK_OBJECT(item),(gpointer)nomer++);
gtk_widget_show (item);
gtk_menu_append (GTK_MENU (menu), item);
item = gtk_menu_item_new_with_label (iceb_u_toutf(gettext("Без НДС")));
gtk_signal_connect (GTK_OBJECT (item), "activate",GTK_SIGNAL_FUNC(iceb_get_menu), nomerstr);
gtk_object_set_user_data(GTK_OBJECT(item),(gpointer)nomer++);
gtk_widget_show (item);
gtk_menu_append (GTK_MENU (menu), item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
gtk_option_menu_set_history(GTK_OPTION_MENU(opt),*nomerstr);
return(opt);
}
void KeyOptionView::_createItem() {
myKeyButton = gtk_button_new();
gtk_signal_connect(GTK_OBJECT(myKeyButton), "focus_in_event", G_CALLBACK(key_view_focus_in_event), 0);
gtk_signal_connect(GTK_OBJECT(myKeyButton), "focus_out_event", G_CALLBACK(key_view_focus_out_event), 0);
gtk_signal_connect(GTK_OBJECT(myKeyButton), "key_press_event", G_CALLBACK(key_view_key_press_event), this);
gtk_signal_connect(GTK_OBJECT(myKeyButton), "button_press_event", G_CALLBACK(key_view_button_press_event), this);
key_view_focus_out_event(myKeyButton, 0, 0);
myLabel = gtk_label_new("");
myComboBox = gtk_option_menu_new();
const std::vector<std::string> &actions = ((ZLKeyOptionEntry*)myOption)->actionNames();
GtkWidget *menu = gtk_menu_new();
for (std::vector<std::string>::const_iterator it = actions.begin(); it != actions.end(); ++it) {
GtkWidget *menuItem = gtk_menu_item_new_with_label(it->c_str());
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuItem);
gtk_widget_show(menuItem);
}
gtk_option_menu_set_menu(GTK_OPTION_MENU(myComboBox), menu);
myWidget = gtk_table_new(2, 2, false);
gtk_table_set_col_spacings(GTK_TABLE(myWidget), 5);
gtk_table_set_row_spacings(GTK_TABLE(myWidget), 5);
gtk_table_attach_defaults(GTK_TABLE(myWidget), myKeyButton, 0, 2, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(myWidget), myLabel, 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(myWidget), myComboBox, 1, 2, 1, 2);
g_signal_connect(myComboBox, "changed", G_CALLBACK(_onValueChange), this);
myTab->addItem(myWidget, myRow, myFromColumn, myToColumn);
}
/*
* create_option_menu:
* @ Create option menu widget.
*
* menu_items : Menu entries.
* def_val : Default value.
* func : Callback function for each menu items.
* data : Pointer to user data for callback function.
* Return : Option menu widget.
*/
GtkWidget *
create_option_menu (const gchar **menu_items, gint def_val,
gpointer func, gpointer data)
{
GtkWidget *option_menu;
GtkWidget *menu_item;
GtkWidget *menu;
gint i;
option_menu = gtk_option_menu_new();
gtk_widget_set_name (option_menu, "/ThumbWin/DispModeOptionMenu");
menu = gtk_menu_new();
for (i = 0; menu_items[i]; i++) {
menu_item = gtk_menu_item_new_with_label (_(menu_items[i]));
g_object_set_data (G_OBJECT (menu_item), "num", GINT_TO_POINTER(i));
g_signal_connect(G_OBJECT(menu_item), "activate",
G_CALLBACK(func),
data);
gtk_menu_append (GTK_MENU(menu), menu_item);
gtk_widget_show (menu_item);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
gtk_option_menu_set_history (GTK_OPTION_MENU (option_menu), def_val);
return option_menu;
}
static void
pollmultidlg_init(PollMultiDlg *pmdlg, GtkWindow *parent) {
GtkWidget *mainbox, *vbox, *paned;
GtkWidget *menu, *label;
pmdlg->dlg = gtk_dialog_new_with_buttons(_("Multi Poll Question"),
parent, GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
jam_win_set_size(GTK_WINDOW(pmdlg->dlg), 500, -1);
mainbox = gtk_vbox_new(FALSE, 12);
menu = gtk_menu_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_menu_item_new_with_mnemonic(_("Choose best answer (_radio buttons)")));
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_menu_item_new_with_mnemonic(_("Choose best answer (_drop-down menu)")));
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_menu_item_new_with_mnemonic(_("Select _all that apply (checkboxes)")));
pmdlg->typemenu = gtk_option_menu_new();
gtk_option_menu_set_menu(GTK_OPTION_MENU(pmdlg->typemenu), menu);
gtk_box_pack_start(GTK_BOX(mainbox),
labelled_box_new_expand(_("Choice _Type:"), pmdlg->typemenu, TRUE),
FALSE, FALSE, 0);
paned = gtk_hpaned_new();
gtk_box_pack_start(GTK_BOX(mainbox), paned, TRUE, TRUE, 0);
vbox = gtk_vbox_new(FALSE, 6);
label = gtk_label_new_with_mnemonic(_("_Question:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
pmdlg->question = gtk_text_view_new();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(pmdlg->question), GTK_WRAP_WORD);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), pmdlg->question);
gtk_box_pack_start(GTK_BOX(vbox),
scroll_wrap(pmdlg->question),
TRUE, TRUE, 0);
gtk_paned_pack1(GTK_PANED(paned), vbox, TRUE, FALSE);
vbox = gtk_vbox_new(FALSE, 6);
pollmulti_make_list(pmdlg);
label = gtk_label_new_with_mnemonic(_("O_ptions:"));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), pmdlg->answers.view);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), pmdlg->answers.box, TRUE, TRUE, 0);
gtk_paned_pack2(GTK_PANED(paned), vbox, TRUE, FALSE);
jam_dialog_set_contents(GTK_DIALOG(pmdlg->dlg), mainbox);
}
static void
picture_add(JamView *view) {
moodpic_add(view);
view->pic = gtk_option_menu_new();
picture_populate(view);
view->picbox = labelled_box_new_sg(_("_Picture:"), view->pic, view->sizegroup);
gtk_box_pack_start(GTK_BOX(view->moodpicbar), view->picbox, FALSE, FALSE, 0);
gtk_widget_show_all(view->picbox);
}
static void
game_preferences_callback (GtkWidget *widget, void *data)
{
GtkWidget *menu, *omenu, *l, *hb, *cb, *f, *fv;
GtkWidget *button;
if (pref_dialog)
return;
pref_dialog = gnome_dialog_new (_("Preferences"),
GNOME_STOCK_BUTTON_OK, GNOME_STOCK_BUTTON_CANCEL,
NULL);
gnome_dialog_set_parent (GNOME_DIALOG (pref_dialog), GTK_WINDOW (app));
gtk_signal_connect (GTK_OBJECT(pref_dialog), "delete_event",
GTK_SIGNAL_FUNC (cancel), NULL);
omenu = gtk_option_menu_new ();
menu = gtk_menu_new ();
fill_menu (menu);
gtk_widget_show (omenu);
gtk_option_menu_set_menu (GTK_OPTION_MENU(omenu), menu);
f = gtk_frame_new (_ ("Scenario"));
gtk_container_border_width (GTK_CONTAINER (f), 5);
hb = gtk_hbox_new (FALSE, FALSE);
gtk_widget_show (hb);
l = gtk_label_new (_("Select scenario:"));
gtk_widget_show (l);
gtk_box_pack_start_defaults (GTK_BOX(hb), l);
gtk_box_pack_start_defaults (GTK_BOX(hb), omenu);
cb = gtk_check_button_new_with_label ( _("Make it the default scenario") );
gtk_signal_connect (GTK_OBJECT(cb), "clicked", (GtkSignalFunc)set_selection_def, NULL);
gtk_widget_show (cb);
fv = gtk_vbox_new (0, 5);
gtk_container_border_width (GTK_CONTAINER (fv), 5);
gtk_widget_show (fv);
gtk_box_pack_start_defaults (GTK_BOX(fv), hb);
gtk_box_pack_start_defaults (GTK_BOX(fv), cb);
gtk_box_pack_start_defaults (GTK_BOX(GNOME_DIALOG(pref_dialog)->vbox), f);
gtk_container_add (GTK_CONTAINER (f), fv);
gtk_widget_show (f);
gnome_dialog_button_connect (GNOME_DIALOG (pref_dialog), 0,
GTK_SIGNAL_FUNC (load_scenario_callback), NULL);
gnome_dialog_button_connect (GNOME_DIALOG (pref_dialog), 1,
GTK_SIGNAL_FUNC (cancel), (gpointer)1);
gtk_widget_show (pref_dialog);
}
/*
* Creates a new GtkWidget of class GtkOptionMenu, performing any specialized
* initialization needed for the widget to work correctly in this environment.
* If a dialog box is used to initialize the widget, return NULL from this
* function, and call data->callback with your new widget when it is done.
* If the widget needs a special destroy handler, add a signal here.
*/
GtkWidget *
gb_option_menu_new (GbWidgetNewData * data)
{
GtkWidget *new_widget;
new_widget = gtk_option_menu_new ();
gtk_option_menu_set_menu (GTK_OPTION_MENU (new_widget), gtk_menu_new ());
gtk_signal_connect (GTK_OBJECT (GTK_OPTION_MENU (new_widget)->menu),
"deactivate",
GTK_SIGNAL_FUNC (gb_option_menu_on_option_selected),
new_widget);
return new_widget;
}
static GtkWidget *create_charset_menu(FileInfo *selected_fi)
{
GtkWidget *option_menu;
GtkWidget *menu;
GtkWidget *menu_item;
CharsetTable *ctable;
gint i;
option_menu = gtk_option_menu_new();
menu = gtk_menu_new();
if (mode == OPEN) {
menu_item = gtk_menu_item_new_with_label(_("Auto-Detect"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
gtk_widget_show(menu_item); // <- required for width adjustment
}
ctable = get_charset_table();
for (i = 0; i < ctable->num; i++) {
menu_item = gtk_menu_item_new_with_label(ctable->str[i]);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
gtk_widget_show(menu_item); // <- required for width adjustment
}
menu_item_manual_charset = NULL;
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
init_menu_item_manual_charset(selected_fi->charset_flag
? selected_fi->charset : NULL));
gtk_widget_show(menu_item_manual_charset); // <- required for width adjustment
charset_menu_init_flag = TRUE;
g_signal_connect(G_OBJECT(option_menu), "changed",
G_CALLBACK(cb_select_charset), selected_fi);
gtk_option_menu_set_menu(GTK_OPTION_MENU(option_menu), menu);
i = 0;
if (selected_fi->charset) {
do {
if (g_strcasecmp(selected_fi->charset, ctable->charset[i]) == 0)
break;
i++;
} while (i < ctable->num);
if (mode == OPEN && selected_fi->charset_flag == FALSE) {
g_free(selected_fi->charset);
selected_fi->charset = NULL;
} else if (i == ctable->num && selected_fi->charset_flag == FALSE) {
init_menu_item_manual_charset(selected_fi->charset);
}
i += mode;
}
if (mode == SAVE || selected_fi->charset_flag)
gtk_option_menu_set_history(GTK_OPTION_MENU(option_menu), i);
charset_menu_init_flag = FALSE;
return option_menu;
}
static GtkWidget *
get_config_frame(PurplePlugin *plugin)
{
GtkWidget *ret;
GtkWidget *vbox;
GtkWidget *toggle;
#if 0
GtkWidget *opt;
GtkWidget *menu, *item;
#endif
/* Outside container */
ret = gtk_vbox_new(FALSE, 18);
gtk_container_set_border_width(GTK_CONTAINER(ret), 12);
/* Configuration frame */
vbox = pidgin_make_frame(ret, _("Mouse Gestures Configuration"));
#if 0
/* Mouse button drop-down menu */
menu = gtk_menu_new();
opt = gtk_option_menu_new();
item = gtk_menu_item_new_with_label(_("Middle mouse button"));
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(mouse_button_menu_cb), opt);
gtk_menu_append(menu, item);
item = gtk_menu_item_new_with_label(_("Right mouse button"));
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(mouse_button_menu_cb), opt);
gtk_menu_append(menu, item);
gtk_box_pack_start(GTK_BOX(vbox), opt, FALSE, FALSE, 0);
gtk_option_menu_set_menu(GTK_OPTION_MENU(opt), menu);
gtk_option_menu_set_history(GTK_OPTION_MENU(opt),
gstroke_get_mouse_button() - 2);
#endif
/* "Visual gesture display" checkbox */
toggle = gtk_check_button_new_with_mnemonic(_("_Visual gesture display"));
gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
purple_prefs_get_bool("/plugins/gtk/X11/gestures/visual"));
g_signal_connect(G_OBJECT(toggle), "toggled",
G_CALLBACK(toggle_draw_cb), NULL);
gtk_widget_show_all(ret);
return ret;
}
GtkWidget *create_server_type_menu (int active_type,
gboolean (*filterfunc)(enum server_type),
GtkSignalFunc callback) {
GtkWidget *option_menu = NULL;
GtkWidget *menu = NULL;
GtkWidget *menu_item = NULL;
GtkWidget *first_menu_item = NULL;
int i;
int j = 0;
int menu_type = 0;
option_menu = gtk_option_menu_new ();
menu = gtk_menu_new ();
for (i = 0; i < GAMES_TOTAL; ++i) {
if (filterfunc && !filterfunc (i))
continue;
menu_item = gtk_menu_item_new ();
if (i == active_type) {
first_menu_item = menu_item;
menu_type = j;
}
else if (!first_menu_item)
first_menu_item = menu_item;
gtk_menu_append (GTK_MENU (menu), menu_item);
gtk_container_add (GTK_CONTAINER (menu_item), game_pixmap_with_label (i));
if (callback)
gtk_signal_connect (GTK_OBJECT (menu_item), "activate", GTK_SIGNAL_FUNC (callback), GINT_TO_POINTER (i));
gtk_widget_show (menu_item);
++j; // must be here in case the continue was used
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
// initiates callback to set servertype to first configured game
if (active_type != -1 && first_menu_item) {
gtk_menu_item_activate (GTK_MENU_ITEM (first_menu_item));
gtk_option_menu_set_history (GTK_OPTION_MENU (option_menu), menu_type);
}
return option_menu;
}
GtkWidget *
gtk_utils_create_selector (const gchar **items, gint num_items,
gint selected_item)
{
GtkWidget *widget;
int k;
g_return_val_if_fail (items, NULL);
g_return_val_if_fail (num_items > 0, NULL);
#if GTK_2_4_OR_LATER
widget = gtk_combo_box_new_text ();
{
GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
for (k = 0; k < num_items; k++)
gtk_combo_box_append_text (combo_box, _(items[k]));
gtk_combo_box_set_active (combo_box,
(0 <= selected_item && selected_item < num_items
? selected_item : 0));
}
#else /* not GTK_2_4_OR_LATER */
widget = gtk_option_menu_new ();
{
GtkWidget *menu = gtk_menu_new ();
GtkMenuShell *menu_shell = GTK_MENU_SHELL (menu);
for (k = 0; k < num_items; k++) {
gtk_menu_shell_append (menu_shell,
gtk_menu_item_new_with_label (_(items[k])));
}
gtk_widget_show_all (menu);
gtk_option_menu_set_menu (GTK_OPTION_MENU (widget), menu);
}
if (0 <= selected_item && selected_item < num_items)
gtk_option_menu_set_history (GTK_OPTION_MENU (widget), selected_item);
#endif /* not GTK_2_4_OR_LATER */
return widget;
}
static void
create_testwidgets ()
{
GtkWidget *treeview;
GtkListStore *store;
GtkCellRenderer *renderer;
widgets[WIDGET_NULL] = NULL;
widgets[WIDGET_SCROLLBAR] = gtk_vscrollbar_new (NULL);
widgets[WIDGET_TOGGLE_BUTTON] = gtk_toggle_button_new_with_label ("blah");
widgets[WIDGET_STATUS_BAR] = gtk_statusbar_new ();
treeview = gtk_tree_view_new ();
/* set up the treeview */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Column1", renderer,
"text", 0, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Column2", renderer,
"text", 0, NULL);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store));
widgets[WIDGET_TREE_VIEW] = treeview;
/* lets abuse the private API ... */
widgets[WIDGET_TREE_VIEW_HEADER] = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), 0)->button;
widgets[WIDGET_SCALE] = gtk_hscale_new_with_range (0, 1, 0.1);
widgets[WIDGET_PROGRESS_BAR] = gtk_progress_bar_new ();
widgets[WIDGET_MENUBAR] = gtk_menu_bar_new ();
widgets[WIDGET_MENUBAR_ITEM] = gtk_menu_item_new_with_label ("blah");
gtk_menu_shell_append (GTK_MENU_SHELL (widgets[WIDGET_MENUBAR]), widgets[WIDGET_MENUBAR_ITEM]);
#ifndef GTK_DISABLE_DEPRECATED
widgets[WIDGET_OPTION_MENU] = gtk_option_menu_new ();
#else
#warning Not testing engines against GtkOptionMenu
#endif /* GTK_DISABLE_DEPRECATED */
widgets[WIDGET_TOOLBAR] = gtk_toolbar_new ();
widgets[WIDGET_DEFAULT_BUTTON] = gtk_button_new_with_label ("blah");
/* nasty but *shrug* */
GTK_WIDGET_SET_FLAGS(widgets[WIDGET_DEFAULT_BUTTON], GTK_CAN_DEFAULT);
GTK_WIDGET_SET_FLAGS(widgets[WIDGET_DEFAULT_BUTTON], GTK_HAS_DEFAULT);
}
bool wxChoice::Create( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
long style, const wxValidator& validator, const wxString &name )
{
m_needParent = true;
#if (GTK_MINOR_VERSION > 0)
m_acceptsFocus = true;
#endif
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxChoice creation failed") );
return false;
}
m_widget = gtk_option_menu_new();
if ( style & wxCB_SORT )
{
// if our m_strings != NULL, Append() will check for it and insert
// items in the correct order
m_strings = new wxSortedArrayString;
}
// begin with no selection
m_selection_hack = wxNOT_FOUND;
GtkWidget *menu = gtk_menu_new();
for (unsigned int i = 0; i < (unsigned int)n; i++)
{
GtkAddHelper(menu, i, choices[i]);
}
gtk_option_menu_set_menu( GTK_OPTION_MENU(m_widget), menu );
m_parent->DoAddChild( this );
PostCreation(size);
SetInitialSize(size); // need this too because this is a wxControlWithItems
return true;
}
static GtkWidget*
command_make(SettingsWidget *sw) {
CommandList *cmds = sw->data;
GtkWidget *vbox, *menu;
GtkSizeGroup *sg;
char *cmd = *((char**)sw->conf);
int cur = -1;
int i;
menu = gtk_menu_new();
for (i = 0; cmds[i].label; i++) {
char *curcmd = cmds[i].command;
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_menu_item_new_with_label(_(cmds[i].label)));
if (cur == -1 &&
((cmd == curcmd) ||
(cmd && curcmd && (strcmp(cmd, curcmd) == 0))))
cur = i;
}
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_menu_item_new_with_label(_("Custom Command")));
if (cur == -1) cur = i;
sw->widget = gtk_option_menu_new();
gtk_option_menu_set_menu(GTK_OPTION_MENU(sw->widget), menu);
gtk_option_menu_set_history(GTK_OPTION_MENU(sw->widget), cur);
sw->subwidget = gtk_entry_new();
tie_text(GTK_ENTRY(sw->subwidget), (char**)sw->conf);
g_signal_connect(G_OBJECT(sw->widget), "changed",
G_CALLBACK(command_changed_cb), sw);
jam_widget_set_visible(sw->subwidget, cur == i);
sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
vbox = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox),
labelled_box_new_sg(_(sw->caption), sw->widget, sg),
FALSE, FALSE, 0);
sw->data2 = labelled_box_new_sg(NULL, sw->subwidget, sg); /* ugh. */
gtk_box_pack_start(GTK_BOX(vbox),
sw->data2,
FALSE, FALSE, 0);
return vbox;
}
GtkWidget*
pp_units_new ()
{
pp_Units *ob=PP_UNITS(g_object_new (pp_units_get_type (), NULL));
gtk_box_set_spacing(GTK_BOX(ob),5);
GtkWidget *label;
GtkWidget *hbox;
hbox=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(ob),hbox,TRUE,TRUE,0);
gtk_widget_show(hbox);
label=gtk_label_new(_("Units:"));
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
gtk_widget_show(label);
ob->unitselector = gtk_option_menu_new ();
GtkWidget *menu, *menu_item;
menu = gtk_menu_new ();
menu_item = gtk_menu_item_new_with_label (_("Points"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
menu_item = gtk_menu_item_new_with_label (_("Inches"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
menu_item = gtk_menu_item_new_with_label (_("Millimeters"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
menu_item = gtk_menu_item_new_with_label (_("Centimeters"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (ob->unitselector), menu);
gtk_box_pack_start(GTK_BOX(hbox),ob->unitselector,TRUE,TRUE,5);
gtk_widget_show(ob->unitselector);
pp_units_refresh(ob);
return(GTK_WIDGET(ob));
}
static void qcad_clock_combo_instance_init (GObject *object, gpointer data)
{
GtkWidget *item = NULL, *mnu = NULL ;
QCADClockCombo *qcc = QCAD_CLOCK_COMBO (object) ;
DBG_OO (fprintf (stderr, "QCADClockCombo::instance_init:Entering\n")) ;
qcc->widget = gtk_option_menu_new () ;
gtk_box_pack_start (GTK_BOX (object), qcc->widget, FALSE, TRUE, 0) ;
gtk_widget_show (qcc->widget) ;
g_object_set_data (G_OBJECT (qcc->widget), "clock", (gpointer)-1) ;
mnu = gtk_menu_new () ;
gtk_widget_show (mnu) ;
gtk_option_menu_set_menu (GTK_OPTION_MENU (qcc->widget), mnu) ;
item = gtk_menu_item_new_with_label (_("Clock 0")) ;
gtk_widget_show (item) ;
gtk_container_add (GTK_CONTAINER (mnu), item) ;
g_object_set_data (G_OBJECT (item), "clock", (gpointer)0) ;
g_signal_connect (G_OBJECT (item), "activate", (GCallback)qcad_clock_combo_item_activate, qcc) ;
item = gtk_menu_item_new_with_label (_("Clock 1")) ;
gtk_widget_show (item) ;
gtk_container_add (GTK_CONTAINER (mnu), item) ;
g_object_set_data (G_OBJECT (item), "clock", (gpointer)1) ;
g_signal_connect (G_OBJECT (item), "activate", (GCallback)qcad_clock_combo_item_activate, qcc) ;
item = gtk_menu_item_new_with_label (_("Clock 2")) ;
gtk_widget_show (item) ;
gtk_container_add (GTK_CONTAINER (mnu), item) ;
g_object_set_data (G_OBJECT (item), "clock", (gpointer)2) ;
g_signal_connect (G_OBJECT (item), "activate", (GCallback)qcad_clock_combo_item_activate, qcc) ;
item = gtk_menu_item_new_with_label (_("Clock 3")) ;
gtk_widget_show (item) ;
gtk_container_add (GTK_CONTAINER (mnu), item) ;
g_object_set_data (G_OBJECT (item), "clock", (gpointer)3) ;
g_signal_connect (G_OBJECT (item), "activate", (GCallback)qcad_clock_combo_item_activate, qcc) ;
gtk_option_menu_set_history (GTK_OPTION_MENU (qcc->widget), 0) ;
DBG_OO (fprintf (stderr, "QCADClockCombo::instance_init:Leaving\n")) ;
}
void iceb_pm_vibor(class iceb_u_spisok *strmenu,GtkWidget **opt,int *nomer_str)
{
*opt = gtk_option_menu_new();
GtkWidget *menu = gtk_menu_new();
int nomer=0;
GtkWidget *item;
for(int ii=0; ii < strmenu->kolih(); ii++)
{
item = gtk_menu_item_new_with_label (strmenu->ravno_toutf(ii));
gtk_signal_connect (GTK_OBJECT (item), "activate",GtkSignalFunc(iceb_pm_vibor_get),nomer_str);
gtk_object_set_user_data(GTK_OBJECT(item),(gpointer)nomer++);
gtk_widget_show (item);
gtk_menu_append (GTK_MENU (menu), item);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (*opt), menu);
gtk_option_menu_set_history(GTK_OPTION_MENU(*opt),*nomer_str);
}
GtkWidget *
util_net_type_option(util_option_changed_cb changed_cb, gpointer userdata)
{
GtkWidget * menu, * opt_menu;
int i;
menu = gtk_menu_new();
for (i = 0; i < NET_TYPE_NUM; i++)
gtk_menu_shell_append(
GTK_MENU_SHELL(menu),
make_menu_item(net_name_of_type(i), NULL, TRUE));
opt_menu = gtk_option_menu_new();
g_object_set_data(G_OBJECT(opt_menu), "changed_userdata", userdata);
gtk_option_menu_set_menu(GTK_OPTION_MENU(opt_menu), menu);
if(changed_cb)
g_signal_connect(G_OBJECT(opt_menu), "changed",
G_CALLBACK(util_option_fwd_cb), changed_cb);
return opt_menu;
}
GtkWidget *
util_user_mode_option(util_option_changed_cb changed_cb, gpointer userdata)
{
GtkWidget * menu, * opt_menu;
int mode;
menu = gtk_menu_new();
for (mode = UMODE_FIRST_VALID; mode < UMODE_NUM_VALID; mode++)
gtk_menu_shell_append(
GTK_MENU_SHELL(menu),
make_menu_item(user_mode_name(mode),
util_user_state_stock(mode, TRUE), TRUE) );
opt_menu = gtk_option_menu_new();
g_object_set_data(G_OBJECT(opt_menu), "changed_userdata", userdata);
gtk_option_menu_set_menu(GTK_OPTION_MENU(opt_menu), (gpointer)menu);
if(changed_cb)
g_signal_connect(G_OBJECT(opt_menu), "changed",
G_CALLBACK(util_option_fwd_cb), changed_cb);
return opt_menu;
}
static EAddrConduitGui *
e_addr_gui_new (EPilotSettings *ps)
{
EAddrConduitGui *gui;
GtkWidget *lbl, *menu;
gint rows, i;
static const char *items[] = {"Business", "Home", "Other", NULL};
g_return_val_if_fail (ps != NULL, NULL);
g_return_val_if_fail (E_IS_PILOT_SETTINGS (ps), NULL);
gtk_table_resize (GTK_TABLE (ps), E_PILOT_SETTINGS_TABLE_ROWS + 1,
E_PILOT_SETTINGS_TABLE_COLS);
gui = g_new0 (EAddrConduitGui, 1);
rows = E_PILOT_SETTINGS_TABLE_ROWS;
lbl = gtk_label_new (_("Default Sync Address:"));
gtk_misc_set_alignment (GTK_MISC (lbl), 0.0, 0.5);
gui->default_address = gtk_option_menu_new ();
menu = gtk_menu_new ();
for (i = 0; items[i] != NULL; i++) {
GtkWidget *item;
item = gtk_menu_item_new_with_label (items[i]);
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
}
gtk_widget_show (menu);
gtk_option_menu_set_menu (GTK_OPTION_MENU (gui->default_address), menu);
gtk_table_attach_defaults (GTK_TABLE (ps), lbl, 0, 1, rows, rows + 1);
gtk_table_attach_defaults (GTK_TABLE (ps), gui->default_address, 1, 2, rows, rows + 1);
gtk_widget_show (lbl);
gtk_widget_show (gui->default_address);
return gui;
}
static void add_dither_menu(gint option, gint *option_c, gchar *text, GtkWidget *box)
{
GtkWidget *hbox;
GtkWidget *omenu;
GtkWidget *menu;
*option_c = option;
hbox = pref_box_new(box, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_label_new(hbox, text);
omenu = gtk_option_menu_new();
menu = gtk_menu_new();
add_menu_item(menu, _("None"), option_c, (gint)GDK_RGB_DITHER_NONE);
add_menu_item(menu, _("Normal"), option_c, (gint)GDK_RGB_DITHER_NORMAL);
add_menu_item(menu, _("Best"), option_c, (gint)GDK_RGB_DITHER_MAX);
gtk_option_menu_set_menu(GTK_OPTION_MENU(omenu), menu);
gtk_option_menu_set_history(GTK_OPTION_MENU(omenu), *option_c);
gtk_box_pack_start(GTK_BOX(hbox), omenu, FALSE, FALSE, 0);
gtk_widget_show(omenu);
}
//----------------------------
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *table2;
GtkWidget *label1;
GtkWidget *label2;
GtkObject *spinbutton_width_adj;
GtkWidget *spinbutton_width;
GtkObject *spinbutton_height_adj;
GtkWidget *spinbutton_height;
GtkWidget *label5;
GtkWidget *label6;
GtkWidget *optionmenu_source;
GtkWidget *menu1;
GtkWidget *item1_1;
GtkWidget *_4_1;
GtkWidget *_16_1;
GtkWidget *optionmenu_dest;
GtkWidget *menu2;
GtkWidget *menuitem1;
GtkWidget *menuitem2;
GtkWidget *menuitem3;
GtkWidget *label3;
GtkWidget *label_errorx;
GtkWidget *label7;
GtkWidget *label_errory;
GtkWidget *checkbutton_16;
GtkWidget *optionmenu1;
GtkWidget *menu3;
GtkWidget *bilinear1;
GtkWidget *bicubic1;
GtkWidget *lanczos1;
GtkWidget *alignment1;
GtkWidget *fixed1;
GtkWidget *fixed2;
GtkWidget *hscale1;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *applybutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Resize"));
gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
table2 = gtk_table_new (4, 4, FALSE);
gtk_widget_show (table2);
gtk_box_pack_start (GTK_BOX (vbox1), table2, FALSE, FALSE, 0);
label1 = gtk_label_new (QT_TR_NOOP(" Width "));
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table2), label1, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
label2 = gtk_label_new (QT_TR_NOOP(" Height "));
gtk_widget_show (label2);
gtk_table_attach (GTK_TABLE (table2), label2, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
spinbutton_width_adj = gtk_adjustment_new (2, 0, 3000, 1, 10, 10);
spinbutton_width = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_width_adj), 1, 0);
gtk_widget_show (spinbutton_width);
gtk_table_attach (GTK_TABLE (table2), spinbutton_width, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton_width), TRUE);
spinbutton_height_adj = gtk_adjustment_new (1, 0, 3000, 1, 10, 10);
spinbutton_height = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton_height_adj), 1, 0);
gtk_widget_show (spinbutton_height);
gtk_table_attach (GTK_TABLE (table2), spinbutton_height, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton_height), TRUE);
label5 = gtk_label_new (QT_TR_NOOP("Source :"));
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table2), label5, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label6 = gtk_label_new (QT_TR_NOOP("Destination"));
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table2), label6, 2, 3, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
optionmenu_source = gtk_option_menu_new ();
gtk_widget_show (optionmenu_source);
gtk_table_attach (GTK_TABLE (table2), optionmenu_source, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
menu1 = gtk_menu_new ();
item1_1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("1:1"));
gtk_widget_show (item1_1);
gtk_container_add (GTK_CONTAINER (menu1), item1_1);
_4_1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("4:3"));
gtk_widget_show (_4_1);
gtk_container_add (GTK_CONTAINER (menu1), _4_1);
_16_1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("16:9"));
gtk_widget_show (_16_1);
gtk_container_add (GTK_CONTAINER (menu1), _16_1);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu_source), menu1);
optionmenu_dest = gtk_option_menu_new ();
gtk_widget_show (optionmenu_dest);
gtk_table_attach (GTK_TABLE (table2), optionmenu_dest, 3, 4, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
menu2 = gtk_menu_new ();
menuitem1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("1:1"));
gtk_widget_show (menuitem1);
gtk_container_add (GTK_CONTAINER (menu2), menuitem1);
menuitem2 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("4:3"));
gtk_widget_show (menuitem2);
gtk_container_add (GTK_CONTAINER (menu2), menuitem2);
menuitem3 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("16:9"));
gtk_widget_show (menuitem3);
gtk_container_add (GTK_CONTAINER (menu2), menuitem3);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu_dest), menu2);
label3 = gtk_label_new (QT_TR_NOOP(" Error X:"));
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table2), label3, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label_errorx = gtk_label_new (QT_TR_NOOP("0"));
gtk_widget_show (label_errorx);
gtk_table_attach (GTK_TABLE (table2), label_errorx, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_errorx), 0, 0.5);
label7 = gtk_label_new (QT_TR_NOOP(" Error Y:"));
gtk_widget_show (label7);
gtk_table_attach (GTK_TABLE (table2), label7, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5);
label_errory = gtk_label_new (QT_TR_NOOP("0"));
gtk_widget_show (label_errory);
gtk_table_attach (GTK_TABLE (table2), label_errory, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_errory), 0, 0.5);
checkbutton_16 = gtk_check_button_new_with_mnemonic (QT_TR_NOOP("16 round up"));
gtk_widget_show (checkbutton_16);
gtk_table_attach (GTK_TABLE (table2), checkbutton_16, 3, 4, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
optionmenu1 = gtk_option_menu_new ();
gtk_widget_show (optionmenu1);
gtk_table_attach (GTK_TABLE (table2), optionmenu1, 3, 4, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
menu3 = gtk_menu_new ();
bilinear1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("Bilinear"));
gtk_widget_show (bilinear1);
gtk_container_add (GTK_CONTAINER (menu3), bilinear1);
bicubic1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("Bicubic"));
gtk_widget_show (bicubic1);
gtk_container_add (GTK_CONTAINER (menu3), bicubic1);
lanczos1 = gtk_menu_item_new_with_mnemonic (QT_TR_NOOP("Lanczos3"));
gtk_widget_show (lanczos1);
gtk_container_add (GTK_CONTAINER (menu3), lanczos1);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), menu3);
alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment1);
gtk_table_attach (GTK_TABLE (table2), alignment1, 2, 3, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
fixed1 = gtk_fixed_new ();
gtk_widget_show (fixed1);
gtk_container_add (GTK_CONTAINER (alignment1), fixed1);
fixed2 = gtk_fixed_new ();
gtk_widget_show (fixed2);
gtk_table_attach (GTK_TABLE (table2), fixed2, 2, 3, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (100, 0, 100, 1, 1, 0)));
gtk_widget_show (hscale1);
gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0);
gtk_scale_set_digits (GTK_SCALE (hscale1), 0);
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);
applybutton1 = gtk_button_new_from_stock ("gtk-apply");
gtk_widget_show (applybutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), applybutton1, GTK_RESPONSE_APPLY);
GTK_WIDGET_SET_FLAGS (applybutton1, 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);
/*
g_signal_connect ((gpointer) _4_1, "activate",
G_CALLBACK (on_4_1_activate),
NULL);
g_signal_connect ((gpointer) _16_1, "activate",
G_CALLBACK (on_16_1_activate),
NULL);
g_signal_connect ((gpointer) menuitem2, "activate",
G_CALLBACK (on_4_1_activate),
NULL);
g_signal_connect ((gpointer) menuitem3, "activate",
G_CALLBACK (on_16_1_activate),
NULL);
g_signal_connect ((gpointer) bilinear1, "activate",
G_CALLBACK (on_bilinear1_activate),
NULL);
g_signal_connect ((gpointer) bicubic1, "activate",
G_CALLBACK (on_bicubic1_activate),
NULL);
g_signal_connect ((gpointer) lanczos1, "activate",
G_CALLBACK (on_lanczos1_activate),
NULL);
*/
/* 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, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, table2, "table2");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, spinbutton_width, "spinbutton_width");
GLADE_HOOKUP_OBJECT (dialog1, spinbutton_height, "spinbutton_height");
GLADE_HOOKUP_OBJECT (dialog1, label5, "label5");
GLADE_HOOKUP_OBJECT (dialog1, label6, "label6");
GLADE_HOOKUP_OBJECT (dialog1, optionmenu_source, "optionmenu_source");
GLADE_HOOKUP_OBJECT (dialog1, menu1, "menu1");
GLADE_HOOKUP_OBJECT (dialog1, item1_1, "item1_1");
GLADE_HOOKUP_OBJECT (dialog1, _4_1, "_4_1");
GLADE_HOOKUP_OBJECT (dialog1, _16_1, "_16_1");
GLADE_HOOKUP_OBJECT (dialog1, optionmenu_dest, "optionmenu_dest");
GLADE_HOOKUP_OBJECT (dialog1, menu2, "menu2");
GLADE_HOOKUP_OBJECT (dialog1, menuitem1, "menuitem1");
GLADE_HOOKUP_OBJECT (dialog1, menuitem2, "menuitem2");
GLADE_HOOKUP_OBJECT (dialog1, menuitem3, "menuitem3");
GLADE_HOOKUP_OBJECT (dialog1, label3, "label3");
GLADE_HOOKUP_OBJECT (dialog1, label_errorx, "label_errorx");
GLADE_HOOKUP_OBJECT (dialog1, label7, "label7");
GLADE_HOOKUP_OBJECT (dialog1, label_errory, "label_errory");
GLADE_HOOKUP_OBJECT (dialog1, checkbutton_16, "checkbutton_16");
GLADE_HOOKUP_OBJECT (dialog1, optionmenu1, "optionmenu1");
GLADE_HOOKUP_OBJECT (dialog1, menu3, "menu3");
GLADE_HOOKUP_OBJECT (dialog1, bilinear1, "bilinear1");
GLADE_HOOKUP_OBJECT (dialog1, bicubic1, "bicubic1");
GLADE_HOOKUP_OBJECT (dialog1, lanczos1, "lanczos1");
GLADE_HOOKUP_OBJECT (dialog1, alignment1, "alignment1");
GLADE_HOOKUP_OBJECT (dialog1, fixed1, "fixed1");
GLADE_HOOKUP_OBJECT (dialog1, fixed2, "fixed2");
GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, applybutton1, "applybutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
void create_range_controls( void )
{
GtkWidget *window;
GtkWidget *box1, *box2, *box3;
GtkWidget *button;
GtkWidget *scrollbar;
GtkWidget *separator;
GtkWidget *opt, *menu, *item;
GtkWidget *label;
GtkWidget *scale;
GtkObject *adj1, *adj2;
/* Standard window-creating stuff */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "range controls");
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
/* value, lower, upper, step_increment, page_increment, page_size */
/* Note that the page_size value only makes a difference for
* scrollbar widgets, and the highest value you'll get is actually
* (upper - page_size). */
adj1 = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
vscale = gtk_vscale_new (GTK_ADJUSTMENT (adj1));
scale_set_default_values (GTK_SCALE (vscale));
gtk_box_pack_start (GTK_BOX (box2), vscale, TRUE, TRUE, 0);
gtk_widget_show (vscale);
box3 = gtk_vbox_new (FALSE, 10);
gtk_box_pack_start (GTK_BOX (box2), box3, TRUE, TRUE, 0);
gtk_widget_show (box3);
/* Reuse the same adjustment */
hscale = gtk_hscale_new (GTK_ADJUSTMENT (adj1));
gtk_widget_set_usize (GTK_WIDGET (hscale), 200, 30);
scale_set_default_values (GTK_SCALE (hscale));
gtk_box_pack_start (GTK_BOX (box3), hscale, TRUE, TRUE, 0);
gtk_widget_show (hscale);
/* Reuse the same adjustment again */
scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adj1));
/* Notice how this causes the scales to always be updated
* continuously when the scrollbar is moved */
gtk_range_set_update_policy (GTK_RANGE (scrollbar),
GTK_UPDATE_CONTINUOUS);
gtk_box_pack_start (GTK_BOX (box3), scrollbar, TRUE, TRUE, 0);
gtk_widget_show (scrollbar);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
/* A checkbutton to control whether the value is displayed or not */
button = gtk_check_button_new_with_label("Display value on scale widgets");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
GTK_SIGNAL_FUNC(cb_draw_value), NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* An option menu to change the position of the value */
label = gtk_label_new ("Scale Value Position:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
opt = gtk_option_menu_new();
menu = gtk_menu_new();
item = make_menu_item ("Top",
GTK_SIGNAL_FUNC(cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_TOP));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Bottom", GTK_SIGNAL_FUNC (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_BOTTOM));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Left", GTK_SIGNAL_FUNC (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_LEFT));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Right", GTK_SIGNAL_FUNC (cb_pos_menu_select),
GINT_TO_POINTER (GTK_POS_RIGHT));
gtk_menu_append (GTK_MENU (menu), item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
gtk_widget_show (opt);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* Yet another option menu, this time for the update policy of the
* scale widgets */
label = gtk_label_new ("Scale Update Policy:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
opt = gtk_option_menu_new();
menu = gtk_menu_new();
item = make_menu_item ("Continuous",
GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_CONTINUOUS));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Discontinuous",
GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_DISCONTINUOUS));
gtk_menu_append (GTK_MENU (menu), item);
item = make_menu_item ("Delayed",
GTK_SIGNAL_FUNC (cb_update_menu_select),
GINT_TO_POINTER (GTK_UPDATE_DELAYED));
gtk_menu_append (GTK_MENU (menu), item);
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
gtk_widget_show (opt);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* An HScale widget for adjusting the number of digits on the
* sample scales. */
label = gtk_label_new ("Scale Digits:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adj2 = gtk_adjustment_new (1.0, 0.0, 5.0, 1.0, 1.0, 0.0);
gtk_signal_connect (GTK_OBJECT (adj2), "value_changed",
GTK_SIGNAL_FUNC (cb_digits_scale), NULL);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
box2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* And, one last HScale widget for adjusting the page size of the
* scrollbar. */
label = gtk_label_new ("Scrollbar Page Size:");
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adj2 = gtk_adjustment_new (1.0, 1.0, 101.0, 1.0, 1.0, 0.0);
gtk_signal_connect (GTK_OBJECT (adj2), "value_changed",
GTK_SIGNAL_FUNC (cb_page_size), adj1);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
gtk_scale_set_digits (GTK_SCALE (scale), 0);
gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("Quit");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_main_quit),
NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (window);
}
