diff options
Diffstat (limited to 'gio/src/application.hg')
| -rw-r--r-- | gio/src/application.hg | 219 |
1 files changed, 219 insertions, 0 deletions
diff --git a/gio/src/application.hg b/gio/src/application.hg new file mode 100644 index 00000000..571042ec --- /dev/null +++ b/gio/src/application.hg @@ -0,0 +1,219 @@ +// -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 2 -*- + +/* Copyright (C) 2007 The gtkmm Development Team + * + * 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.1 of the License, 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, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include <giomm/applicationcommandline.h> +#include <giomm/file.h> +#include <glibmm/object.h> +#include <glibmm/variant.h> + +_DEFS(giomm,gio) +_PINCLUDE(glibmm/private/object_p.h) + +namespace Gio +{ + +_WRAP_ENUM(ApplicationFlags, GApplicationFlags, NO_GTYPE) + +class ActionGroup; + +/** Application - Core application class. + * An Application is the foundation of an application, unique for a given + * application identifier. The Application class wraps some low-level + * platform-specific services and is intended to act as the foundation for + * higher-level application classes such as Gtk::Application or MxApplication. + * In general, you should not use this class outside of a higher level + * framework. + * + * One of the core features that Application provides is process uniqueness, + * in the context of a "session". The session concept is platform-dependent, + * but corresponds roughly to a graphical desktop login. When your application + * is launched again, its arguments are passed through platform communication + * to the already running program. The already running instance of the program + * is called the <i>primary instance</i>. + * + * Before using Application, you must choose an "application identifier". The + * expected form of an application identifier is very close to that of of a + * <a href=" + * http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-interface">DBus + * bus name</a>. Examples include: "com.example.MyApp", + * "org.example.internal-apps.Calculator". For details on valid application + * identifiers, see id_is_valid(). + * + * Application provides convenient life cycle management by maintaining a + * <i>use count</i> for the primary application instance. The use count can be + * changed using hold() and release(). If it drops to zero, the application + * exits. + * + * Application also implements the ActionGroup interface and lets you easily + * export actions by adding them with set_action_group(). When + * invoking an action by calling Gio::ActionGroup::activate_action() on the + * application, it is always invoked in the primary instance. + * + * There is a number of different entry points into an Application: + * + * - via 'Activate' (i.e. just starting the application) + * - via 'Open' (i.e. opening some files) + * - via activating an action + * + * The signal_startup() signal lets you handle the application initialization + * for all of these in a single place. + * + * See the C API docs for an example. + * + * @newin{2,28} + */ +class Application : public Glib::Object +{ + _CLASS_GOBJECT(Application, GApplication, G_APPLICATION, Glib::Object, GObject) + +protected: + explicit Application(const Glib::ustring& application_id, ApplicationFlags flags=APPLICATION_FLAGS_NONE); + _IGNORE(g_application_new) + +public: + _WRAP_CREATE(const Glib::ustring& application_id, ApplicationFlags flags=APPLICATION_FLAGS_NONE) + + _WRAP_METHOD(static bool id_is_valid(const Glib::ustring& application_id), g_application_id_is_valid) + + _WRAP_METHOD(Glib::ustring get_id() const, g_application_get_application_id) + _WRAP_METHOD(void set_id(const Glib::ustring& application_id), g_application_set_application_id) + + _WRAP_METHOD(guint get_inactivity_timeout() const, g_application_get_inactivity_timeout) + _WRAP_METHOD(void set_inactivity_timeout(guint inactivity_timeout), g_application_set_inactivity_timeout) + + _WRAP_METHOD(ApplicationFlags get_flags() const, g_application_get_flags) + _WRAP_METHOD(void set_flags(ApplicationFlags flags), g_application_set_flags) + + _WRAP_METHOD(void set_action_group(const Glib::RefPtr<ActionGroup>& action_group), g_application_set_action_group) + + _WRAP_METHOD(bool is_registered() const, g_application_get_is_registered) + _WRAP_METHOD(bool is_remote() const, g_application_get_is_remote) + + //Renamed from register() because that is a C++ keyword. + _WRAP_METHOD(bool register_application(const Glib::RefPtr<Gio::Cancellable>& cancellable), g_application_register, errthrow) + + /// Non-cancellable version of register_application(). + bool register_application(); + + _WRAP_METHOD(void hold(), g_application_hold) + _WRAP_METHOD(void release(), g_application_release) + _WRAP_METHOD(void activate(), g_application_activate) + + typedef std::vector< Glib::RefPtr<File> > type_vec_files; + + /* Opens the given files. + * + * In essence, this results in the open signal being emitted + * in the primary instance. + * + * @a hint is simply passed through to the open signal. It is + * intended to be used by applications that have multiple modes for + * opening files (eg: "view" vs "edit", etc). + * + * The application must be registered before calling this mwethod + * and it must have the APPLICATION_HANDLES_OPEN flag set. + * + * @param files The files to open. This must be non-empty. + * @param hint A hint. + * + * @newin{2,28} + */ + void open(const type_vec_files& files, const Glib::ustring& hint = Glib::ustring()); + _IGNORE(g_application_open) + + /* Opens the given file. + * + * In essence, this results in the open signal being emitted + * in the primary instance. + * + * @a hint is simply passed through to the open signal. It is + * intended to be used by applications that have multiple modes for + * opening files (eg: "view" vs "edit", etc). + * + * The application must be registered before calling this mwethod + * and it must have the APPLICATION_HANDLES_OPEN flag set. + * + * @param file The file to open. This must be non-empty. + * @param hint A hint. + * + * @newin{2,28} + */ + void open(const Glib::RefPtr<Gio::File>& file, const Glib::ustring& hint = Glib::ustring()); + + _WRAP_METHOD(int run(int argc, char** argv), g_application_run) + //TODO: g_application_run_with_arguments) + + _WRAP_PROPERTY("action-group", Glib::RefPtr<ActionGroup>) + _WRAP_PROPERTY("application-id", Glib::ustring) + _WRAP_PROPERTY("flags", ApplicationFlags) + _WRAP_PROPERTY("inactivity-timeout", guint) + _WRAP_PROPERTY("is-registered", bool) + _WRAP_PROPERTY("is-remote", bool) + +//#m4 _CONVERSION(`const gchar*', `const Glib::ustring&', `Glib::ustring($3)') +//#m4 _CONVERSION(`GVariant*', `const Glib::VariantBase&', `Glib::wrap($3, true)') + + _WRAP_SIGNAL(void startup(), "startup") + _WRAP_SIGNAL(void activate(), "activate") + + //We wrap the open signal without _WRAP_SIGNAL(), because we need to change its parameters. + //See bug https://bugzilla.gnome.org/show_bug.cgi?id=637457 + Glib::SignalProxy2< void, const type_vec_files&, const Glib::ustring& > signal_open(); + +#m4 _CONVERSION(`GApplicationCommandLine*', `const Glib::RefPtr<ApplicationCommandLine>&',`Glib::wrap($3, true)') + _WRAP_SIGNAL(int command_line(const Glib::RefPtr<ApplicationCommandLine>& command_line), "command-line") + +protected: + virtual void on_open(const type_vec_files& files, const Glib::ustring& hint); + +#m4begin + _PUSH(SECTION_PCC_CLASS_INIT_DEFAULT_SIGNAL_HANDLERS) + klass->open = &open_callback; + _SECTION(SECTION_PH_DEFAULT_SIGNAL_HANDLERS) + static void open_callback(GApplication* self, GFile** files, gint n_files, const gchar* hint); + _POP() +#m4end + +#m4 _CONVERSION(`char**&', `gchar***',`&($3)') +#m4 _CONVERSION(`gchar***', `char**&',`*($3)') + _WRAP_VFUNC(bool local_command_line(char**& arguments, int& exit_status), local_command_line) + +/* TODO: + void (* before_emit) (GApplication *application, + GVariant *platform_data); + void (* after_emit) (GApplication *application, + GVariant *platform_data); + void (* add_platform_data) (GApplication *application, + GVariantBuilder *builder); + void (* quit_mainloop) (GApplication *application); + void (* run_mainloop) (GApplication *application); +*/ + + +private: + /** This is just a way to call Glib::init() (which calls g_type_init()) before + * calling application_class_.init(), so that + * g_application_get_type() will always succeed. + * See https://bugzilla.gnome.org/show_bug.cgi?id=639925 + */ + const Glib::Class& custom_class_init(); +}; + + +} // namespace Gio |