From 4ea2cc3bd4a7d9b1c54a9d33e6a1cf82e7c8c21d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Wed, 23 Jul 2014 09:06:59 +0200 Subject: Imported Upstream version 0.18.1 --- src/Application.vala | 228 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 228 insertions(+) create mode 100644 src/Application.vala (limited to 'src/Application.vala') diff --git a/src/Application.vala b/src/Application.vala new file mode 100644 index 0000000..95163cf --- /dev/null +++ b/src/Application.vala @@ -0,0 +1,228 @@ +/* Copyright 2010-2014 Yorba Foundation + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +public class Application { + private static Application instance = null; + private Gtk.Application system_app = null; + private int system_app_run_retval = 0; + private bool direct; + + public virtual signal void starting() { + } + + public virtual signal void exiting(bool panicked) { + } + + public virtual signal void init_done() { + } + + private bool fixup_raw_thumbs = false; + + public void set_raw_thumbs_fix_required(bool should_fixup) { + fixup_raw_thumbs = should_fixup; + } + + public bool get_raw_thumbs_fix_required() { + return fixup_raw_thumbs; + } + + private bool running = false; + private bool exiting_fired = false; + + private Application(bool is_direct) { + if (is_direct) { + // we allow multiple instances of ourself in direct mode, so DON'T + // attempt to be unique. We don't request any command-line handling + // here because this is processed elsewhere, and we don't need to handle + // command lines from remote instances, since we don't care about them. + system_app = new Gtk.Application("org.yorba.shotwell-direct", GLib.ApplicationFlags.HANDLES_OPEN | + GLib.ApplicationFlags.NON_UNIQUE); + } else { + // we've been invoked in library mode; set up for uniqueness and handling + // of incoming command lines from remote instances (needed for getting + // storage device and camera mounts). + system_app = new Gtk.Application("org.yorba.shotwell", GLib.ApplicationFlags.HANDLES_OPEN | + GLib.ApplicationFlags.HANDLES_COMMAND_LINE); + } + + // GLib will assert if we don't do this... + try { + system_app.register(); + } catch (Error e) { + panic(); + } + + direct = is_direct; + + if (!direct) { + system_app.command_line.connect(on_command_line); + } + + system_app.activate.connect(on_activated); + system_app.startup.connect(on_activated); + } + + /** + * @brief This is a helper for library mode that should only be + * called if we've gotten a camera mount and are _not_ the primary + * instance. + */ + public static void send_to_primary_instance(string[]? argv) { + get_instance().system_app.run(argv); + } + + /** + * @brief A helper for library mode that tells the primary + * instance to bring its window to the foreground. This + * should only be called if we are _not_ the primary instance. + */ + public static void present_primary_instance() { + get_instance().system_app.activate(); + } + + public static bool get_is_remote() { + return get_instance().system_app.get_is_remote(); + } + + public static bool get_is_direct() { + return get_instance().direct; + } + + /** + * @brief Signal handler for GApplication's 'command-line' signal. + * + * The most likely scenario for this to be fired is if the user + * either tried to run us twice in library mode, or we've just gotten + * a camera/removeable-storage mount; in either case, the remote instance + * will trigger this and exit, and we'll need to bring the window back up... + */ + public static void on_activated() { + get_instance(); + + LibraryWindow lw = AppWindow.get_instance() as LibraryWindow; + if ((lw != null) && (!get_is_direct())) { + LibraryWindow.get_app().present(); + } + } + + /** + * @brief Signal handler for GApplication's 'command-line' signal. + * + * Gets fired whenever a remote instance tries to run, usually + * with an incoming camera connection. + * + * @note This does _not_ get called in direct-edit mode. + */ + public static int on_command_line(ApplicationCommandLine acl) { + string[]? argv = acl.get_arguments(); + + if (argv != null) { + foreach (string s in argv) { + LibraryWindow lw = AppWindow.get_instance() as LibraryWindow; + if (lw != null) { + lw.mounted_camera_shell_notification(s, false); + } + } + } + on_activated(); + return 0; + } + + /** + * @brief Initializes the Shotwell application object and prepares + * it for use. + * + * @param is_direct Whether the application was invoked in direct + * or in library mode; defaults to FALSE, that is, library mode. + * + * @note This MUST be called prior to calling get_instance(), as the + * application needs to know what mode it was brought up in; failure to + * call this first will lead to an assertion. + */ + public static void init(bool is_direct = false) { + if (instance == null) + instance = new Application(is_direct); + } + + public static void terminate() { + get_instance().exit(); + } + + public static Application get_instance() { + assert (instance != null); + + return instance; + } + + public void start(string[]? argv = null) { + if (running) + return; + + running = true; + + starting(); + + assert(AppWindow.get_instance() != null); + system_app.add_window(AppWindow.get_instance()); + system_app_run_retval = system_app.run(argv); + + if (!direct) { + system_app.command_line.disconnect(on_command_line); + } + + system_app.activate.disconnect(on_activated); + system_app.startup.disconnect(on_activated); + + running = false; + } + + public void exit() { + // only fire this once, but thanks to terminate(), it will be fired at least once (even + // if start() is not called and "starting" is not fired) + if (exiting_fired || !running) + return; + + exiting_fired = true; + + exiting(false); + + system_app.release(); + } + + // This will fire the exiting signal with panicked set to true, but only if exit() hasn't + // already been called. This call will immediately halt the application. + public void panic() { + if (!exiting_fired) { + exiting_fired = true; + exiting(true); + } + Posix.exit(1); + } + + /** + * @brief Allows the caller to ask for some part of the desktop session's functionality to + * be prevented from running; wrapper for Gtk.Application.inhibit(). + * + * @note The return value is a 'cookie' that needs to be passed to 'uninhibit' to turn + * off a requested inhibition and should be saved by the caller. + */ + public uint inhibit(Gtk.ApplicationInhibitFlags what, string? reason="none given") { + return system_app.inhibit(AppWindow.get_instance(), what, reason); + } + + /** + * @brief Turns off a previously-requested inhibition. Wrapper for + * Gtk.Application.uninhibit(). + */ + public void uninhibit(uint cookie) { + system_app.uninhibit(cookie); + } + + public int get_run_return_value() { + return system_app_run_retval; + } +} + -- cgit v1.2.3