gtk2/gtk/gtkapplication-quartz.c
2014-01-23 21:04:59 -05:00

335 lines
11 KiB
C

/*
* Copyright © 2010 Codethink Limited
* 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 "gtkapplicationprivate.h"
#include "gtkbuilder.h"
#import <Cocoa/Cocoa.h>
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);
}
typedef GtkApplicationImplClass GtkApplicationImplQuartzClass;
typedef struct
{
GtkApplicationImpl impl;
GtkActionMuxer *muxer;
GMenu *combined;
GSList *inhibitors;
gint quit_inhibit;
guint next_cookie;
NSObject *delegate;
} GtkApplicationImplQuartz;
G_DEFINE_TYPE (GtkApplicationImplQuartz, gtk_application_impl_quartz, GTK_TYPE_APPLICATION_IMPL)
@interface GtkApplicationQuartzDelegate : NSObject
{
GtkApplicationImplQuartz *quartz;
}
- (id)initWithImpl:(GtkApplicationImplQuartz*)impl;
- (NSApplicationTerminateReply) applicationShouldTerminate:(NSApplication *)sender;
@end
@implementation GtkApplicationQuartzDelegate
-(id)initWithImpl:(GtkApplicationImplQuartz*)impl
{
[super init];
quartz = impl;
return self;
}
-(NSApplicationTerminateReply) applicationShouldTerminate:(NSApplication *)sender
{
/* We have no way to give our message other than to pop up a dialog
* ourselves, which we should not do since the OS will already show
* one when we return NSTerminateNow.
*
* Just let the OS show the generic message...
*/
return quartz->quit_inhibit == 0 ? NSTerminateNow : NSTerminateCancel;
}
@end
/* these exist only for accel handling */
static void
gtk_application_impl_quartz_hide (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
[NSApp hide:NSApp];
}
static void
gtk_application_impl_quartz_hide_others (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
[NSApp hideOtherApplications:NSApp];
}
static void
gtk_application_impl_quartz_show_all (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
[NSApp unhideAllApplications:NSApp];
}
static GActionEntry gtk_application_impl_quartz_actions[] = {
{ "hide", gtk_application_impl_quartz_hide },
{ "hide-others", gtk_application_impl_quartz_hide_others },
{ "show-all", gtk_application_impl_quartz_show_all }
};
static void
gtk_application_impl_quartz_startup (GtkApplicationImpl *impl,
gboolean register_session)
{
GtkApplicationImplQuartz *quartz = (GtkApplicationImplQuartz *) impl;
GSimpleActionGroup *gtkinternal;
GMenuModel *app_menu;
if (register_session)
{
quartz->delegate = [[GtkApplicationQuartzDelegate alloc] initWithImpl:quartz];
[NSApp setDelegate: quartz->delegate];
}
quartz->muxer = gtk_action_muxer_new ();
gtk_action_muxer_set_parent (quartz->muxer, gtk_application_get_action_muxer (impl->application));
/* Add the default accels */
gtk_application_add_accelerator (impl->application, "<Primary>comma", "app.preferences", NULL);
gtk_application_add_accelerator (impl->application, "<Primary><Alt>h", "gtkinternal.hide-others", NULL);
gtk_application_add_accelerator (impl->application, "<Primary>h", "gtkinternal.hide", NULL);
gtk_application_add_accelerator (impl->application, "<Primary>q", "app.quit", NULL);
/* and put code behind the 'special' accels */
gtkinternal = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (gtkinternal), gtk_application_impl_quartz_actions,
G_N_ELEMENTS (gtk_application_impl_quartz_actions), quartz);
gtk_application_insert_action_group (impl->application, "gtkinternal", G_ACTION_GROUP (gtkinternal));
g_object_unref (gtkinternal);
/* now setup the menu */
app_menu = gtk_application_get_app_menu (impl->application);
if (app_menu == NULL)
{
GtkBuilder *builder;
/* If the user didn't fill in their own menu yet, add ours.
*
* The fact that we do this here ensures that we will always have the
* app menu at index 0 in 'combined'.
*/
builder = gtk_builder_new_from_resource ("/org/gtk/libgtk/ui/gtkapplication-quartz.ui");
gtk_application_set_app_menu (impl->application, G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu")));
g_object_unref (builder);
}
else
gtk_application_impl_set_app_menu (impl, app_menu);
/* This may or may not add an item to 'combined' */
gtk_application_impl_set_menubar (impl, gtk_application_get_menubar (impl->application));
/* OK. Now put it in the menu. */
gtk_application_impl_quartz_setup_menu (G_MENU_MODEL (quartz->combined), quartz->muxer);
[NSApp finishLaunching];
}
static void
gtk_application_impl_quartz_shutdown (GtkApplicationImpl *impl)
{
GtkApplicationImplQuartz *quartz = (GtkApplicationImplQuartz *) impl;
/* destroy our custom menubar */
[NSApp setMainMenu:[[[NSMenu alloc] init] autorelease]];
if (quartz->delegate)
{
[quartz->delegate release];
quartz->delegate = NULL;
}
g_slist_free_full (quartz->inhibitors, (GDestroyNotify) gtk_application_quartz_inhibitor_free);
quartz->inhibitors = NULL;
}
static void
gtk_application_impl_quartz_active_window_changed (GtkApplicationImpl *impl,
GtkWindow *window)
{
GtkApplicationImplQuartz *quartz = (GtkApplicationImplQuartz *) impl;
gtk_action_muxer_remove (quartz->muxer, "win");
if (G_IS_ACTION_GROUP (window))
gtk_action_muxer_insert (quartz->muxer, "win", G_ACTION_GROUP (window));
}
static void
gtk_application_impl_quartz_set_app_menu (GtkApplicationImpl *impl,
GMenuModel *app_menu)
{
GtkApplicationImplQuartz *quartz = (GtkApplicationImplQuartz *) impl;
/* If there are any items at all, then the first one is the app menu */
if (g_menu_model_get_n_items (G_MENU_MODEL (quartz->combined)))
g_menu_remove (quartz->combined, 0);
if (app_menu)
g_menu_prepend_submenu (quartz->combined, "Application", app_menu);
else
{
GMenu *empty;
/* We must preserve the rule that index 0 is the app menu */
empty = g_menu_new ();
g_menu_prepend_submenu (quartz->combined, "Application", G_MENU_MODEL (empty));
g_object_unref (empty);
}
}
static void
gtk_application_impl_quartz_set_menubar (GtkApplicationImpl *impl,
GMenuModel *menubar)
{
GtkApplicationImplQuartz *quartz = (GtkApplicationImplQuartz *) impl;
/* If we have the menubar, it is a section at index '1' */
if (g_menu_model_get_n_items (G_MENU_MODEL (quartz->combined)) > 1)
g_menu_remove (quartz->combined, 1);
if (menubar)
g_menu_append_section (quartz->combined, NULL, menubar);
}
static guint
gtk_application_impl_quartz_inhibit (GtkApplicationImpl *impl,
GtkWindow *window,
GtkApplicationInhibitFlags flags,
const gchar *reason)
{
GtkApplicationImplQuartz *quartz = (GtkApplicationImplQuartz *) impl;
GtkApplicationQuartzInhibitor *inhibitor;
inhibitor = g_slice_new (GtkApplicationQuartzInhibitor);
inhibitor->cookie = ++quartz->next_cookie;
inhibitor->flags = flags;
inhibitor->reason = g_strdup (reason);
inhibitor->window = window ? g_object_ref (window) : NULL;
quartz->inhibitors = g_slist_prepend (quartz->inhibitors, inhibitor);
if (flags & GTK_APPLICATION_INHIBIT_LOGOUT)
quartz->quit_inhibit++;
return inhibitor->cookie;
}
static void
gtk_application_impl_quartz_uninhibit (GtkApplicationImpl *impl,
guint cookie)
{
GtkApplicationImplQuartz *quartz = (GtkApplicationImplQuartz *) impl;
GSList *iter;
for (iter = quartz->inhibitors; iter; iter = iter->next)
{
GtkApplicationQuartzInhibitor *inhibitor = iter->data;
if (inhibitor->cookie == cookie)
{
if (inhibitor->flags & GTK_APPLICATION_INHIBIT_LOGOUT)
quartz->quit_inhibit--;
gtk_application_quartz_inhibitor_free (inhibitor);
quartz->inhibitors = g_slist_delete_link (quartz->inhibitors, iter);
return;
}
}
g_warning ("Invalid inhibitor cookie");
}
static gboolean
gtk_application_impl_quartz_is_inhibited (GtkApplicationImpl *impl,
GtkApplicationInhibitFlags flags)
{
GtkApplicationImplQuartz *quartz = (GtkApplicationImplQuartz *) impl;
if (flags & GTK_APPLICATION_INHIBIT_LOGOUT)
return quartz->quit_inhibit > 0;
return FALSE;
}
static void
gtk_application_impl_quartz_init (GtkApplicationImplQuartz *quartz)
{
quartz->combined = g_menu_new ();
}
static void
gtk_application_impl_quartz_finalize (GObject *object)
{
GtkApplicationImplQuartz *quartz = (GtkApplicationImplQuartz *) object;
g_clear_object (&quartz->combined);
G_OBJECT_CLASS (gtk_application_impl_quartz_parent_class)->finalize (object);
}
static void
gtk_application_impl_quartz_class_init (GtkApplicationImplClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (class);
class->startup = gtk_application_impl_quartz_startup;
class->shutdown = gtk_application_impl_quartz_shutdown;
class->active_window_changed = gtk_application_impl_quartz_active_window_changed;
class->set_app_menu = gtk_application_impl_quartz_set_app_menu;
class->set_menubar = gtk_application_impl_quartz_set_menubar;
class->inhibit = gtk_application_impl_quartz_inhibit;
class->uninhibit = gtk_application_impl_quartz_uninhibit;
class->is_inhibited = gtk_application_impl_quartz_is_inhibited;
gobject_class->finalize = gtk_application_impl_quartz_finalize;
}