* 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, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Author: Ryan Lortie <desrt@desrt.ca>
*/
#include <string.h>
#include "gtkapplicationprivate.h"
+#include "gtkclipboard.h"
#include "gtkmarshalers.h"
#include "gtkmain.h"
+#include "gtkrecentmanager.h"
#include "gtkaccelmapprivate.h"
-#include "gactionmuxer.h"
#include "gtkintl.h"
#ifdef GDK_WINDOWING_QUARTZ
-#include "gtkquartz-menu.h"
+#include "gtkmodelmenu-quartz.h"
#import <Cocoa/Cocoa.h>
#include <Carbon/Carbon.h>
+#include "gtkmessagedialog.h"
#endif
#include <gdk/gdk.h>
#include <gdk/x11/gdkx.h>
#endif
+extern void _gtk_accessibility_shutdown (void);
+
/**
* SECTION:gtkapplication
* @title: GtkApplication
* associated with #GtkApplicationWindow and to the 'activate' and
* 'open' #GApplication methods.
*
- * To set an application menu on a GtkApplication, use
+ * To set an application menu for a GtkApplication, use
* gtk_application_set_app_menu(). The #GMenuModel that this function
* expects is usually constructed using #GtkBuilder, as seen in the
- * following example. To set a menubar that will be automatically picked
- * up by #GApplicationWindows, use gtk_application_set_menubar(). GTK+
- * makes these menus appear as expected, depending on the platform
+ * following example. To specify a menubar that will be shown by
+ * #GtkApplicationWindows, use gtk_application_set_menubar(). Use the base
+ * #GActionMap interface to add actions, to respond to the user
+ * selecting these menu items.
+ *
+ * GTK+ displays these menus as expected, depending on the platform
* the application is running on.
*
* <figure label="Menu integration in OS X">
* </example>
*
* GtkApplication optionally registers with a session manager
- * of the users session (if you set the #GtkApplication::register-session
+ * of the users session (if you set the #GtkApplication:register-session
* property) and offers various functionality related to the session
* life-cycle.
*
- * An application can be informed when the session is about to end
- * by connecting to the #GtkApplication::quit signal.
- *
- * An application can request the session to be ended by calling
- * gtk_application_end_session().
- *
* An application can block various ways to end the session with
* the gtk_application_inhibit() function. Typical use cases for
* this kind of inhibiting are long-running, uninterruptible operations,
enum {
WINDOW_ADDED,
WINDOW_REMOVED,
- QUIT,
LAST_SIGNAL
};
enum {
PROP_ZERO,
- PROP_REGISTER_SESSION
+ PROP_REGISTER_SESSION,
+ PROP_APP_MENU,
+ PROP_MENUBAR,
+ PROP_ACTIVE_WINDOW
};
G_DEFINE_TYPE (GtkApplication, gtk_application, G_TYPE_APPLICATION)
gboolean register_session;
+ GMenuModel *app_menu;
+ GMenuModel *menubar;
+
#ifdef GDK_WINDOWING_X11
GDBusConnection *session_bus;
- gchar *window_prefix;
+ const gchar *application_id;
+ const gchar *object_path;
+
+ gchar *app_menu_path;
+ guint app_menu_id;
+
+ gchar *menubar_path;
+ guint menubar_id;
+
guint next_id;
GDBusProxy *sm_proxy;
#endif
#ifdef GDK_WINDOWING_QUARTZ
- GActionMuxer *muxer;
GMenu *combined;
- GHashTable *inhibitors;
+ GSList *inhibitors;
gint quit_inhibit;
guint next_cookie;
#endif
};
#ifdef GDK_WINDOWING_X11
+static void
+gtk_application_x11_publish_menu (GtkApplication *application,
+ const gchar *type,
+ GMenuModel *model,
+ guint *id,
+ gchar **path)
+{
+ gint i;
+
+ if (application->priv->session_bus == NULL)
+ return;
+
+ /* unexport any existing menu */
+ if (*id)
+ {
+ g_dbus_connection_unexport_menu_model (application->priv->session_bus, *id);
+ g_free (*path);
+ *path = NULL;
+ *id = 0;
+ }
+
+ /* export the new menu, if there is one */
+ if (model != NULL)
+ {
+ /* try getting the preferred name */
+ *path = g_strconcat (application->priv->object_path, "/menus/", type, NULL);
+ *id = g_dbus_connection_export_menu_model (application->priv->session_bus, *path, model, NULL);
+
+ /* keep trying until we get a working name... */
+ for (i = 0; *id == 0; i++)
+ {
+ g_free (*path);
+ *path = g_strdup_printf ("%s/menus/%s%d", application->priv->object_path, type, i);
+ *id = g_dbus_connection_export_menu_model (application->priv->session_bus, *path, model, NULL);
+ }
+ }
+}
+
+static void
+gtk_application_set_app_menu_x11 (GtkApplication *application,
+ GMenuModel *app_menu)
+{
+ gtk_application_x11_publish_menu (application, "appmenu", app_menu,
+ &application->priv->app_menu_id,
+ &application->priv->app_menu_path);
+}
+
+static void
+gtk_application_set_menubar_x11 (GtkApplication *application,
+ GMenuModel *menubar)
+{
+ gtk_application_x11_publish_menu (application, "menubar", menubar,
+ &application->priv->menubar_id,
+ &application->priv->menubar_path);
+}
+
static void
gtk_application_window_added_x11 (GtkApplication *application,
GtkWindow *window)
guint window_id;
window_id = application->priv->next_id++;
- window_path = g_strdup_printf ("%s%d", application->priv->window_prefix, window_id);
- success = gtk_application_window_publish (app_window, application->priv->session_bus, window_path);
+ window_path = g_strdup_printf ("%s/window/%u", application->priv->object_path, window_id);
+ success = gtk_application_window_publish (app_window, application->priv->session_bus, window_path, window_id);
g_free (window_path);
}
while (!success);
gtk_application_window_unpublish (GTK_APPLICATION_WINDOW (window));
}
-static gchar *
-window_prefix_from_appid (const gchar *appid)
-{
- gchar *appid_path, *iter;
-
- appid_path = g_strconcat ("/", appid, "/windows/", NULL);
- for (iter = appid_path; *iter; iter++)
- {
- if (*iter == '.')
- *iter = '/';
-
- if (*iter == '-')
- *iter = '_';
- }
-
- return appid_path;
-}
-
static void gtk_application_startup_session_dbus (GtkApplication *app);
static void
gtk_application_startup_x11 (GtkApplication *application)
{
- const gchar *application_id;
-
- application_id = g_application_get_application_id (G_APPLICATION (application));
- application->priv->session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
- application->priv->window_prefix = window_prefix_from_appid (application_id);
+ application->priv->session_bus = g_application_get_dbus_connection (G_APPLICATION (application));
+ application->priv->object_path = g_application_get_dbus_object_path (G_APPLICATION (application));
gtk_application_startup_session_dbus (GTK_APPLICATION (application));
}
static void
gtk_application_shutdown_x11 (GtkApplication *application)
{
- g_free (application->priv->window_prefix);
- application->priv->window_prefix = NULL;
- g_clear_object (&application->priv->session_bus);
+ gtk_application_set_app_menu_x11 (application, NULL);
+ gtk_application_set_menubar_x11 (application, NULL);
+
+ application->priv->session_bus = NULL;
+ application->priv->object_path = NULL;
g_clear_object (&application->priv->sm_proxy);
g_clear_object (&application->priv->client_proxy);
g_free (application->priv->app_id);
g_free (application->priv->client_path);
}
+
+const gchar *
+gtk_application_get_app_menu_object_path (GtkApplication *application)
+{
+ return application->priv->app_menu_path;
+}
+
+const gchar *
+gtk_application_get_menubar_object_path (GtkApplication *application)
+{
+ return application->priv->menubar_path;
+}
+
#endif
#ifdef GDK_WINDOWING_QUARTZ
+
+typedef struct {
+ guint cookie;
+ GtkApplicationInhibitFlags flags;
+ char *reason;
+ GtkWindow *window;
+} GtkApplicationQuartzInhibitor;
+
+static void
+gtk_application_quartz_inhibitor_free (GtkApplicationQuartzInhibitor *inhibitor)
+{
+ g_free (inhibitor->reason);
+ g_clear_object (&inhibitor->window);
+ g_slice_free (GtkApplicationQuartzInhibitor, inhibitor);
+}
+
static void
gtk_application_menu_changed_quartz (GObject *object,
GParamSpec *pspec,
g_menu_append_submenu (combined, "Application", gtk_application_get_app_menu (application));
g_menu_append_section (combined, NULL, gtk_application_get_menubar (application));
- gtk_quartz_set_main_menu (G_MENU_MODEL (combined), G_ACTION_OBSERVABLE (application->priv->muxer));
+ gtk_quartz_set_main_menu (G_MENU_MODEL (combined), application);
+
+ g_object_unref (combined);
}
static void gtk_application_startup_session_quartz (GtkApplication *app);
{
[NSApp finishLaunching];
- application->priv->muxer = g_action_muxer_new ();
- g_action_muxer_insert (application->priv->muxer, "app", G_ACTION_GROUP (application));
-
g_signal_connect (application, "notify::app-menu", G_CALLBACK (gtk_application_menu_changed_quartz), NULL);
g_signal_connect (application, "notify::menubar", G_CALLBACK (gtk_application_menu_changed_quartz), NULL);
gtk_application_menu_changed_quartz (G_OBJECT (application), NULL, NULL);
static void
gtk_application_shutdown_quartz (GtkApplication *application)
{
- g_signal_handlers_disconnect_by_func (application, gtk_application_menu_changed_quartz, NULL);
+ gtk_quartz_clear_main_menu ();
- g_object_unref (application->priv->muxer);
- application->priv->muxer = NULL;
-
- g_hash_table_unref (application->priv->inhibitors);
-}
+ g_signal_handlers_disconnect_by_func (application, gtk_application_menu_changed_quartz, NULL);
-static void
-gtk_application_focus_changed (GtkApplication *application,
- GtkWindow *window)
-{
- if (G_IS_ACTION_GROUP (window))
- g_action_muxer_insert (application->priv->muxer, "win", G_ACTION_GROUP (window));
- else
- g_action_muxer_remove (application->priv->muxer, "win");
+ g_slist_free_full (application->priv->inhibitors,
+ (GDestroyNotify) gtk_application_quartz_inhibitor_free);
+ application->priv->inhibitors = NULL;
}
#endif
priv->windows = g_list_concat (link, priv->windows);
}
-#ifdef GDK_WINDOWING_QUARTZ
- gtk_application_focus_changed (application, window);
-#endif
+ g_object_notify (G_OBJECT (application), "active-window");
return FALSE;
}
gtk_application_shutdown_quartz (GTK_APPLICATION (application));
#endif
+ /* Keep this section in sync with gtk_main() */
+
+ /* Try storing all clipboard data we have */
+ _gtk_clipboard_store_all ();
+
+ /* Synchronize the recent manager singleton */
+ _gtk_recent_manager_sync ();
+
+ _gtk_accessibility_shutdown ();
+
G_APPLICATION_CLASS (gtk_application_parent_class)
->shutdown (application);
}
application->priv = G_TYPE_INSTANCE_GET_PRIVATE (application,
GTK_TYPE_APPLICATION,
GtkApplicationPrivate);
+
+#ifdef GDK_WINDOWING_X11
+ application->priv->next_id = 1;
+#endif
}
static void
#ifdef GDK_WINDOWING_X11
gtk_application_window_added_x11 (application, window);
#endif
+
+ g_object_notify (G_OBJECT (application), "active-window");
}
static void
GtkWindow *window)
{
GtkApplicationPrivate *priv = application->priv;
+ gpointer old_active;
+
+ old_active = priv->windows;
#ifdef GDK_WINDOWING_X11
gtk_application_window_removed_x11 (application, window);
g_application_release (G_APPLICATION (application));
priv->windows = g_list_remove (priv->windows, window);
gtk_window_set_application (window, NULL);
+
+ if (priv->windows != old_active)
+ g_object_notify (G_OBJECT (application), "active-window");
}
static void
}
}
-static void
-gtk_application_notify (GObject *object,
- GParamSpec *pspec)
-{
- if (strcmp (pspec->name, "app-menu") == 0 ||
- strcmp (pspec->name, "menubar") == 0)
- {
- GMenuModel *model;
- g_object_get (object, pspec->name, &model, NULL);
- if (model)
- {
- extract_accels_from_menu (model, GTK_APPLICATION (object));
- g_object_unref (model);
- }
- }
-
- if (G_OBJECT_CLASS (gtk_application_parent_class)->notify)
- G_OBJECT_CLASS (gtk_application_parent_class)->notify (object, pspec);
-}
-
static void
gtk_application_get_property (GObject *object,
guint prop_id,
g_value_set_boolean (value, application->priv->register_session);
break;
+ case PROP_APP_MENU:
+ g_value_set_object (value, gtk_application_get_app_menu (application));
+ break;
+
+ case PROP_MENUBAR:
+ g_value_set_object (value, gtk_application_get_menubar (application));
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
application->priv->register_session = g_value_get_boolean (value);
break;
+ case PROP_APP_MENU:
+ gtk_application_set_app_menu (application, g_value_get_object (value));
+ break;
+
+ case PROP_MENUBAR:
+ gtk_application_set_menubar (application, g_value_get_object (value));
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
static void
-gtk_application_quit (GtkApplication *app)
+gtk_application_finalize (GObject *object)
{
- /* we are asked to quit, so don't linger */
- g_application_set_inactivity_timeout (G_APPLICATION (app), 0);
+ GtkApplication *application = GTK_APPLICATION (object);
+
+ g_clear_object (&application->priv->app_menu);
+ g_clear_object (&application->priv->menubar);
+
+ G_OBJECT_CLASS (gtk_application_parent_class)
+ ->finalize (object);
}
static void
object_class->get_property = gtk_application_get_property;
object_class->set_property = gtk_application_set_property;
- object_class->notify = gtk_application_notify;
+ object_class->finalize = gtk_application_finalize;
application_class->add_platform_data = gtk_application_add_platform_data;
application_class->before_emit = gtk_application_before_emit;
class->window_added = gtk_application_window_added;
class->window_removed = gtk_application_window_removed;
- class->quit = gtk_application_quit;
g_type_class_add_private (class, sizeof (GtkApplicationPrivate));
G_TYPE_NONE, 1, GTK_TYPE_WINDOW);
/**
- * GtkApplication::quit:
- * @application: the #GtkApplication
- *
- * Emitted when the session manager wants the application to quit
- * (generally because the user is logging out). The application
- * should exit as soon as possible after receiving this signal; if
- * it does not, the session manager may choose to forcibly kill it.
- *
- * Normally, an application would only be sent a ::quit if there
- * are no inhibitors (see gtk_application_inhibit()).
- * However, this is not guaranteed; in some situations the
- * session manager may decide to end the session without giving
- * applications a chance to object.
- *
- * To receive this signal, you need to set the
- * #GtkApplication::register-session property
- * when creating the application object.
- *
- * Since: 3.4
- */
- gtk_application_signals[QUIT] =
- g_signal_new ("quit", GTK_TYPE_APPLICATION, G_SIGNAL_RUN_FIRST,
- G_STRUCT_OFFSET (GtkApplicationClass, quit),
- NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
-
- /**
- * GtkApplication::register-session:
+ * GtkApplication:register-session:
*
- * Set this property to %TRUE to register with the session manager
- * and receive the #GtkApplication::quit signal when the session
- * is about to end.
+ * Set this property to %TRUE to register with the session manager.
*
* Since: 3.4
*/
P_("Register session"),
P_("Register with the session manager"),
FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (object_class, PROP_APP_MENU,
+ g_param_spec_object ("app-menu",
+ P_("Application menu"),
+ P_("The GMenuModel for the application menu"),
+ G_TYPE_MENU_MODEL,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (object_class, PROP_MENUBAR,
+ g_param_spec_object ("menubar",
+ P_("Menubar"),
+ P_("The GMenuModel for the menubar"),
+ G_TYPE_MENU_MODEL,
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+ g_object_class_install_property (object_class, PROP_ACTIVE_WINDOW,
+ g_param_spec_object ("active-window",
+ P_("Active window"),
+ P_("The window which most recently had focus"),
+ GTK_TYPE_WINDOW,
+ G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
}
/**
* gtk_application_new:
- * @application_id: the application id
+ * @application_id: (allow-none): The application ID.
* @flags: the application flags
*
* Creates a new #GtkApplication instance.
*
- * This function calls g_type_init() for you. gtk_init() is called
- * as soon as the application gets registered as the primary instance.
+ * When using #GtkApplication, it is not necessary to call gtk_init()
+ * manually. It is called as soon as the application gets registered as
+ * the primary instance.
+ *
+ * Concretely, gtk_init() is called in the default handler for the
+ * #GApplication::startup signal. Therefore, #GtkApplication subclasses should
+ * chain up in their #GApplication:startup handler before using any GTK+ API.
*
* Note that commandline arguments are not passed to gtk_init().
* All GTK+ functionality that is available via commandline arguments
* can also be achieved by setting suitable environment variables
- * such as <envvar>G_DEBUG</envvar>, so this should not be a big
+ * such as <envar>G_DEBUG</envar>, so this should not be a big
* problem. If you absolutely must support GTK+ commandline arguments,
* you can explicitly call gtk_init() before creating the application
* instance.
*
- * The application id must be valid. See g_application_id_is_valid().
+ * If non-%NULL, the application ID must be valid. See
+ * g_application_id_is_valid().
+ *
+ * If no application ID is given then some features (most notably application
+ * uniqueness) will be disabled. A null application ID is only allowed with
+ * GTK+ 3.6 or later.
*
* Returns: a new #GtkApplication instance
+ *
+ * Since: 3.0
*/
GtkApplication *
gtk_application_new (const gchar *application_id,
GApplicationFlags flags)
{
- g_return_val_if_fail (g_application_id_is_valid (application_id), NULL);
-
- g_type_init ();
+ g_return_val_if_fail (application_id == NULL || g_application_id_is_valid (application_id), NULL);
return g_object_new (GTK_TYPE_APPLICATION,
"application-id", application_id,
* @application: a #GtkApplication
* @window: a #GtkWindow
*
- * Adds a window from @application.
+ * Adds a window to @application.
*
* This call is equivalent to setting the #GtkWindow:application
* property of @window to @application.
return application->priv->windows;
}
+/**
+ * gtk_application_get_window_by_id:
+ * @application: a #GtkApplication
+ * @id: an identifier number
+ *
+ * Returns the #GtkApplicationWindow with the given ID.
+ *
+ * Returns: (transfer none): the window with ID @id, or
+ * %NULL if there is no window with this ID
+ *
+ * Since: 3.6
+ */
+GtkWindow *
+gtk_application_get_window_by_id (GtkApplication *application,
+ guint id)
+{
+ GList *l;
+
+ g_return_val_if_fail (GTK_IS_APPLICATION (application), NULL);
+
+ for (l = application->priv->windows; l != NULL; l = l->next)
+ {
+ if (GTK_IS_APPLICATION_WINDOW (l->data) &&
+ gtk_application_window_get_id (GTK_APPLICATION_WINDOW (l->data)) == id)
+ return l->data;
+ }
+
+ return NULL;
+}
+
+/**
+ * gtk_application_get_active_window:
+ * @application: a #GtkApplication
+ *
+ * Gets the "active" window for the application.
+ *
+ * The active window is the one that was most recently focused (within
+ * the application). This window may not have the focus at the moment
+ * if another application has it -- this is just the most
+ * recently-focused window within this application.
+ *
+ * Returns: (transfer none): the active window
+ *
+ * Since: 3.6
+ **/
+GtkWindow *
+gtk_application_get_active_window (GtkApplication *application)
+{
+ g_return_val_if_fail (GTK_IS_APPLICATION (application), NULL);
+
+ return application->priv->windows ? application->priv->windows->data : NULL;
+}
+
/**
* gtk_application_add_accelerator:
* @application: a #GtkApplication
* is pressed.
*
* @accelerator must be a string that can be parsed by
- * gtk_accelerator_parse(), e.g. "<Primary>q" or "<Control><Alt>p".
+ * gtk_accelerator_parse(), e.g. "<Primary>q" or
+ * "<Control><Alt>p".
*
* @action_name must be the name of an action as it would be used
* in the app menu, i.e. actions that have been added to the application
/**
* gtk_application_set_app_menu:
* @application: a #GtkApplication
- * @model: (allow-none): a #GMenuModel, or %NULL
+ * @app_menu: (allow-none): a #GMenuModel, or %NULL
*
* Sets or unsets the application menu for @application.
*
+ * This can only be done in the primary instance of the application,
+ * after it has been registered. #GApplication:startup is a good place
+ * to call this.
+ *
* The application menu is a single menu containing items that typically
* impact the application as a whole, rather than acting on a specific
* window or document. For example, you would expect to see
* If supported, the application menu will be rendered by the desktop
* environment.
*
+ * Use the base #GActionMap interface to add actions, to respond to the user
+ * selecting these menu items.
+ *
* Since: 3.4
*/
void
gtk_application_set_app_menu (GtkApplication *application,
- GMenuModel *model)
+ GMenuModel *app_menu)
{
- g_object_set (application, "app-menu", model, NULL);
+ g_return_if_fail (GTK_IS_APPLICATION (application));
+ g_return_if_fail (g_application_get_is_registered (G_APPLICATION (application)));
+ g_return_if_fail (!g_application_get_is_remote (G_APPLICATION (application)));
+
+ if (app_menu != application->priv->app_menu)
+ {
+ if (application->priv->app_menu != NULL)
+ g_object_unref (application->priv->app_menu);
+
+ application->priv->app_menu = app_menu;
+
+ if (application->priv->app_menu != NULL)
+ g_object_ref (application->priv->app_menu);
+
+ if (app_menu)
+ extract_accels_from_menu (app_menu, application);
+
+#ifdef GDK_WINDOWING_X11
+ gtk_application_set_app_menu_x11 (application, app_menu);
+#endif
+
+ g_object_notify (G_OBJECT (application), "app-menu");
+ }
}
/**
GMenuModel *
gtk_application_get_app_menu (GtkApplication *application)
{
- GMenuModel *app_menu = NULL;
-
- g_object_get (application, "app-menu", &app_menu, NULL);
-
- if (app_menu)
- g_object_unref (app_menu);
+ g_return_val_if_fail (GTK_IS_APPLICATION (application), NULL);
- return app_menu;
+ return application->priv->app_menu;
}
/**
* gtk_application_set_menubar:
* @application: a #GtkApplication
- * @model: (allow-none): a #GMenuModel, or %NULL
+ * @menubar: (allow-none): a #GMenuModel, or %NULL
*
* Sets or unsets the menubar for windows of @application.
*
* This is a menubar in the traditional sense.
*
+ * This can only be done in the primary instance of the application,
+ * after it has been registered. #GApplication:startup is a good place
+ * to call this.
+ *
* Depending on the desktop environment, this may appear at the top of
* each window, or at the top of the screen. In some environments, if
* both the application menu and the menubar are set, the application
* example, the application menu may be rendered by the desktop shell
* while the menubar (if set) remains in each individual window.
*
+ * Use the base #GActionMap interface to add actions, to respond to the user
+ * selecting these menu items.
+ *
* Since: 3.4
*/
void
gtk_application_set_menubar (GtkApplication *application,
- GMenuModel *model)
+ GMenuModel *menubar)
{
- g_object_set (application, "menubar", model, NULL);
+ g_return_if_fail (GTK_IS_APPLICATION (application));
+ g_return_if_fail (g_application_get_is_registered (G_APPLICATION (application)));
+ g_return_if_fail (!g_application_get_is_remote (G_APPLICATION (application)));
+
+ if (menubar != application->priv->menubar)
+ {
+ if (application->priv->menubar != NULL)
+ g_object_unref (application->priv->menubar);
+
+ application->priv->menubar = menubar;
+
+ if (application->priv->menubar != NULL)
+ g_object_ref (application->priv->menubar);
+
+ if (menubar)
+ extract_accels_from_menu (menubar, application);
+
+#ifdef GDK_WINDOWING_X11
+ gtk_application_set_menubar_x11 (application, menubar);
+#endif
+
+ g_object_notify (G_OBJECT (application), "menubar");
+ }
}
/**
GMenuModel *
gtk_application_get_menubar (GtkApplication *application)
{
- GMenuModel *menubar = NULL;
-
- g_object_get (application, "menubar", &menubar, NULL);
-
- if (menubar)
- g_object_unref (menubar);
+ g_return_val_if_fail (GTK_IS_APPLICATION (application), NULL);
- return menubar;
+ return application->priv->menubar;
}
#if defined(GDK_WINDOWING_X11)
g_debug ("Received EndSession");
gtk_application_quit_response (app, TRUE, NULL);
unregister_client (app);
- g_signal_emit (app, gtk_application_signals[QUIT], 0);
+ g_application_quit (G_APPLICATION (app));
}
else if (strcmp (signal_name, "Stop") == 0)
{
g_debug ("Received Stop");
unregister_client (app);
- g_signal_emit (app, gtk_application_signals[QUIT], 0);
+ g_application_quit (G_APPLICATION (app));
}
}
* that should not be interrupted, such as creating a CD or DVD. The
* types of actions that may be blocked are specified by the @flags
* parameter. When the application completes the operation it should
- * call g_application_uninhibit() to remove the inhibitor. Note that
+ * call gtk_application_uninhibit() to remove the inhibitor. Note that
* an application can have multiple inhibitors, and all of the must
* be individually removed. Inhibitors are also cleared when the
* application exits.
* this window to find out more about why the action is inhibited.
*
* Returns: A non-zero cookie that is used to uniquely identify this
- * request. It should be used as an argument to g_application_uninhibit()
+ * request. It should be used as an argument to gtk_application_uninhibit()
* in order to remove the request. If the platform does not support
* inhibiting or the request failed for some reason, 0 is returned.
*
GVariant *res;
GError *error = NULL;
guint cookie;
- guint xid;
+ guint xid = 0;
g_return_val_if_fail (GTK_IS_APPLICATION (application), 0);
g_return_val_if_fail (!g_application_get_is_remote (G_APPLICATION (application)), 0);
g_return_val_if_fail (application->priv->sm_proxy != NULL, 0);
if (window != NULL)
- xid = GDK_WINDOW_XID (gtk_widget_get_window (GTK_WIDGET (window)));
- else
- xid = 0;
+ {
+ GdkWindow *gdkwindow;
+
+ gdkwindow = gtk_widget_get_window (GTK_WIDGET (window));
+ if (gdkwindow == NULL)
+ g_warning ("Inhibit called with an unrealized window");
+#ifdef GDK_WINDOWING_X11
+ else if (GDK_IS_X11_WINDOW (gdkwindow))
+ xid = GDK_WINDOW_XID (gdkwindow);
+#endif
+ }
res = g_dbus_proxy_call_sync (application->priv->sm_proxy,
"Inhibit",
/**
* gtk_application_uninhibit:
* @application: the #GApplication
- * @cookie: a cookie that was returned by g_application_inhibit()
+ * @cookie: a cookie that was returned by gtk_application_inhibit()
*
- * Removes an inhibitor that has been established with g_application_inhibit().
+ * Removes an inhibitor that has been established with gtk_application_inhibit().
* Inhibitors are also cleared when the application exits.
*
* Since: 3.4
return inhibited;
}
-/**
- * GtkApplicationEndSessionStyle:
- * @GTK_APPLICATION_LOGOUT: End the session by logging out
- * @GTK_APPLICATION_REBOOT: Restart the computer
- * @GTK_APPLICATION_SHUTDOWN: Shut the computer down
- *
- * Different ways to end a user session, for use with
- * gtk_application_end_session().
- */
-
-/**
- * gtk_application_end_session:
- * @application: the #GtkApplication
- * @style: the desired kind of session end
- * @request_confirmation: whether or not the user should get a chance
- * to confirm the action
- *
- * Requests that the session manager end the current session.
- * @style indicates how the session should be ended, and
- * @request_confirmation indicates whether or not the user should be
- * given a chance to confirm the action. Both of these parameters are
- * merely hints though; the session manager may choose to ignore them.
- *
- * Return value: %TRUE if the request was sent; %FALSE if it could not
- * be sent (eg, because it could not connect to the session manager)
- *
- * Since: 3.4
- */
-gboolean
-gtk_application_end_session (GtkApplication *application,
- GtkApplicationEndSessionStyle style,
- gboolean request_confirmation)
-{
- g_return_val_if_fail (GTK_IS_APPLICATION (application), FALSE);
- g_return_val_if_fail (!g_application_get_is_remote (G_APPLICATION (application)), FALSE);
- g_return_val_if_fail (application->priv->sm_proxy != NULL, FALSE);
-
- switch (style)
- {
- case GTK_APPLICATION_LOGOUT:
- g_dbus_proxy_call (application->priv->sm_proxy,
- "Logout",
- g_variant_new ("(u)", request_confirmation ? 0 : 1),
- G_DBUS_CALL_FLAGS_NONE,
- G_MAXINT,
- NULL, NULL, NULL);
- break;
- case GTK_APPLICATION_REBOOT:
- case GTK_APPLICATION_SHUTDOWN:
- g_dbus_proxy_call (application->priv->sm_proxy,
- "Shutdown",
- NULL,
- G_DBUS_CALL_FLAGS_NONE,
- G_MAXINT,
- NULL, NULL, NULL);
- break;
- }
-
- return TRUE;
-}
-
#elif defined(GDK_WINDOWING_QUARTZ)
/* OS X implementation copied from EggSMClient, but simplified since
GtkApplication *app = data;
if (app->priv->quit_inhibit == 0)
- g_signal_emit (app, gtk_application_signals[QUIT], 0);
+ g_application_quit (G_APPLICATION (app));
+ else
+ {
+ GtkApplicationQuartzInhibitor *inhibitor;
+ GSList *iter;
+ GtkWidget *dialog;
+
+ for (iter = app->priv->inhibitors; iter; iter = iter->next)
+ {
+ inhibitor = iter->data;
+ if (inhibitor->flags & GTK_APPLICATION_INHIBIT_LOGOUT)
+ break;
+ }
+ g_assert (inhibitor != NULL);
+
+ dialog = gtk_message_dialog_new (inhibitor->window,
+ GTK_DIALOG_MODAL,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_OK,
+ _("%s cannot quit at this time:\n\n%s"),
+ g_get_application_name (),
+ inhibitor->reason);
+ g_signal_connect_swapped (dialog,
+ "response",
+ G_CALLBACK (gtk_widget_destroy),
+ dialog);
+ gtk_widget_show_all (dialog);
+ }
- return FALSE;
+ return G_SOURCE_REMOVE;
}
static pascal OSErr
AEInstallEventHandler (kCoreEventClass, kAEQuitApplication,
NewAEEventHandlerUPP (quit_requested),
(long)GPOINTER_TO_SIZE (app), false);
-
- app->priv->inhibitors = g_hash_table_new (NULL, NULL);
}
guint
GtkApplicationInhibitFlags flags,
const gchar *reason)
{
- guint cookie;
+ GtkApplicationQuartzInhibitor *inhibitor;
g_return_val_if_fail (GTK_IS_APPLICATION (application), 0);
g_return_val_if_fail (flags != 0, 0);
- application->priv->next_cookie++;
- cookie = application->priv->next_cookie;
+ inhibitor = g_slice_new (GtkApplicationQuartzInhibitor);
+ inhibitor->cookie = ++application->priv->next_cookie;
+ inhibitor->flags = flags;
+ inhibitor->reason = g_strdup (reason);
+ inhibitor->window = window ? g_object_ref (window) : NULL;
- g_hash_table_insert (application->priv->inhibitors,
- GUINT_TO_POINTER (cookie),
- GUINT_TO_POINTER (flags));
+ application->priv->inhibitors = g_slist_prepend (application->priv->inhibitors, inhibitor);
if (flags & GTK_APPLICATION_INHIBIT_LOGOUT)
application->priv->quit_inhibit++;
- return cookie;
+ return inhibitor->cookie;
}
void
gtk_application_uninhibit (GtkApplication *application,
guint cookie)
{
- GtkApplicationInhibitFlags flags;
+ GSList *iter;
- flags = GPOINTER_TO_UINT (g_hash_table_lookup (application->priv->inhibitors, GUINT_TO_POINTER (cookie)));
-
- if (flags == 0)
+ for (iter = application->priv->inhibitors; iter; iter = iter->next)
{
- g_warning ("Invalid inhibitor cookie");
- return;
+ GtkApplicationQuartzInhibitor *inhibitor = iter->data;
+
+ if (inhibitor->cookie == cookie)
+ {
+ if (inhibitor->flags & GTK_APPLICATION_INHIBIT_LOGOUT)
+ application->priv->quit_inhibit--;
+ gtk_application_quartz_inhibitor_free (inhibitor);
+ application->priv->inhibitors = g_slist_delete_link (application->priv->inhibitors, iter);
+ return;
+ }
}
- g_hash_table_remove (application->priv->inhibitors, GUINT_TO_POINTER (cookie));
-
- if (flags & GTK_APPLICATION_INHIBIT_LOGOUT)
- application->priv->quit_inhibit--;
+ g_warning ("Invalid inhibitor cookie");
}
gboolean
return FALSE;
}
-gboolean
-gtk_application_end_session (GtkApplication *application,
- GtkApplicationEndSessionStyle style,
- gboolean request_confirmation)
-{
- static const ProcessSerialNumber loginwindow_psn = { 0, kSystemProcess };
- AppleEvent event = { typeNull, NULL };
- AppleEvent reply = { typeNull, NULL };
- AEAddressDesc target;
- AEEventID id;
- OSErr err;
-
- switch (style)
- {
- case GTK_APPLICATION_LOGOUT:
- id = request_confirmation ? kAELogOut : kAEReallyLogOut;
- break;
- case GTK_APPLICATION_REBOOT:
- id = request_confirmation ? kAEShowRestartDialog : kAERestart;
- break;
- case GTK_APPLICATION_SHUTDOWN:
- id = request_confirmation ? kAEShowShutdownDialog : kAEShutDown;
- break;
- }
-
- err = AECreateDesc (typeProcessSerialNumber, &loginwindow_psn,
- sizeof (loginwindow_psn), &target);
- if (err != noErr)
- {
- g_warning ("Could not create descriptor for loginwindow: %d", err);
- return FALSE;
- }
-
- err = AECreateAppleEvent (kCoreEventClass, id, &target,
- kAutoGenerateReturnID, kAnyTransactionID,
- &event);
- AEDisposeDesc (&target);
- if (err != noErr)
- {
- g_warning ("Could not create logout AppleEvent: %d", err);
- return FALSE;
- }
-
- err = AESend (&event, &reply, kAENoReply, kAENormalPriority,
- kAEDefaultTimeout, NULL, NULL);
- AEDisposeDesc (&event);
- if (err == noErr)
- AEDisposeDesc (&reply);
-
- return err == noErr;
-}
-
#else
/* Trivial implementation.
return FALSE;
}
-gboolean
-gtk_application_end_session (GtkApplication *application,
- GtkApplicationEndSessionStyle style,
- gboolean request_confirmation)
-{
- return FALSE;
-}
-
#endif
projects / ~andy / gtk / blobdiff