gtkmm  2.24.4
Public Member Functions | Static Public Member Functions | Protected Member Functions | Static Protected Attributes | List of all members
Gtk::Main Class Reference

Main application class Every application must have one of these objects. More...

Inheritance diagram for Gtk::Main:
Inheritance graph
[legend]
Collaboration diagram for Gtk::Main:
Collaboration graph
[legend]

Public Member Functions

 Main (int& argc, char**& argv, Glib::OptionContext& option_context)
 Scans the argument vector, and strips off all parameters parsed by GTK+ or your option_context. More...
 
 Main (int* argc, char*** argv, bool set_locale=true)
 Scans the argument vector, and strips off all parameters known to GTK+. More...
 
 Main (int& argc, char**& argv, bool set_locale=true)
 See Main(int* argc, char*** argv, bool set_locale). More...
 
virtual ~Main ()
 
- Public Member Functions inherited from sigc::trackable
 trackable () noexcept
 
 trackable (const trackable &src) noexcept
 
 trackable (trackable &&src)
 
 ~trackable ()
 
void add_destroy_notify_callback (void *data, func_destroy_notify func) const
 
void notify_callbacks ()
 
trackableoperator= (const trackable &src)
 
trackableoperator= (trackable &&src)
 
void remove_destroy_notify_callback (void *data) const
 

Static Public Member Functions

static Gtk::Maininstance ()
 Access to the one global instance of Gtk::Main. More...
 
static void run ()
 Start the event loop. More...
 
static void run (Window& window)
 Returns from the main loop when the window is closed. More...
 
static void quit ()
 Makes the innermost invocation of the main loop return when it regains control. More...
 
static guint level ()
 
static void add_gtk_option_group (Glib::OptionContext& option_context, bool open_default_display=true)
 Add a Glib::OptionGroup, for the commandline arguments recognized by GTK+ and GDK, to a Glib::OptionContext, so that these commandline arguments will be processed in addition to the existing commandline arguments specified by the Glib::OptionContext. More...
 
static bool iteration (bool blocking=true)
 Runs a single iteration of the main loop. More...
 
static bool events_pending ()
 Checks if any events are pending. More...
 
static RunSig& signal_run ()
 Run signal. More...
 
static QuitSig& signal_quit ()
 Quit signal You can connect signal handlers to invoke actions when Gtk::Main::quit() has been called. More...
 
static KeySnooperSig& signal_key_snooper ()
 KeySnooper signal Allows you to channel keypresses to a signal handler without registering with the widget. More...
 
static void init_gtkmm_internals ()
 

Protected Member Functions

 Main ()
 
void init (int* argc, char*** argv, bool set_locale)
 
virtual void run_impl ()
 
virtual void quit_impl ()
 
virtual guint level_impl ()
 
virtual bool iteration_impl (bool blocking)
 
virtual bool events_pending_impl ()
 
virtual void on_window_hide ()
 

Static Protected Attributes

static RunSig signal_run_
 
static QuitSig signal_quit_
 
static KeySnooperSig signal_key_snooper_
 

Additional Inherited Members

- Public Types inherited from sigc::trackable
typedef internal::func_destroy_notify func_destroy_notify
 

Detailed Description

Main application class Every application must have one of these objects.

It may not be global and must be the first Gtk object created. It is a singleton so declaring more than one will simply access the first created.

Normal use of this class is in the main() function to give argc and argv to the gtk initialization. Widgets can use Gtk::Main::quit() to exit from the application.

The internals of the widget have been disguised as signals so that the user can easily connect using the same methods used throughout the widget interface.

Minimal gtkmm application is something like this:

int main(int argc, char *argv[]) {
Gtk::Main kit(argc, argv);
... create some widgets ...
kit.run();
}

Constructor & Destructor Documentation

Gtk::Main::Main ( int &  argc,
char **&  argv,
Glib::OptionContext option_context 
)

Scans the argument vector, and strips off all parameters parsed by GTK+ or your option_context.

Add a Glib::OptionGroup to the Glib::OptionContext to parse your own command-line arguments.

Note: The argument strings themself won't be modified, although the pointers to them might change. This makes it possible to create your own argv of string literals, which have the type 'const char[]' in standard C++. (You might need to use const_cast<>, though.)

This function automatically generates nicely formatted <option>–help</option> output. Note that your program will be terminated after writing out the help output.

Parameters
argca reference to the number of command line arguments.
argva reference to the array of command line arguments. a string which is displayed in the first line of <option>–help</option> output, after <literal><replaceable>programname</replaceable> [OPTION...]</literal>
option_contextA Glib::OptionContext containing Glib::OptionGroups which described the command-line arguments taken by your program.
Exceptions
Glib::OptionError
Gtk::Main::Main ( int *  argc,
char ***  argv,
bool  set_locale = true 
)

