static GtkWidget *create_kbm_opts()
{
GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
opt_kbm_opts = gtk_combo_box_new_text ();
#if !GTK_CHECK_VERSION(2,4,0)
GtkWidget *menu_kbm_opts = gtk_menu_new ();
#endif
gtk_box_pack_start (GTK_BOX (hbox), opt_kbm_opts, FALSE, FALSE, 0);
int i;
int current_idx = get_current_kbm_idx();
for(i=0; kbm_sel[i].name; i++) {
#if GTK_CHECK_VERSION(2,4,0)
gtk_combo_box_append_text (GTK_COMBO_BOX_TEXT (opt_kbm_opts), _(kbm_sel[i].name));
#else
GtkWidget *item = gtk_menu_item_new_with_label (_(kbm_sel[i].name));
gtk_menu_shell_append (GTK_MENU_SHELL (menu_kbm_opts), item);
#endif
}
#if !GTK_CHECK_VERSION(2,4,0)
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt_kbm_opts), menu_kbm_opts);
#endif
gtk_combo_box_set_active (GTK_COMBO_BOX (opt_kbm_opts), current_idx);
opt_selkeys = gtk_combo_box_new_text ();
#if !GTK_CHECK_VERSION(2,4,0)
GtkWidget *menu_selkey = gtk_menu_new ();
#endif
gtk_box_pack_start (GTK_BOX (hbox), opt_selkeys, FALSE, FALSE, 0);
current_idx = 0;
for(i=0; selkeys[i].kstr; i++) {
#if GTK_CHECK_VERSION(2,4,0)
gtk_combo_box_append_text (GTK_COMBO_BOX_TEXT (opt_selkeys), selkeys[i].kstr);
#else
GtkWidget *item = gtk_menu_item_new_with_label (selkeys[i].kstr);
gtk_menu_shell_append (GTK_MENU_SHELL (menu_selkeys), item);
#endif
if (!strcmp(selkeys[i].kstr, pho_selkey))
current_idx = i;
}
#if !GTK_CHECK_VERSION(2,4,0)
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt_selkeys), menu_kbm_opts);
#endif
gtk_combo_box_set_active (GTK_COMBO_BOX (opt_selkeys), current_idx);
GtkAdjustment *adj =
(GtkAdjustment *) gtk_adjustment_new (pho_candicate_col_N, 1, 10, 1.0, 1.0, 0.0);
spinner_pho_candicate_col_N = gtk_spin_button_new (adj, 0, 0);
gtk_box_pack_start (GTK_BOX (hbox), spinner_pho_candicate_col_N, FALSE, FALSE, 0);
return hbox;
}
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;
}
static void prefs_spelling_btn_aspell_path_clicked_cb(GtkWidget *widget,
gpointer data)
{
SpellingPage *spelling = (SpellingPage *) data;
gchar *file_path;
GtkWidget *new_menu;
file_path = filesel_select_file(_("Select dictionaries location"),
prefs_common.aspell_path);
if (file_path != NULL) {
gchar *tmp_path, *tmp;
tmp_path = g_dirname(file_path);
tmp = g_strdup_printf("%s%s", tmp_path, G_DIR_SEPARATOR_S);
g_free(tmp_path);
new_menu = gtkaspell_dictionary_option_menu_new(tmp);
gtk_option_menu_set_menu(GTK_OPTION_MENU(spelling->optmenu_dictionary),
new_menu);
gtk_entry_set_text(GTK_ENTRY(spelling->entry_aspell_path), tmp);
/* select first one */
gtk_option_menu_set_history(GTK_OPTION_MENU(
spelling->optmenu_dictionary), 0);
g_free(tmp);
}
}
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);
}
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;
}
/*
* 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;
}
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() */
void update_blit_menu() {
GtkOptionMenu *option_menu_blit;
GtkWidget *item;
option_menu_blit = (GtkOptionMenu*) glade_xml_get_widget(gtk,"menu_blit");
if(!option_menu_blit) {
error("glade file corrupted: menu_blit symbol not found");
return;
}
/* cleanup previous menu */
if(menu_blit) delete menu_blit;
menu_blit = (GtkMenu*)gtk_menu_new();
gtk_menu_set_title(menu_blit,"Blit mode");
item = gtk_menu_item_new_with_label("Blit mode");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_blit),item);
Layer *lay = (Layer*)env->layers.selected();
Entry *ptr = lay->blitter.blitlist.begin();
while(ptr) {
item = gtk_menu_item_new_with_label(ptr->name);
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_blit),item);
g_signal_connect_swapped(G_OBJECT(item),"activate",
G_CALLBACK(on_select_blit),
(gpointer)ptr->name);
ptr = ptr->next;
}
gtk_option_menu_set_menu(option_menu_blit,
(GtkWidget*)menu_blit);
}
static GtkWidget *create_int_opts()
{
GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
opt_int_opts = gtk_combo_box_new_text ();
#if !GTK_CHECK_VERSION(2,4,0)
GtkWidget *menu_int_opts = gtk_menu_new ();
#endif
gtk_box_pack_start (GTK_BOX (hbox), opt_int_opts, FALSE, FALSE, 0);
int i;
for(i=0; i < int_selN; i++) {
#if GTK_CHECK_VERSION(2,4,0)
gtk_combo_box_append_text (GTK_COMBO_BOX_TEXT (opt_int_opts), int_sel[i].name);
#else
GtkWidget *item = gtk_menu_item_new_with_label (int_sel[i].name);
gtk_menu_shell_append (GTK_MENU_SHELL (menu_int_opts), item);
#endif
}
#if !GTK_CHECK_VERSION(2,4,0)
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt_int_opts), menu_int_opts);
#endif
gtk_combo_box_set_active (GTK_COMBO_BOX (opt_int_opts), current_intcode);
g_signal_connect (G_OBJECT (opt_int_opts), "changed", G_CALLBACK (cb_select), NULL);
return hbox;
}
static GtkWidget *create_auto_select_by_phrase_opts(GtkWidget **out, int val)
{
*out = gtk_combo_box_new_text ();
#if !GTK_CHECK_VERSION(2,4,0)
GtkWidget *menu_auto_select_by_phrase = gtk_menu_new ();
#endif
int i, current_idx=0;
for(i=0; auto_select_by_phrase_opts[i].str; i++) {
#if !GTK_CHECK_VERSION(2,4,0)
GtkWidget *item = gtk_menu_item_new_with_label (_(auto_select_by_phrase_opts[i].str));
#endif
if (auto_select_by_phrase_opts[i].num == val)
current_idx = i;
#if GTK_CHECK_VERSION(2,4,0)
gtk_combo_box_append_text (GTK_COMBO_BOX_TEXT (*out), _(auto_select_by_phrase_opts[i].str));
#else
gtk_menu_shell_append (GTK_MENU_SHELL (menu_auto_select_by_phrase), item);
#endif
}
#if !GTK_CHECK_VERSION(2,4,0)
gtk_option_menu_set_menu (GTK_OPTION_MENU (*out), menu_auto_select_by_phrase);
#endif
gtk_combo_box_set_active (GTK_COMBO_BOX (*out), current_idx);
return *out;
}
static void
setup_location_optmenu(EContactEditorIm *editor)
{
GtkWidget *item;
GtkWidget *optmenu;
GtkWidget *menu;
optmenu = glade_xml_get_widget(editor->gui, "optmenu-location");
g_signal_connect(G_OBJECT(optmenu), "changed",
G_CALLBACK(location_changed_cb), editor);
menu = gtk_menu_new();
gtk_option_menu_set_menu(GTK_OPTION_MENU(optmenu), menu);
gtk_widget_show(menu);
item = gtk_menu_item_new_with_label(_("Home"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
gtk_widget_show(item);
item = gtk_menu_item_new_with_label(_("Work"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
gtk_widget_show(item);
item = gtk_menu_item_new_with_label(_("Other"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
gtk_widget_show(item);
}
static GtkWidget *create_eng_ch_opts()
{
GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
opt_eng_ch_opts = gtk_combo_box_new_text ();
#if !GTK_CHECK_VERSION(2,4,0)
GtkWidget *menu_eng_ch_opts = gtk_menu_new ();
#endif
gtk_box_pack_start (GTK_BOX (hbox), opt_eng_ch_opts, FALSE, FALSE, 0);
int i;
int current_idx = get_currnet_eng_ch_sw_idx();
for(i=0; i < tsin_eng_ch_swN; i++) {
#if GTK_CHECK_VERSION(2,4,0)
gtk_combo_box_append_text (GTK_COMBO_BOX_TEXT (opt_eng_ch_opts), _(tsin_eng_ch_sw[i].name));
#else
GtkWidget *item = gtk_menu_item_new_with_label (_(tsin_eng_ch_sw[i].name));
gtk_menu_shell_append (GTK_MENU_SHELL (menu_eng_ch_opts), item);
#endif
}
dbg("current_idx:%d\n", current_idx);
#if !GTK_CHECK_VERSION(2,4,0)
gtk_option_menu_set_menu (GTK_OPTION_MENU (opt_eng_ch_opts), menu_eng_ch_opts);
#endif
gtk_combo_box_set_active (GTK_COMBO_BOX (opt_eng_ch_opts), current_idx);
return hbox;
}
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);
}
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);
}
/*
* 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;
}
//*****************************************************
void update(char *name,int idx)
{
GtkWidget *menu1;
// Print
if(!name) return;
menu1 = gtk_menu_new ();
gtk_label_set_text(GTK_LABEL(WID(labelVobsub)),name);
// Try to load it...
vobSubLanguage *lang=NULL;
lang=vobSubAllocateLanguage();
if(vobSubGetLanguage(name,lang))
{
// add them
for(int i=0; i<lang->nbLanguage; i++)
{
fq[i]=gtk_menu_item_new_with_mnemonic (lang->language[i].name);
gtk_widget_show (fq[i]);
gtk_container_add (GTK_CONTAINER (menu1), fq[i]);
indeces[i]=lang->language[i].index;
ADM_assert(i<MAX_INDECES);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (WID(optionmenu1)), menu1);
gtk_option_menu_set_history(GTK_OPTION_MENU(WID(optionmenu1)), idx);
}
// Destroy
vobSubDestroyLanguage(lang);
}
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
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);
}
static void
gb_option_menu_add_child (GtkWidget *widget,
GtkWidget *child,
GbWidgetSetArgData *data)
{
if (GTK_IS_MENU (child))
gtk_option_menu_set_menu (GTK_OPTION_MENU (widget), child);
else
g_warning (_("Cannot add a %s to a GtkOptionMenu."),
g_type_name (G_OBJECT_TYPE (child)));
}
void ctk_drop_down_menu_reset(CtkDropDownMenu *d)
{
g_free(d->values);
d->values = NULL;
d->num_entries = 0;
d->menu = gtk_menu_new();
gtk_option_menu_set_menu(GTK_OPTION_MENU(d->option_menu), d->menu);
} /* ctk_drop_down_menu_reset() */
static void
set_menu (GladeMenuEditor *menued, GtkOptionMenu *option)
{
int history;
g_return_if_fail (GLADE_IS_MENU_EDITOR (menued));
g_return_if_fail (GTK_IS_OPTION_MENU (option));
history = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (option), History));
gtk_option_menu_set_menu (option, GTK_WIDGET (menued->menu));
gtk_option_menu_set_history (option, history);
}
/*#
@method set_menu GtkOptionMenu
@brief Provides the GtkMenu that is popped up to allow the user to choose a new value.
@param menu the GtkMenu to associate with the GtkOptionMenu.
You should provide a simple menu avoiding the use of tearoff menu items,
submenus, and accelerators.
*/
FALCON_FUNC OptionMenu::set_menu( VMARG )
{
Item* i_menu = vm->param( 0 );
#ifndef NO_PARAMETER_CHECK
if ( !i_menu || !i_menu->isObject() || !IS_DERIVED( i_menu, GtkMenu ) )
throw_inv_params( "GtkMenu" );
#endif
GtkWidget* menu = (GtkWidget*) COREGOBJECT( i_menu )->getObject();
MYSELF;
GET_OBJ( self );
gtk_option_menu_set_menu( (GtkOptionMenu*)_obj, menu );
}
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;
}
/*
* 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 *
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
gb_menu_bar_on_edit_menu (GtkWidget *button,
gpointer data)
{
GtkWidget *option, *menued, *menu;
option = property_get_widget ();
g_return_if_fail (GTK_IS_OPTION_MENU (option));
/*
* we need to remove the menu from the option menu otherwise there
* will be a separator where the selected menu is
*/
g_object_set_data (G_OBJECT (option),
History,
GINT_TO_POINTER (gtk_option_menu_get_history (GTK_OPTION_MENU (option))));
menu = gtk_option_menu_get_menu (GTK_OPTION_MENU (option));
if (!menu)
menu = gb_widget_new ("GtkMenu", option);
g_object_ref (menu);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option), gtk_menu_new ());
menued = glade_menu_editor_new (current_project, GTK_MENU_SHELL (menu));
g_signal_connect (menued, "destroy", G_CALLBACK (set_menu), option);
/* I think this was hidden as it doesn't call set_menu() to reset the
history. */
gtk_widget_hide (GLADE_MENU_EDITOR (menued)->apply_button);
dialogize (menued, button);
gtk_widget_show (GTK_WIDGET (menued));
gtk_option_menu_set_menu (GTK_OPTION_MENU (option), menu);
g_object_unref (menu);
}
void wxChoice::DoClear()
{
wxCHECK_RET( m_widget != NULL, wxT("invalid choice") );
gtk_option_menu_remove_menu( GTK_OPTION_MENU(m_widget) );
GtkWidget *menu = gtk_menu_new();
gtk_option_menu_set_menu( GTK_OPTION_MENU(m_widget), menu );
m_clientList.Clear();
if ( m_strings )
m_strings->Clear();
// begin with no selection
m_selection_hack = wxNOT_FOUND;
}
static void
setup_service_optmenu(EContactEditorIm *editor)
{
GtkWidget *optmenu;
GtkWidget *menu;
GtkWidget *hbox;
GtkWidget *item;
GtkWidget *label;
GtkWidget *image;
GtkSizeGroup *sg;
int i;
optmenu = glade_xml_get_widget(editor->gui, "optmenu-service");
g_signal_connect(G_OBJECT(optmenu), "changed",
G_CALLBACK(service_changed_cb), editor);
menu = gtk_menu_new();
gtk_option_menu_set_menu(GTK_OPTION_MENU(optmenu), menu);
gtk_widget_show(menu);
sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
for (i = 0; i < G_N_ELEMENTS(im_labels); i++) {
item = gtk_menu_item_new();
hbox = gtk_hbox_new(FALSE, 4);
gtk_container_add(GTK_CONTAINER(item), hbox);
gtk_widget_show(hbox);
image = e_icon_factory_get_image (im_images[i], E_ICON_SIZE_MENU);
gtk_size_group_add_widget(sg, image);
gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
gtk_widget_show(image);
label = gtk_label_new(im_labels[i]);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
gtk_widget_show(item);
}
}
