Pileus Git - ~andy/gtk/blob - gtk/gtkapplication.c

   1 /*
   2  * Copyright © 2010 Codethink Limited
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the licence, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * Author: Ryan Lortie <desrt@desrt.ca>
  18  */
  19
  20 #include "config.h"
  21
  22 #include "gtkapplication.h"
  23
  24 #include <stdlib.h>
  25 #ifdef HAVE_UNISTD_H
  26 #include <unistd.h>
  27 #endif
  28 #include <string.h>
  29
  30 #include "gtkapplicationprivate.h"
  31 #include "gtkclipboard.h"
  32 #include "gtkmarshalers.h"
  33 #include "gtkmain.h"
  34 #include "gtkrecentmanager.h"
  35 #include "gtkaccelmapprivate.h"
  36 #include "gactionmuxer.h"
  37 #include "gtkintl.h"
  38
  39 #ifdef GDK_WINDOWING_QUARTZ
  40 #include "gtkquartz-menu.h"
  41 #import <Cocoa/Cocoa.h>
  42 #include <Carbon/Carbon.h>
  43 #include "gtkmessagedialog.h"
  44 #endif
  45
  46 #include <gdk/gdk.h>
  47 #ifdef GDK_WINDOWING_X11
  48 #include <gdk/x11/gdkx.h>
  49 #endif
  50
  51 /**
  52  * SECTION:gtkapplication
  53  * @title: GtkApplication
  54  * @short_description: Application class
  55  *
  56  * #GtkApplication is a class that handles many important aspects
  57  * of a GTK+ application in a convenient fashion, without enforcing
  58  * a one-size-fits-all application model.
  59  *
  60  * Currently, GtkApplication handles GTK+ initialization, application
  61  * uniqueness, session management, provides some basic scriptability and
  62  * desktop shell integration by exporting actions and menus and manages a
  63  * list of toplevel windows whose life-cycle is automatically tied to the
  64  * life-cycle of your application.
  65  *
  66  * While GtkApplication works fine with plain #GtkWindows, it is recommended
  67  * to use it together with #GtkApplicationWindow.
  68  *
  69  * When GDK threads are enabled, GtkApplication will acquire the GDK
  70  * lock when invoking actions that arrive from other processes.  The GDK
  71  * lock is not touched for local action invocations.  In order to have
  72  * actions invoked in a predictable context it is therefore recommended
  73  * that the GDK lock be held while invoking actions locally with
  74  * g_action_group_activate_action().  The same applies to actions
  75  * associated with #GtkApplicationWindow and to the 'activate' and
  76  * 'open' #GApplication methods.
  77  *
  78  * To set an application menu for a GtkApplication, use
  79  * gtk_application_set_app_menu(). The #GMenuModel that this function
  80  * expects is usually constructed using #GtkBuilder, as seen in the
  81  * following example. To specify a menubar that will be shown by
  82  * #GApplicationWindows, use gtk_application_set_menubar(). Use the base
  83  * #GActionMap interface to add actions, to respond to the user
  84  * selecting these menu items.
  85  *
  86  * GTK+ displays these menus as expected, depending on the platform
  87  * the application is running on.
  88  *
  89  * <figure label="Menu integration in OS X">
  90  * <graphic fileref="bloatpad-osx.png" format="PNG"/>
  91  * </figure>
  92  *
  93  * <figure label="Menu integration in GNOME">
  94  * <graphic fileref="bloatpad-gnome.png" format="PNG"/>
  95  * </figure>
  96  *
  97  * <figure label="Menu integration in Xfce">
  98  * <graphic fileref="bloatpad-xfce.png" format="PNG"/>
  99  * </figure>
 100  *
 101  * <example id="gtkapplication"><title>A simple application</title>
 102  * <programlisting>
 103  * <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../examples/bloatpad.c">
 104  *  <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
 105  * </xi:include>
 106  * </programlisting>
 107  * </example>
 108  *
 109  * GtkApplication optionally registers with a session manager
 110  * of the users session (if you set the #GtkApplication:register-session
 111  * property) and offers various functionality related to the session
 112  * life-cycle.
 113  *
 114  * An application can block various ways to end the session with
 115  * the gtk_application_inhibit() function. Typical use cases for
 116  * this kind of inhibiting are long-running, uninterruptible operations,
 117  * such as burning a CD or performing a disk backup. The session
 118  * manager may not honor the inhibitor, but it can be expected to
 119  * inform the user about the negative consequences of ending the
 120  * session while inhibitors are present.
 121  */
 122
 123 enum {
 124   WINDOW_ADDED,
 125   WINDOW_REMOVED,
 126   LAST_SIGNAL
 127 };
 128
 129 static guint gtk_application_signals[LAST_SIGNAL];
 130
 131 enum {
 132   PROP_ZERO,
 133   PROP_REGISTER_SESSION,
 134   PROP_APP_MENU,
 135   PROP_MENUBAR
 136 };
 137
 138 G_DEFINE_TYPE (GtkApplication, gtk_application, G_TYPE_APPLICATION)
 139
 140 struct _GtkApplicationPrivate
 141 {
 142   GList *windows;
 143
 144   gboolean register_session;
 145
 146   GMenuModel      *app_menu;
 147   GMenuModel      *menubar;
 148
 149 #ifdef GDK_WINDOWING_X11
 150   GDBusConnection *session_bus;
 151   const gchar     *application_id;
 152   const gchar     *object_path;
 153
 154   gchar           *app_menu_path;
 155   guint            app_menu_id;
 156
 157   gchar           *menubar_path;
 158   guint            menubar_id;
 159
 160   guint next_id;
 161
 162   GDBusProxy *sm_proxy;
 163   GDBusProxy *client_proxy;
 164   gchar *app_id;
 165   gchar *client_path;
 166 #endif
 167
 168 #ifdef GDK_WINDOWING_QUARTZ
 169   GActionMuxer *muxer;
 170   GMenu *combined;
 171
 172   GSList *inhibitors;
 173   gint quit_inhibit;
 174   guint next_cookie;
 175 #endif
 176 };
 177
 178 #ifdef GDK_WINDOWING_X11
 179 static void
 180 gtk_application_x11_publish_menu (GtkApplication  *application,
 181                                   const gchar     *type,
 182                                   GMenuModel      *model,
 183                                   guint           *id,
 184                                   gchar          **path)
 185 {
 186   gint i;
 187
 188   if (application->priv->session_bus == NULL)
 189     return;
 190
 191   /* unexport any existing menu */
 192   if (*id)
 193     {
 194       g_dbus_connection_unexport_menu_model (application->priv->session_bus, *id);
 195       g_free (*path);
 196       *path = NULL;
 197       *id = 0;
 198     }
 199
 200   /* export the new menu, if there is one */
 201   if (model != NULL)
 202     {
 203       /* try getting the preferred name */
 204       *path = g_strconcat (application->priv->object_path, "/menus/", type, NULL);
 205       *id = g_dbus_connection_export_menu_model (application->priv->session_bus, *path, model, NULL);
 206
 207       /* keep trying until we get a working name... */
 208       for (i = 0; *id == 0; i++)
 209         {
 210           g_free (*path);
 211           *path = g_strdup_printf ("%s/menus/%s%d", application->priv->object_path, type, i);
 212           *id = g_dbus_connection_export_menu_model (application->priv->session_bus, *path, model, NULL);
 213         }
 214     }
 215 }
 216
 217 static void
 218 gtk_application_set_app_menu_x11 (GtkApplication *application,
 219                                   GMenuModel     *app_menu)
 220 {
 221   gtk_application_x11_publish_menu (application, "appmenu", app_menu,
 222                                     &application->priv->app_menu_id,
 223                                     &application->priv->app_menu_path);
 224 }
 225
 226 static void
 227 gtk_application_set_menubar_x11 (GtkApplication *application,
 228                                  GMenuModel     *menubar)
 229 {
 230   gtk_application_x11_publish_menu (application, "menubar", menubar,
 231                                     &application->priv->menubar_id,
 232                                     &application->priv->menubar_path);
 233 }
 234
 235 static void
 236 gtk_application_window_added_x11 (GtkApplication *application,
 237                                   GtkWindow      *window)
 238 {
 239   if (application->priv->session_bus == NULL)
 240     return;
 241
 242   if (GTK_IS_APPLICATION_WINDOW (window))
 243     {
 244       GtkApplicationWindow *app_window = GTK_APPLICATION_WINDOW (window);
 245       gboolean success;
 246
 247       /* GtkApplicationWindow associates with us when it is first created,
 248        * so surely it's not realized yet...
 249        */
 250       g_assert (!gtk_widget_get_realized (GTK_WIDGET (window)));
 251
 252       do
 253         {
 254           gchar *window_path;
 255           guint window_id;
 256
 257           window_id = application->priv->next_id++;
 258           window_path = g_strdup_printf ("%s/window/%d", application->priv->object_path, window_id);
 259           success = gtk_application_window_publish (app_window, application->priv->session_bus, window_path);
 260           g_free (window_path);
 261         }
 262       while (!success);
 263     }
 264 }
 265
 266 static void
 267 gtk_application_window_removed_x11 (GtkApplication *application,
 268                                     GtkWindow      *window)
 269 {
 270   if (application->priv->session_bus == NULL)
 271     return;
 272
 273   if (GTK_IS_APPLICATION_WINDOW (window))
 274     gtk_application_window_unpublish (GTK_APPLICATION_WINDOW (window));
 275 }
 276
 277 static void gtk_application_startup_session_dbus (GtkApplication *app);
 278
 279 static void
 280 gtk_application_startup_x11 (GtkApplication *application)
 281 {
 282   application->priv->session_bus = g_application_get_dbus_connection (G_APPLICATION (application));
 283   application->priv->object_path = g_application_get_dbus_object_path (G_APPLICATION (application));
 284
 285   gtk_application_startup_session_dbus (GTK_APPLICATION (application));
 286 }
 287
 288 static void
 289 gtk_application_shutdown_x11 (GtkApplication *application)
 290 {
 291   application->priv->session_bus = NULL;
 292   application->priv->object_path = NULL;
 293
 294   g_clear_object (&application->priv->sm_proxy);
 295   g_clear_object (&application->priv->client_proxy);
 296   g_free (application->priv->app_id);
 297   g_free (application->priv->client_path);
 298 }
 299
 300 const gchar *
 301 gtk_application_get_app_menu_object_path (GtkApplication *application)
 302 {
 303   return application->priv->app_menu_path;
 304 }
 305
 306 const gchar *
 307 gtk_application_get_menubar_object_path (GtkApplication *application)
 308 {
 309   return application->priv->menubar_path;
 310 }
 311
 312 #endif
 313
 314 #ifdef GDK_WINDOWING_QUARTZ
 315
 316 typedef struct {
 317   guint cookie;
 318   GtkApplicationInhibitFlags flags;
 319   char *reason;
 320   GtkWindow *window;
 321 } GtkApplicationQuartzInhibitor;
 322
 323 static void
 324 gtk_application_quartz_inhibitor_free (GtkApplicationQuartzInhibitor *inhibitor)
 325 {
 326   g_free (inhibitor->reason);
 327   g_clear_object (&inhibitor->window);
 328   g_slice_free (GtkApplicationQuartzInhibitor, inhibitor);
 329 }
 330
 331 static void
 332 gtk_application_menu_changed_quartz (GObject    *object,
 333                                      GParamSpec *pspec,
 334                                      gpointer    user_data)
 335 {
 336   GtkApplication *application = GTK_APPLICATION (object);
 337   GMenu *combined;
 338
 339   combined = g_menu_new ();
 340   g_menu_append_submenu (combined, "Application", gtk_application_get_app_menu (application));
 341   g_menu_append_section (combined, NULL, gtk_application_get_menubar (application));
 342
 343   gtk_quartz_set_main_menu (G_MENU_MODEL (combined), G_ACTION_OBSERVABLE (application->priv->muxer));
 344 }
 345
 346 static void gtk_application_startup_session_quartz (GtkApplication *app);
 347
 348 static void
 349 gtk_application_startup_quartz (GtkApplication *application)
 350 {
 351   [NSApp finishLaunching];
 352
 353   application->priv->muxer = g_action_muxer_new ();
 354   g_action_muxer_insert (application->priv->muxer, "app", G_ACTION_GROUP (application));
 355
 356   g_signal_connect (application, "notify::app-menu", G_CALLBACK (gtk_application_menu_changed_quartz), NULL);
 357   g_signal_connect (application, "notify::menubar", G_CALLBACK (gtk_application_menu_changed_quartz), NULL);
 358   gtk_application_menu_changed_quartz (G_OBJECT (application), NULL, NULL);
 359
 360   gtk_application_startup_session_quartz (application);
 361 }
 362
 363 static void
 364 gtk_application_shutdown_quartz (GtkApplication *application)
 365 {
 366   g_signal_handlers_disconnect_by_func (application, gtk_application_menu_changed_quartz, NULL);
 367
 368   g_object_unref (application->priv->muxer);
 369   application->priv->muxer = NULL;
 370
 371   g_slist_free_full (application->priv->inhibitors,
 372                      (GDestroyNotify) gtk_application_quartz_inhibitor_free);
 373   application->priv->inhibitors = NULL;
 374 }
 375
 376 static void
 377 gtk_application_focus_changed (GtkApplication *application,
 378                                GtkWindow      *window)
 379 {
 380   if (G_IS_ACTION_GROUP (window))
 381     g_action_muxer_insert (application->priv->muxer, "win", G_ACTION_GROUP (window));
 382   else
 383     g_action_muxer_remove (application->priv->muxer, "win");
 384 }
 385 #endif
 386
 387 static gboolean
 388 gtk_application_focus_in_event_cb (GtkWindow      *window,
 389                                    GdkEventFocus  *event,
 390                                    GtkApplication *application)
 391 {
 392   GtkApplicationPrivate *priv = application->priv;
 393   GList *link;
 394
 395   /* Keep the window list sorted by most-recently-focused. */
 396   link = g_list_find (priv->windows, window);
 397   if (link != NULL && link != priv->windows)
 398     {
 399       priv->windows = g_list_remove_link (priv->windows, link);
 400       priv->windows = g_list_concat (link, priv->windows);
 401     }
 402
 403 #ifdef GDK_WINDOWING_QUARTZ
 404   gtk_application_focus_changed (application, window);
 405 #endif
 406
 407   return FALSE;
 408 }
 409
 410 static void
 411 gtk_application_startup (GApplication *application)
 412 {
 413   G_APPLICATION_CLASS (gtk_application_parent_class)
 414     ->startup (application);
 415
 416   gtk_init (0, 0);
 417
 418 #ifdef GDK_WINDOWING_X11
 419   gtk_application_startup_x11 (GTK_APPLICATION (application));
 420 #endif
 421
 422 #ifdef GDK_WINDOWING_QUARTZ
 423   gtk_application_startup_quartz (GTK_APPLICATION (application));
 424 #endif
 425 }
 426
 427 static void
 428 gtk_application_shutdown (GApplication *application)
 429 {
 430 #ifdef GDK_WINDOWING_X11
 431   gtk_application_shutdown_x11 (GTK_APPLICATION (application));
 432 #endif
 433
 434 #ifdef GDK_WINDOWING_QUARTZ
 435   gtk_application_shutdown_quartz (GTK_APPLICATION (application));
 436 #endif
 437
 438   /* Try storing all clipboard data we have */
 439   _gtk_clipboard_store_all ();
 440
 441   /* Synchronize the recent manager singleton */
 442   _gtk_recent_manager_sync ();
 443
 444   G_APPLICATION_CLASS (gtk_application_parent_class)
 445     ->shutdown (application);
 446 }
 447
 448 static void
 449 gtk_application_add_platform_data (GApplication    *application,
 450                                    GVariantBuilder *builder)
 451 {
 452   const gchar *startup_id;
 453
 454   startup_id = getenv ("DESKTOP_STARTUP_ID");
 455
 456   if (startup_id && g_utf8_validate (startup_id, -1, NULL))
 457     g_variant_builder_add (builder, "{sv}", "desktop-startup-id",
 458                            g_variant_new_string (startup_id));
 459 }
 460
 461 static void
 462 gtk_application_before_emit (GApplication *application,
 463                              GVariant     *platform_data)
 464 {
 465   GVariantIter iter;
 466   const gchar *key;
 467   GVariant *value;
 468
 469   gdk_threads_enter ();
 470
 471   g_variant_iter_init (&iter, platform_data);
 472   while (g_variant_iter_loop (&iter, "{&sv}", &key, &value))
 473     {
 474 #ifdef GDK_WINDOWING_X11
 475       if (strcmp (key, "desktop-startup-id") == 0)
 476         {
 477           GdkDisplay *display;
 478           const gchar *id;
 479
 480           display = gdk_display_get_default ();
 481           id = g_variant_get_string (value, NULL);
 482           if (GDK_IS_X11_DISPLAY (display))
 483             gdk_x11_display_set_startup_notification_id (display, id);
 484        }
 485 #endif
 486     }
 487 }
 488
 489 static void
 490 gtk_application_after_emit (GApplication *application,
 491                             GVariant     *platform_data)
 492 {
 493   gdk_notify_startup_complete ();
 494
 495   gdk_threads_leave ();
 496 }
 497
 498 static void
 499 gtk_application_init (GtkApplication *application)
 500 {
 501   application->priv = G_TYPE_INSTANCE_GET_PRIVATE (application,
 502                                                    GTK_TYPE_APPLICATION,
 503                                                    GtkApplicationPrivate);
 504 }
 505
 506 static void
 507 gtk_application_window_added (GtkApplication *application,
 508                               GtkWindow      *window)
 509 {
 510   GtkApplicationPrivate *priv = application->priv;
 511
 512   priv->windows = g_list_prepend (priv->windows, window);
 513   gtk_window_set_application (window, application);
 514   g_application_hold (G_APPLICATION (application));
 515
 516   g_signal_connect (window, "focus-in-event",
 517                     G_CALLBACK (gtk_application_focus_in_event_cb),
 518                     application);
 519
 520 #ifdef GDK_WINDOWING_X11
 521   gtk_application_window_added_x11 (application, window);
 522 #endif
 523 }
 524
 525 static void
 526 gtk_application_window_removed (GtkApplication *application,
 527                                 GtkWindow      *window)
 528 {
 529   GtkApplicationPrivate *priv = application->priv;
 530
 531 #ifdef GDK_WINDOWING_X11
 532   gtk_application_window_removed_x11 (application, window);
 533 #endif
 534
 535   g_signal_handlers_disconnect_by_func (window,
 536                                         gtk_application_focus_in_event_cb,
 537                                         application);
 538
 539   g_application_release (G_APPLICATION (application));
 540   priv->windows = g_list_remove (priv->windows, window);
 541   gtk_window_set_application (window, NULL);
 542 }
 543
 544 static void
 545 extract_accel_from_menu_item (GMenuModel     *model,
 546                               gint            item,
 547                               GtkApplication *app)
 548 {
 549   GMenuAttributeIter *iter;
 550   const gchar *key;
 551   GVariant *value;
 552   const gchar *accel = NULL;
 553   const gchar *action = NULL;
 554   GVariant *target = NULL;
 555
 556   iter = g_menu_model_iterate_item_attributes (model, item);
 557   while (g_menu_attribute_iter_get_next (iter, &key, &value))
 558     {
 559       if (g_str_equal (key, "action") && g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
 560         action = g_variant_get_string (value, NULL);
 561       else if (g_str_equal (key, "accel") && g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
 562         accel = g_variant_get_string (value, NULL);
 563       else if (g_str_equal (key, "target"))
 564         target = g_variant_ref (value);
 565       g_variant_unref (value);
 566     }
 567   g_object_unref (iter);
 568
 569   if (accel && action)
 570     gtk_application_add_accelerator (app, accel, action, target);
 571
 572   if (target)
 573     g_variant_unref (target);
 574 }
 575
 576 static void
 577 extract_accels_from_menu (GMenuModel     *model,
 578                           GtkApplication *app)
 579 {
 580   gint i;
 581   GMenuLinkIter *iter;
 582   const gchar *key;
 583   GMenuModel *m;
 584
 585   for (i = 0; i < g_menu_model_get_n_items (model); i++)
 586     {
 587       extract_accel_from_menu_item (model, i, app);
 588
 589       iter = g_menu_model_iterate_item_links (model, i);
 590       while (g_menu_link_iter_get_next (iter, &key, &m))
 591         {
 592           extract_accels_from_menu (m, app);
 593           g_object_unref (m);
 594         }
 595       g_object_unref (iter);
 596     }
 597 }
 598
 599 static void
 600 gtk_application_get_property (GObject    *object,
 601                               guint       prop_id,
 602                               GValue     *value,
 603                               GParamSpec *pspec)
 604 {
 605   GtkApplication *application = GTK_APPLICATION (object);
 606
 607   switch (prop_id)
 608     {
 609     case PROP_REGISTER_SESSION:
 610       g_value_set_boolean (value, application->priv->register_session);
 611       break;
 612
 613     case PROP_APP_MENU:
 614       g_value_set_object (value, gtk_application_get_app_menu (application));
 615       break;
 616
 617     case PROP_MENUBAR:
 618       g_value_set_object (value, gtk_application_get_menubar (application));
 619       break;
 620
 621     default:
 622       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 623       break;
 624     }
 625 }
 626
 627 static void
 628 gtk_application_set_property (GObject      *object,
 629                               guint         prop_id,
 630                               const GValue *value,
 631                               GParamSpec   *pspec)
 632 {
 633   GtkApplication *application = GTK_APPLICATION (object);
 634
 635   switch (prop_id)
 636     {
 637     case PROP_REGISTER_SESSION:
 638       application->priv->register_session = g_value_get_boolean (value);
 639       break;
 640
 641     case PROP_APP_MENU:
 642       gtk_application_set_app_menu (application, g_value_get_object (value));
 643       break;
 644
 645     case PROP_MENUBAR:
 646       gtk_application_set_menubar (application, g_value_get_object (value));
 647       break;
 648
 649     default:
 650       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 651       break;
 652     }
 653 }
 654
 655 static void
 656 gtk_application_finalize (GObject *object)
 657 {
 658   GtkApplication *application = GTK_APPLICATION (object);
 659
 660   g_clear_object (&application->priv->app_menu);
 661   g_clear_object (&application->priv->menubar);
 662
 663   G_OBJECT_CLASS (gtk_application_parent_class)
 664     ->finalize (object);
 665 }
 666
 667 static void
 668 gtk_application_class_init (GtkApplicationClass *class)
 669 {
 670   GObjectClass *object_class = G_OBJECT_CLASS (class);
 671   GApplicationClass *application_class = G_APPLICATION_CLASS (class);
 672
 673   object_class->get_property = gtk_application_get_property;
 674   object_class->set_property = gtk_application_set_property;
 675   object_class->finalize = gtk_application_finalize;
 676
 677   application_class->add_platform_data = gtk_application_add_platform_data;
 678   application_class->before_emit = gtk_application_before_emit;
 679   application_class->after_emit = gtk_application_after_emit;
 680   application_class->startup = gtk_application_startup;
 681   application_class->shutdown = gtk_application_shutdown;
 682
 683   class->window_added = gtk_application_window_added;
 684   class->window_removed = gtk_application_window_removed;
 685
 686   g_type_class_add_private (class, sizeof (GtkApplicationPrivate));
 687
 688   /**
 689    * GtkApplication::window-added:
 690    * @application: the #GtkApplication which emitted the signal
 691    * @window: the newly-added #GtkWindow
 692    *
 693    * Emitted when a #GtkWindow is added to @application through
 694    * gtk_application_add_window().
 695    *
 696    * Since: 3.2
 697    */
 698   gtk_application_signals[WINDOW_ADDED] =
 699     g_signal_new ("window-added", GTK_TYPE_APPLICATION, G_SIGNAL_RUN_FIRST,
 700                   G_STRUCT_OFFSET (GtkApplicationClass, window_added),
 701                   NULL, NULL,
 702                   g_cclosure_marshal_VOID__OBJECT,
 703                   G_TYPE_NONE, 1, GTK_TYPE_WINDOW);
 704
 705   /**
 706    * GtkApplication::window-removed:
 707    * @application: the #GtkApplication which emitted the signal
 708    * @window: the #GtkWindow that is being removed
 709    *
 710    * Emitted when a #GtkWindow is removed from @application,
 711    * either as a side-effect of being destroyed or explicitly
 712    * through gtk_application_remove_window().
 713    *
 714    * Since: 3.2
 715    */
 716   gtk_application_signals[WINDOW_REMOVED] =
 717     g_signal_new ("window-removed", GTK_TYPE_APPLICATION, G_SIGNAL_RUN_FIRST,
 718                   G_STRUCT_OFFSET (GtkApplicationClass, window_removed),
 719                   NULL, NULL,
 720                   g_cclosure_marshal_VOID__OBJECT,
 721                   G_TYPE_NONE, 1, GTK_TYPE_WINDOW);
 722
 723   /**
 724    * GtkApplication:register-session:
 725    *
 726    * Set this property to %TRUE to register with the session manager.
 727    *
 728    * Since: 3.4
 729    */
 730   g_object_class_install_property (object_class, PROP_REGISTER_SESSION,
 731     g_param_spec_boolean ("register-session",
 732                           P_("Register session"),
 733                           P_("Register with the session manager"),
 734                           FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 735
 736   g_object_class_install_property (object_class, PROP_APP_MENU,
 737     g_param_spec_object ("app-menu",
 738                          P_("Application menu"),
 739                          P_("The GMenuModel for the application menu"),
 740                          G_TYPE_MENU_MODEL,
 741                          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 742
 743   g_object_class_install_property (object_class, PROP_MENUBAR,
 744     g_param_spec_object ("menubar",
 745                          P_("Menubar"),
 746                          P_("The GMenuModel for the menubar"),
 747                          G_TYPE_MENU_MODEL,
 748                          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 749 }
 750
 751 /**
 752  * gtk_application_new:
 753  * @application_id: the application id
 754  * @flags: the application flags
 755  *
 756  * Creates a new #GtkApplication instance.
 757  *
 758  * This function calls g_type_init() for you. gtk_init() is called
 759  * as soon as the application gets registered as the primary instance.
 760  *
 761  * Concretely, gtk_init() is called in the default handler for the
 762  * #GApplication:startup signal. Therefore, #GtkApplication subclasses should
 763  * chain up in their #GApplication:startup handler before using any GTK+ API.
 764  *
 765  * Note that commandline arguments are not passed to gtk_init().
 766  * All GTK+ functionality that is available via commandline arguments
 767  * can also be achieved by setting suitable environment variables
 768  * such as <envar>G_DEBUG</envar>, so this should not be a big
 769  * problem. If you absolutely must support GTK+ commandline arguments,
 770  * you can explicitly call gtk_init() before creating the application
 771  * instance.
 772  *
 773  * The application id must be valid. See g_application_id_is_valid().
 774  *
 775  * Returns: a new #GtkApplication instance
 776  *
 777  * Since: 3.0
 778  */
 779 GtkApplication *
 780 gtk_application_new (const gchar       *application_id,
 781                      GApplicationFlags  flags)
 782 {
 783   g_return_val_if_fail (g_application_id_is_valid (application_id), NULL);
 784
 785   g_type_init ();
 786
 787   return g_object_new (GTK_TYPE_APPLICATION,
 788                        "application-id", application_id,
 789                        "flags", flags,
 790                        NULL);
 791 }
 792
 793 /**
 794  * gtk_application_add_window:
 795  * @application: a #GtkApplication
 796  * @window: a #GtkWindow
 797  *
 798  * Adds a window to @application.
 799  *
 800  * This call is equivalent to setting the #GtkWindow:application
 801  * property of @window to @application.
 802  *
 803  * Normally, the connection between the application and the window
 804  * will remain until the window is destroyed, but you can explicitly
 805  * remove it with gtk_application_remove_window().
 806  *
 807  * GTK+ will keep the application running as long as it has
 808  * any windows.
 809  *
 810  * Since: 3.0
 811  **/
 812 void
 813 gtk_application_add_window (GtkApplication *application,
 814                             GtkWindow      *window)
 815 {
 816   g_return_if_fail (GTK_IS_APPLICATION (application));
 817
 818   if (!g_list_find (application->priv->windows, window))
 819     g_signal_emit (application,
 820                    gtk_application_signals[WINDOW_ADDED], 0, window);
 821 }
 822
 823 /**
 824  * gtk_application_remove_window:
 825  * @application: a #GtkApplication
 826  * @window: a #GtkWindow
 827  *
 828  * Remove a window from @application.
 829  *
 830  * If @window belongs to @application then this call is equivalent to
 831  * setting the #GtkWindow:application property of @window to
 832  * %NULL.
 833  *
 834  * The application may stop running as a result of a call to this
 835  * function.
 836  *
 837  * Since: 3.0
 838  **/
 839 void
 840 gtk_application_remove_window (GtkApplication *application,
 841                                GtkWindow      *window)
 842 {
 843   g_return_if_fail (GTK_IS_APPLICATION (application));
 844
 845   if (g_list_find (application->priv->windows, window))
 846     g_signal_emit (application,
 847                    gtk_application_signals[WINDOW_REMOVED], 0, window);
 848 }
 849
 850 /**
 851  * gtk_application_get_windows:
 852  * @application: a #GtkApplication
 853  *
 854  * Gets a list of the #GtkWindows associated with @application.
 855  *
 856  * The list is sorted by most recently focused window, such that the first
 857  * element is the currently focused window. (Useful for choosing a parent
 858  * for a transient window.)
 859  *
 860  * The list that is returned should not be modified in any way. It will
 861  * only remain valid until the next focus change or window creation or
 862  * deletion.
 863  *
 864  * Returns: (element-type GtkWindow) (transfer none): a #GList of #GtkWindow
 865  *
 866  * Since: 3.0
 867  **/
 868 GList *
 869 gtk_application_get_windows (GtkApplication *application)
 870 {
 871   g_return_val_if_fail (GTK_IS_APPLICATION (application), NULL);
 872
 873   return application->priv->windows;
 874 }
 875
 876 /**
 877  * gtk_application_add_accelerator:
 878  * @application: a #GtkApplication
 879  * @accelerator: accelerator string
 880  * @action_name: the name of the action to activate
 881  * @parameter: (allow-none): parameter to pass when activating the action,
 882  *   or %NULL if the action does not accept an activation parameter
 883  *
 884  * Installs an accelerator that will cause the named action
 885  * to be activated when the key combination specificed by @accelerator
 886  * is pressed.
 887  *
 888  * @accelerator must be a string that can be parsed by
 889  * gtk_accelerator_parse(), e.g. "<Primary>q" or "<Control><Alt>p".
 890  *
 891  * @action_name must be the name of an action as it would be used
 892  * in the app menu, i.e. actions that have been added to the application
 893  * are referred to with an "app." prefix, and window-specific actions
 894  * with a "win." prefix.
 895  *
 896  * GtkApplication also extracts accelerators out of 'accel' attributes
 897  * in the #GMenuModels passed to gtk_application_set_app_menu() and
 898  * gtk_application_set_menubar(), which is usually more convenient
 899  * than calling this function for each accelerator.
 900  *
 901  * Since: 3.4
 902  */
 903 void
 904 gtk_application_add_accelerator (GtkApplication *application,
 905                                  const gchar    *accelerator,
 906                                  const gchar    *action_name,
 907                                  GVariant       *parameter)
 908 {
 909   gchar *accel_path;
 910   guint accel_key;
 911   GdkModifierType accel_mods;
 912
 913   g_return_if_fail (GTK_IS_APPLICATION (application));
 914
 915   /* Call this here, since gtk_init() is only getting called in startup() */
 916   _gtk_accel_map_init ();
 917
 918   gtk_accelerator_parse (accelerator, &accel_key, &accel_mods);
 919
 920   if (accel_key == 0)
 921     {
 922       g_warning ("Failed to parse accelerator: '%s'\n", accelerator);
 923       return;
 924     }
 925
 926   accel_path = _gtk_accel_path_for_action (action_name, parameter);
 927
 928   if (gtk_accel_map_lookup_entry (accel_path, NULL))
 929     gtk_accel_map_change_entry (accel_path, accel_key, accel_mods, TRUE);
 930   else
 931     gtk_accel_map_add_entry (accel_path, accel_key, accel_mods);
 932
 933   g_free (accel_path);
 934 }
 935
 936 /**
 937  * gtk_application_remove_accelerator:
 938  * @application: a #GtkApplication
 939  * @action_name: the name of the action to activate
 940  * @parameter: (allow-none): parameter to pass when activating the action,
 941  *   or %NULL if the action does not accept an activation parameter
 942  *
 943  * Removes an accelerator that has been previously added
 944  * with gtk_application_add_accelerator().
 945  *
 946  * Since: 3.4
 947  */
 948 void
 949 gtk_application_remove_accelerator (GtkApplication *application,
 950                                     const gchar    *action_name,
 951                                     GVariant       *parameter)
 952 {
 953   gchar *accel_path;
 954
 955   g_return_if_fail (GTK_IS_APPLICATION (application));
 956
 957   accel_path = _gtk_accel_path_for_action (action_name, parameter);
 958
 959   if (!gtk_accel_map_lookup_entry (accel_path, NULL))
 960     {
 961       g_warning ("No accelerator found for '%s'\n", accel_path);
 962       g_free (accel_path);
 963       return;
 964     }
 965
 966   gtk_accel_map_change_entry (accel_path, 0, 0, FALSE);
 967   g_free (accel_path);
 968 }
 969
 970 /**
 971  * gtk_application_set_app_menu:
 972  * @application: a #GtkApplication
 973  * @app_menu: (allow-none): a #GMenuModel, or %NULL
 974  *
 975  * Sets or unsets the application menu for @application.
 976  *
 977  * This can only be done in the primary instance of the application,
 978  * after it has been registered.  #GApplication:startup is a good place
 979  * to call this.
 980  *
 981  * The application menu is a single menu containing items that typically
 982  * impact the application as a whole, rather than acting on a specific
 983  * window or document.  For example, you would expect to see
 984  * "Preferences" or "Quit" in an application menu, but not "Save" or
 985  * "Print".
 986  *
 987  * If supported, the application menu will be rendered by the desktop
 988  * environment.
 989  *
 990  * Use the base #GActionMap interface to add actions, to respond to the user
 991  * selecting these menu items.
 992  *
 993  * Since: 3.4
 994  */
 995 void
 996 gtk_application_set_app_menu (GtkApplication *application,
 997                               GMenuModel     *app_menu)
 998 {
 999   g_return_if_fail (GTK_IS_APPLICATION (application));
1000   g_return_if_fail (g_application_get_is_registered (G_APPLICATION (application)));
1001   g_return_if_fail (!g_application_get_is_remote (G_APPLICATION (application)));
1002
1003   if (app_menu != application->priv->app_menu)
1004     {
1005       if (application->priv->app_menu != NULL)
1006         g_object_unref (application->priv->app_menu);
1007
1008       application->priv->app_menu = app_menu;
1009
1010       if (application->priv->app_menu != NULL)
1011         g_object_ref (application->priv->app_menu);
1012
1013       extract_accels_from_menu (app_menu, application);
1014
1015 #ifdef GDK_WINDOWING_X11
1016       gtk_application_set_app_menu_x11 (application, app_menu);
1017 #endif
1018
1019       g_object_notify (G_OBJECT (application), "app-menu");
1020     }
1021 }
1022
1023 /**
1024  * gtk_application_get_app_menu:
1025  * @application: a #GtkApplication
1026  *
1027  * Returns the menu model that has been set with
1028  * gtk_application_set_app_menu().
1029  *
1030  * Returns: (transfer none): the application menu of @application
1031  *
1032  * Since: 3.4
1033  */
1034 GMenuModel *
1035 gtk_application_get_app_menu (GtkApplication *application)
1036 {
1037   g_return_val_if_fail (GTK_IS_APPLICATION (application), NULL);
1038
1039   return application->priv->app_menu;
1040 }
1041
1042 /**
1043  * gtk_application_set_menubar:
1044  * @application: a #GtkApplication
1045  * @menubar: (allow-none): a #GMenuModel, or %NULL
1046  *
1047  * Sets or unsets the menubar for windows of @application.
1048  *
1049  * This is a menubar in the traditional sense.
1050  *
1051  * This can only be done in the primary instance of the application,
1052  * after it has been registered.  #GApplication:startup is a good place
1053  * to call this.
1054  *
1055  * Depending on the desktop environment, this may appear at the top of
1056  * each window, or at the top of the screen.  In some environments, if
1057  * both the application menu and the menubar are set, the application
1058  * menu will be presented as if it were the first item of the menubar.
1059  * Other environments treat the two as completely separate -- for
1060  * example, the application menu may be rendered by the desktop shell
1061  * while the menubar (if set) remains in each individual window.
1062  *
1063  * Use the base #GActionMap interface to add actions, to respond to the user
1064  * selecting these menu items.
1065  *
1066  * Since: 3.4
1067  */
1068 void
1069 gtk_application_set_menubar (GtkApplication *application,
1070                              GMenuModel     *menubar)
1071 {
1072   g_return_if_fail (GTK_IS_APPLICATION (application));
1073   g_return_if_fail (g_application_get_is_registered (G_APPLICATION (application)));
1074   g_return_if_fail (!g_application_get_is_remote (G_APPLICATION (application)));
1075
1076   if (menubar != application->priv->menubar)
1077     {
1078       if (application->priv->menubar != NULL)
1079         g_object_unref (application->priv->menubar);
1080
1081       application->priv->menubar = menubar;
1082
1083       if (application->priv->menubar != NULL)
1084         g_object_ref (application->priv->menubar);
1085
1086       extract_accels_from_menu (menubar, application);
1087
1088 #ifdef GDK_WINDOWING_X11
1089       gtk_application_set_menubar_x11 (application, menubar);
1090 #endif
1091
1092       g_object_notify (G_OBJECT (application), "menubar");
1093     }
1094 }
1095
1096 /**
1097  * gtk_application_get_menubar:
1098  * @application: a #GtkApplication
1099  *
1100  * Returns the menu model that has been set with
1101  * gtk_application_set_menubar().
1102  *
1103  * Returns: (transfer none): the menubar for windows of @application
1104  *
1105  * Since: 3.4
1106  */
1107 GMenuModel *
1108 gtk_application_get_menubar (GtkApplication *application)
1109 {
1110   g_return_val_if_fail (GTK_IS_APPLICATION (application), NULL);
1111
1112   return application->priv->menubar;
1113 }
1114
1115 #if defined(GDK_WINDOWING_X11)
1116
1117 /* D-Bus Session Management
1118  *
1119  * The protocol and the D-Bus API are described here:
1120  * http://live.gnome.org/SessionManagement/GnomeSession
1121  * http://people.gnome.org/~mccann/gnome-session/docs/gnome-session.html
1122  */
1123
1124 static void
1125 unregister_client (GtkApplication *app)
1126 {
1127   GError *error = NULL;
1128
1129   g_debug ("Unregistering client");
1130
1131   g_dbus_proxy_call_sync (app->priv->sm_proxy,
1132                           "UnregisterClient",
1133                           g_variant_new ("(o)", app->priv->client_path),
1134                           G_DBUS_CALL_FLAGS_NONE,
1135                           G_MAXINT,
1136                           NULL,
1137                           &error);
1138
1139   if (error)
1140     {
1141       g_warning ("Failed to unregister client: %s", error->message);
1142       g_error_free (error);
1143     }
1144
1145   g_clear_object (&app->priv->client_proxy);
1146
1147   g_free (app->priv->client_path);
1148   app->priv->client_path = NULL;
1149 }
1150
1151 static void
1152 gtk_application_quit_response (GtkApplication *application,
1153                                gboolean        will_quit,
1154                                const gchar    *reason)
1155 {
1156   g_debug ("Calling EndSessionResponse %d '%s'", will_quit, reason);
1157
1158   g_dbus_proxy_call (application->priv->client_proxy,
1159                      "EndSessionResponse",
1160                      g_variant_new ("(bs)", will_quit, reason ? reason : ""),
1161                      G_DBUS_CALL_FLAGS_NONE,
1162                      G_MAXINT,
1163                      NULL, NULL, NULL);
1164 }
1165 static void
1166 client_proxy_signal (GDBusProxy     *proxy,
1167                      const gchar    *sender_name,
1168                      const gchar    *signal_name,
1169                      GVariant       *parameters,
1170                      GtkApplication *app)
1171 {
1172   if (strcmp (signal_name, "QueryEndSession") == 0)
1173     {
1174       g_debug ("Received QueryEndSession");
1175       gtk_application_quit_response (app, TRUE, NULL);
1176     }
1177   else if (strcmp (signal_name, "CancelEndSession") == 0)
1178     {
1179       g_debug ("Received CancelEndSession");
1180     }
1181   else if (strcmp (signal_name, "EndSession") == 0)
1182     {
1183       g_debug ("Received EndSession");
1184       gtk_application_quit_response (app, TRUE, NULL);
1185       unregister_client (app);
1186       g_application_quit (G_APPLICATION (app));
1187     }
1188   else if (strcmp (signal_name, "Stop") == 0)
1189     {
1190       g_debug ("Received Stop");
1191       unregister_client (app);
1192       g_application_quit (G_APPLICATION (app));
1193     }
1194 }
1195
1196 static void
1197 gtk_application_startup_session_dbus (GtkApplication *app)
1198 {
1199   static gchar *client_id;
1200   GError *error = NULL;
1201   GVariant *res;
1202
1203   if (app->priv->session_bus == NULL)
1204     return;
1205
1206   if (client_id == NULL)
1207     {
1208       const gchar *desktop_autostart_id;
1209
1210       desktop_autostart_id = g_getenv ("DESKTOP_AUTOSTART_ID");
1211       /* Unset DESKTOP_AUTOSTART_ID in order to avoid child processes to
1212        * use the same client id.
1213        */
1214       g_unsetenv ("DESKTOP_AUTOSTART_ID");
1215       client_id = g_strdup (desktop_autostart_id ? desktop_autostart_id : "");
1216     }
1217
1218   g_debug ("Connecting to session manager");
1219
1220   app->priv->sm_proxy = g_dbus_proxy_new_sync (app->priv->session_bus,
1221                                                G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |
1222                                                G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
1223                                                NULL,
1224                                                "org.gnome.SessionManager",
1225                                                "/org/gnome/SessionManager",
1226                                                "org.gnome.SessionManager",
1227                                                NULL,
1228                                                &error);
1229   if (error)
1230     {
1231       g_warning ("Failed to get a session proxy: %s", error->message);
1232       g_error_free (error);
1233       return;
1234     }
1235
1236   /* FIXME: should we reuse the D-Bus application id here ? */
1237   app->priv->app_id = g_strdup (g_get_prgname ());
1238
1239   if (!app->priv->register_session)
1240     return;
1241
1242   g_debug ("Registering client '%s' '%s'", app->priv->app_id, client_id);
1243
1244   res = g_dbus_proxy_call_sync (app->priv->sm_proxy,
1245                                 "RegisterClient",
1246                                 g_variant_new ("(ss)", app->priv->app_id, client_id),
1247                                 G_DBUS_CALL_FLAGS_NONE,
1248                                 G_MAXINT,
1249                                 NULL,
1250                                 &error);
1251
1252   if (error)
1253     {
1254       g_warning ("Failed to register client: %s", error->message);
1255       g_error_free (error);
1256       g_clear_object (&app->priv->sm_proxy);
1257       return;
1258     }
1259
1260   g_variant_get (res, "(o)", &app->priv->client_path);
1261   g_variant_unref (res);
1262
1263   g_debug ("Registered client at '%s'", app->priv->client_path);
1264
1265   app->priv->client_proxy = g_dbus_proxy_new_sync (app->priv->session_bus, 0,
1266                                                    NULL,
1267                                                    "org.gnome.SessionManager",
1268                                                    app->priv->client_path,
1269                                                    "org.gnome.SessionManager.ClientPrivate",
1270                                                    NULL,
1271                                                    &error);
1272   if (error)
1273     {
1274       g_warning ("Failed to get client proxy: %s", error->message);
1275       g_error_free (error);
1276       g_clear_object (&app->priv->sm_proxy);
1277       g_free (app->priv->client_path);
1278       app->priv->client_path = NULL;
1279       return;
1280     }
1281
1282   g_signal_connect (app->priv->client_proxy, "g-signal", G_CALLBACK (client_proxy_signal), app);
1283 }
1284
1285
1286
1287 /**
1288  * GtkApplicationInhibitFlags:
1289  * @GTK_APPLICATION_INHIBIT_LOGOUT: Inhibit ending the user session
1290  *     by logging out or by shutting down the computer
1291  * @GTK_APPLICATION_INHIBIT_SWITCH: Inhibit user switching
1292  * @GTK_APPLICATION_INHIBIT_SUSPEND: Inhibit suspending the
1293  *     session or computer
1294  * @GTK_APPLICATION_INHIBIT_IDLE: Inhibit the session being
1295  *     marked as idle (and possibly locked)
1296  *
1297  * Types of user actions that may be blocked by gtk_application_inhibit().
1298  *
1299  * Since: 3.4
1300  */
1301
1302 /**
1303  * gtk_application_inhibit:
1304  * @application: the #GApplication
1305  * @window: (allow-none): a #GtkWindow, or %NULL
1306  * @flags: what types of actions should be inhibited
1307  * @reason: (allow-none): a short, human-readable string that explains
1308  *     why these operations are inhibited
1309  *
1310  * Inform the session manager that certain types of actions should be
1311  * inhibited. This is not guaranteed to work on all platforms and for
1312  * all types of actions.
1313  *
1314  * Applications should invoke this method when they begin an operation
1315  * that should not be interrupted, such as creating a CD or DVD. The
1316  * types of actions that may be blocked are specified by the @flags
1317  * parameter. When the application completes the operation it should
1318  * call g_application_uninhibit() to remove the inhibitor. Note that
1319  * an application can have multiple inhibitors, and all of the must
1320  * be individually removed. Inhibitors are also cleared when the
1321  * application exits.
1322  *
1323  * Applications should not expect that they will always be able to block
1324  * the action. In most cases, users will be given the option to force
1325  * the action to take place.
1326  *
1327  * Reasons should be short and to the point.
1328  *
1329  * If @window is given, the session manager may point the user to
1330  * this window to find out more about why the action is inhibited.
1331  *
1332  * Returns: A non-zero cookie that is used to uniquely identify this
1333  *     request. It should be used as an argument to g_application_uninhibit()
1334  *     in order to remove the request. If the platform does not support
1335  *     inhibiting or the request failed for some reason, 0 is returned.
1336  *
1337  * Since: 3.4
1338  */
1339 guint
1340 gtk_application_inhibit (GtkApplication             *application,
1341                          GtkWindow                  *window,
1342                          GtkApplicationInhibitFlags  flags,
1343                          const gchar                *reason)
1344 {
1345   GVariant *res;
1346   GError *error = NULL;
1347   guint cookie;
1348   guint xid;
1349
1350   g_return_val_if_fail (GTK_IS_APPLICATION (application), 0);
1351   g_return_val_if_fail (!g_application_get_is_remote (G_APPLICATION (application)), 0);
1352   g_return_val_if_fail (application->priv->sm_proxy != NULL, 0);
1353
1354   if (window != NULL)
1355     xid = GDK_WINDOW_XID (gtk_widget_get_window (GTK_WIDGET (window)));
1356   else
1357     xid = 0;
1358
1359   res = g_dbus_proxy_call_sync (application->priv->sm_proxy,
1360                                 "Inhibit",
1361                                 g_variant_new ("(susu)",
1362                                                application->priv->app_id,
1363                                                xid,
1364                                                reason,
1365                                                flags),
1366                                 G_DBUS_CALL_FLAGS_NONE,
1367                                 G_MAXINT,
1368                                 NULL,
1369                                 &error);
1370  if (error)
1371     {
1372       g_warning ("Calling Inhibit failed: %s", error->message);
1373       g_error_free (error);
1374       return 0;
1375     }
1376
1377   g_variant_get (res, "(u)", &cookie);
1378   g_variant_unref (res);
1379
1380   return cookie;
1381 }
1382
1383 /**
1384  * gtk_application_uninhibit:
1385  * @application: the #GApplication
1386  * @cookie: a cookie that was returned by g_application_inhibit()
1387  *
1388  * Removes an inhibitor that has been established with g_application_inhibit().
1389  * Inhibitors are also cleared when the application exits.
1390  *
1391  * Since: 3.4
1392  */
1393 void
1394 gtk_application_uninhibit (GtkApplication *application,
1395                            guint           cookie)
1396 {
1397   g_return_if_fail (GTK_IS_APPLICATION (application));
1398   g_return_if_fail (!g_application_get_is_remote (G_APPLICATION (application)));
1399   g_return_if_fail (application->priv->sm_proxy != NULL);
1400
1401   g_dbus_proxy_call (application->priv->sm_proxy,
1402                      "Uninhibit",
1403                      g_variant_new ("(u)", cookie),
1404                      G_DBUS_CALL_FLAGS_NONE,
1405                      G_MAXINT,
1406                      NULL, NULL, NULL);
1407 }
1408
1409 /**
1410  * gtk_application_is_inhibited:
1411  * @application: the #GApplication
1412  * @flags: what types of actions should be queried
1413  *
1414  * Determines if any of the actions specified in @flags are
1415  * currently inhibited (possibly by another application).
1416  *
1417  * Returns: %TRUE if any of the actions specified in @flags are inhibited
1418  *
1419  * Since: 3.4
1420  */
1421 gboolean
1422 gtk_application_is_inhibited (GtkApplication             *application,
1423                               GtkApplicationInhibitFlags  flags)
1424 {
1425   GVariant *res;
1426   GError *error = NULL;
1427   gboolean inhibited;
1428
1429   g_return_val_if_fail (GTK_IS_APPLICATION (application), FALSE);
1430   g_return_val_if_fail (!g_application_get_is_remote (G_APPLICATION (application)), FALSE);
1431   g_return_val_if_fail (application->priv->sm_proxy != NULL, FALSE);
1432
1433   res = g_dbus_proxy_call_sync (application->priv->sm_proxy,
1434                                 "IsInhibited",
1435                                 g_variant_new ("(u)", flags),
1436                                 G_DBUS_CALL_FLAGS_NONE,
1437                                 G_MAXINT,
1438                                 NULL,
1439                                 &error);
1440   if (error)
1441     {
1442       g_warning ("Calling IsInhibited failed: %s", error->message);
1443       g_error_free (error);
1444       return FALSE;
1445     }
1446
1447   g_variant_get (res, "(b)", &inhibited);
1448   g_variant_unref (res);
1449
1450   return inhibited;
1451 }
1452
1453 #elif defined(GDK_WINDOWING_QUARTZ)
1454
1455 /* OS X implementation copied from EggSMClient, but simplified since
1456  * it doesn't need to interact with the user.
1457  */
1458
1459 static gboolean
1460 idle_will_quit (gpointer data)
1461 {
1462   GtkApplication *app = data;
1463
1464   if (app->priv->quit_inhibit == 0)
1465     g_application_quit (G_APPLICATION (app));
1466   else
1467     {
1468       GtkApplicationQuartzInhibitor *inhibitor;
1469       GSList *iter;
1470       GtkWidget *dialog;
1471
1472       for (iter = app->priv->inhibitors; iter; iter = iter->next)
1473         {
1474           inhibitor = iter->data;
1475           if (inhibitor->flags & GTK_APPLICATION_INHIBIT_LOGOUT)
1476             break;
1477         }
1478       g_assert (inhibitor != NULL);
1479
1480       dialog = gtk_message_dialog_new (inhibitor->window,
1481                                        GTK_DIALOG_MODAL,
1482                                        GTK_MESSAGE_ERROR,
1483                                        GTK_BUTTONS_OK,
1484                                        _("%s cannot quit at this time:\n\n%s"),
1485                                        g_get_application_name (),
1486                                        inhibitor->reason);
1487       g_signal_connect_swapped (dialog,
1488                                 "response",
1489                                 G_CALLBACK (gtk_widget_destroy),
1490                                 dialog);
1491       gtk_widget_show_all (dialog);
1492     }
1493
1494   return G_SOURCE_REMOVE;
1495 }
1496
1497 static pascal OSErr
1498 quit_requested (const AppleEvent *aevt,
1499                 AppleEvent       *reply,
1500                 long              refcon)
1501 {
1502   GtkApplication *app = GSIZE_TO_POINTER ((gsize)refcon);
1503
1504   /* Don't emit the "quit" signal immediately, since we're
1505    * called from a weird point in the guts of gdkeventloop-quartz.c
1506    */
1507   g_idle_add_full (G_PRIORITY_DEFAULT, idle_will_quit, app, NULL);
1508
1509   return app->priv->quit_inhibit == 0 ? noErr : userCanceledErr;
1510 }
1511
1512 static void
1513 gtk_application_startup_session_quartz (GtkApplication *app)
1514 {
1515   if (app->priv->register_session)
1516     AEInstallEventHandler (kCoreEventClass, kAEQuitApplication,
1517                            NewAEEventHandlerUPP (quit_requested),
1518                            (long)GPOINTER_TO_SIZE (app), false);
1519 }
1520
1521 guint
1522 gtk_application_inhibit (GtkApplication             *application,
1523                          GtkWindow                  *window,
1524                          GtkApplicationInhibitFlags  flags,
1525                          const gchar                *reason)
1526 {
1527   GtkApplicationQuartzInhibitor *inhibitor;
1528
1529   g_return_val_if_fail (GTK_IS_APPLICATION (application), 0);
1530   g_return_val_if_fail (flags != 0, 0);
1531
1532   inhibitor = g_slice_new (GtkApplicationQuartzInhibitor);
1533   inhibitor->cookie = ++application->priv->next_cookie;
1534   inhibitor->flags = flags;
1535   inhibitor->reason = g_strdup (reason);
1536   inhibitor->window = window ? g_object_ref (window) : NULL;
1537
1538   application->priv->inhibitors = g_slist_prepend (application->priv->inhibitors, inhibitor);
1539
1540   if (flags & GTK_APPLICATION_INHIBIT_LOGOUT)
1541     application->priv->quit_inhibit++;
1542
1543   return inhibitor->cookie;
1544 }
1545
1546 void
1547 gtk_application_uninhibit (GtkApplication *application,
1548                            guint           cookie)
1549 {
1550   GSList *iter;
1551
1552   for (iter = application->priv->inhibitors; iter; iter = iter->next)
1553     {
1554       GtkApplicationQuartzInhibitor *inhibitor = iter->data;
1555
1556       if (inhibitor->cookie == cookie)
1557         {
1558           if (inhibitor->flags & GTK_APPLICATION_INHIBIT_LOGOUT)
1559             application->priv->quit_inhibit--;
1560           gtk_application_quartz_inhibitor_free (inhibitor);
1561           application->priv->inhibitors = g_slist_delete_link (application->priv->inhibitors, iter);
1562           return;
1563         }
1564     }
1565
1566   g_warning ("Invalid inhibitor cookie");
1567 }
1568
1569 gboolean
1570 gtk_application_is_inhibited (GtkApplication             *application,
1571                               GtkApplicationInhibitFlags  flags)
1572 {
1573   if (flags & GTK_APPLICATION_INHIBIT_LOGOUT)
1574     return application->priv->quit_inhibit > 0;
1575
1576   return FALSE;
1577 }
1578
1579 #else
1580
1581 /* Trivial implementation.
1582  *
1583  * For the inhibit API on Windows, see
1584  * http://msdn.microsoft.com/en-us/library/ms700677%28VS.85%29.aspx
1585  */
1586
1587 guint
1588 gtk_application_inhibit (GtkApplication             *application,
1589                          GtkWindow                  *window,
1590                          GtkApplicationInhibitFlags  flags,
1591                          const gchar                *reason)
1592 {
1593   return 0;
1594 }
1595
1596 void
1597 gtk_application_uninhibit (GtkApplication *application,
1598                            guint           cookie)
1599 {
1600 }
1601
1602 gboolean
1603 gtk_application_is_inhibited (GtkApplication             *application,
1604                               GtkApplicationInhibitFlags  flags)
1605 {
1606   return FALSE;
1607 }
1608
1609 #endif