static void menu_cardview_context_menu(GtkWidget *treeview, GdkEventButton *event, gpointer userdata)
/* Create a right click context menu */
{
GtkWidget *menu, *menuitem;
GtkTreeViewColumn *column2 = gtk_tree_view_get_column(GTK_TREE_VIEW(treeview),2);
#if GTK_CHECK_VERSION(3,6,0)
GtkWidget *menuitem_child;
#endif
UNUSED(userdata);
menu = gtk_menu_new();
/* Menu Item */
menuitem = gtk_menu_item_new_with_label("Copy");
g_signal_connect(menuitem, "activate",
(GCallback) menu_cardview_copy, treeview);
#if GTK_CHECK_VERSION(3,6,0)
menuitem_child = gtk_bin_get_child (GTK_BIN (menuitem));
gtk_accel_label_set_accel (GTK_ACCEL_LABEL (menuitem_child), GDK_KEY_c, GDK_CONTROL_MASK);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* Menu Item */
menuitem = gtk_menu_item_new_with_label("Expand all");
g_signal_connect(menuitem, "activate",
(GCallback) menu_cardview_context_menu_expand_all, treeview);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* Menu Item */
if (gtk_tree_view_column_get_visible(column2))
{
menuitem = gtk_menu_item_new_with_label("Show interpreted value");
g_signal_connect(menuitem, "activate",
(GCallback) menu_cardview_context_menu_change_value_type, treeview);
}
else
{
menuitem = gtk_menu_item_new_with_label("Show raw value");
g_signal_connect(menuitem, "activate",
(GCallback) menu_cardview_context_menu_change_value_type, treeview);
}
#if GTK_CHECK_VERSION(3,6,0)
menuitem_child = gtk_bin_get_child (GTK_BIN (menuitem));
gtk_accel_label_set_accel (GTK_ACCEL_LABEL (menuitem_child), GDK_KEY_r, GDK_CONTROL_MASK);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
gtk_widget_show_all(menu);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
(event != NULL) ? event->button : 0,
gdk_event_get_time((GdkEvent *)event));
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkMenuItemPeer_setLabel
(JNIEnv *env, jobject obj, jstring label)
{
void *ptr;
const char *str;
ptr = NSA_GET_PTR (env, obj);
str = (*env)->GetStringUTFChars (env, label, NULL);
gdk_threads_enter ();
if (strcmp (str, "-") == 0) /* "-" signals that we need a separator */
gtk_container_remove (GTK_CONTAINER (ptr), GTK_BIN (ptr)->child);
else
{
GtkAccelLabel *accel_label = GTK_ACCEL_LABEL (GTK_BIN (ptr)->child);
gtk_label_set_text (GTK_LABEL (accel_label), str);
gtk_accel_label_refetch (accel_label);
}
gdk_threads_leave ();
(*env)->ReleaseStringUTFChars (env, label, str);
}
static void CreateAndConnect( intf_thread_t *p_intf,
GtkMenu *menu, const char *psz_var,
const char *text, const char *help,
int i_item_type, vlc_object_t *p_obj,
vlc_value_t val, int i_val_type,
bool checked )
{
GtkMenuItem *menu_item =
(GtkMenuItem *)vlc_menu_item_new (p_obj, i_item_type, val, psz_var );
(void)help; (void)i_val_type;
#if GTK_CHECK_VERSION(2,16,0)
gtk_menu_item_set_label (menu_item, text ? text : psz_var);
#else
GtkWidget *accel_label = gtk_accel_label_new(text ? text : psz_var);
gtk_misc_set_alignment(GTK_MISC (accel_label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), GTK_WIDGET(menu_item));
gtk_widget_show (accel_label);
#endif /* GTK_CHECK_VERSION(2,16,0) */
gtk_menu_append( GTK_WIDGET(menu), GTK_WIDGET(menu_item) );
if( i_item_type == ITEM_CHECK || i_item_type == ITEM_RADIO )
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), checked);
g_signal_connect( GTK_OBJECT(menu_item), "activate", G_CALLBACK( menu_callback ),
p_intf );
}
void wxMenuBar::SetMenuLabel( size_t pos, const wxString& label )
{
wxMenuList::compatibility_iterator node = m_menus.Item( pos );
wxCHECK_RET( node, wxT("menu not found") );
wxMenu* menu = node->GetData();
const wxString str( wxReplaceUnderscore( label ) );
menu->SetTitle( str );
if (menu->m_owner)
{
GtkLabel *glabel = GTK_LABEL( GTK_BIN(menu->m_owner)->child );
/* set new text */
gtk_label_set( glabel, wxGTK_CONV( str ) );
/* reparse key accel */
(void)gtk_label_parse_uline (GTK_LABEL(glabel), wxGTK_CONV( str ) );
gtk_accel_label_refetch( GTK_ACCEL_LABEL(glabel) );
}
}
/* Recreates the string representing the accelerator keys. This should
not be needed since the string is automatically updated whenever
accelerators are added or removed from the associated widget. */
int
clip_GTK_ACCELLABELREFETCH(ClipMachine * ClipMachineMemory)
{
C_widget *clbl = _fetch_cw_arg(ClipMachineMemory);
CHECKCWID(clbl, GTK_IS_ACCEL_LABEL);
_clip_retl(ClipMachineMemory, gtk_accel_label_refetch(GTK_ACCEL_LABEL(clbl->widget)));
return 0;
err:
return 1;
}
/* Returns the width needed to display the accelerator key(s). This is
used by menus to align all of the GtkMenuItem widgets, and shouldn't
be needed by applications. */
int
clip_GTK_ACCELLABELGETACCELWIDTH(ClipMachine * ClipMachineMemory)
{
C_widget *clbl = _fetch_cw_arg(ClipMachineMemory);
CHECKCWID(clbl, GTK_IS_ACCEL_LABEL);
_clip_retni(ClipMachineMemory, gtk_accel_label_get_accel_width(GTK_ACCEL_LABEL(clbl->widget)));
return 0;
err:
return 1;
}
/* Sets the widget whose accelerators are to be shown. */
int
clip_GTK_ACCELLABELSETACCELWIDGET(ClipMachine * cm)
{
C_widget *clbl = _fetch_cw_arg(cm);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
CHECKCWID(clbl,GTK_IS_ACCEL_LABEL);
CHECKARG2(2,MAP_t,NUMERIC_t);
gtk_accel_label_set_accel_widget(GTK_ACCEL_LABEL(clbl->widget), cwid->widget);
return 0;
err:
return 1;
}
/* Sets the widget whose accelerators are to be shown. */
int
clip_GTK_ACCELLABELSETACCELWIDGET(ClipMachine * ClipMachineMemory)
{
C_widget *clbl = _fetch_cw_arg(ClipMachineMemory);
C_widget *cwid = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKCWID(clbl, GTK_IS_ACCEL_LABEL);
CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
gtk_accel_label_set_accel_widget(GTK_ACCEL_LABEL(clbl->widget), cwid->widget);
return 0;
err:
return 1;
}
static void
carbon_menu_item_accel_changed (GtkAccelGroup *accel_group,
guint keyval,
GdkModifierType modifier,
GClosure *accel_closure,
GtkWidget *widget)
{
CarbonMenuItem *carbon_item = carbon_menu_item_get (widget);
GtkWidget *label;
get_menu_label_text (widget, &label);
if (GTK_IS_ACCEL_LABEL (label) &&
GTK_ACCEL_LABEL (label)->accel_closure == accel_closure)
carbon_menu_item_update_accelerator (carbon_item, widget);
}
GtkWidget*
gtk_radio_menu_item_new_with_label (GSList *group,
const gchar *label)
{
GtkWidget *radio_menu_item;
GtkWidget *accel_label;
radio_menu_item = gtk_radio_menu_item_new (group);
accel_label = gtk_accel_label_new (label);
gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (radio_menu_item), accel_label);
gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (accel_label), radio_menu_item);
gtk_widget_show (accel_label);
return radio_menu_item;
}
void
setup_menuitem (GtkWidget *menuitem,
GtkIconSize icon_size,
GtkWidget *image,
const char *title)
{
GtkWidget *label;
char *_title;
/* this creates a label with an invisible mnemonic */
label = g_object_new (GTK_TYPE_ACCEL_LABEL, NULL);
_title = menu_escape_underscores_and_prepend (title);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _title);
g_free (_title);
gtk_label_set_pattern (GTK_LABEL (label), "");
gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), menuitem);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (menuitem), label);
if (image) {
g_object_set_data_full (G_OBJECT (menuitem),
"Panel:Image",
g_object_ref (image),
(GDestroyNotify) g_object_unref);
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
image);
} else if (icon_size != GTK_ICON_SIZE_INVALID)
#if GTK_CHECK_VERSION (3, 0, 0)
image_menuitem_set_size_request (menuitem, icon_size);
#else
g_signal_connect (menuitem, "size_request",
G_CALLBACK (image_menuitem_size_request),
GINT_TO_POINTER (icon_size));
#endif
gtk_widget_show (menuitem);
}
GtkDialog*
encoding_dialog_new(GtkWindow* parent)
{
GtkBuilder* builder;
GObject* object;
GtkDialog* dialog;
GtkWidget* combobox;
GtkTreeModel* model;
dialog = NULL;
builder = gtk_builder_new();
gtk_builder_add_from_file(builder, ENCODINGS_DIALOG_UI, NULL);
gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
object = gtk_builder_get_object(builder, "encoding_dialog");
if (object == NULL)
goto done;
dialog = GTK_DIALOG(object);
gtk_window_set_transient_for(GTK_WINDOW(dialog), parent);
model = GTK_TREE_MODEL(get_encoding_list_model());
combobox = combobox_entry_new(model);
g_object_set_data(G_OBJECT(dialog), "encoding_entry", combobox);
object = gtk_builder_get_object(builder, "hbox1");
if (object == NULL)
goto done;
gtk_box_pack_start(GTK_BOX(object), combobox, FALSE, TRUE, 0);
gtk_widget_show(combobox);
object = gtk_builder_get_object(builder, "accellabel1");
if (object == NULL)
goto done;
gtk_accel_label_set_accel_widget(GTK_ACCEL_LABEL(object), combobox);
done:
g_object_unref(builder);
return dialog;
}
void
setup_menuitem (GtkWidget *menuitem,
GtkIconSize icon_size,
GtkWidget *image,
const char *title)
{
GtkWidget *label;
char *_title;
/* this creates a label with an invisible mnemonic */
label = g_object_new (GTK_TYPE_ACCEL_LABEL, NULL);
_title = menu_escape_underscores_and_prepend (title);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _title);
g_free (_title);
gtk_label_set_pattern (GTK_LABEL (label), "");
gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), menuitem);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_yalign (GTK_LABEL (label), 0.5);
#else
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
#endif
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (menuitem), label);
if (image) {
gint icon_height = PANEL_DEFAULT_MENU_ICON_SIZE;
gtk_icon_size_lookup (icon_size, NULL, &icon_height);
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
image);
gtk_image_set_pixel_size (GTK_IMAGE(image), icon_height);
}
gtk_widget_show (menuitem);
}
static void
set_accel (GtkApplication *app, GtkWidget *widget)
{
GtkWidget *accel_label;
const gchar *action;
gchar **accels;
guint key;
GdkModifierType mods;
accel_label = gtk_bin_get_child (GTK_BIN (widget));
g_assert (GTK_IS_ACCEL_LABEL (accel_label));
action = gtk_actionable_get_action_name (GTK_ACTIONABLE (widget));
accels = gtk_application_get_accels_for_action (app, action);
gtk_accelerator_parse (accels[0], &key, &mods);
gtk_accel_label_set_accel (GTK_ACCEL_LABEL (accel_label), key, mods);
g_strfreev (accels);
}
static void
carbon_menu_item_update_accel_closure (CarbonMenuItem *carbon_item,
GtkWidget *widget)
{
GtkAccelGroup *group;
GtkWidget *label;
get_menu_label_text (widget, &label);
if (carbon_item->accel_closure)
{
group = gtk_accel_group_from_accel_closure (carbon_item->accel_closure);
if (group)
g_signal_handlers_disconnect_by_func (group,
carbon_menu_item_accel_changed,
widget);
g_closure_unref (carbon_item->accel_closure);
carbon_item->accel_closure = NULL;
}
if (GTK_IS_ACCEL_LABEL (label))
carbon_item->accel_closure = GTK_ACCEL_LABEL (label)->accel_closure;
if (carbon_item->accel_closure)
{
g_closure_ref (carbon_item->accel_closure);
group = gtk_accel_group_from_accel_closure (carbon_item->accel_closure);
g_signal_connect_object (group, "accel-changed",
G_CALLBACK (carbon_menu_item_accel_changed),
widget, 0);
}
carbon_menu_item_update_accelerator (carbon_item, widget);
}
void
setup_menuitem (GtkWidget *menuitem,
GtkIconSize icon_size,
GtkWidget *image,
const char *title)
{
GtkWidget *label;
char *_title;
/* this creates a label with an invisible mnemonic */
label = g_object_new (GTK_TYPE_ACCEL_LABEL, NULL);
_title = menu_escape_underscores_and_prepend (title);
gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _title);
g_free (_title);
gtk_label_set_pattern (GTK_LABEL (label), "");
gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), menuitem);
gtk_label_set_xalign (GTK_LABEL (label), 0);
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (menuitem), label);
if (image) {
g_object_set_data_full (G_OBJECT (menuitem),
"Panel:Image",
g_object_ref (image),
(GDestroyNotify) g_object_unref);
gtk_widget_show (image);
panel_image_menu_item_set_image (PANEL_IMAGE_MENU_ITEM (menuitem), image);
} else if (icon_size != GTK_ICON_SIZE_INVALID)
image_menuitem_set_size_request (menuitem, icon_size);
gtk_widget_show (menuitem);
}
void wxMenuItem::SetItemLabel( const wxString& string )
{
wxString str = string;
if ( str.empty() && !IsSeparator() )
{
wxASSERT_MSG(wxIsStockID(GetId()), wxT("A non-stock menu item with an empty label?"));
str = wxGetStockLabel(GetId(), wxSTOCK_WITH_ACCELERATOR |
wxSTOCK_WITH_MNEMONIC);
}
// Some optimization to avoid flicker
wxString oldLabel = m_text;
oldLabel = wxStripMenuCodes(oldLabel);
oldLabel.Replace(wxT("_"), wxEmptyString);
wxString label1 = wxStripMenuCodes(str);
wxString oldhotkey = GetHotKey(); // Store the old hotkey in Ctrl-foo format
wxCharBuffer oldbuf = wxGTK_CONV( GetGtkHotKey(*this) ); // and as <control>foo
DoSetText(str);
if (oldLabel == label1 &&
oldhotkey == GetHotKey()) // Make sure we can change a hotkey even if the label is unaltered
return;
if (m_menuItem)
{
GtkLabel *label;
if (m_labelWidget)
label = (GtkLabel*) m_labelWidget;
else
label = GTK_LABEL( GTK_BIN(m_menuItem)->child );
// set new text
gtk_label_set( label, wxGTK_CONV( m_text ) );
// reparse key accel
(void)gtk_label_parse_uline (GTK_LABEL(label), wxGTK_CONV(m_text) );
gtk_accel_label_refetch( GTK_ACCEL_LABEL(label) );
}
guint accel_key;
GdkModifierType accel_mods;
gtk_accelerator_parse( (const char*) oldbuf, &accel_key, &accel_mods);
if (accel_key != 0)
{
gtk_widget_remove_accelerator( GTK_WIDGET(m_menuItem),
m_parentMenu->m_accel,
accel_key,
accel_mods );
}
wxCharBuffer buf = wxGTK_CONV( GetGtkHotKey(*this) );
gtk_accelerator_parse( (const char*) buf, &accel_key, &accel_mods);
if (accel_key != 0)
{
gtk_widget_add_accelerator( GTK_WIDGET(m_menuItem),
"activate",
m_parentMenu->m_accel,
accel_key,
accel_mods,
GTK_ACCEL_VISIBLE);
}
}
/* This function returns a string of the form A;B;C where A is
* the keybinding for the widget; B is the keybinding to traverse
* from the menubar and C is the accelerator. The items in the
* keybinding to traverse from the menubar are separated by ":".
*/
static const gchar *
gtk_menu_item_accessible_get_keybinding (AtkAction *action,
gint i)
{
gchar *keybinding = NULL;
gchar *item_keybinding = NULL;
gchar *full_keybinding = NULL;
gchar *accelerator = NULL;
GtkWidget *item;
GtkWidget *temp_item;
GtkWidget *child;
GtkWidget *parent;
item = gtk_accessible_get_widget (GTK_ACCESSIBLE (action));
if (item == NULL)
return NULL;
if (i != 0)
return NULL;
temp_item = item;
while (TRUE)
{
GdkModifierType mnemonic_modifier = 0;
guint key_val;
gchar *key, *temp_keybinding;
child = gtk_bin_get_child (GTK_BIN (temp_item));
if (child == NULL)
return NULL;
parent = gtk_widget_get_parent (temp_item);
if (!parent)
/* parent can be NULL when activating a window from the panel */
return NULL;
if (GTK_IS_MENU_BAR (parent))
{
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (parent);
if (toplevel && GTK_IS_WINDOW (toplevel))
mnemonic_modifier =
gtk_window_get_mnemonic_modifier (GTK_WINDOW (toplevel));
}
if (GTK_IS_LABEL (child))
{
key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (child));
if (key_val != GDK_KEY_VoidSymbol)
{
key = gtk_accelerator_name (key_val, mnemonic_modifier);
if (full_keybinding)
temp_keybinding = g_strconcat (key, ":", full_keybinding, NULL);
else
temp_keybinding = g_strdup (key);
if (temp_item == item)
item_keybinding = g_strdup (key);
g_free (key);
g_free (full_keybinding);
full_keybinding = temp_keybinding;
}
else
{
/* No keybinding */
g_free (full_keybinding);
full_keybinding = NULL;
break;
}
}
/* We have reached the menu bar so we are finished */
if (GTK_IS_MENU_BAR (parent))
break;
g_return_val_if_fail (GTK_IS_MENU (parent), NULL);
temp_item = gtk_menu_get_attach_widget (GTK_MENU (parent));
if (!GTK_IS_MENU_ITEM (temp_item))
{
/* Menu is attached to something other than a menu item;
* probably an option menu
*/
g_free (full_keybinding);
full_keybinding = NULL;
break;
}
}
parent = gtk_widget_get_parent (item);
if (GTK_IS_MENU (parent))
{
GtkAccelGroup *group;
GtkAccelKey *key;
group = gtk_menu_get_accel_group (GTK_MENU (parent));
if (group)
key = gtk_accel_group_find (group, find_accel_by_widget, item);
else
{
key = NULL;
child = gtk_bin_get_child (GTK_BIN (item));
if (GTK_IS_ACCEL_LABEL (child))
{
GtkAccelLabel *accel_label;
GClosure *accel_closure;
accel_label = GTK_ACCEL_LABEL (child);
g_object_get (accel_label, "accel-closure", &accel_closure, NULL);
if (accel_closure)
{
key = gtk_accel_group_find (gtk_accel_group_from_accel_closure (accel_closure),
find_accel_by_closure,
accel_closure);
g_closure_unref (accel_closure);
}
}
}
if (key)
accelerator = gtk_accelerator_name (key->accel_key, key->accel_mods);
}
/* Concatenate the bindings */
if (item_keybinding || full_keybinding || accelerator)
{
gchar *temp;
if (item_keybinding)
{
keybinding = g_strconcat (item_keybinding, KEYBINDING_SEPARATOR, NULL);
g_free (item_keybinding);
}
else
keybinding = g_strdup (KEYBINDING_SEPARATOR);
if (full_keybinding)
{
temp = g_strconcat (keybinding, full_keybinding,
KEYBINDING_SEPARATOR, NULL);
g_free (full_keybinding);
}
else
temp = g_strconcat (keybinding, KEYBINDING_SEPARATOR, NULL);
g_free (keybinding);
keybinding = temp;
if (accelerator)
{
temp = g_strconcat (keybinding, accelerator, NULL);
g_free (accelerator);
g_free (keybinding);
keybinding = temp;
}
}
return keybinding;
}
/*
* 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_menu_item_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gboolean input_label = TRUE, input_rest = TRUE;
GtkAccelGroup *accel_group;
guint key;
GdkModifierType modifiers;
/* We only support loading the properties here. */
if (data->action != GB_LOADING)
return;
#ifdef USE_GNOME
/* Check for a stock menu item. */
if (glade_project_get_gnome_support (data->project))
{
GnomeUIInfo *uiinfo;
gchar *stock_item;
GtkWidget *label;
gint stock_item_index;
stock_item = gb_widget_input_string (data, "stock_item");
if (stock_item && stock_item[0])
{
/* Special case for the NEW_SUBTREE. */
if (!strcmp (stock_item, "GNOMEUIINFO_MENU_NEW_SUBTREE"))
{
stock_item_index = GladeStockMenuItemNew;
}
else
{
stock_item_index = glade_util_string_array_index (GladeStockMenuItemSymbols, GladeStockMenuItemSize, stock_item);
}
if (stock_item_index != -1)
{
uiinfo = &GladeStockMenuItemValues[stock_item_index];
if (uiinfo->type == GNOME_APP_UI_ITEM_CONFIGURABLE)
gnome_app_ui_configure_configurable (uiinfo);
/* Note that we don't have to worry about the pixmap, since if
it had a pixmap it would be a GtkImageMenuItem. */
label = gtk_accel_label_new ("");
gtk_label_set_text_with_mnemonic (GTK_LABEL (label),
uiinfo->label);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_show (label);
gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label),
widget);
gtk_container_add (GTK_CONTAINER (widget), label);
/* Add the configured accelerator key. */
if (uiinfo->accelerator_key != 0 && widget->parent
&& GTK_IS_MENU (widget->parent))
{
accel_group = GTK_MENU (widget->parent)->accel_group;
gtk_widget_add_accelerator (widget, "activate", accel_group,
uiinfo->accelerator_key,
uiinfo->ac_mods,
GTK_ACCEL_VISIBLE);
}
/* Remember the index of the stock item. */
gtk_object_set_data (GTK_OBJECT (widget),
GladeMenuItemStockIndexKey,
GINT_TO_POINTER (stock_item_index));
/* The 'New' item can have a label. The rest can't. */
if (stock_item_index != GladeStockMenuItemNew)
input_label = FALSE;
input_rest = FALSE;
}
else
{
#ifdef FIXME
load_add_error_message_with_tag (data,
GLADE_LINE_PROPERTY,
_("Invalid stock menu item"),
"stock_item", stock_item);
#endif
}
}
}
#endif
if (input_label)
gb_widget_input_child_label (widget, data, Label);
if (input_rest)
{
/* FIXME: should this be somewhere else? */
/* If we are loading, install the 'activate' accelerator, if it has one,
so that is is visible. */
if (data->action == GB_LOADING && widget->parent
&& GTK_IS_MENU (widget->parent))
{
int i;
for (i = 0; i < data->widget_info->n_accels; i++)
{
if (!strcmp (data->widget_info->accels[i].signal, "activate"))
{
key = data->widget_info->accels[i].key;
modifiers = data->widget_info->accels[i].modifiers;
accel_group = GTK_MENU (widget->parent)->accel_group;
gtk_widget_add_accelerator (widget, "activate", accel_group,
key, modifiers,
GTK_ACCEL_VISIBLE);
break;
}
}
}
}
}
static G_CONST_RETURN gchar*
gail_menu_item_get_keybinding (AtkAction *action,
gint i)
{
/*
* This function returns a string of the form A;B;C where
* A is the keybinding for the widget; B is the keybinding to traverse
* from the menubar and C is the accelerator.
* The items in the keybinding to traverse from the menubar are separated
* by ":".
*/
GailMenuItem *gail_menu_item;
gchar *keybinding = NULL;
gchar *item_keybinding = NULL;
gchar *full_keybinding = NULL;
gchar *accelerator = NULL;
gail_menu_item = GAIL_MENU_ITEM (action);
if (i == 0)
{
GtkWidget *item;
GtkWidget *temp_item;
GtkWidget *child;
GtkWidget *parent;
item = GTK_ACCESSIBLE (action)->widget;
if (item == NULL)
/* State is defunct */
return NULL;
temp_item = item;
while (TRUE)
{
GdkModifierType mnemonic_modifier = 0;
guint key_val;
gchar *key, *temp_keybinding;
child = gtk_bin_get_child (GTK_BIN (temp_item));
if (child == NULL)
{
/* Possibly a tear off menu item; it could also be a menu
* separator generated by gtk_item_factory_create_items()
*/
return NULL;
}
parent = gtk_widget_get_parent (temp_item);
if (!parent)
{
/*
* parent can be NULL when activating a window from the panel
*/
return NULL;
}
g_return_val_if_fail (GTK_IS_MENU_SHELL (parent), NULL);
if (GTK_IS_MENU_BAR (parent))
{
GtkWidget *toplevel;
toplevel = gtk_widget_get_toplevel (parent);
if (toplevel && GTK_IS_WINDOW (toplevel))
mnemonic_modifier = gtk_window_get_mnemonic_modifier (
GTK_WINDOW (toplevel));
}
if (GTK_IS_LABEL (child))
{
key_val = gtk_label_get_mnemonic_keyval (GTK_LABEL (child));
if (key_val != GDK_VoidSymbol)
{
key = gtk_accelerator_name (key_val, mnemonic_modifier);
if (full_keybinding)
temp_keybinding = g_strconcat (key, ":", full_keybinding, NULL);
else
temp_keybinding = g_strconcat (key, NULL);
if (temp_item == item)
{
item_keybinding = g_strdup (key);
}
g_free (key);
g_free (full_keybinding);
full_keybinding = temp_keybinding;
}
else
{
/* No keybinding */
g_free (full_keybinding);
full_keybinding = NULL;
break;
}
}
if (GTK_IS_MENU_BAR (parent))
/* We have reached the menu bar so we are finished */
break;
g_return_val_if_fail (GTK_IS_MENU (parent), NULL);
temp_item = gtk_menu_get_attach_widget (GTK_MENU (parent));
if (!GTK_IS_MENU_ITEM (temp_item))
{
/*
* Menu is attached to something other than a menu item;
* probably an option menu
*/
g_free (full_keybinding);
full_keybinding = NULL;
break;
}
}
parent = gtk_widget_get_parent (item);
if (GTK_IS_MENU (parent))
{
GtkAccelGroup *group;
GtkAccelKey *key;
group = gtk_menu_get_accel_group (GTK_MENU (parent));
if (group)
{
key = gtk_accel_group_find (group, find_accel, item);
}
else
{
/*
* If the menu item is created using GtkAction and GtkUIManager
* we get here.
*/
key = NULL;
child = GTK_BIN (item)->child;
if (GTK_IS_ACCEL_LABEL (child))
{
GtkAccelLabel *accel_label;
accel_label = GTK_ACCEL_LABEL (child);
if (accel_label->accel_closure)
{
key = gtk_accel_group_find (accel_label->accel_group,
find_accel_new,
accel_label->accel_closure);
}
}
}
if (key)
{
accelerator = gtk_accelerator_name (key->accel_key,
key->accel_mods);
}
}
}
/*
* Concatenate the bindings
*/
if (item_keybinding || full_keybinding || accelerator)
{
gchar *temp;
if (item_keybinding)
{
keybinding = g_strconcat (item_keybinding, KEYBINDING_SEPARATOR, NULL);
g_free (item_keybinding);
}
else
keybinding = g_strconcat (KEYBINDING_SEPARATOR, NULL);
if (full_keybinding)
{
temp = g_strconcat (keybinding, full_keybinding,
KEYBINDING_SEPARATOR, NULL);
g_free (full_keybinding);
}
else
temp = g_strconcat (keybinding, KEYBINDING_SEPARATOR, NULL);
g_free (keybinding);
keybinding = temp;
if (accelerator)
{
temp = g_strconcat (keybinding, accelerator, NULL);
g_free (accelerator);
g_free (keybinding);
keybinding = temp;
}
}
g_free (gail_menu_item->click_keybinding);
gail_menu_item->click_keybinding = keybinding;
return keybinding;
}
GtkAccelLabel* cast_GtkAccelLabel(GtkWidget* widget) {
return GTK_ACCEL_LABEL(widget);
}
static void
carbon_menu_item_update_accelerator (CarbonMenuItem *carbon_item,
GtkWidget *widget)
{
GtkWidget *label;
get_menu_label_text (widget, &label);
if (GTK_IS_ACCEL_LABEL (label) &&
GTK_ACCEL_LABEL (label)->accel_closure)
{
GtkAccelKey *key;
key = gtk_accel_group_find (GTK_ACCEL_LABEL (label)->accel_group,
accel_find_func,
GTK_ACCEL_LABEL (label)->accel_closure);
if (key &&
key->accel_key &&
key->accel_flags & GTK_ACCEL_VISIBLE)
{
GdkDisplay *display = gtk_widget_get_display (widget);
GdkKeymap *keymap = gdk_keymap_get_for_display (display);
GdkKeymapKey *keys;
gint n_keys;
if (gdk_keymap_get_entries_for_keyval (keymap, key->accel_key,
&keys, &n_keys))
{
UInt8 modifiers = 0;
SetMenuItemCommandKey (carbon_item->menu, carbon_item->index,
true, keys[0].keycode);
g_free (keys);
if (key->accel_mods)
{
if (key->accel_mods & GDK_SHIFT_MASK)
modifiers |= kMenuShiftModifier;
if (key->accel_mods & GDK_MOD1_MASK)
modifiers |= kMenuOptionModifier;
}
if (!(key->accel_mods & GDK_CONTROL_MASK))
{
modifiers |= kMenuNoCommandModifier;
}
SetMenuItemModifiers (carbon_item->menu, carbon_item->index,
modifiers);
return;
}
}
}
/* otherwise, clear the menu shortcut */
SetMenuItemModifiers (carbon_item->menu, carbon_item->index,
kMenuNoModifiers | kMenuNoCommandModifier);
ChangeMenuItemAttributes (carbon_item->menu, carbon_item->index,
0, kMenuItemAttrUseVirtualKey);
SetMenuItemCommandKey (carbon_item->menu, carbon_item->index,
false, 0);
}
