JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkCheckMenuItem_gtk_1check_1menu_1item_1set_1draw_1as_1radio
(
JNIEnv* env,
jclass cls,
jlong _self,
jboolean _drawAsRadio
)
{
GtkCheckMenuItem* self;
gboolean drawAsRadio;
// convert parameter self
self = (GtkCheckMenuItem*) _self;
// convert parameter drawAsRadio
drawAsRadio = (gboolean) _drawAsRadio;
// call function
gtk_check_menu_item_set_draw_as_radio(self, drawAsRadio);
// cleanup parameter self
// cleanup parameter drawAsRadio
}
static void
gtk_check_menu_item_update (GtkActivatable *activatable,
GtkAction *action,
const gchar *property_name)
{
GtkCheckMenuItem *check_menu_item;
gboolean use_action_appearance;
check_menu_item = GTK_CHECK_MENU_ITEM (activatable);
parent_activatable_iface->update (activatable, action, property_name);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
if (strcmp (property_name, "active") == 0)
{
gtk_action_block_activate (action);
gtk_check_menu_item_set_active (check_menu_item, gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
gtk_action_unblock_activate (action);
}
use_action_appearance = gtk_activatable_get_use_action_appearance (activatable);
G_GNUC_END_IGNORE_DEPRECATIONS;
if (!use_action_appearance)
return;
if (strcmp (property_name, "draw-as-radio") == 0)
{
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
gtk_check_menu_item_set_draw_as_radio (check_menu_item,
gtk_toggle_action_get_draw_as_radio (GTK_TOGGLE_ACTION (action)));
G_GNUC_END_IGNORE_DEPRECATIONS;
}
}
static void
gtk_check_menu_item_sync_action_properties (GtkActivatable *activatable,
GtkAction *action)
{
GtkCheckMenuItem *check_menu_item;
gboolean use_action_appearance;
gboolean is_toggle_action;
check_menu_item = GTK_CHECK_MENU_ITEM (activatable);
parent_activatable_iface->sync_action_properties (activatable, action);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
is_toggle_action = GTK_IS_TOGGLE_ACTION (action);
G_GNUC_END_IGNORE_DEPRECATIONS;
if (!is_toggle_action)
return;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
gtk_action_block_activate (action);
gtk_check_menu_item_set_active (check_menu_item, gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
gtk_action_unblock_activate (action);
use_action_appearance = gtk_activatable_get_use_action_appearance (activatable);
G_GNUC_END_IGNORE_DEPRECATIONS;
if (!use_action_appearance)
return;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
gtk_check_menu_item_set_draw_as_radio (check_menu_item,
gtk_toggle_action_get_draw_as_radio (GTK_TOGGLE_ACTION (action)));
G_GNUC_END_IGNORE_DEPRECATIONS;
}
void MainWindowToolbarMenu::addToolbarMenuEntry(ToolbarData* d, GtkMenuShell* menubar, int& menuPos)
{
XOJ_CHECK_TYPE(MainWindowToolbarMenu);
GtkWidget* item = gtk_check_menu_item_new_with_label(d->getName().c_str());
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(item), true);
gtk_widget_show(item);
gtk_menu_shell_insert(menubar, item, menuPos);
menuitems.push_back(item);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), d == selectedToolbar);
MenuSelectToolbarData* data = new MenuSelectToolbarData(this, item, d, toolbarMenuData.size());
toolbarMenuData.push_back(data);
g_signal_connect(item, "toggled", G_CALLBACK(tbSelectMenuitemActivated), data);
if (inPredefinedSection && !d->isPredefined())
{
GtkWidget* separator = gtk_separator_menu_item_new();
gtk_widget_show(separator);
gtk_menu_shell_insert(menubar, separator, menuPos++);
inPredefinedSection = false;
menuitems.push_back(separator);
}
}
static void
gtk_check_menu_item_update (GtkActivatable *activatable,
GtkAction *action,
const gchar *property_name)
{
GtkCheckMenuItem *check_menu_item;
check_menu_item = GTK_CHECK_MENU_ITEM (activatable);
parent_activatable_iface->update (activatable, action, property_name);
if (strcmp (property_name, "active") == 0)
{
gtk_action_block_activate (action);
gtk_check_menu_item_set_active (check_menu_item, gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
gtk_action_unblock_activate (action);
}
if (!gtk_activatable_get_use_action_appearance (activatable))
return;
if (strcmp (property_name, "draw-as-radio") == 0)
gtk_check_menu_item_set_draw_as_radio (check_menu_item,
gtk_toggle_action_get_draw_as_radio (GTK_TOGGLE_ACTION (action)));
}
static void on_show_history_menu(GtkMenuToolButton* btn, FmMainWin* win)
{
GtkMenuShell* menu = (GtkMenuShell*)gtk_menu_tool_button_get_menu(btn);
GList* l;
GList* cur = fm_nav_history_get_cur_link(win->nav_history);
/* delete old items */
gtk_container_foreach(GTK_CONTAINER(menu), (GtkCallback)gtk_widget_destroy, NULL);
for(l = fm_nav_history_list(win->nav_history); l; l=l->next)
{
const FmNavHistoryItem* item = (FmNavHistoryItem*)l->data;
FmPath* path = item->path;
char* str = fm_path_display_name(path, TRUE);
GtkMenuItem* mi;
if( l == cur )
{
mi = gtk_check_menu_item_new_with_label(str);
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(mi), TRUE);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mi), TRUE);
}
else
mi = gtk_menu_item_new_with_label(str);
g_free(str);
g_object_set_qdata_full(G_OBJECT(mi), fm_qdata_id, l, NULL);
g_signal_connect(mi, "activate", G_CALLBACK(on_history_item), win);
gtk_menu_shell_append(menu, mi);
}
gtk_widget_show_all( GTK_WIDGET(menu) );
}
static GtkWidget *
menu_item_new (MenuItem *menuitem, int workspace_id)
{
unsigned int key;
MetaVirtualModifier mods;
const char *i18n_label;
GtkWidget *mi;
GtkWidget *accel_label;
if (menuitem->type == MENU_ITEM_NORMAL)
{
mi = gtk_menu_item_new ();
}
else if (menuitem->type == MENU_ITEM_IMAGE)
{
GtkWidget *image;
image = gtk_image_new_from_stock (menuitem->stock_id, GTK_ICON_SIZE_MENU);
mi = gtk_image_menu_item_new ();
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), image);
gtk_widget_show (image);
}
else if (menuitem->type == MENU_ITEM_CHECKBOX)
{
mi = gtk_check_menu_item_new ();
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
menuitem->checked);
}
else if (menuitem->type == MENU_ITEM_RADIOBUTTON)
{
mi = gtk_check_menu_item_new ();
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (mi),
TRUE);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
menuitem->checked);
}
else if (menuitem->type == MENU_ITEM_WORKSPACE_LIST)
return NULL;
else
return gtk_separator_menu_item_new ();
i18n_label = _(menuitem->label);
meta_core_get_menu_accelerator (menuitem->op, workspace_id, &key, &mods);
accel_label = meta_accel_label_new_with_mnemonic (i18n_label);
gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (mi), accel_label);
gtk_widget_show (accel_label);
meta_accel_label_set_accelerator (META_ACCEL_LABEL (accel_label),
key, mods);
return mi;
}
static void
gtk_radio_menu_item_init (GtkRadioMenuItem *radio_menu_item)
{
GtkRadioMenuItemPrivate *priv;
radio_menu_item->priv = gtk_radio_menu_item_get_instance_private (radio_menu_item);
priv = radio_menu_item->priv;
priv->group = g_slist_prepend (NULL, radio_menu_item);
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (radio_menu_item), TRUE);
}
static GtkWidget *build_roll_menu(void)
{
GtkWidget *menu;
gint i;
gchar buffer[128];
MapTheme *theme = theme_get_current();
THEME_COLOR tcolor;
GdkColor *color;
GtkWidget *item;
GtkWidget *label;
menu = gtk_menu_new();
for (i = 2; i <= 12; i++) {
if (i == 7)
continue;
tcolor = (i == 6 || i == 8) ? TC_CHIP_H_FG : TC_CHIP_FG;
color = &theme->colors[tcolor].color;
sprintf(buffer,
"<span foreground=\"#%04x%04x%04x\">%d</span>",
color->red, color->green, color->blue, i);
item = gtk_check_menu_item_new();
label = gtk_label_new("");
gtk_label_set_markup(GTK_LABEL(label), buffer);
gtk_container_add(GTK_CONTAINER(item), label);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(item), "toggled",
G_CALLBACK(select_roll_cb),
GINT_TO_POINTER(i));
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM
(item), TRUE);
roll_numbers[i] = item;
}
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_separator_menu_item_new());
/* Menu item */
item = gtk_check_menu_item_new_with_label(_("Shuffle"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(item), "toggled",
G_CALLBACK(select_shuffle_cb), NULL);
shuffle_tile = GTK_CHECK_MENU_ITEM(item);
gtk_widget_show_all(menu);
return menu;
}
static GtkWidget *build_port_menu(void)
{
gint i;
GtkWidget *item;
GdkPixmap *pixmap;
GtkWidget *image;
GtkWidget *menu;
MapTheme *theme = theme_get_current();
menu = gtk_menu_new();
for (i = 0; i <= ANY_RESOURCE; i++) {
item =
gtk_image_menu_item_new_with_mnemonic(gettext
(port_names[i]));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(select_port_resource_cb),
GINT_TO_POINTER(i));
pixmap = theme->port_tiles[i];
if (i >= NO_RESOURCE || pixmap == NULL)
continue;
image = gtk_image_new_from_pixmap(pixmap, NULL);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
image);
}
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_separator_menu_item_new());
for (i = 0; i < 6; i++) {
item =
gtk_check_menu_item_new_with_label(Q_
(port_direction_names
[i]));
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM
(item), TRUE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(item), "toggled",
G_CALLBACK(select_port_direction_cb),
GINT_TO_POINTER(i));
port_directions[i] = item;
}
gtk_widget_show_all(menu);
return menu;
}
static void
gtk_check_menu_item_sync_action_properties (GtkActivatable *activatable,
GtkAction *action)
{
GtkCheckMenuItem *check_menu_item;
check_menu_item = GTK_CHECK_MENU_ITEM (activatable);
parent_activatable_iface->sync_action_properties (activatable, action);
if (!GTK_IS_TOGGLE_ACTION (action))
return;
gtk_action_block_activate (action);
gtk_check_menu_item_set_active (check_menu_item, gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)));
gtk_action_unblock_activate (action);
if (!gtk_activatable_get_use_action_appearance (activatable))
return;
gtk_check_menu_item_set_draw_as_radio (check_menu_item,
gtk_toggle_action_get_draw_as_radio (GTK_TOGGLE_ACTION (action)));
}
static GtkWidget *
panel_menu_item_presence_new (TpAccountManager *account_manager,
PanelSessionManagerPresenceType presence_type,
const char *name,
const char *icon,
gboolean use_icon)
{
GtkWidget *item;
if (!account_manager)
return NULL;
item = gtk_check_menu_item_new ();
setup_menuitem (item, GTK_ICON_SIZE_INVALID, NULL, name);
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (item), TRUE);
/* TODO: we need to add an icon at the right of this CheckMenuItem */
#if 0
if (use_icon) {
GtkWidget *image;
image = gtk_image_new_from_icon_name (icon,
panel_menu_icon_get_size ());
gtk_container_add (GTK_CONTAINER (item), image);
}
#endif
g_object_set_data (G_OBJECT (item), "panel-menu-presence",
GINT_TO_POINTER (presence_type));
g_signal_connect (item, "activate",
G_CALLBACK (panel_menu_item_activate_presence),
account_manager);
g_signal_connect (G_OBJECT (item), "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
return item;
}
static void
gtk_check_menu_item_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkCheckMenuItem *checkitem = GTK_CHECK_MENU_ITEM (object);
switch (prop_id)
{
case PROP_ACTIVE:
gtk_check_menu_item_set_active (checkitem, g_value_get_boolean (value));
break;
case PROP_INCONSISTENT:
gtk_check_menu_item_set_inconsistent (checkitem, g_value_get_boolean (value));
break;
case PROP_DRAW_AS_RADIO:
gtk_check_menu_item_set_draw_as_radio (checkitem, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
void pocketvox_indicator_add_module_item(PocketvoxIndicator *indicator,gchar *id)
{
g_return_if_fail(NULL != indicator);
g_return_if_fail(NULL != id);
indicator->priv = G_TYPE_INSTANCE_GET_PRIVATE (indicator,
TYPE_POCKETVOX_INDICATOR, PocketvoxIndicatorPrivate);
PocketvoxIndicatorPrivate *priv = indicator->priv;
GtkWidget* item = gtk_check_menu_item_new_with_label(id);
gtk_check_menu_item_set_draw_as_radio((GtkCheckMenuItem *)item, TRUE);
gtk_check_menu_item_set_active((GtkCheckMenuItem *)item, TRUE);
g_signal_connect_swapped((GtkCheckMenuItem *)item, "toggled", G_CALLBACK(pocketvox_indicator_module_toggled), indicator);
g_hash_table_insert(priv->table, g_strdup(id), item);
gtk_menu_shell_append((GtkMenuShell *)priv->modulesMenu, item);
gtk_widget_queue_draw(priv->modulesMenu);
gtk_widget_show(item);
gtk_widget_show(priv->modulesMenu);
gtk_widget_show(priv->modulesItem);
}
static gboolean
gtk_toggle_tool_button_create_menu_proxy (GtkToolItem *item)
{
GtkToolButton *tool_button = GTK_TOOL_BUTTON (item);
GtkToggleToolButton *toggle_tool_button = GTK_TOGGLE_TOOL_BUTTON (item);
GtkWidget *menu_item = NULL;
GtkStockItem stock_item;
gboolean use_mnemonic = TRUE;
const char *label;
GtkWidget *label_widget;
const gchar *label_text;
const gchar *stock_id;
if (_gtk_tool_item_create_menu_proxy (item))
return TRUE;
label_widget = gtk_tool_button_get_label_widget (tool_button);
label_text = gtk_tool_button_get_label (tool_button);
stock_id = gtk_tool_button_get_stock_id (tool_button);
if (GTK_IS_LABEL (label_widget))
{
label = gtk_label_get_label (GTK_LABEL (label_widget));
use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (label_widget));
}
else if (label_text)
{
label = label_text;
use_mnemonic = gtk_tool_button_get_use_underline (tool_button);
}
else if (stock_id && gtk_stock_lookup (stock_id, &stock_item))
{
label = stock_item.label;
}
else
{
label = "";
}
if (use_mnemonic)
menu_item = gtk_check_menu_item_new_with_mnemonic (label);
else
menu_item = gtk_check_menu_item_new_with_label (label);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
toggle_tool_button->priv->active);
if (GTK_IS_RADIO_TOOL_BUTTON (toggle_tool_button))
{
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (menu_item),
TRUE);
}
g_signal_connect_closure_by_id (menu_item,
g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,
g_cclosure_new_object (G_CALLBACK (menu_item_activated),
G_OBJECT (toggle_tool_button)),
FALSE);
gtk_tool_item_set_proxy_menu_item (item, MENU_ID, menu_item);
return TRUE;
}
static void
ls_build_menu (GOLocaleSel *ls)
{
GtkWidget *item;
GtkMenu *menu;
LGroupInfo const *lgroup = lgroups;
gint lg_cnt = 0;
menu = GTK_MENU (gtk_menu_new ());
while (lgroup->group_name) {
LocaleInfo const *locale_trans;
GtkMenu *submenu = NULL;
locale_trans = locale_trans_array;
while (locale_trans->lgroup != LG_LAST) {
if (locale_trans->lgroup == lgroup->lgroup && locale_trans->available) {
GtkWidget *subitem=
gtk_check_menu_item_new_with_label
(_(locale_trans->locale_title));
if (!submenu)
submenu = GTK_MENU (gtk_menu_new ());
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (subitem), TRUE);
gtk_widget_show (subitem);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), subitem);
g_object_set_data (G_OBJECT (subitem), LOCALE_NAME_KEY,
(locale_trans->actual_locale));
}
locale_trans++;
}
if (submenu) {
GtkWidget *item = gtk_menu_item_new_with_label (_(lgroup->group_name));
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item),
GTK_WIDGET (submenu));
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
lg_cnt++;
}
lgroup++;
}
item = gtk_separator_menu_item_new ();
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
lg_cnt++;
{
char *locale_name = get_locale_name (ls);
char *locale_menu_title = g_strconcat (_("Current Locale: "),
locale_name, NULL);
g_free (locale_name);
item = gtk_check_menu_item_new_with_label (locale_menu_title);
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (item), TRUE);
g_free (locale_menu_title);
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
lg_cnt++;
}
go_option_menu_set_menu (ls->locales, GTK_WIDGET (menu));
ls->locales_menu = menu;
set_menu_to_default (ls, lg_cnt);
}
void vx_gtk_display_show_context_menu(vx_display_t * disp, vx_mouse_event_t * event)
{
state_t * state = disp->impl;
vx_camera_pos_t layer_cam_pos;
pthread_mutex_lock(&state->mutex);
state->popup_layer_id = pick_layer(state->last_render_info, event->x, event->y);
vx_camera_pos_t * pos = NULL;
zhash_get(state->last_render_info->camera_positions, &state->popup_layer_id, &pos);
if (pos != NULL)
memcpy(&layer_cam_pos, pos, sizeof(vx_camera_pos_t));
pthread_mutex_unlock(&state->mutex);
if (state->popup_layer_id == 0)
return;
layer_info_t * linfo = NULL;
zhash_get(state->layer_info_map, &state->popup_layer_id, &linfo);
GtkWidget * menu = gtk_menu_new();
// Camera buttons
{
GtkWidget * labelwrapper = gtk_menu_item_new();
GtkWidget * label = gtk_label_new("Foo");
gtk_label_set_markup(GTK_LABEL(label), "<b>Camera options</b>");
gtk_container_add(GTK_CONTAINER(labelwrapper), label); // Auto centers? I guess that's fine
gtk_menu_shell_append(GTK_MENU_SHELL(menu), labelwrapper);
GtkWidget * resetCam = gtk_menu_item_new_with_label("Reset Camera");
g_signal_connect(resetCam, "activate", (GCallback) menu_action_reset_camera, state);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), resetCam);
GtkWidget * button1 = gtk_check_menu_item_new_with_label ("Perspective projection");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), button1);
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(button1), 1);
GtkWidget * button2 = gtk_check_menu_item_new_with_label ("Orthographic projection");
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(button2), 1);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), button2);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (layer_cam_pos.perspectiveness == 1.0 ? button1 : button2), TRUE);
g_signal_connect(button1, "activate",
(GCallback) menu_action_perspective, state);
g_signal_connect(button2, "activate",
(GCallback) menu_action_ortho, state);
// Interface modes
GtkWidget * iface_wrapper = gtk_menu_item_new_with_label("Interface mode");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), iface_wrapper);
{
GtkWidget * iface_menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(iface_wrapper), iface_menu);
GtkWidget * iface_20d = gtk_check_menu_item_new_with_label("2.0D");
gtk_menu_shell_append(GTK_MENU_SHELL(iface_menu), iface_20d);
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(iface_20d), 1);
GtkWidget * iface_25d = gtk_check_menu_item_new_with_label("2.5D");
gtk_menu_shell_append(GTK_MENU_SHELL(iface_menu), iface_25d);
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(iface_25d), 1);
GtkWidget * iface_30d = gtk_check_menu_item_new_with_label("3.0D");
gtk_menu_shell_append(GTK_MENU_SHELL(iface_menu), iface_30d);
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(iface_30d), 1);
float iface = default_cam_mgr_get_interface_mode(linfo->cam_mgr);
GtkWidget * active = NULL;
if (iface == 2.0f) {
active = iface_20d;
} else if (iface == 2.5f) {
active = iface_25d;
} else if (iface == 3.0f) {
active = iface_30d;
} else {
printf("WRN: iface mode %f not supported by menu!\n", iface);
active = iface_25d;
}
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (active), TRUE);
g_signal_connect(iface_20d, "activate", (GCallback) menu_action_iface_20d, state);
g_signal_connect(iface_25d, "activate", (GCallback) menu_action_iface_25d, state);
g_signal_connect(iface_30d, "activate", (GCallback) menu_action_iface_30d, state);
}
}
{
GtkWidget * labelwrapper = gtk_menu_item_new();
GtkWidget * label = gtk_label_new("Foo");
gtk_label_set_markup(GTK_LABEL(label), "<b>Display Options</b>");
gtk_container_add(GTK_CONTAINER(labelwrapper), label); // Auto centers? I guess that's fine
gtk_menu_shell_append(GTK_MENU_SHELL(menu), labelwrapper);
GtkWidget * showBM = gtk_menu_item_new_with_label("Show Buffer/Layer Manager");
g_signal_connect(showBM, "activate",(GCallback) menu_action_buffer_manager, state);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), showBM);
GtkWidget * scene = gtk_menu_item_new_with_label("Save Vx Scene");
g_signal_connect(scene, "activate",(GCallback) menu_action_scene, state);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), scene);
GtkWidget * shot = gtk_menu_item_new_with_label("Save Screenshot");
g_signal_connect(shot, "activate",(GCallback) menu_action_screen_shot, state);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), shot);
if (state->movie_file == NULL) {
GtkWidget * movie = gtk_menu_item_new_with_label("Record movie");
g_signal_connect(movie, "activate",(GCallback) menu_action_record_movie, state);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), movie);
} else {
GtkWidget * movie = gtk_menu_item_new_with_label("Stop movie");
g_signal_connect(movie, "activate",(GCallback) menu_action_stop_movie, state);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), movie);
}
}
gtk_widget_show_all(menu);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
/* (event != NULL) ? event->button : 0, */
0,
gtk_get_current_event_time());
//gdk_event_get_time((GdkEvent*)event));
}
static void
sensor_enabled(IsManager *manager,
IsSensor *sensor,
gint position,
IsIndicator *self)
{
IsIndicatorPrivate *priv = self->priv;
/* make sure we haven't seen this sensor before - if sensor has a
* menu-item then ignore it */
if (!g_object_get_data(G_OBJECT(sensor), "menu-item"))
{
GtkMenu *menu;
GtkWidget *menu_item;
is_debug("indicator", "Creating menu item for newly enabled sensor %s",
is_sensor_get_path(sensor));
g_signal_connect(sensor, "notify::value",
G_CALLBACK(sensor_notify),
self);
g_signal_connect(sensor, "notify::label",
G_CALLBACK(sensor_notify),
self);
g_signal_connect(sensor, "notify::alarmed",
G_CALLBACK(sensor_notify),
self);
g_signal_connect(sensor, "notify::low-value",
G_CALLBACK(sensor_notify),
self);
g_signal_connect(sensor, "notify::high-value",
G_CALLBACK(sensor_notify),
self);
/* add a menu entry for this sensor */
menu = is_indicator_get_menu(self);
menu_item = gtk_check_menu_item_new();
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(menu_item),
TRUE);
g_object_set_data(G_OBJECT(sensor), "menu-item", menu_item);
g_object_set_data(G_OBJECT(menu_item), "sensor", sensor);
priv->menu_items = g_slist_insert(priv->menu_items, menu_item,
position);
/* if we haven't seen our primary sensor yet or if this is the
* primary sensor, display this as primary anyway */
if (!priv->primary ||
g_strcmp0(is_sensor_get_path(sensor),
priv->primary_sensor_path) == 0)
{
is_debug("indicator", "Using sensor with path %s as primary",
is_sensor_get_path(sensor));
if (priv->primary)
{
GtkCheckMenuItem *item;
/* uncheck menu item if exists for this
* existing primary sensor */
item = (GtkCheckMenuItem *)(g_object_get_data(G_OBJECT(priv->primary),
"menu-item"));
if (item)
{
is_debug("indicator", "Unchecking current primary sensor item");
gtk_check_menu_item_set_active(item, FALSE);
}
g_object_unref(priv->primary);
}
priv->primary = g_object_ref(sensor);
is_debug("indicator", "Checking new primary sensor item");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item),
TRUE);
update_sensor_menu_item_label(self, sensor,
GTK_MENU_ITEM(menu_item));
}
/* connect to toggled signal now - if we connect to it earlier
* we may interpret the above menu_item_set_active as a user
* initiated setting of the primary sensor rather than us just
* picking the first available sensor */
g_signal_connect(menu_item, "toggled",
G_CALLBACK(sensor_menu_item_toggled),
self);
gtk_widget_show_all(menu_item);
update_sensor_menu_item_label(self, sensor, GTK_MENU_ITEM(menu_item));
gtk_menu_shell_insert(GTK_MENU_SHELL(menu), menu_item, position);
}
else
{
is_debug("indicator", "Newly enabled sensor %s already has a menu-item, ignoring...",
is_sensor_get_path(sensor));
}
}
static void
popup_prop_menu(GtkButton *prop_button, GdkEventButton *event,
GtkWidget *widget)
{
GtkWidget *menu_item, *hbox, *label, *img;
GList *menu_item_list, *icon_list, *label_list, *tooltip_list, *action_list,
*state_list, *list;
int i, selected = -1;
uim_toolbar_check_helper_connection(widget);
menu_item_list = gtk_container_get_children(GTK_CONTAINER(prop_menu));
icon_list = g_object_get_data(G_OBJECT(prop_button), "prop_icon");
label_list = g_object_get_data(G_OBJECT(prop_button), "prop_label");
tooltip_list = g_object_get_data(G_OBJECT(prop_button), "prop_tooltip");
action_list = g_object_get_data(G_OBJECT(prop_button), "prop_action");
state_list = g_object_get_data(G_OBJECT(prop_button), "prop_state");
list = menu_item_list;
while (list) {
gtk_widget_destroy(list->data);
list = list->next;
}
g_list_free(menu_item_list);
gtk_widget_destroy(prop_menu);
prop_menu = gtk_menu_new();
/* check selected item */
i = 0;
while (state_list) {
if (!strcmp("*", state_list->data)) {
selected = i;
break;
}
state_list = state_list->next;
i++;
}
i = 0;
while (label_list) {
if (selected != -1) {
menu_item = gtk_check_menu_item_new();
label = gtk_label_new(label_list->data);
#if GTK_CHECK_VERSION(3, 2, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new(FALSE, 0);
#endif
#if GTK_CHECK_VERSION(2, 4, 0)
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(menu_item),
TRUE);
#endif
if (register_icon(icon_list->data))
img = gtk_image_new_from_stock(icon_list->data, GTK_ICON_SIZE_MENU);
else
img = gtk_image_new_from_stock("null", GTK_ICON_SIZE_MENU);
if (img) {
gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 3);
gtk_widget_show(img);
}
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 3);
gtk_container_add(GTK_CONTAINER(menu_item), hbox);
gtk_widget_show(label);
gtk_widget_show(hbox);
if (i == selected)
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), TRUE);
} else {
menu_item = gtk_image_menu_item_new_with_label(label_list->data);
if (register_icon(icon_list->data)) {
img = gtk_image_new_from_stock(icon_list->data, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item), img);
#if GTK_CHECK_VERSION(2, 16, 0)
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(menu_item), TRUE);
#endif
}
}
/* tooltips */
gtk_widget_set_tooltip_text(menu_item,
tooltip_list ? tooltip_list->data : NULL);
/* add to the menu */
gtk_menu_shell_append(GTK_MENU_SHELL(prop_menu), menu_item);
gtk_widget_show(menu_item);
g_signal_connect(G_OBJECT(menu_item), "activate",
G_CALLBACK(prop_menu_activate), prop_menu);
g_object_set_data(G_OBJECT(menu_item), "prop_action",
action_list? action_list->data : NULL);
label_list = label_list->next;
if (icon_list)
icon_list = icon_list->next;
if (action_list)
action_list = action_list->next;
if (tooltip_list)
tooltip_list = tooltip_list->next;
i++;
}
g_signal_connect(G_OBJECT(GTK_MENU_SHELL(prop_menu)), "deactivate",
G_CALLBACK(prop_menu_shell_deactivate), NULL);
gtk_menu_popup(GTK_MENU(prop_menu), NULL, NULL,
(GtkMenuPositionFunc)calc_menu_position,
(gpointer)prop_button, event->button,
gtk_get_current_event_time());
prop_menu_showing = TRUE;
}
static void cs_build_menu(GOCharmapSel *cs)
{
GtkWidget *item;
GtkMenu *menu;
LGroupInfo const *lgroup = lgroups;
gint lg_cnt = 0;
menu = GTK_MENU(gtk_menu_new());
while (lgroup->group_name)
{
CharsetInfo const *charset_trans;
GtkMenu *submenu = NULL;
charset_trans = charset_trans_array;
while (charset_trans->lgroup != LG_LAST)
{
GtkWidget *subitem;
if (charset_trans->lgroup == lgroup->lgroup)
{
const char *name =
(cs->test == GO_CHARMAP_SEL_TO_UTF8) ?
charset_trans->to_utf8_iconv_name :
charset_trans->from_utf8_iconv_name;
if (name)
{
if (!submenu)
submenu = GTK_MENU(gtk_menu_new());
subitem = gtk_check_menu_item_new_with_label(
_(charset_trans->charset_title));
gtk_check_menu_item_set_draw_as_radio(
GTK_CHECK_MENU_ITEM(subitem), TRUE);
gtk_widget_show(subitem);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), subitem);
if (charset_trans->imp == CI_MAJOR)
cs_emphasize_label(
GTK_LABEL(gtk_bin_get_child(GTK_BIN(subitem))));
g_object_set_data(G_OBJECT(subitem), CHARMAP_NAME_KEY,
(gpointer) name);
}
else if (0)
{
g_print("Unsupported: %s\n", charset_trans->aliases);
}
}
charset_trans++;
}
if (submenu)
{
GtkWidget *item = gtk_menu_item_new_with_label(
_(lgroup->group_name));
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), GTK_WIDGET(submenu));
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
lg_cnt++;
}
lgroup++;
}
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
lg_cnt++;
{
char *locale_encoding_menu_title = g_strconcat(_("Locale: "),
get_locale_encoding_name(cs),
NULL);
item = gtk_check_menu_item_new_with_label(locale_encoding_menu_title);
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(item), TRUE);
g_free(locale_encoding_menu_title);
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
lg_cnt++;
cs_emphasize_label(GTK_LABEL(gtk_bin_get_child(GTK_BIN(item))));
}
go_option_menu_set_menu(cs->encodings, GTK_WIDGET(menu));
cs->encodings_menu = menu;
set_menu_to_default(cs, lg_cnt);
}
static void
gtk_radio_menu_item_init (GtkRadioMenuItem *radio_menu_item)
{
radio_menu_item->group = g_slist_prepend (NULL, radio_menu_item);
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (radio_menu_item), TRUE);
}
static GtkWidget *
create_menuitem_from_model (GMenuModel *model,
gint item,
GActionGroup *group)
{
GtkWidget *w;
gchar *label;
gchar *action;
gchar *target;
gchar *s;
ActionData *a;
const GVariantType *type;
GVariant *v;
label = NULL;
g_menu_model_get_item_attribute (model, item, G_MENU_ATTRIBUTE_LABEL, "s", &label);
action = NULL;
g_menu_model_get_item_attribute (model, item, G_MENU_ATTRIBUTE_ACTION, "s", &action);
if (action != NULL)
type = g_action_group_get_action_state_type (group, action);
else
type = NULL;
if (type == NULL)
w = gtk_menu_item_new_with_mnemonic (label);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
w = gtk_check_menu_item_new_with_label (label);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
w = gtk_check_menu_item_new_with_label (label);
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (w), TRUE);
}
else
g_assert_not_reached ();
if (action != NULL)
{
a = g_new0 (ActionData, 1);
a->group = g_object_ref (group);
a->name = g_strdup (action);
g_object_set_data_full (G_OBJECT (w), "action", a, action_data_free);
if (!g_action_group_get_action_enabled (group, action))
gtk_widget_set_sensitive (w, FALSE);
s = g_strconcat ("action-enabled-changed::", action, NULL);
a->enabled_changed_id = g_signal_connect (group, s,
G_CALLBACK (enabled_changed), w);
g_free (s);
a->activate_handler = g_signal_connect (w, "activate", G_CALLBACK (item_activated), NULL);
if (type == NULL)
{
/* all set */
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
{
s = g_strconcat ("action-state-changed::", action, NULL);
a->state_changed_id = g_signal_connect (group, s,
G_CALLBACK (toggle_state_changed), w);
g_free (s);
v = g_action_group_get_action_state (group, action);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w),
g_variant_get_boolean (v));
g_variant_unref (v);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
s = g_strconcat ("action-state-changed::", action, NULL);
a->state_changed_id = g_signal_connect (group, s,
G_CALLBACK (radio_state_changed), w);
g_free (s);
g_menu_model_get_item_attribute (model, item, G_MENU_ATTRIBUTE_TARGET, "s", &target);
a->target = g_strdup (target);
v = g_action_group_get_action_state (group, action);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w),
g_strcmp0 (g_variant_get_string (v, NULL), target) == 0);
g_variant_unref (v);
g_free (target);
}
else
g_assert_not_reached ();
}
g_free (label);
g_free (action);
return w;
}
