build: Don't introspect ShellMenu

It is now only used internally by ShellApp to track remote actions,
so there's no need to expose it to javascript code.

https://gitlab.gnome.org/GNOME/gnome-shell/issues/624

data/org.gnome.shell.gschema.xml.in

@@ -104,13 +104,6 @@
 
   <schema id="org.gnome.shell.keybindings" path="/org/gnome/shell/keybindings/"
           gettext-domain="@GETTEXT_PACKAGE@">
-    <key name="open-application-menu" type="as">
-      <default>["&lt;Super&gt;F10"]</default>
-      <summary>Keybinding to open the application menu</summary>
-      <description>
-        Keybinding to open the application menu.
-      </description>
-    </key>
     <key name="toggle-application-view" type="as">
       <default>["&lt;Super&gt;a"]</default>
       <summary>Keybinding to open the “Show Applications” view</summary>

js/js-resources.gresource.xml

@@ -82,7 +82,6 @@
     <file>ui/panelMenu.js</file>
     <file>ui/pointerWatcher.js</file>
     <file>ui/popupMenu.js</file>
-    <file>ui/remoteMenu.js</file>
     <file>ui/remoteSearch.js</file>
     <file>ui/runDialog.js</file>
     <file>ui/screenShield.js</file>

js/ui/panel.js

@@ -2,36 +2,25 @@
 
 const Cairo = imports.cairo;
 const Clutter = imports.gi.Clutter;
-const Gio = imports.gi.Gio;
 const GLib = imports.gi.GLib;
 const GObject = imports.gi.GObject;
 const Gtk = imports.gi.Gtk;
 const Mainloop = imports.mainloop;
 const Meta = imports.gi.Meta;
-const Pango = imports.gi.Pango;
 const Shell = imports.gi.Shell;
 const St = imports.gi.St;
-const Signals = imports.signals;
 const Atk = imports.gi.Atk;
 
-const Animation = imports.ui.animation;
 const Config = imports.misc.config;
 const CtrlAltTab = imports.ui.ctrlAltTab;
 const DND = imports.ui.dnd;
 const Overview = imports.ui.overview;
 const PopupMenu = imports.ui.popupMenu;
 const PanelMenu = imports.ui.panelMenu;
-const RemoteMenu = imports.ui.remoteMenu;
 const Main = imports.ui.main;
-const Tweener = imports.ui.tweener;
-
-var PANEL_ICON_SIZE = 16;
-var APP_MENU_ICON_MARGIN = 0;
 
 var BUTTON_DND_ACTIVATION_TIMEOUT = 250;
 
-var SPINNER_ANIMATION_TIME = 1.0;
-
 // To make sure the panel corners blend nicely with the panel,
 // we draw background and borders the same way, e.g. drawing
 // them as filled shapes from the outside inwards instead of
@@ -75,328 +64,6 @@ function _unpremultiply(color) {
                                blue: blue, alpha: color.alpha });
 };
 
