static void serializer_visit (Serializer* self, GtkWidget* widget) {
g_return_if_fail (self != NULL);
g_return_if_fail (widget != NULL);
if (GTK_IS_MENU_BAR (widget)) {
GtkWidget* _tmp0_;
serializer_visit_menubar (self, (_tmp0_ = widget, GTK_IS_MENU_BAR (_tmp0_) ? ((GtkMenuBar*) _tmp0_) : NULL));
} else {
if (GTK_IS_MENU (widget)) {
GtkWidget* _tmp1_;
serializer_visit_menu (self, (_tmp1_ = widget, GTK_IS_MENU (_tmp1_) ? ((GtkMenu*) _tmp1_) : NULL));
} else {
if (GTK_IS_MENU_ITEM (widget)) {
GtkWidget* _tmp2_;
serializer_visit_menuitem (self, (_tmp2_ = widget, GTK_IS_MENU_ITEM (_tmp2_) ? ((GtkMenuItem*) _tmp2_) : NULL));
} else {
if (GTK_IS_LABEL (widget)) {
GtkWidget* _tmp3_;
serializer_visit_label (self, (_tmp3_ = widget, GTK_IS_LABEL (_tmp3_) ? ((GtkLabel*) _tmp3_) : NULL));
} else {
if (GTK_IS_IMAGE (widget)) {
GtkWidget* _tmp4_;
serializer_visit_image (self, (_tmp4_ = widget, GTK_IS_IMAGE (_tmp4_) ? ((GtkImage*) _tmp4_) : NULL));
} else {
if (GTK_IS_CONTAINER (widget)) {
GtkWidget* _tmp5_;
serializer_visit_container (self, (_tmp5_ = widget, GTK_IS_CONTAINER (_tmp5_) ? ((GtkContainer*) _tmp5_) : NULL));
}
}
}
}
}
}
}
static void
gb_view_source_lang_activate (GbViewSource *source,
GtkMenuItem *menu_item)
{
GbViewSourcePrivate *priv;
GtkSourceLanguageManager *lm;
GtkSourceLanguage *lang;
const gchar *lang_id;
ENTRY;
g_return_if_fail(GB_IS_VIEW_SOURCE(source));
g_return_if_fail(GTK_IS_MENU_ITEM(menu_item));
priv = source->priv;
if ((lang_id = g_object_get_data(G_OBJECT(menu_item), "language-id"))) {
lm = gtk_source_language_manager_get_default();
lang = gtk_source_language_manager_get_language(lm, lang_id);
gtk_source_buffer_set_language(priv->buffer, lang);
gb_menu_button_set_label(GB_MENU_BUTTON(priv->lang_combo),
gtk_source_language_get_name(lang));
}
EXIT;
}
static void account_item_activated_cb(GtkMenuItem *menuitem, gpointer user_data)
{
//IndicatorFitbit *self = INDICATOR_FITBIT(user_data);
g_return_if_fail(GTK_IS_MENU_ITEM(menuitem));
g_return_if_fail(IS_INDICATOR_FITBIT(user_data));
}
static gboolean
gail_menu_shell_add_selection (AtkSelection *selection,
gint i)
{
GtkMenuShell *shell;
GList *item;
guint length;
GtkWidget *widget;
widget = GTK_ACCESSIBLE (selection)->widget;
if (widget == NULL)
{
/* State is defunct */
return FALSE;
}
shell = GTK_MENU_SHELL (widget);
length = g_list_length (shell->children);
if (i < 0 || i > length)
return FALSE;
item = g_list_nth (shell->children, i);
g_return_val_if_fail (item != NULL, FALSE);
g_return_val_if_fail (GTK_IS_MENU_ITEM(item->data), FALSE);
gtk_menu_shell_select_item (shell, GTK_WIDGET (item->data));
return TRUE;
}
static void
gb_view_source_tab_size_activate (GtkMenuItem *menu_item,
GbViewSource *source)
{
GbViewSourcePrivate *priv;
const gchar *label;
gint size;
ENTRY;
g_return_if_fail(GTK_IS_MENU_ITEM(menu_item));
g_return_if_fail(GB_IS_VIEW_SOURCE(source));
priv = source->priv;
label = gtk_menu_item_get_label(menu_item);
size = g_ascii_strtoll(label, NULL, 10);
if (size > 0) {
gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(priv->source1), size);
if (priv->source2) {
gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(priv->source2), size);
}
g_object_set(priv->size_combo,
"label", label,
NULL);
}
EXIT;
}
static AtkStateSet *
gtk_menu_item_accessible_ref_state_set (AtkObject *obj)
{
AtkObject *menu_item;
AtkStateSet *state_set, *parent_state_set;
state_set = ATK_OBJECT_CLASS (_gtk_menu_item_accessible_parent_class)->ref_state_set (obj);
menu_item = atk_object_get_parent (obj);
if (menu_item)
{
if (!GTK_IS_MENU_ITEM (gtk_accessible_get_widget (GTK_ACCESSIBLE (menu_item))))
return state_set;
parent_state_set = atk_object_ref_state_set (menu_item);
if (!atk_state_set_contains_state (parent_state_set, ATK_STATE_SELECTED))
{
atk_state_set_remove_state (state_set, ATK_STATE_FOCUSED);
atk_state_set_remove_state (state_set, ATK_STATE_SHOWING);
}
g_object_unref (parent_state_set);
}
return state_set;
}
static void
gwy_sensitivity_group_debug(GwySensitivityGroup *sensgroup)
{
SensList *senslist;
GtkWidget *widget, *w;
GList *l, *ll;
const gchar *s;
gint nw = 0;
g_printerr("SENS GROUP %p\n", sensgroup);
for (ll = sensgroup->lists; ll; ll = g_list_next(ll)) {
g_printerr(" LIST: ");
senslist = (SensList*)ll->data;
g_printerr("mask=%04x, dirty=%d, parent=%p\n",
senslist->mask, senslist->dirty, senslist->parent);
for (l = senslist->widgets; l; l = g_list_next(l)) {
nw++;
g_printerr(" WIDGET: ");
widget = GTK_WIDGET(l->data);
g_printerr("%s ", g_type_name(G_TYPE_FROM_INSTANCE(widget)));
if (GTK_IS_BUTTON(widget)) {
s = gtk_button_get_label(GTK_BUTTON(widget));
if (s)
g_printerr("<%s> ", s);
else {
w = gtk_bin_get_child(GTK_BIN(widget));
if (w) {
g_printerr("%s ", g_type_name(G_TYPE_FROM_INSTANCE(w)));
if (GTK_IS_LABEL(w)) {
s = gtk_label_get_text(GTK_LABEL(w));
if (s)
g_printerr("<%s> ", s);
}
else if (GTK_IS_IMAGE(w)) {
s = NULL;
gtk_image_get_stock(GTK_IMAGE(w), (gchar**)&s,
NULL);
if (s)
g_printerr("<%s> ", s);
}
}
}
}
else if (GTK_IS_MENU_ITEM(widget)) {
w = gtk_bin_get_child(GTK_BIN(widget));
if (w) {
g_printerr("%s ", g_type_name(G_TYPE_FROM_INSTANCE(w)));
if (GTK_IS_LABEL(w)) {
s = gtk_label_get_text(GTK_LABEL(w));
if (s)
g_printerr("<%s> ", s);
}
}
}
g_printerr("\n");
}
}
g_printerr(" nwidgets=%d, ref_count=%d\n",
nw, G_OBJECT(sensgroup)->ref_count);
}
/**
* gtk_tool_item_set_proxy_menu_item:
* @tool_item: a #GtkToolItem
* @menu_item_id: a string used to identify @menu_item
* @menu_item: a #GtkMenuItem to be used in the overflow menu
*
* Sets the #GtkMenuItem used in the toolbar overflow menu. The
* @menu_item_id is used to identify the caller of this function and
* should also be used with gtk_tool_item_get_proxy_menu_item().
*
* Since: 2.4
**/
void
gtk_tool_item_set_proxy_menu_item (GtkToolItem *tool_item,
const gchar *menu_item_id,
GtkWidget *menu_item)
{
g_return_if_fail (GTK_IS_TOOL_ITEM (tool_item));
g_return_if_fail (menu_item == NULL || GTK_IS_MENU_ITEM (menu_item));
g_return_if_fail (menu_item_id != NULL);
g_free (tool_item->priv->menu_item_id);
tool_item->priv->menu_item_id = g_strdup (menu_item_id);
if (tool_item->priv->menu_item != menu_item)
{
if (tool_item->priv->menu_item)
g_object_unref (tool_item->priv->menu_item);
if (menu_item)
{
g_object_ref_sink (menu_item);
gtk_widget_set_sensitive (menu_item,
gtk_widget_get_sensitive (GTK_WIDGET (tool_item)));
}
tool_item->priv->menu_item = menu_item;
}
}
static void
mail_browser_connect_proxy_cb (EMailBrowser *browser,
GtkAction *action,
GtkWidget *proxy)
{
GtkStatusbar *statusbar;
guint context_id;
if (!GTK_IS_MENU_ITEM (proxy))
return;
statusbar = GTK_STATUSBAR (browser->priv->statusbar);
context_id = gtk_statusbar_get_context_id (statusbar, G_STRFUNC);
g_object_set_data (
G_OBJECT (proxy), "context-id",
GUINT_TO_POINTER (context_id));
g_signal_connect_swapped (
proxy, "select",
G_CALLBACK (mail_browser_menu_item_select_cb), browser);
g_signal_connect_swapped (
proxy, "deselect",
G_CALLBACK (mail_browser_menu_item_deselect_cb), browser);
}
static gboolean
gtk_menu_item_accessible_add_selection (AtkSelection *selection,
gint i)
{
GtkMenuShell *shell;
GList *kids;
guint length;
GtkWidget *widget;
GtkWidget *menu;
GtkWidget *child;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
if (widget == NULL)
return FALSE;
menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
if (menu == NULL)
return FALSE;
shell = GTK_MENU_SHELL (menu);
kids = gtk_container_get_children (GTK_CONTAINER (shell));
length = g_list_length (kids);
if (i < 0 || i > length)
{
g_list_free (kids);
return FALSE;
}
child = g_list_nth_data (kids, i);
g_list_free (kids);
g_return_val_if_fail (GTK_IS_MENU_ITEM (child), FALSE);
gtk_menu_shell_select_item (shell, GTK_WIDGET (child));
return TRUE;
}
static gboolean
qtcMenuShellLeave(GtkWidget *widget, GdkEventCrossing *event, void *data)
{
QTC_UNUSED(data);
QTC_UNUSED(event);
if (GTK_IS_MENU_SHELL(widget) && GTK_IS_CONTAINER(widget)) {
GList *children = gtk_container_get_children(GTK_CONTAINER(widget));
for (GList *child = children;child;child = g_list_next(child)) {
if ((child->data) && GTK_IS_MENU_ITEM(child->data) &&
(gtk_widget_get_state(GTK_WIDGET(child->data)) !=
GTK_STATE_INSENSITIVE)) {
GtkWidget *submenu =
gtk_menu_item_get_submenu(GTK_MENU_ITEM(child->data));
GtkWidget *topLevel =
submenu ? gtk_widget_get_toplevel(submenu) : NULL;
if (submenu &&
((!GTK_IS_MENU(submenu)) ||
(!(gtk_widget_get_realized(submenu) &&
gtk_widget_get_visible(submenu) &&
gtk_widget_get_realized(topLevel) &&
gtk_widget_get_visible(topLevel))))) {
gtk_widget_set_state(GTK_WIDGET(child->data),
GTK_STATE_NORMAL);
}
}
}
if (children) {
g_list_free(children);
}
}
return false;
}
static void
menu_choice_activate (GtkWidget *item,
gpointer data)
{
gpointer udata = gtk_object_get_user_data (GTK_OBJECT (item));
if (GTK_IS_MENU (current_popup_menu))
{
gtk_object_set_data (GTK_OBJECT (current_popup_menu), "BstChoice", udata);
if (modal_loop_quit_on_menu_item_activate)
modal_loop_running = FALSE;
}
else /* current_popup_menu is not set e.g. for option menus */
{
while (GTK_IS_MENU (item->parent))
{
GtkWidget *tmp;
item = item->parent;
tmp = gtk_menu_get_attach_widget (GTK_MENU (item));
if (GTK_IS_MENU_ITEM (tmp))
item = tmp;
}
g_assert (GTK_IS_MENU (item));
gtk_object_set_data (GTK_OBJECT (item), "BstChoice", udata);
}
}
/*****************************************************************************
* Useful function to retrieve p_intf
****************************************************************************/
void * E_(__GtkGetIntf)( GtkWidget * widget )
{
void *p_data;
if( GTK_IS_MENU_ITEM( widget ) )
{
/* Look for a GTK_MENU */
while( widget->parent && !GTK_IS_MENU( widget ) )
{
widget = widget->parent;
}
/* Maybe this one has the data */
p_data = gtk_object_get_data( GTK_OBJECT( widget ), "p_intf" );
if( p_data )
{
return p_data;
}
/* Otherwise, the parent widget has it */
widget = gtk_menu_get_attach_widget( GTK_MENU( widget ) );
}
/* We look for the top widget */
widget = gtk_widget_get_toplevel( GTK_WIDGET( widget ) );
p_data = gtk_object_get_data( GTK_OBJECT( widget ), "p_intf" );
return p_data;
}
static void
disconnect_proxy_cb (GtkUIManager *manager,
GtkAction *action,
GtkWidget *proxy,
CajaWindow *window)
{
GtkWidget *widget;
if (GTK_IS_MENU_ITEM (proxy))
{
g_signal_handlers_disconnect_by_func
(proxy, G_CALLBACK (menu_item_select_cb), window);
g_signal_handlers_disconnect_by_func
(proxy, G_CALLBACK (menu_item_deselect_cb), window);
}
widget = get_event_widget (proxy);
if (widget)
{
g_signal_handlers_disconnect_by_func (widget,
G_CALLBACK (proxy_button_press_event_cb),
action);
g_signal_handlers_disconnect_by_func (widget,
G_CALLBACK (proxy_button_release_event_cb),
action);
}
}
PanelWidget *
menu_get_panel (GtkWidget *menu)
{
PanelWidget *retval = NULL;
g_return_val_if_fail (menu != NULL, NULL);
if (GTK_IS_MENU_ITEM (menu))
menu = gtk_widget_get_parent (menu);
g_return_val_if_fail (GTK_IS_MENU (menu), NULL);
while (menu) {
retval = g_object_get_data (G_OBJECT (menu), "menu_panel");
if (retval)
break;
menu = gtk_widget_get_parent (gtk_menu_get_attach_widget (GTK_MENU (menu)));
if (!GTK_IS_MENU (menu))
break;
}
if (retval && !PANEL_IS_WIDGET (retval)) {
g_warning ("Invalid PanelWidget associated with menu");
retval = NULL;
}
if (!retval) {
g_warning ("Cannot find the PanelWidget associated with menu");
retval = panels->data;
}
return retval;
}
static GtkWidget *
get_event_widget (GtkWidget *proxy)
{
GtkWidget *widget;
/**
* Finding the interesting widget requires internal knowledge of
* the widgets in question. This can't be helped, but by keeping
* the sneaky code in one place, it can easily be updated.
*/
if (GTK_IS_MENU_ITEM (proxy)) {
/* Menu items already forward middle clicks */
widget = NULL;
} else if (GTK_IS_MENU_TOOL_BUTTON (proxy)) {
widget = eel_gtk_menu_tool_button_get_button (GTK_MENU_TOOL_BUTTON (proxy));
} else if (GTK_IS_TOOL_BUTTON (proxy)) {
/* The tool button's button is the direct child */
widget = gtk_bin_get_child (GTK_BIN (proxy));
} else if (GTK_IS_BUTTON (proxy)) {
widget = proxy;
} else {
/* Don't touch anything we don't know about */
widget = NULL;
}
return widget;
}
static void
connect_proxy_cb (GtkActionGroup *action_group,
GtkAction *action,
GtkWidget *proxy,
gpointer dummy)
{
GtkLabel *label;
GIcon *icon;
if (!GTK_IS_MENU_ITEM (proxy))
return;
label = GTK_LABEL (gtk_bin_get_child (GTK_BIN (proxy)));
gtk_label_set_use_underline (label, FALSE);
gtk_label_set_ellipsize (label, PANGO_ELLIPSIZE_END);
gtk_label_set_max_width_chars (label, MENU_ITEM_MAX_WIDTH_CHARS);
icon = g_object_get_data (G_OBJECT (action), "menu-icon");
if (icon != NULL) {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy),
gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_MENU));
}
}
static gint
menu_item_remove_gtk (GtkContainer *container,
GtkWidget *widget)
{
GtkWidget *parent_widget;
AtkObject *atk_parent;
AtkObject *atk_child;
GtkContainerAccessible *container_accessible;
gint index;
gint list_length;
g_return_val_if_fail (GTK_IS_MENU (container), 1);
parent_widget = gtk_menu_get_attach_widget (GTK_MENU (container));
if (GTK_IS_MENU_ITEM (parent_widget))
{
atk_parent = gtk_widget_get_accessible (parent_widget);
atk_child = gtk_widget_get_accessible (widget);
g_object_notify (G_OBJECT (atk_child), "accessible-parent");
container_accessible = GTK_CONTAINER_ACCESSIBLE (atk_parent);
index = g_list_index (container_accessible->children, widget);
list_length = g_list_length (container_accessible->children);
g_list_free (container_accessible->children);
container_accessible->children = gtk_container_get_children (container);
if (index >= 0 && index <= list_length)
g_signal_emit_by_name (atk_parent, "children-changed::remove",
index, atk_child, NULL);
}
return 1;
}
static void
connect_proxy_cb (GtkUIManager *manager,
GtkAction *action,
GtkWidget *proxy,
NautilusWindow *window)
{
GdkPixbuf *icon;
GtkWidget *widget;
if (GTK_IS_MENU_ITEM (proxy)) {
g_signal_connect (proxy, "select",
G_CALLBACK (menu_item_select_cb), window);
g_signal_connect (proxy, "deselect",
G_CALLBACK (menu_item_deselect_cb), window);
/* This is a way to easily get pixbufs into the menu items */
icon = g_object_get_data (G_OBJECT (action), "menu-icon");
if (icon != NULL) {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy),
gtk_image_new_from_pixbuf (icon));
}
}
if (GTK_IS_TOOL_BUTTON (proxy)) {
icon = g_object_get_data (G_OBJECT (action), "toolbar-icon");
if (icon != NULL) {
widget = gtk_image_new_from_pixbuf (icon);
gtk_widget_show (widget);
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (proxy),
widget);
}
}
}
static gboolean
gail_menu_shell_add_selection (AtkSelection *selection,
gint i)
{
GList *kids;
GtkWidget *item;
guint length;
GtkWidget *widget;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
if (widget == NULL)
{
/* State is defunct */
return FALSE;
}
kids = gtk_container_get_children (GTK_CONTAINER (widget));
length = g_list_length (kids);
if (i < 0 || i > length)
{
g_list_free (kids);
return FALSE;
}
item = g_list_nth_data (kids, i);
g_list_free (kids);
g_return_val_if_fail (GTK_IS_MENU_ITEM(item), FALSE);
gtk_menu_shell_select_item (GTK_MENU_SHELL (widget), item);
return TRUE;
}
/**
* _gtk_action_sync_menu_visible:
* @action: (allow-none): a #GtkAction, or %NULL to determine the action from @proxy
* @proxy: a proxy menu item
* @empty: whether the submenu attached to @proxy is empty
*
* Updates the visibility of @proxy from the visibility of @action
* according to the following rules:
* <itemizedlist>
* <listitem><para>if @action is invisible, @proxy is too
* </para></listitem>
* <listitem><para>if @empty is %TRUE, hide @proxy unless the "hide-if-empty"
* property of @action indicates otherwise
* </para></listitem>
* </itemizedlist>
*
* This function is used in the implementation of #GtkUIManager.
**/
void
_gtk_action_sync_menu_visible (GtkAction *action,
GtkWidget *proxy,
gboolean empty)
{
gboolean visible = TRUE;
gboolean hide_if_empty = TRUE;
g_return_if_fail (GTK_IS_MENU_ITEM (proxy));
g_return_if_fail (action == NULL || GTK_IS_ACTION (action));
if (action == NULL)
action = gtk_activatable_get_related_action (GTK_ACTIVATABLE (proxy));
if (action)
{
/* a GtkMenu for a <popup/> doesn't have to have an action */
visible = gtk_action_is_visible (action);
hide_if_empty = action->private_data->hide_if_empty;
}
if (visible && !(empty && hide_if_empty))
gtk_widget_show (proxy);
else
gtk_widget_hide (proxy);
}
void init_clock_indicator(void)
{
if(!config.clock.enabled)
{
gtk_widget_hide(greeter.ui.clock.time_box);
return;
}
if(config.clock.calendar && GTK_IS_MENU_SHELL(greeter.ui.clock.time_menu))
{
GtkWidget* calendar_menuitem = NULL;
#ifdef CLOCK_USE_IDO_CALENDAR
calendar_menuitem = ido_calendar_menu_item_new();
greeter.ui.clock.calendar_widget = ido_calendar_menu_item_get_calendar(IDO_CALENDAR_MENU_ITEM(calendar_menuitem));
#else
calendar_menuitem = create_simple_calendar_item(&greeter.ui.clock.calendar_widget);
#endif
if(!greeter.ui.clock.date_widget)
greeter.ui.clock.date_widget = gtk_menu_item_new_with_label("");
gtk_menu_shell_append(GTK_MENU_SHELL(greeter.ui.clock.time_menu), greeter.ui.clock.date_widget);
gtk_menu_shell_append(GTK_MENU_SHELL(greeter.ui.clock.time_menu), calendar_menuitem);
gtk_widget_add_events(greeter.ui.clock.date_widget, GDK_VISIBILITY_NOTIFY_MASK);
visibility_notify_id = g_signal_connect(greeter.ui.clock.date_widget,
"visibility-notify-event",
G_CALLBACK(on_visibility_notify),
NULL);
gtk_widget_show_all(greeter.ui.clock.time_menu);
if(GTK_IS_MENU_ITEM(greeter.ui.clock.time_widget))
gtk_menu_item_set_submenu(GTK_MENU_ITEM(greeter.ui.clock.time_widget), greeter.ui.clock.time_menu);
}
else if(GTK_IS_MENU_ITEM(greeter.ui.clock.time_widget))
gtk_menu_item_set_submenu(GTK_MENU_ITEM(greeter.ui.clock.time_widget), NULL);
else
gtk_widget_hide(greeter.ui.clock.time_menu);
if(greeter.ui.clock.time_widget)
{
clock_handler(NULL);
g_timeout_add_seconds(1, (GSourceFunc)clock_handler, (gpointer)TRUE);
gtk_widget_show(greeter.ui.clock.time_widget);
}
}
static bool
childrenUseEvent(GtkWidget *widget, GdkEventButton *event, bool inNoteBook)
{
// accept, by default
bool usable = true;
// get children and check
GList *children = gtk_container_get_children(GTK_CONTAINER(widget));
for (GList *child = children;child && usable;child = g_list_next(child)) {
// cast child to GtkWidget
if (GTK_IS_WIDGET(child->data)) {
GtkWidget *childWidget = GTK_WIDGET(child->data);
GdkWindow *window = nullptr;
// check widget state and type
if (gtk_widget_get_state(childWidget) == GTK_STATE_PRELIGHT) {
// if widget is prelight, we don't need to check where event
// happen, any prelight widget indicate we can't do a move
usable = false;
continue;
}
window = gtk_widget_get_window(childWidget);
if (!(window && gdk_window_is_visible(window)))
continue;
if (GTK_IS_NOTEBOOK(childWidget))
inNoteBook = true;
if(!(event && withinWidget(childWidget, event)))
continue;
// check special cases for which grab should not be enabled
if((isBlackListed(G_OBJECT(childWidget))) ||
(GTK_IS_NOTEBOOK(widget) && Tab::isLabel(GTK_NOTEBOOK(widget),
childWidget)) ||
(GTK_IS_BUTTON(childWidget) &&
gtk_widget_get_state(childWidget) != GTK_STATE_INSENSITIVE) ||
(gtk_widget_get_events(childWidget) &
(GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK)) ||
(GTK_IS_MENU_ITEM(childWidget)) ||
(GTK_IS_SCROLLED_WINDOW(childWidget) &&
(!inNoteBook || gtk_widget_is_focus(childWidget)))) {
usable = false;
}
// if child is a container and event has been accepted so far,
// also check it, recursively
if (usable && GTK_IS_CONTAINER(childWidget)) {
usable = childrenUseEvent(childWidget, event, inNoteBook);
}
}
}
if (children) {
g_list_free(children);
}
return usable;
}
void
glade_gtk_menu_item_remove_child (GladeWidgetAdaptor * adaptor,
GObject * object, GObject * child)
{
g_return_if_fail (GTK_IS_MENU_ITEM (object));
g_return_if_fail (GTK_IS_MENU (child));
g_object_set_data (child, "special-child-type", NULL);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (object), NULL);
}
static void
gam_app_ui_disconnect_proxy_cb (GtkUIManager *manager, GtkAction *action,
GtkWidget *proxy, GamApp *gam_app)
{
if (GTK_IS_MENU_ITEM (proxy)) {
g_signal_handlers_disconnect_by_func (G_OBJECT (proxy),
G_CALLBACK (gam_app_menu_item_select_cb), gam_app);
g_signal_handlers_disconnect_by_func (G_OBJECT (proxy),
G_CALLBACK (gam_app_menu_item_deselect_cb), gam_app);
}
}
GtkWidget *
menu_item_connect (GtkWidget * item, MenuData * item_data)
{
TRACE ("entering menu_item_connect");
g_return_val_if_fail (item != NULL, NULL);
g_return_val_if_fail (GTK_IS_MENU_ITEM (item), NULL);
g_signal_connect_closure (GTK_OBJECT (item), "activate",
g_cclosure_new (GTK_SIGNAL_FUNC (activate_cb), item_data,
(GClosureNotify) closure_notify), FALSE);
return (item);
}
static void
proxy_set_use_underline (GtkWidget *proxy,
gboolean use_underline)
{
g_return_if_fail (GTK_IS_WIDGET (proxy));
if (GTK_IS_MENU_ITEM (proxy) && GTK_BIN (proxy)->child && GTK_IS_LABEL (GTK_BIN (proxy)->child))
gtk_label_set_use_underline (GTK_LABEL (GTK_BIN (proxy)->child), use_underline);
else if (GTK_IS_BUTTON (proxy))
gtk_button_set_use_underline (GTK_BUTTON (proxy), use_underline);
}
static gboolean
parent_set_emission_hook (GSignalInvocationHint *ihint,
guint n_param_values,
const GValue *param_values,
gpointer data)
{
GtkWidget *instance = g_value_get_object (param_values);
if (GTK_IS_MENU_ITEM (instance))
{
GtkWidget *previous_parent = g_value_get_object (param_values + 1);
GtkWidget *menu_shell = NULL;
if (GTK_IS_MENU_SHELL (previous_parent))
{
menu_shell = previous_parent;
}
else
{
GtkWidget *parent;
parent = gtk_widget_get_parent (instance);
if (GTK_IS_MENU_SHELL (parent))
{
menu_shell = parent;
}
}
if (menu_shell)
{
CarbonMenu *carbon_menu = carbon_menu_get (menu_shell);
if (carbon_menu)
{
#if 0
g_printerr ("%s: item %s %p (%s, %s)\n", G_STRFUNC,
previous_parent ? "removed from" : "added to",
menu_shell,
get_menu_label_text (instance, NULL),
g_type_name (G_TYPE_FROM_INSTANCE (instance)));
#endif
sync_menu_shell (GTK_MENU_SHELL (menu_shell),
carbon_menu->menu,
carbon_menu->toplevel,
FALSE);
}
}
}
return TRUE;
}
static void
on_ui_proxy_disconnected (GtkUIManager *ui, GtkAction *action,
GtkWidget *proxy, LdWindowMain *window)
{
if (GTK_IS_MENU_ITEM (proxy))
{
g_signal_handlers_disconnect_by_func
(proxy, G_CALLBACK (on_menu_item_selected), window);
g_signal_handlers_disconnect_by_func
(proxy, G_CALLBACK (on_menu_item_deselected), window);
}
}
static void
activate_back_or_forward_menu_item (GtkMenuItem *menu_item,
NemoWindow *window,
gboolean back)
{
int index;
g_assert (GTK_IS_MENU_ITEM (menu_item));
index = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menu_item), "user_data"));
nemo_window_back_or_forward (window, back, index, should_open_in_new_tab ());
}