Scans the argument vector, and strips off all parameters known to GTK+.

Your application may then handle the remaining arguments.

Note: The argument strings themself won't be modified, although the pointers to them might change. This makes it possible to create your own argv of string literals, which have the type 'const char[]' in standard C++. (You might need to use const_cast<>, though.)

Gtk::Main::Main ( int &  argc,
char **&  argv,
bool  set_locale = true 
)
virtual Gtk::Main::~Main ( )
virtual
Gtk::Main::Main ( )
protected

Member Function Documentation

static void Gtk::Main::add_gtk_option_group ( Glib::OptionContext option_context,
bool  open_default_display = true 
)
static

Add a Glib::OptionGroup, for the commandline arguments recognized by GTK+ and GDK, to a Glib::OptionContext, so that these commandline arguments will be processed in addition to the existing commandline arguments specified by the Glib::OptionContext.

You do not need to use this method if you pass your Glib::OptionContext to the Main constructor, because it adds the gtk option group automatically.

Parameters
option_contextOption Context to which the group will be added.
open_default_displayWhether to open the default display when parsing the commandline arguments.
static bool Gtk::Main::events_pending ( )
static

Checks if any events are pending.

This can be used to update the GUI and invoke timeouts etc. while doing some time intensive computation.

Example: Updating the GUI during a long computation.

// computation going on
// computation continued
Returns
true if any events are pending, false otherwise.
virtual bool Gtk::Main::events_pending_impl ( )
protectedvirtual
void Gtk::Main::init ( int *  argc,
char ***  argv,
bool  set_locale 
)
protected
static void Gtk::Main::init_gtkmm_internals ( )
static
static Gtk::Main* Gtk::Main::instance ( )
static

Access to the one global instance of Gtk::Main.

static bool Gtk::Main::iteration ( bool  blocking = true)
static

Runs a single iteration of the main loop.

If no events are waiting to be processed GTK+ will block until the next event is noticed. If you don't want to block then pass false for blocking or check if any events are pending with pending() first.

Parameters
blockingWhether the caller must wait until the next event is noticed, or return immediately if there are no events.
Returns
true if quit() has been called for the innermost main loop.
virtual bool Gtk::Main::iteration_impl ( bool  blocking)
protectedvirtual
static guint Gtk::Main::level ( )
static
virtual guint Gtk::Main::level_impl ( )
protectedvirtual
virtual void Gtk::Main::on_window_hide ( )
protectedvirtual
static void Gtk::Main::quit ( )
static

Makes the innermost invocation of the main loop return when it regains control.

virtual void Gtk::Main::quit_impl ( )
protectedvirtual
static void Gtk::Main::run ( )
static

Start the event loop.

This begins the event loop which handles events. No events propagate until this has been called. It may be called recursively to popup dialogs

static void Gtk::Main::run ( Window window)
static

Returns from the main loop when the window is closed.

When using this override, you should not use Gtk::Main::quit() to close the application, but just call hide() on your Window class.

Parameters
windowThe window to show. This method will return when the window is hidden.
virtual void Gtk::Main::run_impl ( )
protectedvirtual
static KeySnooperSig& Gtk::Main::signal_key_snooper ( )
static

KeySnooper signal Allows you to channel keypresses to a signal handler without registering with the widget.

Returns
KeySnooperSig A Signal to which you can connect a sigc::slot< int, Widget *, GdkEventKey * >

It is the responsibility of the snooper to pass the keypress to the widget, however, care must be taken that the keypress is not passed twice.

static QuitSig& Gtk::Main::signal_quit ( )
static

Quit signal You can connect signal handlers to invoke actions when Gtk::Main::quit() has been called.

Note that main loops can be nested by calling Gtk::Main::run() recursively, therefore receiving this signal doesn't necessarily mean the application is about to be terminated. If you want to receive a signal only when the last main loop quits, call connect() with main_level = 1.

bool thisclass::mymethod() { return false; }
Gtk::Main::signal_quit().connect(sigc::mem_fun(this,& thisclass::mymethod));
Returns
bool - false means callback is removed, true means it'll be called again the next the main loop quits.
Deprecated:
This was removed in gtkmm-3.0 because it is not useful.
static RunSig& Gtk::Main::signal_run ( )
static

Run signal.

Returns
void

Member Data Documentation

KeySnooperSig Gtk::Main::signal_key_snooper_
staticprotected
QuitSig Gtk::Main::signal_quit_
staticprotected
RunSig Gtk::Main::signal_run_
staticprotected

The documentation for this class was generated from the following file: