void MainWindowToolbarMenu::menuClicked(GtkCheckMenuItem* menuitem, MenuSelectToolbarData* data)
{
XOJ_CHECK_TYPE(MainWindowToolbarMenu);
if (!gtk_check_menu_item_get_active(menuitem))
{
// Ignore disabled menus
return;
}
win->toolbarSelected(data->d);
for (int i = 0; i < (int)this->toolbarMenuData.size(); i++)
{
if (data->index == i)
{
continue;
}
GtkWidget* w = this->toolbarMenuData[i]->item;
if (GTK_IS_CHECK_MENU_ITEM(w))
{
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(w), false);
}
}
}
static void
time_out_enabled_toggled (GtkCheckMenuItem *menu_item,
TimeOutPlugin *time_out)
{
g_return_if_fail (GTK_IS_CHECK_MENU_ITEM (menu_item));
g_return_if_fail (time_out != NULL);
/* Set enabled state */
time_out->enabled = gtk_check_menu_item_get_active (menu_item);
if (time_out->enabled)
{
/* Start/continue the break countdown */
time_out_start_break_countdown (time_out, time_out->break_countdown_seconds);
}
else
{
/* Update tooltips */
gtk_widget_set_tooltip_text(time_out->ebox, _("Paused"));
/* Pause break countdown */
time_out_countdown_pause (time_out->break_countdown);
}
/* Save plugin configuration */
time_out_save_settings (time_out);
}
/**
* gtk_check_menu_item_set_draw_as_radio:
* @check_menu_item: a #GtkCheckMenuItem
* @draw_as_radio: whether @check_menu_item is drawn like a #GtkRadioMenuItem
*
* Sets whether @check_menu_item is drawn like a #GtkRadioMenuItem
*
* Since: 2.4
**/
void
gtk_check_menu_item_set_draw_as_radio (GtkCheckMenuItem *check_menu_item,
gboolean draw_as_radio)
{
GtkCheckMenuItemPrivate *priv;
g_return_if_fail (GTK_IS_CHECK_MENU_ITEM (check_menu_item));
priv = check_menu_item->priv;
draw_as_radio = draw_as_radio != FALSE;
if (draw_as_radio != priv->draw_as_radio)
{
priv->draw_as_radio = draw_as_radio;
if (draw_as_radio)
gtk_css_node_set_name (priv->indicator_node, I_("radio"));
else
gtk_css_node_set_name (priv->indicator_node, I_("checl"));
gtk_widget_queue_draw (GTK_WIDGET (check_menu_item));
g_object_notify (G_OBJECT (check_menu_item), "draw-as-radio");
}
}
static void gtkItemActivate(GtkWidget *widget, Ihandle* ih)
{
Icallback cb;
if (GTK_IS_CHECK_MENU_ITEM(ih->handle) && !iupAttribGetBoolean(ih, "AUTOTOGGLE") && !iupAttribGetBoolean(ih->parent, "RADIO"))
{
/* GTK by default will do autotoggle */
g_signal_handlers_block_by_func(G_OBJECT(ih->handle), G_CALLBACK(gtkItemActivate), ih);
gtk_check_menu_item_set_active((GtkCheckMenuItem*)ih->handle, !gtk_check_menu_item_get_active((GtkCheckMenuItem*)ih->handle));
g_signal_handlers_unblock_by_func(G_OBJECT(ih->handle), G_CALLBACK(gtkItemActivate), ih);
}
if (GTK_IS_IMAGE_MENU_ITEM(ih->handle))
{
if (iupAttribGetBoolean(ih, "AUTOTOGGLE"))
{
if (iupAttribGetBoolean(ih, "VALUE"))
iupAttribSetStr(ih, "VALUE", "OFF");
else
iupAttribSetStr(ih, "VALUE", "ON");
gtkItemUpdateImage(ih, iupAttribGet(ih, "VALUE"), iupAttribGet(ih, "IMAGE"), iupAttribGet(ih, "IMPRESS"));
}
}
cb = IupGetCallback(ih, "ACTION");
if (cb && cb(ih)==IUP_CLOSE)
IupExitLoop();
(void)widget;
}
// Update each menuItem according to status: enabled, checked.
void FskGtkWindowSetMenuItemStatus(FskGtkWindow win, int id, char* title, Boolean enabled, Boolean checked)
{
menuBars entryBar = win->menu;
menuItems items = NULL;
//if(win->menuStatus == false)
// return;
while(entryBar) {
if(entryBar->id == (id & 0xFF00)) {
break;
}
entryBar = entryBar->next;
}
if(entryBar) {
for(items = (menuItems)entryBar->menulist; items != NULL; items = items->next) {
if(items && (items->id == id)) {
gdk_threads_enter();
gtk_widget_set_sensitive(GTK_WIDGET(items->item), enabled);
if (GTK_IS_CHECK_MENU_ITEM(items->item))
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(items->item), checked);
if (title) gtk_menu_item_set_label(GTK_MENU_ITEM(items->item), title);
gdk_threads_leave();
break;
}
}
}
}
/**
* gtk_check_menu_item_get_inconsistent:
* @check_menu_item: a #GtkCheckMenuItem
*
* Retrieves the value set by gtk_check_menu_item_set_inconsistent().
*
* Return value: %TRUE if inconsistent
**/
gboolean
gtk_check_menu_item_get_inconsistent (GtkCheckMenuItem *check_menu_item)
{
g_return_val_if_fail (GTK_IS_CHECK_MENU_ITEM (check_menu_item), FALSE);
return check_menu_item->priv->inconsistent;
}
/**
* gtk_check_menu_item_get_draw_as_radio:
* @check_menu_item: a #GtkCheckMenuItem
*
* Returns whether @check_menu_item looks like a #GtkRadioMenuItem
*
* Return value: Whether @check_menu_item looks like a #GtkRadioMenuItem
*
* Since: 2.4
**/
gboolean
gtk_check_menu_item_get_draw_as_radio (GtkCheckMenuItem *check_menu_item)
{
g_return_val_if_fail (GTK_IS_CHECK_MENU_ITEM (check_menu_item), FALSE);
return check_menu_item->priv->draw_as_radio;
}
static void menu_item_toggled_cb(GtkCheckMenuItem *menuitem, gpointer gdata)
{
GeanyDocument *doc;
if (sc_ignore_callback)
return;
if (menuitem != NULL &&
GTK_IS_CHECK_MENU_ITEM(menuitem) &&
! gtk_check_menu_item_get_active(menuitem))
{
return;
}
doc = document_get_current();
/* Another language was chosen from the menu item, so make it default for this session. */
if (gdata != NULL)
{
setptr(sc_info->default_language, g_strdup(gdata));
sc_speller_reinit_enchant_dict();
sc_gui_update_menu();
update_labels();
}
perform_check(doc);
}
/**
* gtk_check_menu_item_get_active:
* @check_menu_item: a #GtkCheckMenuItem
*
* Returns whether the check menu item is active. See
* gtk_check_menu_item_set_active ().
*
* Return value: %TRUE if the menu item is checked.
*/
gboolean
gtk_check_menu_item_get_active (GtkCheckMenuItem *check_menu_item)
{
g_return_val_if_fail (GTK_IS_CHECK_MENU_ITEM (check_menu_item), FALSE);
return check_menu_item->priv->active;
}
static void on_menu_select_cb(GtkWidget *widget, gpointer data)
{
FskEvent fskEvent;
menuItems selected = (menuItems)data;
FskGtkWindow win;
//Have to check firstly since radio item will emit two signals
if (selected == NULL)
return;
win = selected->win;
if (win->menuStatus == false)
return;
gdk_threads_enter();
if (GTK_IS_CHECK_MENU_ITEM(selected->item) && !gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(selected->item)))
return;
if (kFskErrNone == FskEventNew(&fskEvent, kFskEventMenuCommand, NULL, kFskEventModifierNotSet)) {
SInt32 command = selected->id;
FskEventParameterAdd(fskEvent, kFskEventParameterCommand, sizeof(command), &command);
FskWindowEventQueue(selected->win->owner, fskEvent);
FskWindowCheckEvents();
}
gdk_threads_leave();
}
static char* gtkItemGetValueAttrib(Ihandle* ih)
{
if (GTK_IS_CHECK_MENU_ITEM(ih->handle))
{
if (gtk_check_menu_item_get_active((GtkCheckMenuItem*)ih->handle))
return "ON";
else
return "OFF";
}
else
return NULL;
}
static void
menu_update_cb(GtkWidget *menu, menu_entry * me, char *target)
{
GtkWidget *item;
item = menu_find(menu, me->path, me->label);
if (item) {
gtk_widget_set_sensitive(item, me->enable);
/* must do it without triggering the callback */
if (GTK_IS_CHECK_MENU_ITEM(item))
GTK_CHECK_MENU_ITEM(item)->active = me->state;
}
}
static void menuitem_activate_handler(GtkMenuItem *menu_item)
{
printf("menuitem_activate_handler\n");
if (in_handler_flag == 0)
{
in_handler_flag = 1;
if (GTK_IS_CHECK_MENU_ITEM(menu_item))
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), !(GTK_CHECK_MENU_ITEM(menu_item)->active));
GdkEvent* event = gtk_get_current_event();
if (!event || event->key.type != GDK_KEY_RELEASE) // We only look for key presses, otherwise every shortcut fires twice
SendMessage2ToClean (CcWmCOMMAND, GTK_WIDGET(menu_item), GetModifiers ());
in_handler_flag = 0;
}
}
AtkObject*
gail_check_sub_menu_item_new (GtkWidget *widget)
{
GObject *object;
AtkObject *accessible;
g_return_val_if_fail (GTK_IS_CHECK_MENU_ITEM (widget), NULL);
object = g_object_new (GAIL_TYPE_CHECK_SUB_MENU_ITEM, NULL);
accessible = ATK_OBJECT (object);
atk_object_initialize (accessible, widget);
return accessible;
}
void EvalCcRqCHECKMENUITEM (CrossCallInfo *pcci) /* menu, HITEM, on/off; no result. */
{
printf("EvalCcRqCHECKMENUITEM\n");
if (GTK_IS_MENU(pcci->p1))
{
GtkWidget *menu = GTK_WIDGET(pcci->p1);
GtkWidget *menu_item = GTK_WIDGET(pcci->p2);
if (GTK_IS_CHECK_MENU_ITEM(menu_item))
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item),
(gboolean) pcci->p3);
}
MakeReturn0Cci (pcci);
}
/**
* gtk_check_menu_item_set_active:
* @check_menu_item: a #GtkCheckMenuItem.
* @is_active: boolean value indicating whether the check box is active.
*
* Sets the active state of the menu item's check box.
*/
void
gtk_check_menu_item_set_active (GtkCheckMenuItem *check_menu_item,
gboolean is_active)
{
GtkCheckMenuItemPrivate *priv;
g_return_if_fail (GTK_IS_CHECK_MENU_ITEM (check_menu_item));
priv = check_menu_item->priv;
is_active = is_active != 0;
if (priv->active != is_active)
gtk_menu_item_activate (GTK_MENU_ITEM (check_menu_item));
}
static void
gtk_check_menu_item_toggle_size_request (GtkMenuItem *menu_item,
gint *requisition)
{
guint toggle_spacing;
guint indicator_size;
g_return_if_fail (GTK_IS_CHECK_MENU_ITEM (menu_item));
gtk_widget_style_get (GTK_WIDGET (menu_item),
"toggle-spacing", &toggle_spacing,
"indicator-size", &indicator_size,
NULL);
*requisition = indicator_size + toggle_spacing;
}
/**
* gtk_check_menu_item_set_inconsistent:
* @check_menu_item: a #GtkCheckMenuItem
* @setting: %TRUE to display an "inconsistent" third state check
*
* If the user has selected a range of elements (such as some text or
* spreadsheet cells) that are affected by a boolean setting, and the
* current values in that range are inconsistent, you may want to
* display the check in an "in between" state. This function turns on
* "in between" display. Normally you would turn off the inconsistent
* state again if the user explicitly selects a setting. This has to be
* done manually, gtk_check_menu_item_set_inconsistent() only affects
* visual appearance, it doesn't affect the semantics of the widget.
*
**/
void
gtk_check_menu_item_set_inconsistent (GtkCheckMenuItem *check_menu_item,
gboolean setting)
{
GtkCheckMenuItemPrivate *priv;
g_return_if_fail (GTK_IS_CHECK_MENU_ITEM (check_menu_item));
priv = check_menu_item->priv;
setting = setting != FALSE;
if (setting != priv->inconsistent)
{
priv->inconsistent = setting;
gtk_widget_queue_draw (GTK_WIDGET (check_menu_item));
g_object_notify (G_OBJECT (check_menu_item), "inconsistent");
}
}
// Extract the ActionType from the menu item
ContextMenuItem::ContextMenuItem(GtkMenuItem* item)
: m_platformDescription()
{
if (GTK_IS_SEPARATOR_MENU_ITEM(item))
m_platformDescription.type = SeparatorType;
else if (gtk_menu_item_get_submenu(item))
m_platformDescription.type = SubmenuType;
else if (GTK_IS_CHECK_MENU_ITEM(item)) {
m_platformDescription.type = CheckableActionType;
m_platformDescription.checked = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item));
} else
m_platformDescription.type = ActionType;
m_platformDescription.action = *static_cast<ContextMenuAction*>(g_object_get_data(G_OBJECT(item), WEBKIT_CONTEXT_MENU_ACTION));
m_platformDescription.subMenu = GTK_MENU(gtk_menu_item_get_submenu(item));
if (m_platformDescription.subMenu)
g_object_ref(m_platformDescription.subMenu);
}
static int gtkItemSetValueAttrib(Ihandle* ih, const char* value)
{
if (GTK_IS_CHECK_MENU_ITEM(ih->handle))
{
if (iupAttribGetBoolean(ih->parent, "RADIO"))
value = "ON";
g_signal_handlers_block_by_func(G_OBJECT(ih->handle), G_CALLBACK(gtkItemActivate), ih);
gtk_check_menu_item_set_active((GtkCheckMenuItem*)ih->handle, iupStrBoolean(value));
g_signal_handlers_unblock_by_func(G_OBJECT(ih->handle), G_CALLBACK(gtkItemActivate), ih);
return 0;
}
else if (GTK_IS_IMAGE_MENU_ITEM(ih->handle))
{
gtkItemUpdateImage(ih, value, iupAttribGet(ih, "IMAGE"), iupAttribGet(ih, "IMPRESS"));
return 1;
}
else
return 0;
}
static void menu_select_cb(GtkWidget *widget, gpointer data)
{
FskEvent fskEvent;
menuItems selected = (menuItems)data;
menuBars entryBar;
menuItems items = NULL;
int groupID;
//Have to check firstly since radio item will emit two signals
if(GTK_IS_CHECK_MENU_ITEM(selected->item) && !gtk_check_menu_item_get_active((GtkCheckMenuItem*)selected->item))
return;
if(kFskErrNone == FskEventNew(&fskEvent, kFskEventMenuCommand, NULL, kFskEventModifierNotSet)) {
SInt32 command = selected->id;
FskEventParameterAdd(fskEvent, kFskEventParameterCommand, sizeof(command), &command);
FskWindowEventQueue(selected->win->owner, fskEvent);
}
// FIXME: actually, we should do this operations in event like menubar popup, but I do not find suitable event till now
// So just put them here!!!
FskGtkWindow win = selected->win;
groupID = selected->id & 0xFF00;
entryBar = win->menu;
while(entryBar) {
if(entryBar->id == groupID) {
break;
}
entryBar = entryBar->next;
}
if(entryBar) {
for(items = (menuItems)entryBar->menulist; items != NULL; items = items->next) {
int id = items->id;
if(kFskErrNone == FskEventNew(&fskEvent, kFskEventMenuStatus, NULL, kFskEventModifierNotSet)) {
FskEventParameterAdd(fskEvent, kFskEventParameterCommand, sizeof(id), &id);
FskWindowEventSend(win->owner, fskEvent);
}
}
}
}
void shell_action_set_active(const gchar *action_name, gboolean setting)
{
GtkAction *action;
GSList *proxies;
/* FIXME: Ugh. Are you sure there isn't any simpler way? O_o */
action = gtk_action_group_get_action(shell->action_group, action_name);
if (action) {
proxies = gtk_action_get_proxies(action);
for (; proxies; proxies = proxies->next) {
GtkWidget *widget = (GtkWidget *)proxies->data;
if (GTK_IS_CHECK_MENU_ITEM(widget)) {
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), setting);
return;
}
}
}
}
GtkWidget *menu_connect(const char *name, MenuInfo *menu_info, GtkWidget *widget)
{
MenuItem *menu_item;
GtkWidget *menu = get_widget(name);
g_signal_connect(menu, "show", G_CALLBACK(on_menu_show), menu_info);
g_signal_connect(menu, "hide", G_CALLBACK(on_menu_hide), NULL);
for (menu_item = menu_info->items; menu_item->name; menu_item++)
{
menu_item->widget = get_widget(menu_item->name);
g_signal_connect(menu_item->widget,
GTK_IS_CHECK_MENU_ITEM(menu_item->widget) ? "toggled" : "activate",
G_CALLBACK(on_menu_item_activate), menu_info);
}
if (widget)
g_signal_connect(widget, "button-press-event", G_CALLBACK(on_button_3_press), menu);
return menu;
}
void stickynotes_applet_update_menus(void)
{
GList *l;
gboolean inconsistent = FALSE;
gboolean locked = gconf_client_get_bool(stickynotes->gconf, GCONF_PATH "/settings/locked", NULL);
gboolean locked_writable = gconf_client_key_is_writable(stickynotes->gconf, GCONF_PATH "/settings/locked", NULL);
for (l = stickynotes->notes; l != NULL; l = l->next) {
StickyNote *note = l->data;
if (note->locked != locked) {
inconsistent = TRUE;
break;
}
}
for (l = stickynotes->applets; l != NULL; l = l->next) {
StickyNotesApplet *applet = l->data;
GSList *proxies, *p;
GtkAction *action = gtk_action_group_get_action (applet->action_group, "lock");
g_object_set (action,
"active", locked,
"sensitive", locked_writable,
NULL);
proxies = gtk_action_get_proxies (action);
for (p = proxies; p; p = g_slist_next (p)) {
if (GTK_IS_CHECK_MENU_ITEM (p->data)) {
gtk_check_menu_item_set_inconsistent (GTK_CHECK_MENU_ITEM (p->data),
inconsistent);
}
}
}
}
static void serializer_visit_menuitem (Serializer* self, GtkMenuItem* menuitem) {
char* _tmp0_;
gboolean _tmp2_ = FALSE;
g_return_if_fail (self != NULL);
g_return_if_fail (menuitem != NULL);
if (GTK_IS_TEAROFF_MENU_ITEM (menuitem)) {
return;
}
serializer_indent (self);
g_string_append (self->priv->sb, "<item");
g_string_append (self->priv->sb, _tmp0_ = g_markup_printf_escaped (" id=\"W%lu\"", (gulong) menuitem));
_g_free0 (_tmp0_);
if (self->priv->hybrid) {
g_string_append (self->priv->sb, " client-side=\"1\"");
}
g_string_erase (self->priv->label_sb, (gssize) 0, (gssize) (-1));
self->priv->last_item_empty = TRUE;
self->priv->guessed_type = NULL;
serializer_visit_container (self, (GtkContainer*) menuitem);
if (self->priv->label_sb->len > 0) {
char* _tmp1_;
g_string_append (self->priv->sb, _tmp1_ = g_markup_printf_escaped (" label=\"%s\"", self->priv->label_sb->str));
_g_free0 (_tmp1_);
self->priv->last_item_empty = FALSE;
}
if (GTK_IS_SEPARATOR_MENU_ITEM (menuitem)) {
_tmp2_ = TRUE;
} else {
_tmp2_ = gtk_bin_get_child ((GtkBin*) menuitem) == NULL;
}
if (_tmp2_) {
self->priv->guessed_type = "s";
self->priv->last_item_empty = FALSE;
}
if (GTK_IS_IMAGE_MENU_ITEM (menuitem)) {
GtkMenuItem* _tmp3_;
GtkWidget* _tmp4_;
GtkImage* image;
image = _g_object_ref0 ((_tmp4_ = gtk_image_menu_item_get_image ((_tmp3_ = menuitem, GTK_IS_IMAGE_MENU_ITEM (_tmp3_) ? ((GtkImageMenuItem*) _tmp3_) : NULL)), GTK_IS_IMAGE (_tmp4_) ? ((GtkImage*) _tmp4_) : NULL));
if (image != NULL) {
self->priv->guessed_type = "i";
serializer_append_icon_attribute (self, image);
self->priv->last_item_empty = FALSE;
}
_g_object_unref0 (image);
}
if (GTK_IS_CHECK_MENU_ITEM (menuitem)) {
GtkMenuItem* _tmp5_;
GtkCheckMenuItem* checkmenuitem;
checkmenuitem = _g_object_ref0 ((_tmp5_ = menuitem, GTK_IS_CHECK_MENU_ITEM (_tmp5_) ? ((GtkCheckMenuItem*) _tmp5_) : NULL));
if (gtk_check_menu_item_get_draw_as_radio (checkmenuitem)) {
self->priv->guessed_type = "r";
} else {
self->priv->guessed_type = "c";
}
if (!gtk_check_menu_item_get_inconsistent (checkmenuitem)) {
if (gtk_check_menu_item_get_active (checkmenuitem)) {
g_string_append (self->priv->sb, " state=\"1\"");
} else {
g_string_append (self->priv->sb, " state=\"0\"");
}
}
self->priv->last_item_empty = FALSE;
_g_object_unref0 (checkmenuitem);
}
if (gtk_widget_get_visible ((GtkWidget*) menuitem) == FALSE) {
g_string_append (self->priv->sb, " visible=\"0\"");
self->priv->last_item_empty = FALSE;
}
if (gtk_widget_get_sensitive ((GtkWidget*) menuitem) == FALSE) {
g_string_append (self->priv->sb, " sensitive=\"0\"");
}
if (self->priv->last_item_empty) {
g_string_append (self->priv->sb, " visible=\"0\"");
}
if (self->priv->guessed_type != NULL) {
g_string_append_printf (self->priv->sb, " type=\"%s\"", self->priv->guessed_type);
}
if (gtk_menu_item_get_submenu (menuitem) == NULL) {
g_string_append (self->priv->sb, "/>");
serializer_linebreak (self);
} else {
g_string_append_c (self->priv->sb, '>');
serializer_linebreak (self);
self->priv->level++;
if (gtk_menu_item_get_submenu (menuitem) != NULL) {
serializer_visit_menu (self, gtk_menu_item_get_submenu (menuitem));
}
self->priv->level--;
serializer_indent (self);
g_string_append (self->priv->sb, "</item>");
serializer_linebreak (self);
}
}
void ui_menu_set_tick(GtkWidget *w, int flag) {
if(GTK_IS_CHECK_MENU_ITEM(w))
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(w), flag != 0);
}
static char* gtkItemGetValueAttrib(Ihandle* ih)
{
return iupStrReturnChecked(GTK_IS_CHECK_MENU_ITEM(ih->handle) && gtk_check_menu_item_get_active((GtkCheckMenuItem*)ih->handle));
}
static void
sync_menu_shell (GtkMenuShell *menu_shell,
MenuRef carbon_menu,
gboolean toplevel,
gboolean debug)
{
GList *children;
GList *l;
MenuItemIndex carbon_index = 1;
if (debug)
g_printerr ("%s: syncing shell %p\n", G_STRFUNC, menu_shell);
carbon_menu_connect (GTK_WIDGET (menu_shell), carbon_menu, toplevel);
children = gtk_container_get_children (GTK_CONTAINER (menu_shell));
for (l = children; l; l = l->next)
{
GtkWidget *menu_item = l->data;
CarbonMenuItem *carbon_item;
if (GTK_IS_TEAROFF_MENU_ITEM (menu_item))
continue;
if (toplevel && g_object_get_data (G_OBJECT (menu_item),
"gtk-empty-menu-item"))
continue;
carbon_item = carbon_menu_item_get (menu_item);
if (debug)
g_printerr ("%s: carbon_item %d for menu_item %d (%s, %s)\n",
G_STRFUNC, carbon_item ? carbon_item->index : -1,
carbon_index, get_menu_label_text (menu_item, NULL),
g_type_name (G_TYPE_FROM_INSTANCE (menu_item)));
if (carbon_item && carbon_item->index != carbon_index)
{
if (debug)
g_printerr ("%s: -> not matching, deleting\n", G_STRFUNC);
DeleteMenuItem (carbon_item->menu, carbon_index);
carbon_item = NULL;
}
if (!carbon_item)
{
GtkWidget *label = NULL;
const gchar *label_text;
CFStringRef cfstr = NULL;
MenuItemAttributes attributes = 0;
if (debug)
g_printerr ("%s: -> creating new\n", G_STRFUNC);
label_text = get_menu_label_text (menu_item, &label);
if (label_text)
cfstr = CFStringCreateWithCString (NULL, label_text,
kCFStringEncodingUTF8);
if (GTK_IS_SEPARATOR_MENU_ITEM (menu_item))
attributes |= kMenuItemAttrSeparator;
if (!gtk_widget_is_sensitive (menu_item))
attributes |= kMenuItemAttrDisabled;
if (!gtk_widget_get_visible (menu_item))
attributes |= kMenuItemAttrHidden;
InsertMenuItemTextWithCFString (carbon_menu, cfstr,
carbon_index - 1,
attributes, 0);
SetMenuItemProperty (carbon_menu, carbon_index,
IGE_QUARTZ_MENU_CREATOR,
IGE_QUARTZ_ITEM_WIDGET,
sizeof (menu_item), &menu_item);
if (cfstr)
CFRelease (cfstr);
carbon_item = carbon_menu_item_connect (menu_item, label,
carbon_menu,
carbon_index);
if (GTK_IS_CHECK_MENU_ITEM (menu_item))
carbon_menu_item_update_active (carbon_item, menu_item);
carbon_menu_item_update_accel_closure (carbon_item, menu_item);
if (gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu_item)))
carbon_menu_item_update_submenu (carbon_item, menu_item);
}
carbon_index++;
}
g_list_free (children);
}
static void
sync_menu_shell (GtkMenuShell *menu_shell,
MenuRef carbon_menu,
gboolean toplevel)
{
GList *children;
GList *l;
MenuItemIndex carbon_index = 1;
carbon_menu_connect (GTK_WIDGET (menu_shell), carbon_menu);
children = gtk_container_get_children (GTK_CONTAINER (menu_shell));
UInt16 carbon_item_count = CountMenuItems(carbon_menu);
for (l = children; l; l = l->next)
{
GtkWidget *menu_item = l->data;
CarbonMenuItem *carbon_item;
if (GTK_IS_TEAROFF_MENU_ITEM (menu_item))
continue;
if (toplevel && g_object_get_data (G_OBJECT (menu_item),
"gtk-empty-menu-item"))
continue;
GtkWidget *label = NULL;
const gchar *label_text = NULL;
label_text = get_menu_label_text (menu_item, &label);
if (label_text && strcmp(label_text, "_SKIP_") == 0)
{
carbon_index++;
continue;
}
else if (!label_text)
label_text = "";
MenuItemAttributes attributes = 0;
if (GTK_IS_SEPARATOR_MENU_ITEM (menu_item))
attributes |= kMenuItemAttrSeparator;
if (!GTK_WIDGET_IS_SENSITIVE (menu_item))
attributes |= kMenuItemAttrDisabled;
if (!GTK_WIDGET_VISIBLE (menu_item))
attributes |= kMenuItemAttrHidden;
CFStringRef cfstr = CFStringCreateWithCString (NULL, label_text,
kCFStringEncodingUTF8);
if (carbon_index > carbon_item_count)
AppendMenuItemTextWithCFString(carbon_menu, cfstr, attributes, 0,
NULL);
else if (!toplevel && (carbon_index > carbon_item_count))
InsertMenuItemTextWithCFString (carbon_menu, cfstr,
carbon_index, attributes, 0);
else
SetMenuItemTextWithCFString(carbon_menu, carbon_index, cfstr);
CFRelease (cfstr);
MenuItemAttributes c_attributes = kMenuItemAttrSectionHeader |
kMenuItemAttrAutoDisable;
if (!(attributes & kMenuItemAttrDisabled))
c_attributes |= kMenuItemAttrDisabled;
if (!(attributes & kMenuItemAttrSeparator))
c_attributes |= kMenuItemAttrSeparator;
if (!(attributes & kMenuItemAttrHidden))
c_attributes |= kMenuItemAttrHidden;
ChangeMenuItemAttributes(carbon_menu, carbon_index,
attributes, c_attributes);
SetMenuItemProperty (carbon_menu, carbon_index,
GTK_QUARTZ_MENU_CREATOR,
GTK_QUARTZ_ITEM_WIDGET,
sizeof (menu_item), &menu_item);
carbon_item = carbon_menu_item_connect (menu_item, label,
carbon_menu,
carbon_index);
if (GTK_IS_CHECK_MENU_ITEM (menu_item))
carbon_menu_item_update_active (carbon_item, menu_item);
carbon_menu_item_update_accel_closure (carbon_item, menu_item);
if (gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu_item)))
carbon_menu_item_update_submenu (carbon_item, menu_item);
carbon_index++;
}
while (carbon_index <= carbon_item_count)
{
DeleteMenuItem (carbon_menu, carbon_index);
carbon_index++;
}
g_list_free (children);
}