-/**
- * AppMenuButton:
- *
- * This class manages the "application menu" component.  It tracks the
- * currently focused application.  However, when an app is launched,
- * this menu also handles startup notification for it.  So when we
- * have an active startup notification, we switch modes to display that.
- */
-var AppMenuButton = GObject.registerClass({
-    Signals: {'changed': {}},
-}, class AppMenuButton extends PanelMenu.Button {
-    _init(panel) {
-        super._init(0.0, null, true);
-
-        this.actor.accessible_role = Atk.Role.MENU;
-
-        this._startingApps = [];
-
-        this._menuManager = panel.menuManager;
-        this._gtkSettings = Gtk.Settings.get_default();
-        this._targetApp = null;
-        this._appMenuNotifyId = 0;
-        this._actionGroupNotifyId = 0;
-        this._busyNotifyId = 0;
-
-        let bin = new St.Bin({ name: 'appMenu' });
-        bin.connect('style-changed', this._onStyleChanged.bind(this));
-        this.actor.add_actor(bin);
-
-        this.actor.bind_property("reactive", this.actor, "can-focus", 0);
-        this.actor.reactive = false;
-
-        this._container = new St.BoxLayout({ style_class: 'panel-status-menu-box' });
-        bin.set_child(this._container);
-
-        let textureCache = St.TextureCache.get_default();
-        textureCache.connect('icon-theme-changed',
-                             this._onIconThemeChanged.bind(this));
-
-        this._iconBox = new St.Bin({ style_class: 'app-menu-icon' });
-        this._container.add_actor(this._iconBox);
-
-        this._label = new St.Label({ y_expand: true,
-                                     y_align: Clutter.ActorAlign.CENTER });
-        this._container.add_actor(this._label);
-        this._arrow = PopupMenu.arrowIcon(St.Side.BOTTOM);
-        this._container.add_actor(this._arrow);
-
-        this._visible = this._gtkSettings.gtk_shell_shows_app_menu &&
-                        !Main.overview.visible;
-        if (!this._visible)
-            this.hide();
-        this._overviewHidingId = Main.overview.connect('hiding', this._sync.bind(this));
-        this._overviewShowingId = Main.overview.connect('showing', this._sync.bind(this));
-        this._showsAppMenuId = this._gtkSettings.connect('notify::gtk-shell-shows-app-menu',
-                                                         this._sync.bind(this));
-
-        this._stop = true;
-
-        this._spinner = null;
-
-        let tracker = Shell.WindowTracker.get_default();
-        let appSys = Shell.AppSystem.get_default();
-        this._focusAppNotifyId =
-            tracker.connect('notify::focus-app', this._focusAppChanged.bind(this));
-        this._appStateChangedSignalId =
-            appSys.connect('app-state-changed', this._onAppStateChanged.bind(this));
-        this._switchWorkspaceNotifyId =
-            global.window_manager.connect('switch-workspace', this._sync.bind(this));
-
-        this._sync();
-    }
-
-    fadeIn() {
-        if (this._visible)
-            return;
-
-        this._visible = true;
-        this.actor.reactive = true;
-        this.show();
-        Tweener.removeTweens(this.actor);
-        Tweener.addTween(this.actor,
-                         { opacity: 255,
-                           time: Overview.ANIMATION_TIME,
-                           transition: 'easeOutQuad' });
-    }
-
-    fadeOut() {
-        if (!this._visible)
-            return;
-
-        this._visible = false;
-        this.actor.reactive = false;
-        Tweener.removeTweens(this.actor);
-        Tweener.addTween(this.actor,
-                         { opacity: 0,
-                           time: Overview.ANIMATION_TIME,
-                           transition: 'easeOutQuad',
-                           onComplete() {
-                               this.hide();
-                           },
-                           onCompleteScope: this });
-    }
-
-    _onStyleChanged(actor) {
-        let node = actor.get_theme_node();
-        let [success, icon] = node.lookup_url('spinner-image', false);
-        if (!success || (this._spinnerIcon && this._spinnerIcon.equal(icon)))
-            return;
-        this._spinnerIcon = icon;
-        this._spinner = new Animation.AnimatedIcon(this._spinnerIcon, PANEL_ICON_SIZE);
-        this._container.add_actor(this._spinner.actor);
-        this._spinner.actor.hide();
-    }
-
-    _syncIcon() {
-        if (!this._targetApp)
-            return;
-
-        let icon = this._targetApp.create_icon_texture(PANEL_ICON_SIZE - APP_MENU_ICON_MARGIN);
-        this._iconBox.set_child(icon);
-    }
-
-    _onIconThemeChanged() {
-        if (this._iconBox.child == null)
-            return;
-
-        this._syncIcon();
-    }
-
-    stopAnimation() {
-        if (this._stop)
-            return;
-
-        this._stop = true;
-
-        if (this._spinner == null)
-            return;
-
-        Tweener.addTween(this._spinner.actor,
-                         { opacity: 0,
-                           time: SPINNER_ANIMATION_TIME,
-                           transition: "easeOutQuad",
-                           onCompleteScope: this,
-                           onComplete() {
-                               this._spinner.stop();
-                               this._spinner.actor.opacity = 255;
-                               this._spinner.actor.hide();
-                           }
-                         });
-    }
-
-    startAnimation() {
-        this._stop = false;
-
-        if (this._spinner == null)
-            return;
-
-        this._spinner.play();
-        this._spinner.actor.show();
-    }
-
-    _onAppStateChanged(appSys, app) {
-        let state = app.state;
-        if (state != Shell.AppState.STARTING)
-            this._startingApps = this._startingApps.filter(a => a != app);
-        else if (state == Shell.AppState.STARTING)
-            this._startingApps.push(app);
-        // For now just resync on all running state changes; this is mainly to handle
-        // cases where the focused window's application changes without the focus
-        // changing.  An example case is how we map OpenOffice.org based on the window
-        // title which is a dynamic property.
-        this._sync();
-    }
-
-    _focusAppChanged() {
-        let tracker = Shell.WindowTracker.get_default();
-        let focusedApp = tracker.focus_app;
-        if (!focusedApp) {
-            // If the app has just lost focus to the panel, pretend
-            // nothing happened; otherwise you can't keynav to the
-            // app menu.
-            if (global.stage.key_focus != null)
-                return;
-        }
-        this._sync();
-    }
-
-    _findTargetApp() {
-        let workspaceManager = global.workspace_manager;
-        let workspace = workspaceManager.get_active_workspace();
-        let tracker = Shell.WindowTracker.get_default();
-        let focusedApp = tracker.focus_app;
-        if (focusedApp && focusedApp.is_on_workspace(workspace))
-            return focusedApp;
-
-        for (let i = 0; i < this._startingApps.length; i++)
-            if (this._startingApps[i].is_on_workspace(workspace))
-                return this._startingApps[i];
-
-        return null;
-    }
-
-    _sync() {
-        let targetApp = this._findTargetApp();
-
-        if (this._targetApp != targetApp) {
-            if (this._appMenuNotifyId) {
-                this._targetApp.disconnect(this._appMenuNotifyId);
-                this._appMenuNotifyId = 0;
-            }
-            if (this._actionGroupNotifyId) {
-                this._targetApp.disconnect(this._actionGroupNotifyId);
-                this._actionGroupNotifyId = 0;
-            }
-            if (this._busyNotifyId) {
-                this._targetApp.disconnect(this._busyNotifyId);
-                this._busyNotifyId = 0;
-            }
-
-            this._targetApp = targetApp;
-
-            if (this._targetApp) {
-                this._appMenuNotifyId = this._targetApp.connect('notify::menu', this._sync.bind(this));
-                this._actionGroupNotifyId = this._targetApp.connect('notify::action-group', this._sync.bind(this));
-                this._busyNotifyId = this._targetApp.connect('notify::busy', this._sync.bind(this));
-                this._label.set_text(this._targetApp.get_name());
-                this.actor.set_accessible_name(this._targetApp.get_name());
-            }
-        }
-
-        let shellShowsAppMenu = this._gtkSettings.gtk_shell_shows_app_menu;
-        Meta.prefs_set_show_fallback_app_menu(!shellShowsAppMenu);
-
-        let visible = (this._targetApp != null &&
-                       shellShowsAppMenu &&
-                       !Main.overview.visibleTarget);
-        if (visible)
-            this.fadeIn();
-        else
-            this.fadeOut();
-
-        let isBusy = (this._targetApp != null &&
-                      (this._targetApp.get_state() == Shell.AppState.STARTING ||
-                       this._targetApp.get_busy()));
-        if (isBusy)
-            this.startAnimation();
-        else
-            this.stopAnimation();
-
-        this.actor.reactive = (visible && !isBusy);
-
-        this._syncIcon();
-        this._maybeSetMenu();
-        this.emit('changed');
-    }
-
-    _maybeSetMenu() {
-        let menu;
-
-        if (this._targetApp == null) {
-            menu = null;
-        } else if (this._targetApp.action_group && this._targetApp.menu) {
-            if (this.menu instanceof RemoteMenu.RemoteMenu &&
-                this.menu.actionGroup == this._targetApp.action_group)
-                return;
-
-            menu = new RemoteMenu.RemoteMenu(this.actor, this._targetApp.menu, this._targetApp.action_group);
-            menu.connect('activate', () => {
-                let win = this._targetApp.get_windows()[0];
-                win.check_alive(global.get_current_time());
-            });
-
-        } else {
-            if (this.menu && this.menu.isDummyQuitMenu)
-                return;
-
-            // fallback to older menu
-            menu = new PopupMenu.PopupMenu(this.actor, 0.0, St.Side.TOP, 0);
-            menu.isDummyQuitMenu = true;
-            menu.addAction(_("Quit"), () => {
-                this._targetApp.request_quit();
-            });
-        }
-
-        this.setMenu(menu);
-        if (menu)
-            this._menuManager.addMenu(menu);
-    }
-
-    _onDestroy() {
-        if (this._appStateChangedSignalId > 0) {
-            let appSys = Shell.AppSystem.get_default();
-            appSys.disconnect(this._appStateChangedSignalId);
-            this._appStateChangedSignalId = 0;
-        }
-        if (this._focusAppNotifyId > 0) {
-            let tracker = Shell.WindowTracker.get_default();
-            tracker.disconnect(this._focusAppNotifyId);
-            this._focusAppNotifyId = 0;
-        }
-        if (this._overviewHidingId > 0) {
-            Main.overview.disconnect(this._overviewHidingId);
-            this._overviewHidingId = 0;
-        }
-        if (this._overviewShowingId > 0) {
-            Main.overview.disconnect(this._overviewShowingId);
-            this._overviewShowingId = 0;
-        }
-        if (this._showsAppMenuId > 0) {
-            this._gtkSettings.disconnect(this._showsAppMenuId);
-            this._showsAppMenuId = 0;
-        }
-        if (this._switchWorkspaceNotifyId > 0) {
-            global.window_manager.disconnect(this._switchWorkspaceNotifyId);
-            this._switchWorkspaceNotifyId = 0;
-        }
-
-        super._onDestroy();
-    }
-});
-
 var ActivitiesButton = GObject.registerClass(
 class ActivitiesButton extends PanelMenu.Button {
     _init() {
@@ -755,7 +422,6 @@ class AggregateMenu extends PanelMenu.Button {
 const PANEL_ITEM_IMPLEMENTATIONS = {
     'activities': ActivitiesButton,
     'aggregateMenu': AggregateMenu,
-    'appMenu': AppMenuButton,
     'dateMenu': imports.ui.dateMenu.DateMenuButton,
     'a11y': imports.ui.status.accessibility.ATIndicator,
     'keyboard': imports.ui.status.keyboard.InputSourceIndicator,
@@ -774,6 +440,8 @@ class Panel extends St.Widget {
 
         this._sessionStyle = null;
 
+        Meta.prefs_set_show_fallback_app_menu(true);
+
         this.statusArea = {};
 
         this.menuManager = new PopupMenu.PopupMenuManager(this);
@@ -992,10 +660,6 @@ class Panel extends St.Widget {
             menu.actor.navigate_focus(null, Gtk.DirectionType.TAB_FORWARD, false);
     }
 
-    toggleAppMenu() {
-        this._toggleMenu(this.statusArea.appMenu);
-    }
-
     toggleCalendar() {
         this._toggleMenu(this.statusArea.dateMenu);
     }

js/ui/remoteMenu.js

@@ -1,199 +0,0 @@
-// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
-
-const Atk = imports.gi.Atk;
-const GLib = imports.gi.GLib;
-const GObject = imports.gi.GObject;
-const Gio = imports.gi.Gio;
-const Shell = imports.gi.Shell;
-const ShellMenu = imports.gi.ShellMenu;
-const St = imports.gi.St;
-
-const PopupMenu = imports.ui.popupMenu;
-
-function stripMnemonics(label) {
-    if (!label)
-        return '';
-
-    // remove all underscores that are not followed by another underscore
-    return label.replace(/_([^_])/, '$1');
-}
-
-function _insertItem(menu, trackerItem, position) {
-    let mapper;
-
-    if (trackerItem.get_is_separator())
-        mapper = new RemoteMenuSeparatorItemMapper(trackerItem);
-    else if (trackerItem.get_has_submenu())
-        mapper = new RemoteMenuSubmenuItemMapper(trackerItem);
-    else
-        mapper = new RemoteMenuItemMapper(trackerItem);
-
-    let item = mapper.menuItem;
-    menu.addMenuItem(item, position);
-}
-
-function _removeItem(menu, position) {
-    let items = menu._getMenuItems();
-    items[position].destroy();
-}
-
-var RemoteMenuSeparatorItemMapper = class {
-    constructor(trackerItem) {
-        this._trackerItem = trackerItem;
-        this.menuItem = new PopupMenu.PopupSeparatorMenuItem();
-        this._trackerItem.connect('notify::label', this._updateLabel.bind(this));
-        this._updateLabel();
-
-        this.menuItem.connect('destroy', () => {
-            trackerItem.run_dispose();
-        });
-    }
-
-    _updateLabel() {
-        this.menuItem.label.text = stripMnemonics(this._trackerItem.label);
-    }
-};
-
-var RequestSubMenu = class extends PopupMenu.PopupSubMenuMenuItem {
-    constructor() {
-        super('');
-        this._requestOpen = false;
-    }
-
-    _setOpenState(open) {
-        this.emit('request-open', open);
-        this._requestOpen = open;
-    }
-
-    _getOpenState() {
-        return this._requestOpen;
-    }
-};
-
-var RemoteMenuSubmenuItemMapper = class {
-    constructor(trackerItem) {
-        this._trackerItem = trackerItem;
-        this.menuItem = new RequestSubMenu();
-        this._trackerItem.connect('notify::label', this._updateLabel.bind(this));
-        this._updateLabel();
-
-        this._tracker = Shell.MenuTracker.new_for_item_submenu(this._trackerItem,
-                                                               _insertItem.bind(null, this.menuItem.menu),
-                                                               _removeItem.bind(null, this.menuItem.menu));
-
-        this.menuItem.connect('request-open', (menu, open) => {
-            this._trackerItem.request_submenu_shown(open);
-        });
-
-        this._trackerItem.connect('notify::submenu-shown', () => {
-            this.menuItem.setSubmenuShown(this._trackerItem.get_submenu_shown());
-        });
-
-        this.menuItem.connect('destroy', () => {
-            trackerItem.run_dispose();
-        });
-    }
-
-    destroy() {
-        this._tracker.destroy();
-    }
-
-    _updateLabel() {
-        this.menuItem.label.text = stripMnemonics(this._trackerItem.label);
-    }
-};
-
-var RemoteMenuItemMapper = class {
-    constructor(trackerItem) {
-        this._trackerItem = trackerItem;
-
-        this.menuItem = new PopupMenu.PopupBaseMenuItem();
-        this._icon = new St.Icon({ style_class: 'popup-menu-icon' });
-        this.menuItem.actor.add_child(this._icon);
-
-        this._label = new St.Label();
-        this.menuItem.actor.add_child(this._label);
-        this.menuItem.actor.label_actor = this._label;
-
-        this.menuItem.connect('activate', () => {
-            this._trackerItem.activated();
-        });
-
-        this._trackerItem.bind_property('visible', this.menuItem.actor, 'visible', GObject.BindingFlags.SYNC_CREATE);
-
-        this._trackerItem.connect('notify::icon', this._updateIcon.bind(this));
-        this._trackerItem.connect('notify::label', this._updateLabel.bind(this));
-        this._trackerItem.connect('notify::sensitive', this._updateSensitivity.bind(this));
-        this._trackerItem.connect('notify::role', this._updateRole.bind(this));
-        this._trackerItem.connect('notify::toggled', this._updateDecoration.bind(this));
-
-        this._updateIcon();
-        this._updateLabel();
-        this._updateSensitivity();
-        this._updateRole();
-
-        this.menuItem.connect('destroy', () => {
-            trackerItem.run_dispose();
-        });
-    }
-
-    _updateIcon() {
-        this._icon.gicon = this._trackerItem.icon;
-        this._icon.visible = (this._icon.gicon != null);
-    }
-
-    _updateLabel() {
-        this._label.text = stripMnemonics(this._trackerItem.label);
-    }
-
-    _updateSensitivity() {
-        this.menuItem.setSensitive(this._trackerItem.sensitive);
-    }
-
-    _updateDecoration() {
-        let ornamentForRole = {};
-        ornamentForRole[ShellMenu.MenuTrackerItemRole.RADIO] = PopupMenu.Ornament.DOT;
-        ornamentForRole[ShellMenu.MenuTrackerItemRole.CHECK] = PopupMenu.Ornament.CHECK;
-
-        let ornament = PopupMenu.Ornament.NONE;
-        if (this._trackerItem.toggled)
-            ornament = ornamentForRole[this._trackerItem.role];
-
-        this.menuItem.setOrnament(ornament);
-    }
-
-    _updateRole() {
-        let a11yRoles = {};
-        a11yRoles[ShellMenu.MenuTrackerItemRole.NORMAL] = Atk.Role.MENU_ITEM;
-        a11yRoles[ShellMenu.MenuTrackerItemRole.RADIO] = Atk.Role.RADIO_MENU_ITEM;
-        a11yRoles[ShellMenu.MenuTrackerItemRole.CHECK] = Atk.Role.CHECK_MENU_ITEM;
-
-        let a11yRole = a11yRoles[this._trackerItem.role];
-        this.menuItem.actor.accessible_role = a11yRole;
-
-        this._updateDecoration();
-    }
-};
-
-var RemoteMenu = class extends PopupMenu.PopupMenu {
-    constructor(sourceActor, model, actionGroup) {
-        super(sourceActor, 0.0, St.Side.TOP);
-
-        this._model = model;
-        this._actionGroup = actionGroup;
-        this._tracker = Shell.MenuTracker.new(this._actionGroup,
-                                              this._model,
-                                              null, /* action namespace */
-                                              _insertItem.bind(null, this),
-                                              _removeItem.bind(null, this));
-    }
-
-    get actionGroup() {
-        return this._actionGroup;
-    }
-
-    destroy() {
-        this._tracker.destroy();
-        super.destroy();
-    }
-};

js/ui/sessionMode.js

@@ -98,7 +98,7 @@ const _modes = {
                      'keyring', 'autorunManager', 'automountManager'],
 
         panel: {
-            left: ['activities', 'appMenu'],
+            left: ['activities'],
             center: ['dateMenu'],
             right: ['a11y', 'keyboard', 'aggregateMenu']
         }

js/ui/windowManager.js

@@ -923,13 +923,6 @@ var WindowManager = class {
                            Shell.ActionMode.ALL,
                            this._toggleTweens.bind(this));
 
-        this.addKeybinding('open-application-menu',
-                           new Gio.Settings({ schema_id: SHELL_KEYBINDINGS_SCHEMA }),
-                           Meta.KeyBindingFlags.IGNORE_AUTOREPEAT,
-                           Shell.ActionMode.NORMAL |
-                           Shell.ActionMode.POPUP,
-                           this._toggleAppMenu.bind(this));
-
         this.addKeybinding('toggle-message-tray',
                            new Gio.Settings({ schema_id: SHELL_KEYBINDINGS_SCHEMA }),
                            Meta.KeyBindingFlags.IGNORE_AUTOREPEAT,
@@ -2012,10 +2005,6 @@ var WindowManager = class {
         Main.ctrlAltTabManager.popup(binding.is_reversed(), binding.get_name(), binding.get_mask());
     }
 
-    _toggleAppMenu(display, window, event, binding) {
-        Main.panel.toggleAppMenu();
-    }
-
     _toggleCalendar(display, window, event, binding) {
         Main.panel.toggleCalendar();
     }

js/ui/windowMenu.js

@@ -3,12 +3,10 @@
 const Gtk = imports.gi.Gtk;
 const Meta = imports.gi.Meta;
 const St = imports.gi.St;
-const Shell = imports.gi.Shell;
 
 const BoxPointer = imports.ui.boxpointer;
 const Main = imports.ui.main;
 const PopupMenu = imports.ui.popupMenu;
-const RemoteMenu = imports.ui.remoteMenu;
 
 var WindowMenu = class extends PopupMenu.PopupMenu {
     constructor(window, sourceActor) {
@@ -175,22 +173,6 @@ var WindowMenu = class extends PopupMenu.PopupMenu {
     }
 };
 
-var AppMenu = class extends RemoteMenu.RemoteMenu {
-    constructor(window, sourceActor) {
-        let app = Shell.WindowTracker.get_default().get_window_app(window);
-
-        super(sourceActor, app.menu, app.action_group);
-
-        this.actor.add_style_class_name('fallback-app-menu');
-        let variant = window.get_gtk_theme_variant();
-        if (variant)
-            this.actor.add_style_class_name(variant);
-
-        Main.layoutManager.uiGroup.add_actor(this.actor);
-        this.actor.hide();
-    }
-};
-
 var WindowMenuManager = class {
     constructor() {
         this._manager = new PopupMenu.PopupMenuManager({ actor: Main.layoutManager.dummyCursor });
@@ -203,8 +185,9 @@ var WindowMenuManager = class {
     }
 
     showWindowMenuForWindow(window, type, rect) {
-        let menuType = (type == Meta.WindowMenuType.WM) ? WindowMenu : AppMenu;
+        if (type != Meta.WindowMenuType.WM)
-        let menu = new menuType(window, this._sourceActor);
+            throw new Error('Unsupported window menu type');
+        let menu = new WindowMenu(window, this._sourceActor);
 
         this._manager.addMenu(menu);
 

src/gtkmenutracker.c

@@ -1,596 +0,0 @@
-/*
- * Copyright © 2013 Canonical Limited
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the licence, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- * Author: Ryan Lortie <desrt@desrt.ca>
- */
-
-#include "config.h"
-
-#include "gtkmenutracker.h"
-
-/**
- * SECTION:gtkmenutracker
- * @Title: GtkMenuTracker
- * @Short_description: A helper class for interpreting #GMenuModel
- *
- * #GtkMenuTracker is a simple object to ease implementations of #GMenuModel.
- * Given a #GtkActionObservable (usually a #GActionMuxer) along with a
- * #GMenuModel, it will tell you which menu items to create and where to place
- * them. If a menu item is removed, it will tell you the position of the menu
- * item to remove.
- *
- * Using #GtkMenuTracker is fairly simple. The only guarantee you must make
- * to #GtkMenuTracker is that you must obey all insert signals and track the
- * position of items that #GtkMenuTracker gives you. That is, #GtkMenuTracker
- * expects positions of all the latter items to change when it calls your
- * insertion callback with an early position, as it may ask you to remove
- * an item with a readjusted position later.
- *
- * #GtkMenuTracker will give you a #GtkMenuTrackerItem in your callback. You
- * must hold onto this object until a remove signal is emitted. This item
- * represents a single menu item, which can be one of three classes: normal item,
- * separator, or submenu.
- *
- * Certain properties on the #GtkMenuTrackerItem are mutable, and you must
- * listen for changes in the item. For more details, see the documentation
- * for #GtkMenuTrackerItem along with https://live.gnome.org/GApplication/GMenuModel.
- *
- * The idea of @with_separators is for special cases where menu models may
- * be tracked in places where separators are not available, like in toplevel
- * "File", "Edit" menu bars. Ignoring separator items is wrong, as #GtkMenuTracker
- * expects the position to change, so we must tell #GtkMenuTracker to ignore
- * separators itself.
- */
-
-typedef struct _GtkMenuTrackerSection GtkMenuTrackerSection;
-
-struct _GtkMenuTracker
-{
-  GtkActionObservable      *observable;
-  GtkMenuTrackerInsertFunc  insert_func;
-  GtkMenuTrackerRemoveFunc  remove_func;
-  gpointer                  user_data;
-
-  GtkMenuTrackerSection    *toplevel;
-};
-
-struct _GtkMenuTrackerSection
-{
-  gpointer    model;   /* may be a GtkMenuTrackerItem or a GMenuModel */
-  GSList     *items;
-  gchar      *action_namespace;
-
-  guint       separator_label : 1;
-  guint       with_separators : 1;
-  guint       has_separator   : 1;
-  guint       is_fake         : 1;
-
-  gulong      handler;
-};
-
-static GtkMenuTrackerSection *  gtk_menu_tracker_section_new    (GtkMenuTracker        *tracker,
-                                                                 GMenuModel            *model,
-                                                                 gboolean               with_separators,
-                                                                 gboolean               separator_label,
-                                                                 gint                   offset,
-                                                                 const gchar           *action_namespace);
-static void                    gtk_menu_tracker_section_free    (GtkMenuTrackerSection *section);
-
-static GtkMenuTrackerSection *
-gtk_menu_tracker_section_find_model (GtkMenuTrackerSection *section,
-                                     gpointer               model,
-                                     gint                  *offset)
-{
-  GSList *item;
-
-  if (section->has_separator)
-    (*offset)++;
-
-  if (section->model == model)
-    return section;
-
-  for (item = section->items; item; item = item->next)
-    {
-      GtkMenuTrackerSection *subsection = item->data;
-
-      if (subsection)
-        {
-          GtkMenuTrackerSection *found_section;
-
-          found_section = gtk_menu_tracker_section_find_model (subsection, model, offset);
-
-          if (found_section)
-            return found_section;
-        }
-      else
-        (*offset)++;
-    }
-
-  return FALSE;
-}
-
-/* this is responsible for syncing the showing of a separator for a
- * single subsection (and its children).
- *
- * we only ever show separators if we have _actual_ children (ie: we do
- * not show a separator if the section contains only empty child
- * sections).  it's difficult to determine this on-the-fly, so we have
- * this separate function to come back later and figure it out.
- *
- * 'section' is that section.
- *
- * 'tracker' is passed in so that we can emit callbacks when we decide
- * to add/remove separators.
- *
- * 'offset' is passed in so we know which position to emit in our
- * callbacks.  ie: if we add a separator right at the top of this
- * section then we would emit it with this offset.  deeper inside, we
- * adjust accordingly.
- *
- * could_have_separator is true in two situations:
- *
- *  - our parent section had with_separators defined and there are items
- *    before us (ie: we should add a separator if we have content in
- *    order to divide us from the items above)
- *
- *  - if we had a 'label' attribute set for this section
- *
- * parent_model and parent_index are passed in so that we can give them
- * to the insertion callback so that it can see the label (and anything
- * else that happens to be defined on the section).
- *
- * we iterate each item in ourselves.  for subsections, we recursively
- * run ourselves to sync separators.  after we are done, we notice if we
- * have any items in us or if we are completely empty and sync if our
- * separator is shown or not.
- */
-static gint
-gtk_menu_tracker_section_sync_separators (GtkMenuTrackerSection *section,
-                                          GtkMenuTracker        *tracker,
-                                          gint                   offset,
-                                          gboolean               could_have_separator,
-                                          GMenuModel            *parent_model,
-                                          gint                   parent_index)
-{
-  gboolean should_have_separator;
-  gint n_items = 0;
-  GSList *item;
-  gint i = 0;
-
-  for (item = section->items; item; item = item->next)
-    {
-      GtkMenuTrackerSection *subsection = item->data;
-
-      if (subsection)
-        {
-          gboolean section_could_have_separator;
-
-          section_could_have_separator = (section->with_separators && n_items > 0) || subsection->separator_label;
-
-          /* Only pass the parent_model and parent_index in case they may be used to create the separator. */
-          n_items += gtk_menu_tracker_section_sync_separators (subsection, tracker, offset + n_items,
-                                                               section_could_have_separator,
-                                                               section_could_have_separator ? section->model : NULL,
-                                                               section_could_have_separator ? i : 0);
-        }
-      else
-        n_items++;
-
-      i++;
-    }
-
-  should_have_separator = !section->is_fake && could_have_separator && n_items != 0;
-
-  if (should_have_separator > section->has_separator)
-    {
-      /* Add a separator */
-      GtkMenuTrackerItem *menuitem;
-
-      menuitem = _gtk_menu_tracker_item_new (tracker->observable, parent_model, parent_index, NULL, TRUE);
-      (* tracker->insert_func) (menuitem, offset, tracker->user_data);
-      g_object_unref (menuitem);
-
-      section->has_separator = TRUE;
-    }
-  else if (should_have_separator < section->has_separator)
-    {
-      /* Remove a separator */
-      (* tracker->remove_func) (offset, tracker->user_data);
-      section->has_separator = FALSE;
-    }
-
-  n_items += section->has_separator;
-
-  return n_items;
-}
-
-static void
-gtk_menu_tracker_item_visibility_changed (GtkMenuTrackerItem *item,
-                                          gboolean            is_now_visible,
-                                          gpointer            user_data)
-{
-  GtkMenuTracker *tracker = user_data;
-  GtkMenuTrackerSection *section;
-  gboolean was_visible;
-  gint offset = 0;
-
-  /* remember: the item is our model */
-  section = gtk_menu_tracker_section_find_model (tracker->toplevel, item, &offset);
-
-  was_visible = section->items != NULL;
-
-  if (is_now_visible == was_visible)
-    return;
-
-  if (is_now_visible)
-    {
-      section->items = g_slist_prepend (NULL, NULL);
-      (* tracker->insert_func) (section->model, offset, tracker->user_data);
-    }
-  else
-    {
-      section->items = g_slist_delete_link (section->items, section->items);
-      (* tracker->remove_func) (offset, tracker->user_data);
-    }
-
-  gtk_menu_tracker_section_sync_separators (tracker->toplevel, tracker, 0, FALSE, NULL, 0);
-}
-
-static gint
-gtk_menu_tracker_section_measure (GtkMenuTrackerSection *section)
-{
-  GSList *item;
-  gint n_items;
-
-  if (section == NULL)
-    return 1;
-
-  n_items = 0;
-
-  if (section->has_separator)
-    n_items++;
-
-  for (item = section->items; item; item = item->next)
-    n_items += gtk_menu_tracker_section_measure (item->data);
-
-  return n_items;
-}
-
-static void
-gtk_menu_tracker_remove_items (GtkMenuTracker  *tracker,
-                               GSList         **change_point,
-                               gint             offset,
-                               gint             n_items)
-{
-  gint i;
-
-  for (i = 0; i < n_items; i++)
-    {
-      GtkMenuTrackerSection *subsection;
-      gint n;
-
-      subsection = (*change_point)->data;
-      *change_point = g_slist_delete_link (*change_point, *change_point);
-
-      n = gtk_menu_tracker_section_measure (subsection);
-      gtk_menu_tracker_section_free (subsection);
-
-      while (n--)
-        (* tracker->remove_func) (offset, tracker->user_data);
-    }
-}
-
-static void
-gtk_menu_tracker_add_items (GtkMenuTracker         *tracker,
-                            GtkMenuTrackerSection  *section,
-                            GSList                **change_point,
-                            gint                    offset,
-                            GMenuModel             *model,
-                            gint                    position,
-                            gint                    n_items)
-{
-  while (n_items--)
-    {
-      GMenuModel *submenu;
-
-      submenu = g_menu_model_get_item_link (model, position + n_items, G_MENU_LINK_SECTION);
-      g_assert (submenu != model);
-      if (submenu != NULL)
-        {
-          GtkMenuTrackerSection *subsection;
-          gchar *action_namespace = NULL;
-          gboolean has_label;
-
-          has_label = g_menu_model_get_item_attribute (model, position + n_items,
-                                                       G_MENU_ATTRIBUTE_LABEL, "s", NULL);
-
-          g_menu_model_get_item_attribute (model, position + n_items,
-                                           G_MENU_ATTRIBUTE_ACTION_NAMESPACE, "s", &action_namespace);
-
-          if (section->action_namespace)
-            {
-              gchar *namespace;
-
-              namespace = g_strjoin (".", section->action_namespace, action_namespace, NULL);
-              subsection = gtk_menu_tracker_section_new (tracker, submenu, FALSE, has_label, offset, namespace);
-              g_free (namespace);
-            }
-          else
-            subsection = gtk_menu_tracker_section_new (tracker, submenu, FALSE, has_label, offset, action_namespace);
-
-          *change_point = g_slist_prepend (*change_point, subsection);
-          g_free (action_namespace);
-          g_object_unref (submenu);
-        }
-      else
-        {
-          GtkMenuTrackerItem *item;
-
-          item = _gtk_menu_tracker_item_new (tracker->observable, model, position + n_items,
-                                             section->action_namespace, FALSE);
-
-          /* In the case that the item may disappear we handle that by
-           * treating the item that we just created as being its own
-           * subsection.  This happens as so:
-           *
-           *  - the subsection is created without the possibility of
-           *    showing a separator
-           *
-           *  - the subsection will have either 0 or 1 item in it at all
-           *    times: either the shown item or not (in the case it is
-           *    hidden)
-           *
-           *  - the created item acts as the "model" for this section
-           *    and we use its "visiblity-changed" signal in the same
-           *    way that we use the "items-changed" signal from a real
-           *    GMenuModel
-           *
-           * We almost never use the '->model' stored in the section for
-           * anything other than lookups and for dropped the ref and
-           * disconnecting the signal when we destroy the menu, and we
-           * need to do exactly those things in this case as well.
-           *
-           * The only other thing that '->model' is used for is in the
-           * case that we want to show a separator, but we will never do
-           * that because separators are not shown for this fake section.
-           */
-          if (_gtk_menu_tracker_item_may_disappear (item))
-            {
-              GtkMenuTrackerSection *fake_section;
-
-              fake_section = g_slice_new0 (GtkMenuTrackerSection);
-              fake_section->is_fake = TRUE;
-              fake_section->model = g_object_ref (item);
-              fake_section->handler = g_signal_connect (item, "visibility-changed",
-                                                        G_CALLBACK (gtk_menu_tracker_item_visibility_changed),
-                                                        tracker);
-              *change_point = g_slist_prepend (*change_point, fake_section);
-
-              if (_gtk_menu_tracker_item_is_visible (item))
-                {
-                  (* tracker->insert_func) (item, offset, tracker->user_data);
-                  fake_section->items = g_slist_prepend (NULL, NULL);
-                }
-            }
-          else
-            {
-              /* In the normal case, we store NULL in the linked list.
-               * The measurement and lookup code count NULL always as
-               * exactly 1: an item that will always be there.
-               */
-              (* tracker->insert_func) (item, offset, tracker->user_data);
-              *change_point = g_slist_prepend (*change_point, NULL);
-            }
-
-          g_object_unref (item);
-        }
-    }
-}
-
-static void
-gtk_menu_tracker_model_changed (GMenuModel *model,
-                                gint        position,
-                                gint        removed,
-                                gint        added,
-                                gpointer    user_data)
-{
-  GtkMenuTracker *tracker = user_data;
-  GtkMenuTrackerSection *section;
-  GSList **change_point;
-  gint offset = 0;
-  gint i;
-
-  /* First find which section the changed model corresponds to, and the
-   * position of that section within the overall menu.
-   */
-  section = gtk_menu_tracker_section_find_model (tracker->toplevel, model, &offset);
-
-  /* Next, seek through that section to the change point.  This gives us
-   * the correct GSList** to make the change to and also finds the final
-   * offset at which we will make the changes (by measuring the number
-   * of items within each item of the section before the change point).
-   */
-  change_point = &section->items;
-  for (i = 0; i < position; i++)
-    {
-      offset += gtk_menu_tracker_section_measure ((*change_point)->data);
-      change_point = &(*change_point)->next;
-    }
-
-  /* We remove items in order and add items in reverse order.  This
-   * means that the offset used for all inserts and removes caused by a
-   * single change will be the same.
-   *
-   * This also has a performance advantage: GtkMenuShell stores the
-   * menu items in a linked list.  In the case where we are creating a
-   * menu for the first time, adding the items in reverse order means
-   * that we only ever insert at index zero, prepending the list.  This
-   * means that we can populate in O(n) time instead of O(n^2) that we
-   * would do by appending.
-   */
-  gtk_menu_tracker_remove_items (tracker, change_point, offset, removed);
-  gtk_menu_tracker_add_items (tracker, section, change_point, offset, model, position, added);
-
-  /* The offsets for insertion/removal of separators will be all over
-   * the place, however...
-   */
-  gtk_menu_tracker_section_sync_separators (tracker->toplevel, tracker, 0, FALSE, NULL, 0);
-}
-
-static void
-gtk_menu_tracker_section_free (GtkMenuTrackerSection *section)
-{
-  if (section == NULL)
-    return;
-
-  g_signal_handler_disconnect (section->model, section->handler);
-  g_slist_free_full (section->items, (GDestroyNotify) gtk_menu_tracker_section_free);
-  g_free (section->action_namespace);
-  g_object_unref (section->model);
-  g_slice_free (GtkMenuTrackerSection, section);
-}
-
-static GtkMenuTrackerSection *
-gtk_menu_tracker_section_new (GtkMenuTracker *tracker,
-                              GMenuModel     *model,
-                              gboolean        with_separators,
-                              gboolean        separator_label,
-                              gint            offset,
-                              const gchar    *action_namespace)
-{
-  GtkMenuTrackerSection *section;
-
-  section = g_slice_new0 (GtkMenuTrackerSection);
-  section->model = g_object_ref (model);
-  section->with_separators = with_separators;
-  section->action_namespace = g_strdup (action_namespace);
-  section->separator_label = separator_label;
-
-  gtk_menu_tracker_add_items (tracker, section, &section->items, offset, model, 0, g_menu_model_get_n_items (model));
-  section->handler = g_signal_connect (model, "items-changed", G_CALLBACK (gtk_menu_tracker_model_changed), tracker);
-
-  return section;
-}
-
-/*< private >
- * gtk_menu_tracker_new:
- * @model: the model to flatten
- * @with_separators: if the toplevel should have separators (ie: TRUE
- *   for menus, FALSE for menubars)
- * @action_namespace: the passed-in action namespace
- * @insert_func: insert callback
- * @remove_func: remove callback
- * @user_data user data for callbacks
- *
- * Creates a GtkMenuTracker for @model, holding a ref on @model for as
- * long as the tracker is alive.
- *
- * This flattens out the model, merging sections and inserting
- * separators where appropriate.  It monitors for changes and performs
- * updates on the fly.  It also handles action_namespace for subsections
- * (but you will need to handle it yourself for submenus).
- *
- * When the tracker is first created, @insert_func will be called many
- * times to populate the menu with the initial contents of @model
- * (unless it is empty), before gtk_menu_tracker_new() returns.  For
- * this reason, the menu that is using the tracker ought to be empty
- * when it creates the tracker.
- *
- * Future changes to @model will result in more calls to @insert_func
- * and @remove_func.
- *
- * The position argument to both functions is the linear 0-based
- * position in the menu at which the item in question should be inserted
- * or removed.
- *
- * For @insert_func, @model and @item_index are used to get the
- * information about the menu item to insert.  @action_namespace is the
- * action namespace that actions referred to from that item should place
- * themselves in.  Note that if the item is a submenu and the
- * "action-namespace" attribute is defined on the item, it will _not_ be
- * applied to the @action_namespace argument as it is meant for the
- * items inside of the submenu, not the submenu item itself.
- *
- * @is_separator is set to %TRUE in case the item being added is a
- * separator.  @model and @item_index will still be meaningfully set in
- * this case -- to the section menu item corresponding to the separator.
- * This is useful if the section specifies a label, for example.  If
- * there is an "action-namespace" attribute on this menu item then it
- * should be ignored by the consumer because #GtkMenuTracker has already
- * handled it.
- *
- * When using #GtkMenuTracker there is no need to hold onto @model or
- * monitor it for changes.  The model will be unreffed when
- * gtk_menu_tracker_free() is called.
- */
-GtkMenuTracker *
-gtk_menu_tracker_new (GtkActionObservable      *observable,
-                      GMenuModel               *model,
-                      gboolean                  with_separators,
-                      const gchar              *action_namespace,
-                      GtkMenuTrackerInsertFunc  insert_func,
-                      GtkMenuTrackerRemoveFunc  remove_func,
-                      gpointer                  user_data)
-{
-  GtkMenuTracker *tracker;
-
-  tracker = g_slice_new (GtkMenuTracker);
-  tracker->observable = g_object_ref (observable);
-  tracker->insert_func = insert_func;
-  tracker->remove_func = remove_func;
-  tracker->user_data = user_data;
-
-  tracker->toplevel = gtk_menu_tracker_section_new (tracker, model, with_separators, FALSE, 0, action_namespace);
-  gtk_menu_tracker_section_sync_separators (tracker->toplevel, tracker, 0, FALSE, NULL, 0);
-
-  return tracker;
-}
-
-GtkMenuTracker *
-gtk_menu_tracker_new_for_item_submenu (GtkMenuTrackerItem       *item,
-                                       GtkMenuTrackerInsertFunc  insert_func,
-                                       GtkMenuTrackerRemoveFunc  remove_func,
-                                       gpointer                  user_data)
-{
-  GtkMenuTracker *tracker;
-  GMenuModel *submenu;
-  gchar *namespace;
-
-  submenu = _gtk_menu_tracker_item_get_submenu (item);
-  namespace = _gtk_menu_tracker_item_get_submenu_namespace (item);
-
-  tracker = gtk_menu_tracker_new (_gtk_menu_tracker_item_get_observable (item), submenu,
-                                  TRUE, namespace, insert_func, remove_func, user_data);
-
-  g_object_unref (submenu);
-  g_free (namespace);
-
-  return tracker;
-}
-
-/*< private >
- * gtk_menu_tracker_free:
- * @tracker: a #GtkMenuTracker
- *
- * Frees the tracker, ...
- */
-void
-gtk_menu_tracker_free (GtkMenuTracker *tracker)
-{
-  gtk_menu_tracker_section_free (tracker->toplevel);
-  g_object_unref (tracker->observable);
-  g_slice_free (GtkMenuTracker, tracker);
-}

src/gtkmenutracker.h

@@ -1,50 +0,0 @@
-/*
- * Copyright © 2013 Canonical Limited
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the licence, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- * Author: Ryan Lortie <desrt@desrt.ca>
- */
-
-#ifndef __GTK_MENU_TRACKER_H__
-#define __GTK_MENU_TRACKER_H__
-
-#include "gtkmenutrackeritem.h"
-
-typedef struct _GtkMenuTracker GtkMenuTracker;
-
-typedef void         (* GtkMenuTrackerInsertFunc)                       (GtkMenuTrackerItem       *item,
-                                                                         gint                      position,
-                                                                         gpointer                  user_data);
-
-typedef void         (* GtkMenuTrackerRemoveFunc)                       (gint                      position,
-                                                                         gpointer                  user_data);
-
-
-GtkMenuTracker *        gtk_menu_tracker_new                            (GtkActionObservable      *observer,
-                                                                         GMenuModel               *model,
-                                                                         gboolean                  with_separators,
-                                                                         const gchar              *action_namespace,
-                                                                         GtkMenuTrackerInsertFunc  insert_func,
-                                                                         GtkMenuTrackerRemoveFunc  remove_func,
-                                                                         gpointer                  user_data);
-
-GtkMenuTracker *        gtk_menu_tracker_new_for_item_submenu           (GtkMenuTrackerItem       *item,
-                                                                         GtkMenuTrackerInsertFunc  insert_func,
-                                                                         GtkMenuTrackerRemoveFunc  remove_func,
-                                                                         gpointer                  user_data);
-
-void                    gtk_menu_tracker_free                           (GtkMenuTracker           *tracker);
-
-#endif /* __GTK_MENU_TRACKER_H__ */

src/gtkmenutrackeritem.c

@@ -1,894 +0,0 @@
-/*
- * Copyright © 2013 Canonical Limited
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the licence, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, see <http://www.gnu.org/licenses/>.
- *
- * Author: Ryan Lortie <desrt@desrt.ca>
- */
-
-#include "config.h"
-
-#include "gtkmenutrackeritem.h"
-#include "gtkactionmuxer.h"
-
-#include "gtkactionmuxer.h"
-
-#include <string.h>
-
-/**
- * SECTION:gtkmenutrackeritem
- * @Title: GtkMenuTrackerItem
- * @Short_description: Small helper for model menu items
- *
- * A #GtkMenuTrackerItem is a small helper class used by #GtkMenuTracker to
- * represent menu items. It has one of three classes: normal item, separator,
- * or submenu.
- *
- * If an item is one of the non-normal classes (submenu, separator), only the
- * label of the item needs to be respected. Otherwise, all the properties
- * of the item contribute to the item's appearance and state.
- *
- * Implementing the appearance of the menu item is up to toolkits, and certain
- * toolkits may choose to ignore certain properties, like icon or accel. The
- * role of the item determines its accessibility role, along with its
- * decoration if the GtkMenuTrackerItem::toggled property is true. As an
- * example, if the item has the role %GTK_MENU_TRACKER_ITEM_ROLE_CHECK and
- * GtkMenuTrackerItem::toggled is %FALSE, its accessible role should be that of
- * a check menu item, and no decoration should be drawn. But if
- * GtkMenuTrackerItem::toggled is %TRUE, a checkmark should be drawn.
- *
- * All properties except for the two class-determining properties,
- * GtkMenuTrackerItem::is-separator and GtkMenuTrackerItem::has-submenu are
- * allowed to change, so listen to the notify signals to update your item's
- * appearance. When using a GObject library, this can conveniently be done
- * with g_object_bind_property() and #GBinding, and this is how this is
- * implemented in GTK+; the appearance side is implemented in #GtkModelMenuItem.
- *
- * When an item is clicked, simply call gtk_menu_tracker_item_activated() in
- * response. The #GtkMenuTrackerItem will take care of everything related to
- * activating the item and will itself update the state of all items in
- * response.
- *
- * Submenus are a special case of menu item. When an item is a submenu, you
- * should create a submenu for it with gtk_menu_tracker_new_item_for_submenu(),
- * and apply the same menu tracking logic you would for a toplevel menu.
- * Applications using submenus may want to lazily build their submenus in
- * response to the user clicking on it, as building a submenu may be expensive.
- *
- * Thus, the submenu has two special controls -- the submenu's visibility
- * should be controlled by the GtkMenuTrackerItem::submenu-shown property,
- * and if a user clicks on the submenu, do not immediately show the menu,
- * but call gtk_menu_tracker_item_request_submenu_shown() and wait for the
- * GtkMenuTrackerItem::submenu-shown property to update. If the user navigates,
- * the application may want to be notified so it can cancel the expensive
- * operation that it was using to build the submenu. Thus,
- * gtk_menu_tracker_item_request_submenu_shown() takes a boolean parameter.
- * Use %TRUE when the user wants to open the submenu, and %FALSE when the
- * user wants to close the submenu.
- */
-
-typedef GObjectClass GtkMenuTrackerItemClass;
-
-struct _GtkMenuTrackerItem
-{
-  GObject parent_instance;
-
-  GtkActionObservable *observable;
-  gchar *action_namespace;
-  gchar *action_and_target;
-  GMenuItem *item;
-  GtkMenuTrackerItemRole role : 4;
-  guint is_separator : 1;
-  guint can_activate : 1;
-  guint sensitive : 1;
-  guint toggled : 1;
-  guint submenu_shown : 1;
-  guint submenu_requested : 1;
-  guint hidden_when : 2;
-  guint is_visible : 1;
-};
-
-#define HIDDEN_NEVER         0
-#define HIDDEN_WHEN_MISSING  1
-#define HIDDEN_WHEN_DISABLED 2
-
-enum {
-  PROP_0,
-  PROP_IS_SEPARATOR,
-  PROP_HAS_SUBMENU,
-  PROP_LABEL,
-  PROP_ICON,
-  PROP_SENSITIVE,
-  PROP_VISIBLE,
-  PROP_ROLE,
-  PROP_TOGGLED,
-  PROP_ACCEL,
-  PROP_SUBMENU_SHOWN,
-  N_PROPS
-};
-
-static GParamSpec *gtk_menu_tracker_item_pspecs[N_PROPS];
-static guint gtk_menu_tracker_visibility_changed_signal;
-
-static void gtk_menu_tracker_item_init_observer_iface (GtkActionObserverInterface *iface);
-G_DEFINE_TYPE_WITH_CODE (GtkMenuTrackerItem, gtk_menu_tracker_item, G_TYPE_OBJECT,
-                         G_IMPLEMENT_INTERFACE (GTK_TYPE_ACTION_OBSERVER, gtk_menu_tracker_item_init_observer_iface))
-
-GType
-gtk_menu_tracker_item_role_get_type (void)
-{
-  static gsize gtk_menu_tracker_item_role_type;
-
-  if (g_once_init_enter (&gtk_menu_tracker_item_role_type))
-    {
-      static const GEnumValue values[] = {
-        { GTK_MENU_TRACKER_ITEM_ROLE_NORMAL, "GTK_MENU_TRACKER_ITEM_ROLE_NORMAL", "normal" },
-        { GTK_MENU_TRACKER_ITEM_ROLE_CHECK, "GTK_MENU_TRACKER_ITEM_ROLE_CHECK", "check" },
-        { GTK_MENU_TRACKER_ITEM_ROLE_RADIO, "GTK_MENU_TRACKER_ITEM_ROLE_RADIO", "radio" },
-        { 0, NULL, NULL }
-      };
-      GType type;
-
-      type = g_enum_register_static ("GtkMenuTrackerItemRole", values);
-
-      g_once_init_leave (&gtk_menu_tracker_item_role_type, type);
-    }
-
-  return gtk_menu_tracker_item_role_type;
-}
-
-static void
-gtk_menu_tracker_item_get_property (GObject    *object,
-                                    guint       prop_id,
-                                    GValue     *value,
-                                    GParamSpec *pspec)
-{
-  GtkMenuTrackerItem *self = GTK_MENU_TRACKER_ITEM (object);
-
-  switch (prop_id)
-    {
-    case PROP_IS_SEPARATOR:
-      g_value_set_boolean (value, gtk_menu_tracker_item_get_is_separator (self));
-      break;
-    case PROP_HAS_SUBMENU:
-      g_value_set_boolean (value, gtk_menu_tracker_item_get_has_submenu (self));
-      break;
-    case PROP_LABEL:
-      g_value_set_string (value, gtk_menu_tracker_item_get_label (self));
-      break;
-    case PROP_ICON:
-      g_value_set_object (value, gtk_menu_tracker_item_get_icon (self));
-      break;
-    case PROP_SENSITIVE:
-      g_value_set_boolean (value, gtk_menu_tracker_item_get_sensitive (self));
-      break;
-    case PROP_VISIBLE:
-      g_value_set_boolean (value, gtk_menu_tracker_item_get_visible (self));
-      break;
-    case PROP_ROLE:
-      g_value_set_enum (value, gtk_menu_tracker_item_get_role (self));
-      break;
-    case PROP_TOGGLED:
-      g_value_set_boolean (value, gtk_menu_tracker_item_get_toggled (self));
-      break;
-    case PROP_ACCEL:
-      g_value_set_string (value, gtk_menu_tracker_item_get_accel (self));
-      break;
-    case PROP_SUBMENU_SHOWN:
-      g_value_set_boolean (value, gtk_menu_tracker_item_get_submenu_shown (self));
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-      break;
-  }
-}
-
-static void
-gtk_menu_tracker_item_finalize (GObject *object)
-{
-  GtkMenuTrackerItem *self = GTK_MENU_TRACKER_ITEM (object);
-
-  g_free (self->action_namespace);
-  g_free (self->action_and_target);
-
-  if (self->observable)
-    g_object_unref (self->observable);
-
-  g_object_unref (self->item);
-
-  G_OBJECT_CLASS (gtk_menu_tracker_item_parent_class)->finalize (object);
-}
-
-static void
-gtk_menu_tracker_item_init (GtkMenuTrackerItem * self)
-{
-}
-
-static void
-gtk_menu_tracker_item_class_init (GtkMenuTrackerItemClass *class)
-{
-  class->get_property = gtk_menu_tracker_item_get_property;
-  class->finalize = gtk_menu_tracker_item_finalize;
-
-  gtk_menu_tracker_item_pspecs[PROP_IS_SEPARATOR] =
-    g_param_spec_boolean ("is-separator", "", "", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
-  gtk_menu_tracker_item_pspecs[PROP_HAS_SUBMENU] =
-    g_param_spec_boolean ("has-submenu", "", "", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
-  gtk_menu_tracker_item_pspecs[PROP_LABEL] =
-    g_param_spec_string ("label", "", "", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
-  gtk_menu_tracker_item_pspecs[PROP_ICON] =
-    g_param_spec_object ("icon", "", "", G_TYPE_ICON, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
-  gtk_menu_tracker_item_pspecs[PROP_SENSITIVE] =
-    g_param_spec_boolean ("sensitive", "", "", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
-  gtk_menu_tracker_item_pspecs[PROP_VISIBLE] =
-    g_param_spec_boolean ("visible", "", "", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
-  gtk_menu_tracker_item_pspecs[PROP_ROLE] =
-    g_param_spec_enum ("role", "", "",
-                       GTK_TYPE_MENU_TRACKER_ITEM_ROLE, GTK_MENU_TRACKER_ITEM_ROLE_NORMAL,
-                       G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
-  gtk_menu_tracker_item_pspecs[PROP_TOGGLED] =
-    g_param_spec_boolean ("toggled", "", "", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
-  gtk_menu_tracker_item_pspecs[PROP_ACCEL] =
-    g_param_spec_string ("accel", "", "", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
-  gtk_menu_tracker_item_pspecs[PROP_SUBMENU_SHOWN] =
-    g_param_spec_boolean ("submenu-shown", "", "", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
-
-  g_object_class_install_properties (class, N_PROPS, gtk_menu_tracker_item_pspecs);
-
-  gtk_menu_tracker_visibility_changed_signal = g_signal_new ("visibility-changed", GTK_TYPE_MENU_TRACKER_ITEM,
-                                                             G_SIGNAL_RUN_FIRST, 0, NULL, NULL,
-                                                             g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE,
-                                                             1, G_TYPE_BOOLEAN);
-}
-
-/* This syncs up the visibility for the hidden-when='' case.  We call it
- * from the action observer functions on changes to the action group and
- * on initialisation (via the action observer functions that are invoked
- * at that time).
- */
-static void
-gtk_menu_tracker_item_update_visibility (GtkMenuTrackerItem *self)
-{
-  gboolean visible;
-
-  switch (self->hidden_when)
-    {
-    case HIDDEN_NEVER:
-      visible = TRUE;
-      break;
-
-    case HIDDEN_WHEN_MISSING:
-      visible = self->can_activate;
-      break;
-
-    case HIDDEN_WHEN_DISABLED:
-      visible = self->sensitive;
-      break;
-
-    default:
-      g_assert_not_reached ();
-    }
-
-  if (visible != self->is_visible)
-    {
-      self->is_visible = visible;
-      g_signal_emit (self, gtk_menu_tracker_visibility_changed_signal, 0, visible);
-    }
-}
-
-static void
-gtk_menu_tracker_item_action_added (GtkActionObserver   *observer,
-                                    GtkActionObservable *observable,
-                                    const gchar         *action_name,
-                                    const GVariantType  *parameter_type,
-                                    gboolean             enabled,
-                                    GVariant            *state)
-{
-  GtkMenuTrackerItem *self = GTK_MENU_TRACKER_ITEM (observer);
-  GVariant *action_target;
-
-  action_target = g_menu_item_get_attribute_value (self->item, G_MENU_ATTRIBUTE_TARGET, NULL);
-
-  self->can_activate = (action_target == NULL && parameter_type == NULL) ||
-                        (action_target != NULL && parameter_type != NULL &&
-                        g_variant_is_of_type (action_target, parameter_type));
-
-  if (!self->can_activate)
-    {
-      if (action_target)
-        g_variant_unref (action_target);
-      return;
-    }
-
-  self->sensitive = enabled;
-
-  if (action_target != NULL && state != NULL)
-    {
-      self->toggled = g_variant_equal (state, action_target);
-      self->role = GTK_MENU_TRACKER_ITEM_ROLE_RADIO;
-    }
-
-  else if (state != NULL && g_variant_is_of_type (state, G_VARIANT_TYPE_BOOLEAN))
-    {
-      self->toggled = g_variant_get_boolean (state);
-      self->role = GTK_MENU_TRACKER_ITEM_ROLE_CHECK;
-    }
-
-  g_object_freeze_notify (G_OBJECT (self));
-
-  if (self->sensitive)
-    g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_SENSITIVE]);
-
-  if (self->toggled)
-    g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_TOGGLED]);
-
-  if (self->role != GTK_MENU_TRACKER_ITEM_ROLE_NORMAL)
-    g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_ROLE]);
-
-  g_object_thaw_notify (G_OBJECT (self));
-
-  if (action_target)
-    g_variant_unref (action_target);
-
-  /* In case of hidden-when='', we want to Wait until after refreshing
-   * all of the properties to emit the signal that will cause the
-   * tracker to expose us (to prevent too much thrashing).
-   */
-  gtk_menu_tracker_item_update_visibility (self);
-}
-
-static void
-gtk_menu_tracker_item_action_enabled_changed (GtkActionObserver   *observer,
-                                              GtkActionObservable *observable,
-                                              const gchar         *action_name,
-                                              gboolean             enabled)
-{
-  GtkMenuTrackerItem *self = GTK_MENU_TRACKER_ITEM (observer);
-
-  if (!self->can_activate)
-    return;
-
-  if (self->sensitive == enabled)
-    return;
-
-  self->sensitive = enabled;
-
-  g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_SENSITIVE]);
-
-  gtk_menu_tracker_item_update_visibility (self);
-}
-
-static void
-gtk_menu_tracker_item_action_state_changed (GtkActionObserver   *observer,
-                                            GtkActionObservable *observable,
-                                            const gchar         *action_name,
-                                            GVariant            *state)
-{
-  GtkMenuTrackerItem *self = GTK_MENU_TRACKER_ITEM (observer);
-  GVariant *action_target;
-  gboolean was_toggled;
-
-  if (!self->can_activate)
-    return;
-
-  action_target = g_menu_item_get_attribute_value (self->item, G_MENU_ATTRIBUTE_TARGET, NULL);
-  was_toggled = self->toggled;
-
-  if (action_target)
-    {
-      self->toggled = g_variant_equal (state, action_target);
-      g_variant_unref (action_target);
-    }
-
-  else if (g_variant_is_of_type (state, G_VARIANT_TYPE_BOOLEAN))
-    self->toggled = g_variant_get_boolean (state);
-
-  else
-    self->toggled = FALSE;
-
-  if (self->toggled != was_toggled)
-    g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_TOGGLED]);
-}
-
-static void
-gtk_menu_tracker_item_action_removed (GtkActionObserver   *observer,
-                                      GtkActionObservable *observable,
-                                      const gchar         *action_name)
-{
-  GtkMenuTrackerItem *self = GTK_MENU_TRACKER_ITEM (observer);
-  gboolean was_sensitive, was_toggled;
-  GtkMenuTrackerItemRole old_role;
-
-  if (!self->can_activate)
-    return;
-
-  was_sensitive = self->sensitive;
-  was_toggled = self->toggled;
-  old_role = self->role;
-
-  self->can_activate = FALSE;
-  self->sensitive = FALSE;
-  self->toggled = FALSE;
-  self->role = GTK_MENU_TRACKER_ITEM_ROLE_NORMAL;
-
-  /* Backwards from adding: we want to remove ourselves from the menu
-   * -before- thrashing the properties.
-   */
-  gtk_menu_tracker_item_update_visibility (self);
-
-  g_object_freeze_notify (G_OBJECT (self));
-
-  if (was_sensitive)
-    g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_SENSITIVE]);
-
-  if (was_toggled)
-    g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_TOGGLED]);
-
-  if (old_role != GTK_MENU_TRACKER_ITEM_ROLE_NORMAL)
-    g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_ROLE]);
-
-  g_object_thaw_notify (G_OBJECT (self));
-}
-
-static void
-gtk_menu_tracker_item_primary_accel_changed (GtkActionObserver   *observer,
-                                             GtkActionObservable *observable,
-                                             const gchar         *action_name,
-                                             const gchar         *action_and_target)
-{
-  GtkMenuTrackerItem *self = GTK_MENU_TRACKER_ITEM (observer);
-
-  if (g_str_equal (action_and_target, self->action_and_target))
-    g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_ACCEL]);
-}
-
-static void
-gtk_menu_tracker_item_init_observer_iface (GtkActionObserverInterface *iface)
-{
-  iface->action_added = gtk_menu_tracker_item_action_added;
-  iface->action_enabled_changed = gtk_menu_tracker_item_action_enabled_changed;
-  iface->action_state_changed = gtk_menu_tracker_item_action_state_changed;
-  iface->action_removed = gtk_menu_tracker_item_action_removed;
-  iface->primary_accel_changed = gtk_menu_tracker_item_primary_accel_changed;
-}
-
-GtkMenuTrackerItem *
-_gtk_menu_tracker_item_new (GtkActionObservable *observable,
-                            GMenuModel          *model,
-                            gint                 item_index,
-                            const gchar         *action_namespace,
-                            gboolean             is_separator)
-{
-  GtkMenuTrackerItem *self;
-  const gchar *action_name;
-  const gchar *hidden_when;
-
-  g_return_val_if_fail (GTK_IS_ACTION_OBSERVABLE (observable), NULL);
-  g_return_val_if_fail (G_IS_MENU_MODEL (model), NULL);
-
-  self = g_object_new (GTK_TYPE_MENU_TRACKER_ITEM, NULL);
-  self->item = g_menu_item_new_from_model (model, item_index);
-  self->action_namespace = g_strdup (action_namespace);
-  self->observable = g_object_ref (observable);
-  self->is_separator = is_separator;
-
-  if (!is_separator && g_menu_item_get_attribute (self->item, "hidden-when", "&s", &hidden_when))
-    {
-      if (g_str_equal (hidden_when, "action-disabled"))
-        self->hidden_when = HIDDEN_WHEN_DISABLED;
-      else if (g_str_equal (hidden_when, "action-missing"))
-        self->hidden_when = HIDDEN_WHEN_MISSING;
-
-      /* Ignore other values -- this code may be running in context of a
-       * desktop shell or the like and should not spew criticals due to
-       * application bugs...
-       *
-       * Note: if we just set a hidden-when state, but don't get the
-       * action_name below then our visibility will be FALSE forever.
-       * That's to be expected since the action is missing...
-       */
-    }
-
-  if (!is_separator && g_menu_item_get_attribute (self->item, "action", "&s", &action_name))
-    {
-      GActionGroup *group = G_ACTION_GROUP (observable);
-      const GVariantType *parameter_type;
-      GVariant *target;
-      gboolean enabled;
-      GVariant *state;
-      gboolean found;
-
-      target = g_menu_item_get_attribute_value (self->item, "target", NULL);
-
-      self->action_and_target = gtk_print_action_and_target (action_namespace, action_name, target);
-
-      if (target)
-        g_variant_unref (target);
-
-      action_name = strrchr (self->action_and_target, '|') + 1;
-
-      state = NULL;
-
-      gtk_action_observable_register_observer (self->observable, action_name, GTK_ACTION_OBSERVER (self));
-      found = g_action_group_query_action (group, action_name, &enabled, &parameter_type, NULL, NULL, &state);
-
-      if (found)
-        gtk_menu_tracker_item_action_added (GTK_ACTION_OBSERVER (self), observable, NULL, parameter_type, enabled, state);
-      else
-        gtk_menu_tracker_item_action_removed (GTK_ACTION_OBSERVER (self), observable, NULL);
-
-      if (state)
-        g_variant_unref (state);
-    }
-  else
-    self->sensitive = TRUE;
-
-  return self;
-}
-
-GtkActionObservable *
-_gtk_menu_tracker_item_get_observable (GtkMenuTrackerItem *self)
-{
-  return self->observable;
-}
-
-/**
- * gtk_menu_tracker_item_get_is_separator:
- * @self: A #GtkMenuTrackerItem instance
- *
- * Returns whether the menu item is a separator. If so, only
- * certain properties may need to be obeyed. See the documentation
- * for #GtkMenuTrackerItem.
- */
-gboolean
-gtk_menu_tracker_item_get_is_separator (GtkMenuTrackerItem *self)
-{
-  return self->is_separator;
-}
-
-/**
- * gtk_menu_tracker_item_get_has_submenu:
- * @self: A #GtkMenuTrackerItem instance
- *
- * Returns whether the menu item has a submenu. If so, only
- * certain properties may need to be obeyed. See the documentation
- * for #GtkMenuTrackerItem.
- */
-gboolean
-gtk_menu_tracker_item_get_has_submenu (GtkMenuTrackerItem *self)
-{
-  GMenuModel *link;
-
-  link = g_menu_item_get_link (self->item, G_MENU_LINK_SUBMENU);
-
-  if (link)
-    {
-      g_object_unref (link);
-      return TRUE;
-    }
-  else
-    return FALSE;
-}
-
-const gchar *
-gtk_menu_tracker_item_get_label (GtkMenuTrackerItem *self)
-{
-  const gchar *label = NULL;
-
-  g_menu_item_get_attribute (self->item, G_MENU_ATTRIBUTE_LABEL, "&s", &label);
-
-  return label;
-}
-
-/**
- * gtk_menu_tracker_item_get_icon:
- *
- * Returns: (transfer full):
- */
-GIcon *
-gtk_menu_tracker_item_get_icon (GtkMenuTrackerItem *self)
-{
-  GVariant *icon_data;
-  GIcon *icon;
-
-  icon_data = g_menu_item_get_attribute_value (self->item, "icon", NULL);
-
-  if (icon_data == NULL)
-    return NULL;
-
-  icon = g_icon_deserialize (icon_data);
-  g_variant_unref (icon_data);
-
-  return icon;
-}
-
-gboolean
-gtk_menu_tracker_item_get_sensitive (GtkMenuTrackerItem *self)
-{
-  return self->sensitive;
-}
-
-gboolean
-gtk_menu_tracker_item_get_visible (GtkMenuTrackerItem *self)
-{
-  return TRUE;
-}
-
-GtkMenuTrackerItemRole
-gtk_menu_tracker_item_get_role (GtkMenuTrackerItem *self)
-{
-  return self->role;
-}
-
-gboolean
-gtk_menu_tracker_item_get_toggled (GtkMenuTrackerItem *self)
-{
-  return self->toggled;
-}
-
-const gchar *
-gtk_menu_tracker_item_get_accel (GtkMenuTrackerItem *self)
-{
-  const gchar *accel;
-
-  if (!self->action_and_target)
-    return NULL;
-
-  if (g_menu_item_get_attribute (self->item, "accel", "&s", &accel))
-    return accel;
-
-  if (!GTK_IS_ACTION_MUXER (self->observable))
-    return NULL;
-
-  return gtk_action_muxer_get_primary_accel (GTK_ACTION_MUXER (self->observable), self->action_and_target);
-}
-
-GMenuModel *
-_gtk_menu_tracker_item_get_submenu (GtkMenuTrackerItem *self)
-{
-  return g_menu_item_get_link (self->item, "submenu");
-}
-
-gchar *
-_gtk_menu_tracker_item_get_submenu_namespace (GtkMenuTrackerItem *self)
-{
-  const gchar *namespace;
-
-  if (g_menu_item_get_attribute (self->item, "action-namespace", "&s", &namespace))
-    {
-      if (self->action_namespace)
-        return g_strjoin (".", self->action_namespace, namespace, NULL);
-      else
-        return g_strdup (namespace);
-    }
-  else
-    return g_strdup (self->action_namespace);
-}
-
-gboolean
-gtk_menu_tracker_item_get_should_request_show (GtkMenuTrackerItem *self)
-{
-  return g_menu_item_get_attribute (self->item, "submenu-action", "&s", NULL);
-}
-
-gboolean
-gtk_menu_tracker_item_get_submenu_shown (GtkMenuTrackerItem *self)
-{
-  return self->submenu_shown;
-}
-
-static void
-gtk_menu_tracker_item_set_submenu_shown (GtkMenuTrackerItem *self,
-                                         gboolean            submenu_shown)
-{
-  if (submenu_shown == self->submenu_shown)
-    return;
-
-  self->submenu_shown = submenu_shown;
-  g_object_notify_by_pspec (G_OBJECT (self), gtk_menu_tracker_item_pspecs[PROP_SUBMENU_SHOWN]);
-}
-
-void
-gtk_menu_tracker_item_activated (GtkMenuTrackerItem *self)
-{
-  const gchar *action_name;
-  GVariant *action_target;
-
-  g_return_if_fail (GTK_IS_MENU_TRACKER_ITEM (self));
-
-  if (!self->can_activate)
-    return;
-
-  action_name = strrchr (self->action_and_target, '|') + 1;
-  action_target = g_menu_item_get_attribute_value (self->item, G_MENU_ATTRIBUTE_TARGET, NULL);
-
-  g_action_group_activate_action (G_ACTION_GROUP (self->observable), action_name, action_target);
-
-  if (action_target)
-    g_variant_unref (action_target);
-}
-
-typedef struct
-{
-  GtkMenuTrackerItem *item;
-  gchar              *submenu_action;
-  gboolean            first_time;
-} GtkMenuTrackerOpener;
-
-static void
-gtk_menu_tracker_opener_update (GtkMenuTrackerOpener *opener)
-{
-  GActionGroup *group = G_ACTION_GROUP (opener->item->observable);
-  gboolean is_open = TRUE;
-
-  /* We consider the menu as being "open" if the action does not exist
-   * or if there is another problem (no state, wrong state type, etc.).
-   * If the action exists, with the correct state then we consider it
-   * open if we have ever seen this state equal to TRUE.
-   *
-   * In the event that we see the state equal to FALSE, we force it back
-   * to TRUE.  We do not signal that the menu was closed because this is
-   * likely to create UI thrashing.
-   *
-   * The only way the menu can have a true-to-false submenu-shown
-   * transition is if the user calls _request_submenu_shown (FALSE).
-   * That is handled in _free() below.
-   */
-
-  if (g_action_group_has_action (group, opener->submenu_action))
-    {
-      GVariant *state = g_action_group_get_action_state (group, opener->submenu_action);
-
-      if (state)
-        {
-          if (g_variant_is_of_type (state, G_VARIANT_TYPE_BOOLEAN))
-            is_open = g_variant_get_boolean (state);
-          g_variant_unref (state);
-        }
-    }
-
-  /* If it is already open, signal that.
-   *
-   * If it is not open, ask it to open.
-   */
-  if (is_open)
-    gtk_menu_tracker_item_set_submenu_shown (opener->item, TRUE);
-
-  if (!is_open || opener->first_time)
-    {
-      g_action_group_change_action_state (group, opener->submenu_action, g_variant_new_boolean (TRUE));
-      opener->first_time = FALSE;
-    }
-}
-
-static void
-gtk_menu_tracker_opener_added (GActionGroup *group,
-                               const gchar  *action_name,
-                               gpointer      user_data)
-{
-  GtkMenuTrackerOpener *opener = user_data;
-
-  if (g_str_equal (action_name, opener->submenu_action))
-    gtk_menu_tracker_opener_update (opener);
-}
-
-static void
-gtk_menu_tracker_opener_removed (GActionGroup *action_group,
-                                 const gchar  *action_name,
-                                 gpointer      user_data)
-{
-  GtkMenuTrackerOpener *opener = user_data;
-
-  if (g_str_equal (action_name, opener->submenu_action))
-    gtk_menu_tracker_opener_update (opener);
-}
-
-static void
-gtk_menu_tracker_opener_changed (GActionGroup *action_group,
-                                 const gchar  *action_name,
-                                 GVariant     *new_state,
-                                 gpointer      user_data)
-{
-  GtkMenuTrackerOpener *opener = user_data;
-
-  if (g_str_equal (action_name, opener->submenu_action))
-    gtk_menu_tracker_opener_update (opener);
-}
-
-static void
-gtk_menu_tracker_opener_free (gpointer data)
-{
-  GtkMenuTrackerOpener *opener = data;
-
-  g_signal_handlers_disconnect_by_func (opener->item->observable, gtk_menu_tracker_opener_added, opener);
-  g_signal_handlers_disconnect_by_func (opener->item->observable, gtk_menu_tracker_opener_removed, opener);
-  g_signal_handlers_disconnect_by_func (opener->item->observable, gtk_menu_tracker_opener_changed, opener);
-
-  g_action_group_change_action_state (G_ACTION_GROUP (opener->item->observable),
-                                      opener->submenu_action,
-                                      g_variant_new_boolean (FALSE));
-
-  gtk_menu_tracker_item_set_submenu_shown (opener->item, FALSE);
-
-  g_free (opener->submenu_action);
-
-  g_slice_free (GtkMenuTrackerOpener, opener);
-}
-
-static GtkMenuTrackerOpener *
-gtk_menu_tracker_opener_new (GtkMenuTrackerItem *item,
-                             const gchar        *submenu_action)
-{
-  GtkMenuTrackerOpener *opener;
-
-  opener = g_slice_new (GtkMenuTrackerOpener);
-  opener->first_time = TRUE;
-  opener->item = item;
-
-  if (item->action_namespace)
-    opener->submenu_action = g_strjoin (".", item->action_namespace, submenu_action, NULL);
-  else
-    opener->submenu_action = g_strdup (submenu_action);
-
-  g_signal_connect (item->observable, "action-added", G_CALLBACK (gtk_menu_tracker_opener_added), opener);
-  g_signal_connect (item->observable, "action-removed", G_CALLBACK (gtk_menu_tracker_opener_removed), opener);
-  g_signal_connect (item->observable, "action-state-changed", G_CALLBACK (gtk_menu_tracker_opener_changed), opener);
-
-  gtk_menu_tracker_opener_update (opener);
-
-  return opener;
-}
-
-void
-gtk_menu_tracker_item_request_submenu_shown (GtkMenuTrackerItem *self,
-                                             gboolean            shown)
-{
-  const gchar *submenu_action;
-  gboolean has_submenu_action;
-
-  if (shown == self->submenu_requested)
-    return;
-
-  has_submenu_action = g_menu_item_get_attribute (self->item, "submenu-action", "&s", &submenu_action);
-
-  self->submenu_requested = shown;
-
-  /* If we have a submenu action, start a submenu opener and wait
-   * for the reply from the client. Otherwise, simply open the
-   * submenu immediately.
-   */
-  if (has_submenu_action)
-    {
-      if (shown)
-        g_object_set_data_full (G_OBJECT (self), "submenu-opener",
-                                gtk_menu_tracker_opener_new (self, submenu_action),
-                                gtk_menu_tracker_opener_free);
-      else
-        g_object_set_data (G_OBJECT (self), "submenu-opener", NULL);
-    }
-  else
-    gtk_menu_tracker_item_set_submenu_shown (self, shown);
-}
-
-gboolean
-_gtk_menu_tracker_item_is_visible (GtkMenuTrackerItem *self)
-{
-  return self->is_visible;
-}
-
-gboolean
-_gtk_menu_tracker_item_may_disappear (GtkMenuTrackerItem *self)
-{
-  return self->hidden_when != HIDDEN_NEVER;
-}

src/gtkmenutrackeritem.h

@@ -1,88 +0,0 @@
-/*
- * Copyright © 2011, 2013 Canonical Limited
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the licence, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library. If not, see <http://www.gnu.org/licenses/>.
- *
- * Author: Ryan Lortie <desrt@desrt.ca>
- */
-
-#ifndef __GTK_MENU_TRACKER_ITEM_H__
-#define __GTK_MENU_TRACKER_ITEM_H__
-
-#include "gtkactionobservable.h"
-
-#define GTK_TYPE_MENU_TRACKER_ITEM                          (gtk_menu_tracker_item_get_type ())
-#define GTK_MENU_TRACKER_ITEM(inst)                         (G_TYPE_CHECK_INSTANCE_CAST ((inst), \
-                                                             GTK_TYPE_MENU_TRACKER_ITEM, GtkMenuTrackerItem))
-#define GTK_IS_MENU_TRACKER_ITEM(inst)                      (G_TYPE_CHECK_INSTANCE_TYPE ((inst), \
-                                                             GTK_TYPE_MENU_TRACKER_ITEM))
-
-typedef struct _GtkMenuTrackerItem GtkMenuTrackerItem;
-
-#define GTK_TYPE_MENU_TRACKER_ITEM_ROLE                     (gtk_menu_tracker_item_role_get_type ())
-
-typedef enum  {
-  GTK_MENU_TRACKER_ITEM_ROLE_NORMAL,
-  GTK_MENU_TRACKER_ITEM_ROLE_CHECK,
-  GTK_MENU_TRACKER_ITEM_ROLE_RADIO,
-} GtkMenuTrackerItemRole;
-
-GType                   gtk_menu_tracker_item_get_type                  (void) G_GNUC_CONST;
-
-GType                   gtk_menu_tracker_item_role_get_type             (void) G_GNUC_CONST;
-
-GtkMenuTrackerItem *   _gtk_menu_tracker_item_new                       (GtkActionObservable *observable,
-                                                                         GMenuModel          *model,
-                                                                         gint                 item_index,
-                                                                         const gchar         *action_namespace,
-                                                                         gboolean             is_separator);
-
-GtkActionObservable *  _gtk_menu_tracker_item_get_observable            (GtkMenuTrackerItem *self);
-
-gboolean                gtk_menu_tracker_item_get_is_separator          (GtkMenuTrackerItem *self);
-
-gboolean                gtk_menu_tracker_item_get_has_submenu           (GtkMenuTrackerItem *self);
-
-const gchar *           gtk_menu_tracker_item_get_label                 (GtkMenuTrackerItem *self);
-
-GIcon *                 gtk_menu_tracker_item_get_icon                  (GtkMenuTrackerItem *self);
-
-gboolean                gtk_menu_tracker_item_get_sensitive             (GtkMenuTrackerItem *self);
-
-gboolean                gtk_menu_tracker_item_get_visible               (GtkMenuTrackerItem *self);
-
-GtkMenuTrackerItemRole  gtk_menu_tracker_item_get_role                  (GtkMenuTrackerItem *self);
-
-gboolean                gtk_menu_tracker_item_get_toggled               (GtkMenuTrackerItem *self);
-
-const gchar *           gtk_menu_tracker_item_get_accel                 (GtkMenuTrackerItem *self);
-
-GMenuModel *           _gtk_menu_tracker_item_get_submenu               (GtkMenuTrackerItem *self);
-
-gchar *                _gtk_menu_tracker_item_get_submenu_namespace     (GtkMenuTrackerItem *self);
-
-gboolean               _gtk_menu_tracker_item_may_disappear             (GtkMenuTrackerItem *self);
-
-gboolean               _gtk_menu_tracker_item_is_visible                (GtkMenuTrackerItem *self);
-
-gboolean                gtk_menu_tracker_item_get_should_request_show   (GtkMenuTrackerItem *self);
-
-void                    gtk_menu_tracker_item_activated                 (GtkMenuTrackerItem *self);
-
-void                    gtk_menu_tracker_item_request_submenu_shown     (GtkMenuTrackerItem *self,
-                                                                         gboolean            shown);
-
-gboolean                gtk_menu_tracker_item_get_submenu_shown         (GtkMenuTrackerItem *self);
-
-#endif

