/*
 * 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 <gtk/gtk.h>

#include <sigc++/sigc++.h>
#include <gdkmm/types.h>
#include <glibmm/optioncontext.h>

_DEFS(gtkmm,gtk)

#m4 _PUSH(SECTION_CC_PRE_INCLUDES)
#undef GTK_DISABLE_DEPRECATED
#define GDK_DISABLE_DEPRECATION_WARNINGS 1
#m4 _POP()

namespace Gtk
{

class Window;

//**********************************************************************

/** 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 Main : public sigc::trackable
{
public:

_DEPRECATE_IFDEF_START
  //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
   * <tt>--help</tt> 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();

_DEPRECATE_IFDEF_END

  //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();

  /** 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:

_DEPRECATE_IFDEF_START
  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<const Glib::OptionEntry&>& 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();

private:
  static Main* instance_;
_DEPRECATE_IFDEF_END
};

} // namespace Gtk

