// Generated by gmmproc 2.66.7 -- DO NOT MODIFY! #ifndef _GTKMM_MAIN_H #define _GTKMM_MAIN_H #include #include #include /* * Copyright (C) 1998-2003 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include #include #include #include namespace Gtk { #ifndef GTKMM_DISABLE_DEPRECATED class GTKMM_API Widget; class GTKMM_API Window; //********************************************************************** #ifndef DOXYGEN_SHOULD_SKIP_THIS //Actually, I'd like to just keep these out of the alphabetical list. murrayc. /// KeySnooper Signal Class (internal) class GTKMM_API KeySnooperSig { public: typedef sigc::slot SlotType; sigc::connection connect(const SlotType& slot); protected: static int gtk_callback(GtkWidget* widget, GdkEventKey* event, gpointer data); }; #endif /* DOXYGEN_SHOULD_SKIP_THIS */ #endif // GTKMM_DISABLE_DEPRECATED //********************************************************************** /** Main application class. * Every application must have one of these objects. * It may not be global and must be the first gtkmm object created. * It is a singleton so declaring more than one will simply access the first * created. * * You would normally use this class in your main() function to initialize gtkmm * and optionally to give argc and argv to the GTK+ initialization. * After calling Gtk::Main::run(), you may use Gtk::Main::quit() to exit from * the application, or just pass your main window to run(), to make run() * return when that window closes. * * A minimal gtkmm application would be something like this: * @code * int main(int argc, char *argv[]) * { * Gtk::Main kit(argc, argv); * ... create some widgets and windows... * kit.run(window); * } * @endcode * * @deprecated Use Gtk::Application instead. */ class GTKMM_API Main : public sigc::trackable { public: #ifndef GTKMM_DISABLE_DEPRECATED //This offers the same functionality as gtk_init_with_args(): /** Scans the argument vector, and strips off all parameters parsed by GTK+ or your @a 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 * --help output. Note that your program will * be terminated after writing out the help output. * * @param argc a reference to the number of command line arguments. * @param argv a reference to the array of command line arguments. * @param option_context A Glib::OptionContext containing Glib::OptionGroups which described the command-line arguments taken by your program. * * @throw Glib::OptionError * * @deprecated Use Gtk::Application instead. */ Main(int& argc, char**& argv, Glib::OptionContext& option_context); /** 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.) * * @param argc a pointer to the number of command line arguments. * @param argv a pointer to the array of command line arguments. * @param set_locale Passing false prevents GTK+ from automatically calling * setlocale(LC_ALL, ""). You would want to pass false if you wanted to set * the locale for your program to something other than the user's locale, or * if you wanted to set different values for different locale categories. * * @deprecated Use Gtk::Application instead. */ 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. * * @param argc a reference to the number of command line arguments. * @param argv a reference to the array of command line arguments. * @param set_locale Passing false prevents GTK+ from automatically calling * setlocale(LC_ALL, ""). You would want to pass false if you wanted to set * the locale for your program to something other than the user's locale, or * if you wanted to set different values for different locale categories. * * @deprecated Use Gtk::Application instead. */ Main(int& argc, char**& argv, bool set_locale = true); /** Initialization without command-line arguments. * * @param set_locale Passing false prevents GTK+ from automatically calling * setlocale(LC_ALL, ""). You would want to pass false if you wanted to set * the locale for your program to something other than the user's locale, or * if you wanted to set different values for different locale categories. * * @deprecated Use Gtk::Application instead. */ explicit Main(bool set_locale = true); /** * @deprecated Use Gtk::Application instead. */ virtual ~Main(); /** Access to the one global instance of Gtk::Main. * * @deprecated Use Gtk::Application instead. */ static Gtk::Main* instance(); /** 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 * * @deprecated Use Gtk::Application instead. */ static void run(); /** 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. * * @param window The window to show. This method will return when the window is hidden. * * @deprecated Use Gtk::Application instead. */ static void run(Window& window); /** Makes the innermost invocation of the main loop return when it regains control. * * @deprecated Use Gtk::Application instead. */ static void quit(); /** * @deprecated Use Gtk::Application instead. */ static guint level(); #endif // GTKMM_DISABLE_DEPRECATED //TODO: Move these general methods out of Main when we really remove Main, //one day when Gtk::Application can really do everything, which should probably //include handling OptionContext properly. murrayc. //This attempts to provide the same functionality as gtk_get_option_group(): /** 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. * * @param option_context Option Context to which the group will be added. * @param open_default_display Whether to open the default display when parsing the commandline arguments. * * @deprecated Use Gtk::Application instead. */ static void add_gtk_option_group(Glib::OptionContext& option_context, bool open_default_display = true); /** 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 @a blocking or check if any events are pending with * pending() first. * * @param blocking Whether the caller must wait until the next event is noticed, or return immediately if there are no events. * @result true if quit() has been called for the innermost main loop. */ static bool iteration(bool blocking = true); /** 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. * @code * // computation going on * while( Gtk::Main::events_pending() ) * Gtk::Main::iteration(); * * // computation continued * @endcode * * @result true if any events are pending, false otherwise. */ static bool events_pending(); #ifndef GTKMM_DISABLE_DEPRECATED /** KeySnooper signal * Allows you to channel keypresses to a signal handler * without registering with the widget. * * @return 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. * * @deprecated Key snooping should not be done. Events should be handled by widgets. */ static KeySnooperSig& signal_key_snooper(); #endif // GTKMM_DISABLE_DEPRECATED /** Initialize the table of wrap_new functions. * This doesn't need an instance of Gtk::Main. * This would usually only be used by the init() methods of libraries that depend on gtkmm. */ static void init_gtkmm_internals(); protected: #ifndef GTKMM_DISABLE_DEPRECATED void init(int* argc, char*** argv, bool set_locale); // TODO: implement this to use the new Glib::OptionEntry argument parsing classes. //void init(int* argc, char*** argv, const std::string& parameter_string, const std::vector& entries, const std::string& translation_domain); virtual void run_impl(); virtual void quit_impl(); virtual guint level_impl(); virtual bool iteration_impl(bool blocking); virtual bool events_pending_impl(); // Signal handlers: virtual void on_window_hide(); // Signal proxies: static KeySnooperSig signal_key_snooper_; private: static Main* instance_; #endif // GTKMM_DISABLE_DEPRECATED }; } // namespace Gtk #endif /* _GTKMM_MAIN_H */