src/meson.build

@@ -60,24 +60,17 @@ gnome_shell_deps += recorder_deps
 tools_cflags = '-DLOCALEDIR="@0@"'.format(localedir)
 tools_deps = [gio_dep, gjs_dep]
 
-libshell_menu_gir_sources = [
+libshell_menu_sources = [
   'gtkactionmuxer.h',
   'gtkactionmuxer.c',
   'gtkactionobservable.h',
   'gtkactionobservable.c',
   'gtkactionobserver.h',
-  'gtkactionobserver.c',
+  'gtkactionobserver.c'
-  'gtkmenutrackeritem.c',
-  'gtkmenutrackeritem.h'
-]
-
-libshell_menu_no_gir_sources= [
-  'gtkmenutracker.c',
-  'gtkmenutracker.h'
 ]
 
 libshell_menu = library('gnome-shell-menu',
-  sources: libshell_menu_gir_sources + libshell_menu_no_gir_sources,
+  sources: libshell_menu_sources,
   dependencies: [gio_dep, clutter_dep],
   include_directories: conf_inc,
   build_rpath: mutter_typelibdir,
@@ -86,20 +79,6 @@ libshell_menu = library('gnome-shell-menu',
   install: true
 )
 
-libshell_menu_gir = gnome.generate_gir(libshell_menu,
-  sources: libshell_menu_gir_sources,
-  nsversion: '0.1',
-  namespace: 'ShellMenu',
-  identifier_prefix: 'Gtk',
-  symbol_prefix: 'gtk',
-  includes: ['Gio-2.0', libst_gir[0]],
-  dependencies: [mutter_dep],
-  extra_args: ['--quiet'],
-  install_dir_gir: pkgdatadir,
-  install_dir_typelib: pkglibdir,
-  install: true
-)
-
 libshell_menu_dep = declare_dependency(link_with: libshell_menu)
 
 libshell_public_headers = [
@@ -148,8 +127,6 @@ libshell_sources = [
   'shell-invert-lightness-effect.c',
   'shell-keyring-prompt.c',
   'shell-keyring-prompt.h',
-  'shell-menu-tracker.c',
-  'shell-menu-tracker.h',
   'shell-mount-operation.c',
   'shell-perf-log.c',
   'shell-polkit-authentication-agent.c',
@@ -231,7 +208,6 @@ endif
 
 libshell_gir_includes += [
   libgvc_gir[0],
-  libshell_menu_gir[0],
   libst_gir[0]
 ]
 

src/shell-app.c

@@ -51,7 +51,6 @@ typedef struct {
   guint window_sort_stale : 1;
 
   /* See GApplication documentation */
-  GDBusMenuModel   *remote_menu;
   GtkActionMuxer   *muxer;
   char             *unique_bus_name;
   GDBusConnection  *session;
@@ -98,7 +97,6 @@ enum {
   PROP_ID,
   PROP_DBUS_ID,
   PROP_ACTION_GROUP,
-  PROP_MENU,
   PROP_APP_INFO
 };
 
@@ -137,10 +135,6 @@ shell_app_get_property (GObject    *gobject,
       if (app->running_state)
         g_value_set_object (value, app->running_state->muxer);
       break;
-    case PROP_MENU:
-      if (app->running_state)
-        g_value_set_object (value, app->running_state->remote_menu);
-      break;
     case PROP_APP_INFO:
       if (app->info)
         g_value_set_object (value, app->info);
@@ -608,6 +602,7 @@ gboolean
 shell_app_can_open_new_window (ShellApp *app)
 {
   ShellAppRunningState *state;
+  MetaWindow *window;
 
   /* Apps that are not running can always open new windows, because
      activating them would open the first one */
@@ -641,11 +636,13 @@ shell_app_can_open_new_window (ShellApp *app)
      Activate() knows nothing about the other instances, so it will show a
      new window.
   */
-  if (state->remote_menu)
+
+  window = g_slist_nth_data (state->windows, 0);
+
+  if (state->unique_bus_name != NULL &&
+      meta_window_get_gtk_application_object_path (window) != NULL)
     {
-      const char *application_id;
+      if (meta_window_get_gtk_application_id (window) != NULL)
-      application_id = meta_window_get_gtk_application_id (state->windows->data);
-      if (application_id != NULL)
         return FALSE;
       else
         return TRUE;
@@ -1078,7 +1075,7 @@ _shell_app_add_window (ShellApp        *app,
   g_signal_connect (window, "notify::user-time", G_CALLBACK(shell_app_on_user_time_changed), app);
   g_signal_connect (window, "notify::skip-taskbar", G_CALLBACK(shell_app_on_skip_taskbar_changed), app);
 
-  shell_app_update_app_menu (app, window);
+  shell_app_update_app_actions (app, window);
   shell_app_ensure_busy_watch (app);
 
   if (!meta_window_is_skip_taskbar (window))
@@ -1380,8 +1377,8 @@ create_running_state (ShellApp *app)
 }
 
 void
-shell_app_update_app_menu (ShellApp   *app,
+shell_app_update_app_actions (ShellApp   *app,
-                           MetaWindow *window)
+                              MetaWindow *window)
 {
   const gchar *unique_bus_name;
 
@@ -1397,23 +1394,18 @@ shell_app_update_app_menu (ShellApp   *app,
 
   unique_bus_name = meta_window_get_gtk_unique_bus_name (window);
 
-  if (app->running_state->remote_menu == NULL ||
+  if (g_strcmp0 (app->running_state->unique_bus_name, unique_bus_name) != 0)
-      g_strcmp0 (app->running_state->unique_bus_name, unique_bus_name) != 0)
     {
       const gchar *application_object_path;
-      const gchar *app_menu_object_path;
       GDBusActionGroup *actions;
 
       application_object_path = meta_window_get_gtk_application_object_path (window);
-      app_menu_object_path = meta_window_get_gtk_app_menu_object_path (window);
 
-      if (application_object_path == NULL || app_menu_object_path == NULL || unique_bus_name == NULL)
+      if (application_object_path == NULL || unique_bus_name == NULL)
         return;
 
       g_clear_pointer (&app->running_state->unique_bus_name, g_free);
       app->running_state->unique_bus_name = g_strdup (unique_bus_name);
-      g_clear_object (&app->running_state->remote_menu);
-      app->running_state->remote_menu = g_dbus_menu_model_get (app->running_state->session, unique_bus_name, app_menu_object_path);
       actions = g_dbus_action_group_get (app->running_state->session, unique_bus_name, application_object_path);
       gtk_action_muxer_insert (app->running_state->muxer, "app", G_ACTION_GROUP (actions));
       g_object_unref (actions);
@@ -1443,11 +1435,9 @@ unref_running_state (ShellAppRunningState *state)
       g_clear_object (&state->cancellable);
     }
 
-  g_clear_object (&state->remote_menu);
   g_clear_object (&state->muxer);
   g_clear_object (&state->session);
   g_clear_pointer (&state->unique_bus_name, g_free);
-  g_clear_pointer (&state->remote_menu, g_free);
 
   g_slice_free (ShellAppRunningState, state);
 }
@@ -1575,19 +1565,6 @@ shell_app_class_init(ShellAppClass *klass)
                                                         "The action group exported by the remote application",
                                                         G_TYPE_ACTION_GROUP,
                                                         G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
-  /**
-   * ShellApp:menu:
-   *
-   * The #GMenuProxy associated with this ShellApp, if any. See the
-   * documentation of #GMenuModel for details.
-   */
-  g_object_class_install_property (gobject_class,
-                                   PROP_MENU,
-                                   g_param_spec_object ("menu",
-                                                        "Application Menu",
-                                                        "The primary menu exported by the remote application",
-                                                        G_TYPE_MENU_MODEL,
-                                                        G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
   /**
    * ShellApp:app-info:
    *

src/shell-app.h

@@ -67,7 +67,7 @@ int shell_app_compare_by_name (ShellApp *app, ShellApp *other);
 int shell_app_compare (ShellApp *app, ShellApp *other);
 
 void shell_app_update_window_actions (ShellApp *app, MetaWindow *window);
-void shell_app_update_app_menu       (ShellApp *app, MetaWindow *window);
+void shell_app_update_app_actions    (ShellApp *app, MetaWindow *window);
 
 gboolean shell_app_get_busy          (ShellApp *app);
 

src/shell-menu-tracker.c

@@ -1,166 +0,0 @@
-/*
- * Copyright (C) 2013 Red Hat
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- *
- * Written by:
- *     Jasper St. Pierre <jstpierre@mecheye.net>
- */
-
-#include "config.h"
-
-#include "shell-menu-tracker.h"
-#include "gtkmenutracker.h"
-
-/**
- * SECTION:shell-menu-tracker
- * @short_description: a simple wrapper around #GtkMenuTracker
- *                     to make it bindable.
- */
-
-struct _ShellMenuTracker
-{
-  guint ref_count;
-
-  GtkMenuTracker *tracker;
-
-  ShellMenuTrackerInsertFunc insert_func;
-  gpointer insert_user_data;
-  GDestroyNotify insert_notify;
-  ShellMenuTrackerRemoveFunc remove_func;
-  gpointer remove_user_data;
-  GDestroyNotify remove_notify;
-};
-
-static void
-shell_menu_tracker_insert_func (GtkMenuTrackerItem *item,
-                                gint position,
-                                gpointer user_data)
-{
-  ShellMenuTracker *tracker = (ShellMenuTracker *) user_data;
-  tracker->insert_func (item, position, tracker->insert_user_data);
-}
-
-static void
-shell_menu_tracker_remove_func (gint position,
-                                gpointer user_data)
-{
-  ShellMenuTracker *tracker = (ShellMenuTracker *) user_data;
-  tracker->remove_func (position, tracker->remove_user_data);
-}
-
-/**
- * shell_menu_tracker_new:
- * @observable:
- * @model:
- * @action_namespace: (nullable):
- * @insert_func:
- * @insert_user_data:
- * @insert_notify:
- * @remove_func:
- * @remove_user_data:
- * @remove_notify:
- */
-ShellMenuTracker *
-shell_menu_tracker_new (GtkActionObservable        *observable,
-                        GMenuModel                 *model,
-                        const gchar                *action_namespace,
-                        ShellMenuTrackerInsertFunc  insert_func,
-                        gpointer                    insert_user_data,
-                        GDestroyNotify              insert_notify,
-                        ShellMenuTrackerRemoveFunc  remove_func,
-                        gpointer                    remove_user_data,
-                        GDestroyNotify              remove_notify)
-{
-  ShellMenuTracker *tracker = g_slice_new0 (ShellMenuTracker);
-
-  tracker->ref_count = 1;
-  tracker->insert_func = insert_func;
-  tracker->insert_user_data = insert_user_data;
-  tracker->insert_notify = insert_notify;
-  tracker->remove_func = remove_func;
-  tracker->remove_user_data = remove_user_data;
-  tracker->remove_notify = remove_notify;
-
-  tracker->tracker = gtk_menu_tracker_new (observable,
-                                           model,
-                                           TRUE, /* with separators */
-                                           action_namespace,
-                                           shell_menu_tracker_insert_func,
-                                           shell_menu_tracker_remove_func,
-                                           tracker);
-
-  return tracker;
-}
-
-ShellMenuTracker *
-shell_menu_tracker_new_for_item_submenu (GtkMenuTrackerItem         *item,
-                                         ShellMenuTrackerInsertFunc  insert_func,
-                                         gpointer                    insert_user_data,
-                                         GDestroyNotify              insert_notify,
-                                         ShellMenuTrackerRemoveFunc  remove_func,
-                                         gpointer                    remove_user_data,
-                                         GDestroyNotify              remove_notify)
-{
-  ShellMenuTracker *tracker = g_slice_new0 (ShellMenuTracker);
-
-  tracker->ref_count = 1;
-  tracker->insert_func = insert_func;
-  tracker->insert_user_data = insert_user_data;
-  tracker->insert_notify = insert_notify;
-  tracker->remove_func = remove_func;
-  tracker->remove_user_data = remove_user_data;
-  tracker->remove_notify = remove_notify;
-
-  tracker->tracker = gtk_menu_tracker_new_for_item_submenu (item,
-                                                            shell_menu_tracker_insert_func,
-                                                            shell_menu_tracker_remove_func,
-                                                            tracker);
-
-  return tracker;
-}
-
-ShellMenuTracker *
-shell_menu_tracker_ref (ShellMenuTracker *tracker)
-{
-  tracker->ref_count++;
-  return tracker;
-}
-
-void
-shell_menu_tracker_unref (ShellMenuTracker *tracker)
-{
-  if (tracker->ref_count-- <= 0)
-    {
-      shell_menu_tracker_destroy (tracker);
-      g_slice_free (ShellMenuTracker, tracker);
-    }
-}
-
-void
-shell_menu_tracker_destroy (ShellMenuTracker *tracker)
-{
-  if (tracker->tracker != NULL)
-    {
-      gtk_menu_tracker_free (tracker->tracker);
-      tracker->tracker = NULL;
-      tracker->insert_notify (tracker->insert_user_data);
-      tracker->remove_notify (tracker->remove_user_data);
-    }
-}
-
-G_DEFINE_BOXED_TYPE(ShellMenuTracker,
-                    shell_menu_tracker,
-                    shell_menu_tracker_ref,
-                    shell_menu_tracker_unref)

src/shell-menu-tracker.h

@@ -1,60 +0,0 @@
-/*
- * Copyright (C) 2013 Red Hat
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- *
- * Written by:
- *     Jasper St. Pierre <jstpierre@mecheye.net>
- */
-
-#ifndef __SHELL_MENU_TRACKER_H__
-#define __SHELL_MENU_TRACKER_H__
-
-#include <gio/gio.h>
-
-#include "gtkmenutrackeritem.h"
-
-typedef struct _ShellMenuTracker ShellMenuTracker;
-
-GType shell_menu_tracker_get_type (void) G_GNUC_CONST;
-
-typedef void         (* ShellMenuTrackerInsertFunc)       (GtkMenuTrackerItem       *item,
-                                                           gint                      position,
-                                                           gpointer                  user_data);
-
-typedef void         (* ShellMenuTrackerRemoveFunc)       (gint                      position,
-                                                           gpointer                  user_data);
-
-ShellMenuTracker * shell_menu_tracker_new (GtkActionObservable        *observable,
-                                           GMenuModel                 *model,
-                                           const gchar                *action_namespace,
-                                           ShellMenuTrackerInsertFunc  insert_func,
-                                           gpointer                    insert_user_data,
-                                           GDestroyNotify              insert_notify,
-                                           ShellMenuTrackerRemoveFunc  remove_func,
-                                           gpointer                    remove_user_data,
-                                           GDestroyNotify              remove_notify);
-ShellMenuTracker * shell_menu_tracker_new_for_item_submenu (GtkMenuTrackerItem         *item,
-                                                            ShellMenuTrackerInsertFunc  insert_func,
-                                                            gpointer                    insert_user_data,
-                                                            GDestroyNotify              insert_notify,
-                                                            ShellMenuTrackerRemoveFunc  remove_func,
-                                                            gpointer                    remove_user_data,
-                                                            GDestroyNotify              remove_notify);
-
-ShellMenuTracker * shell_menu_tracker_ref (ShellMenuTracker *tracker);
-void shell_menu_tracker_unref (ShellMenuTracker *tracker);
-void shell_menu_tracker_destroy (ShellMenuTracker *tracker);
-
-#endif /* __SHELL_MENU_TRACKER_H__ */

src/shell-window-tracker.c

@@ -478,7 +478,7 @@ update_focus_app (ShellWindowTracker *self)
   if (new_focus_app)
     {
       shell_app_update_window_actions (new_focus_app, new_focus_win);
-      shell_app_update_app_menu (new_focus_app, new_focus_win);
+      shell_app_update_app_actions (new_focus_app, new_focus_win);
     }
 
   set_focus_app (self, new_focus_app);