static void
on_romaji_theme_menu_changed (GtkOptionMenu *omenu, gpointer user_data)
{
bool success;
if (__widget_romaji_theme_menu != GTK_WIDGET (omenu)) {
g_signal_handlers_block_by_func (
G_OBJECT (__widget_romaji_theme_menu),
(gpointer) (on_romaji_theme_menu_changed),
NULL);
gtk_option_menu_set_history (
GTK_OPTION_MENU (__widget_romaji_theme_menu),
gtk_option_menu_get_history (omenu));
g_signal_handlers_unblock_by_func (
G_OBJECT (__widget_romaji_theme_menu),
(gpointer) (on_romaji_theme_menu_changed),
NULL);
success = load_romaji_theme ();
setup_romaji_window_value (SCIM_ANTHY_TABLE_EDITOR (user_data));
} else {
success = load_romaji_theme ();
}
if (success) {
// sync widgets
__style_changed = true;
__config_changed = true;
}
}
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;
}
void ACDProcCopy4to8(bool cw)
{
GtkWidget *opt = cw ? optAC2 : optAC3;
GtkWidget *menu, *active_item;
menu = GTK_OPTION_MENU(opt)->menu;
active_item = gtk_menu_get_active(GTK_MENU(menu));
int noact = g_list_index(GTK_MENU_SHELL(menu)->children, active_item);
int numact = actor->GetNumAction() - noact * 8;
if (numact < 8) {
GtkWidget *mes;
mes = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK, _("This act doesn't have 8 actions."));
gtk_dialog_run(GTK_DIALOG(mes));
gtk_widget_destroy(mes);
return;
}
int baseact = noact * 8;
for (int i=0; i<4; i++) {
if (cw) {
actor->CopyAction(baseact+i*2+1, baseact+i*2);
} else {
actor->CopyAction(baseact+i*2, baseact+i*2+1);
}
}
}
static void
add_menuitem_to_source (GtkWidget * widget,
GbWriteMenuItemSourceData * write_data)
{
gchar *label_text;
GtkWidget *menuitem, *child = GTK_BIN (widget)->child;
menuitem = GTK_OPTION_MENU (write_data->option_menu)->menu_item;
if (child == NULL && menuitem == widget)
{
child = GTK_BUTTON (write_data->option_menu)->child;
write_data->selected_index = write_data->index;
}
if (child && GTK_IS_LABEL (child))
{
gtk_label_get (GTK_LABEL (child), &label_text);
source_add (write_data->data,
" glade_menuitem = gtk_menu_item_new_with_label (%s);\n"
" gtk_widget_show (glade_menuitem);\n"
" gtk_menu_append (GTK_MENU (%s_menu), glade_menuitem);\n",
source_make_string (label_text,
write_data->data->use_gettext),
write_data->data->real_wname);
}
write_data->index++;
}
static time_t
get_requested_time (DialogData *data,
const char *filename)
{
int idx = gtk_option_menu_get_history (GTK_OPTION_MENU (data->date_optionmenu));
time_t t = (time_t)0;
switch (idx) {
case NO_DATE:
break;
case FOLLOWING_DATE:
t = gnome_date_edit_get_time (GNOME_DATE_EDIT (data->date_dateedit));
break;
case CURRENT_DATE:
t = time (NULL);
break;
case EXIF_DATE:
t = get_metadata_time (NULL, filename);
break;
case LAST_MODIFIED_DATE:
t = get_file_mtime (filename);
break;
case IMAGE_CREATION_DATE:
t = get_file_ctime (filename);
break;
}
return t;
}
static bool
load_romaji_theme (void)
{
GtkOptionMenu *omenu = GTK_OPTION_MENU (__widget_romaji_theme_menu);
gint idx = gtk_option_menu_get_history (omenu);
GtkWidget *menu = gtk_option_menu_get_menu (omenu);
GList *list = gtk_container_get_children (GTK_CONTAINER (menu));
GtkWidget *menuitem = GTK_WIDGET (g_list_nth_data (list, idx));
if (!menuitem)
return false;
gint theme_idx = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menuitem),
INDEX_KEY));
// set new romaji table
if (idx == ROMAJI_THEME_INDEX_USER_DEFINED) {
// User defined table
__config_romaji_theme_file = __user_style_file.get_file_name ();
StyleLines lines;
bool success = __user_style_file.get_entry_list
(lines, __romaji_fund_table);
if (!success || lines.empty ())
setup_default_romaji_table ();
return true;
} else if (idx == ROMAJI_THEME_INDEX_DEFAULT) {
// Default table
__config_romaji_theme_file = "";
setup_default_romaji_table ();
return true;
} else if (theme_idx >= 0 && theme_idx < (int) __style_list.size ()) {
// Tables defined in system theme files
__config_romaji_theme_file = __style_list[theme_idx].get_file_name ();
__user_style_file.delete_section (__romaji_fund_table);
std::vector<String> keys;
bool success = __style_list[theme_idx].get_key_list
(keys, __romaji_fund_table);
if (success) {
std::vector<String>::iterator it;
for (it = keys.begin (); it != keys.end (); it++) {
std::vector<WideString> value;
__style_list[theme_idx].get_string_array
(value, __romaji_fund_table, *it);
__user_style_file.set_string_array (__romaji_fund_table,
*it, value);
}
}
return true;
} else {
// error
return false;
}
}
static void
util_option_fwd_cb(GtkOptionMenu * opt_menu, gpointer callback)
{
((util_option_changed_cb)callback)(
gtk_option_menu_get_history(GTK_OPTION_MENU(opt_menu)),
g_object_get_data(G_OBJECT(opt_menu), "changed_userdata")
);
}
static void
change_toolbar_style (GtkWidget *option_menu, GtkWidget *toolbar)
{
GtkToolbarStyle style;
style = gtk_option_menu_get_history (GTK_OPTION_MENU (option_menu));
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), style);
}
void KeyOptionView::onValueChange() {
if (!myCurrentKey.empty()) {
((ZLKeyOptionEntry*)myOption)->onValueChange(
myCurrentKey,
gtk_option_menu_get_history(GTK_OPTION_MENU(myComboBox))
);
}
}
static void
comments_load(JamView *view) {
LJCommentsType type = jam_doc_get_comments(view->doc);
if (type != LJ_COMMENTS_DEFAULT)
show_meta(view, JAM_VIEW_COMMENTS);
if (comments_visible(view))
gtk_option_menu_set_history(GTK_OPTION_MENU(view->comments), type);
}
static void
sp_fill_style_widget_update_repr (SPWidget *spw, SPRepr *repr)
{
SPPaintSelector *psel;
GtkWidget *fillrule;
SPPaintSelectorMode pselmode;
SPStyle *style;
gfloat c[5];
if (g_object_get_data (G_OBJECT (spw), "update")) return;
g_object_set_data (G_OBJECT (spw), "update", GINT_TO_POINTER (TRUE));
#ifdef SP_FS_VERBOSE
g_print ("FillStyleWidget: Set update flag\n");
#endif
psel = SP_PAINT_SELECTOR(g_object_get_data (G_OBJECT (spw), "paint-selector"));
style = sp_style_new ();
sp_style_read_from_repr (style, repr);
pselmode = sp_fill_style_determine_paint_selector_mode (style);
#ifdef SP_FS_VERBOSE
g_print ("FillStyleWidget: paint selector mode %d\n", pselmode);
#endif
switch (pselmode) {
case SP_PAINT_SELECTOR_MODE_NONE:
/* No paint at all */
sp_paint_selector_set_mode (psel, SP_PAINT_SELECTOR_MODE_NONE);
break;
case SP_PAINT_SELECTOR_MODE_COLOR_RGB:
sp_paint_selector_set_mode (psel, SP_PAINT_SELECTOR_MODE_COLOR_RGB);
sp_color_get_rgb_floatv (&style->fill.value.color, c);
c[3] = SP_SCALE24_TO_FLOAT (style->fill_opacity.value);
sp_paint_selector_set_color_rgba_floatv (psel, c);
break;
case SP_PAINT_SELECTOR_MODE_COLOR_CMYK:
sp_paint_selector_set_mode (psel, SP_PAINT_SELECTOR_MODE_COLOR_CMYK);
sp_color_get_cmyk_floatv (&style->fill.value.color, c);
c[4] = SP_SCALE24_TO_FLOAT (style->fill_opacity.value);
sp_paint_selector_set_color_cmyka_floatv (psel, c);
break;
case SP_PAINT_SELECTOR_MODE_GRADIENT_LINEAR:
break;
default:
break;
}
fillrule = GTK_WIDGET(g_object_get_data (G_OBJECT (spw), "fill-rule"));
gtk_option_menu_set_history (GTK_OPTION_MENU (fillrule), (style->fill_rule.computed == ART_WIND_RULE_NONZERO) ? 0 : 1);
sp_style_unref (style);
g_object_set_data (G_OBJECT (spw), "update", GINT_TO_POINTER (FALSE));
#ifdef SP_FS_VERBOSE
g_print ("FillStyleWidget: Cleared update flag\n");
#endif
}
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;
}
/**
* Populate fields from control data.
* \param ctl Export control data.
*/
static void export_html_fill_fields( ExportHtmlCtl *ctl ) {
gtk_entry_set_text( GTK_ENTRY(exphtml_dlg.entryHtml), "" );
if( ctl->path ) {
gtk_entry_set_text( GTK_ENTRY(exphtml_dlg.entryHtml),
ctl->path );
}
gtk_option_menu_set_history(
GTK_OPTION_MENU( exphtml_dlg.optmenuCSS ), ctl->stylesheet );
gtk_option_menu_set_history(
GTK_OPTION_MENU( exphtml_dlg.optmenuName ), ctl->nameFormat );
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON( exphtml_dlg.checkBanding ), ctl->banding );
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON( exphtml_dlg.checkLinkEMail ), ctl->linkEMail );
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON( exphtml_dlg.checkAttributes ), ctl->showAttribs );
}
void select_polsarpro_classification_lut(const char *lut_basename)
{
int which = GPOINTER_TO_INT(
g_hash_table_lookup(g_polsarpro_classification_optionmenu_ht,
lut_basename));
GtkWidget *option_menu;
option_menu = get_widget_checked("browse_select_colormap_optionmenu");
gtk_option_menu_set_history(GTK_OPTION_MENU(option_menu), which);
}
int
menu_select_cb(GtkMenuItem * menuitem, GtkWidget * menu)
{
const char *label = menuitem_get_label(menuitem);
// printf( "menuitem = %s(%p), menu = %s(%p)\n", G_OBJECT_TYPE_NAME(menuitem), menuitem, G_OBJECT_TYPE_NAME(menu), menu );
if(label[0] == '<')
{
GtkWidget *selection = menu_get_first_menuitem(GTK_MENU(menu));
gtk_widget_hide(selection);
}
else
{
char *str = g_strdup(label);
GtkWidget *parent;
for (;;)
{
GtkMenuItem *parentitem;
const char *label2;
char *temp;
parent = gtk_widget_get_parent(GTK_WIDGET(menuitem));
// printf( "parent = %s(%p)\n", G_OBJECT_TYPE_NAME(parent), parent);
if(menu == parent)
break;
parentitem = GTK_MENU_ITEM(gtk_menu_get_attach_widget(GTK_MENU(parent)));
// printf( "parentitem = %s(%p)\n", G_OBJECT_TYPE_NAME(parentitem), parentitem);
label2 = menuitem_get_label(parentitem);
if(strcmp(label2, MORE_STRING) != 0)
{
temp = g_strconcat(label2, "/", str, NULL);
g_free(str);
str = temp;
}
menuitem = parentitem;
}
{
GtkLabel *label;
GtkWidget *selection = menu_get_first_menuitem(GTK_MENU(menu));
GtkOptionMenu *optionmenu = GTK_OPTION_MENU(gtk_menu_get_attach_widget(GTK_MENU(menu)));
label = GTK_LABEL(gtk_bin_get_child(GTK_BIN(selection)));
gtk_label_set_text(label, str);
gtk_widget_show(GTK_WIDGET(selection));
gtk_option_menu_set_history(optionmenu, 0);
g_free(str);
}
}
return 0;
}
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);
}
/*
* setup_reset_button() - enables the reset button if any of the current
* settings are not the default.
*/
static void setup_reset_button(CtkDitheringControls *ctk_dithering_controls)
{
gint history;
gint val;
if (!GTK_WIDGET_SENSITIVE(ctk_dithering_controls->dithering_controls_box)) {
/* Nothing is available, don't bother enabling the reset button yet. */
return;
}
/* The config menu is always available */
history = gtk_option_menu_get_history
(GTK_OPTION_MENU(ctk_dithering_controls->dithering_config_menu));
val = map_dithering_config_menu_idx_to_nvctrl(history);
if (val != NV_CTRL_DITHERING_AUTO) {
goto enable;
}
if (GTK_WIDGET_SENSITIVE(ctk_dithering_controls->dithering_mode_box)) {
history = gtk_option_menu_get_history
(GTK_OPTION_MENU(ctk_dithering_controls->dithering_mode_menu));
val = ctk_dithering_controls->dithering_mode_table[history];
if (val != NV_CTRL_DITHERING_MODE_AUTO) {
goto enable;
}
}
if (GTK_WIDGET_SENSITIVE(ctk_dithering_controls->dithering_depth_box)) {
history = gtk_option_menu_get_history
(GTK_OPTION_MENU(ctk_dithering_controls->dithering_depth_menu));
val = map_dithering_depth_menu_idx_to_nvctrl(history);
if (val != NV_CTRL_DITHERING_DEPTH_AUTO) {
goto enable;
}
}
/* Don't disable reset button here, since other settings that are not
* managed by the ctk_image_slider here may need it enabled
*/
return;
enable:
gtk_widget_set_sensitive(ctk_dithering_controls->reset_button, TRUE);
}
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);
}
/// gtk add on to get the rank in a pull down menu
uint8_t getRangeInMenu(GtkWidget * Menu)
{
GtkWidget *br, *active;
int mode;
br = gtk_option_menu_get_menu(GTK_OPTION_MENU(Menu));
active = gtk_menu_get_active(GTK_MENU(br));
mode = g_list_index(GTK_MENU_SHELL(br)->children, active);
return (uint8_t) mode;
}
static void
fill_in_info(EContactEditorIm *editor)
{
GtkWidget *optmenu;
fill_in_field(editor, "entry-username", editor->username);
optmenu = glade_xml_get_widget(editor->gui, "optmenu-service");
if (optmenu != NULL)
gtk_option_menu_set_history(GTK_OPTION_MENU(optmenu), editor->service - FIRST_IM_TYPE);
optmenu = glade_xml_get_widget(editor->gui, "optmenu-location");
if (optmenu != NULL)
gtk_option_menu_set_history(GTK_OPTION_MENU(optmenu),
(editor->location == NULL ? 2 :
!strcmp(editor->location, "WORK") ? 1 : 0));
}
static void
property_dialog_setup_option_menu (GtkWidget *option_menu,
GCallback func,
gpointer user_data,
gconstpointer str1, ...)
{
GtkWidget *menu;
GtkWidget *menu_item;
gint i;
va_list args;
gconstpointer str;
gint type;
menu = gtk_option_menu_get_menu (GTK_OPTION_MENU (option_menu));
if (menu) {
gtk_widget_destroy (menu);
}
menu = gtk_menu_new ();
va_start (args, str1);
for (str = str1, i = 0; str != NULL; str = va_arg (args, gpointer), i++) {
menu_item = gtk_menu_item_new_with_label (str);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
type = va_arg (args, gint);
g_object_set_data (G_OBJECT (menu_item),
"data",
GINT_TO_POINTER (type));
if (func) {
g_signal_connect (menu_item,
"activate",
func,
user_data);
}
}
va_end (args);
gtk_widget_show (menu);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
}
static void
on_table_editor_removed_entry (ScimAnthyTableEditor *editor, gpointer data)
{
// change menu item to "User deined"
gtk_option_menu_set_history (
GTK_OPTION_MENU (__widget_romaji_theme_menu2),
ROMAJI_THEME_INDEX_USER_DEFINED);
__style_changed = true;
}
/*
Change the text of the nth entry in the menu
*/
void changeTextInMenu(GtkWidget *menu,int range,const char *text)
{
GtkWidget *br, *active;
int mode;
br = gtk_option_menu_get_menu(GTK_OPTION_MENU(menu));
//gtk_label_set_text(GTK_LABEL(br),text);
}
void xvidFill(GtkWidget *dialog,xvidEncParam *myParam)
{
SPIN_SET(spinImin,imin);
SPIN_SET(spinImax,imax);
SPIN_SET(spinPmin,pmin);
SPIN_SET(spinPmax,pmax);
SPIN_SET(spinbuttonMaxIFrame,max_key_interval);
SPIN_SET(spinbuttonMinIFrame,min_key_interval);
if(myParam->quantizer==stQuant[0])
gtk_option_menu_set_history (GTK_OPTION_MENU(WID(optionQzer)),0);
else
gtk_option_menu_set_history (GTK_OPTION_MENU(WID(optionQzer)),1);
MENU_SET(optionME,gui_option);
}
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")) ;
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_option_menu_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gchar *items;
GtkWidget *menu, *menuitem;
gint choice;
items = gb_widget_input_text (data, Items);
if (data->apply)
{
gchar *pos = items;
gchar *items_end = &items[strlen (items)];
menu = gtk_menu_new ();
gtk_signal_connect (GTK_OBJECT (menu), "deactivate",
GTK_SIGNAL_FUNC (gb_option_menu_on_option_selected),
widget);
while (pos < items_end)
{
gchar *item_end = strchr (pos, '\n');
if (item_end == NULL)
item_end = items_end;
*item_end = '\0';
menuitem = gtk_menu_item_new_with_label (pos);
gtk_widget_show (menuitem);
gtk_menu_append (GTK_MENU (menu), menuitem);
pos = item_end + 1;
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (widget), menu);
}
if (data->action == GB_APPLYING)
g_free (items);
choice = gb_widget_input_int (data, Choice);
if (data->apply)
{
gtk_option_menu_set_history (GTK_OPTION_MENU (widget), choice);
}
}
static void
check_visible_sizes (const gchar *stock_id, gboolean show_all)
{
GtkIconSet *icon_set;
GtkIconSize *sizes;
gint n_sizes, i, j;
GtkWidget *option_menu, *menu;
gboolean item_visible[G_N_ELEMENTS(GladeIconSizeValues)];
GList *children;
for (j = 0; j < GladeIconSizeChoicesSize; j++)
item_visible[j] = show_all;
if (!show_all)
{
icon_set = gtk_icon_factory_lookup_default (stock_id);
if (icon_set)
{
gtk_icon_set_get_sizes (icon_set, &sizes, &n_sizes);
/* Figure out which of our choices should be visible. */
for (i = 0; i < n_sizes; i++)
{
for (j = 0; j < GladeIconSizeChoicesSize; j++)
{
if (sizes[i] == GladeIconSizeValues[j])
item_visible[j] = TRUE;
}
}
g_free (sizes);
}
}
/* Show or Hide the items as appropriate. */
option_menu = property_get_value_widget (IconSize);
g_return_if_fail (GTK_IS_OPTION_MENU (option_menu));
menu = gtk_option_menu_get_menu (GTK_OPTION_MENU (option_menu));
g_return_if_fail (GTK_IS_MENU (menu));
children = GTK_MENU_SHELL (menu)->children;
for (j = 0; j < GladeIconSizeChoicesSize; j++)
{
GtkWidget *item;
item = children->data;
if (item_visible[j])
gtk_widget_show (item);
else
gtk_widget_hide (item);
children = children->next;
}
}
static void
picture_store(JamView *view) {
int sel = gtk_option_menu_get_history(GTK_OPTION_MENU(view->pic));
LJUser *user = jam_account_lj_get_user(JAM_ACCOUNT_LJ(view->account));
const char *pickw = NULL;
if (sel > 0)
pickw = g_slist_nth(user->pickws, sel-1)->data;
jam_doc_set_picture(view->doc, pickw);
}
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_set_current_value(CtkDropDownMenu *d, gint value)
{
gint i;
for (i = 0; i < d->num_entries; i++) {
if (d->values[i].value == value) {
gtk_option_menu_set_history(GTK_OPTION_MENU(d->option_menu), i);
return;
}
}
} /* ctk_drop_down_menu_set_current_value() */