/* GTK - The GIMP Toolkit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * 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 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 

 */

#include "config.h"

#include "gtkmain.h"

#include <glib.h>

#include "gdkconfig.h"

#include <locale.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <sys/types.h>		/* For uid_t, gid_t */

#ifdef G_OS_WIN32

#define STRICT

#include <windows.h>

#undef STRICT

#endif

#include "gtkintl.h"

#include "gtkaccelmap.h"

#include "gtkbox.h"

#include "gtkclipboard.h"

#include "gtkdnd.h"

#include "gtkversion.h"

#include "gtkmodules.h"

#include "gtkrc.h"

#include "gtkrecentmanager.h"

#include "gtkselection.h"

#include "gtksettings.h"

#include "gtkwidget.h"

#include "gtkwindow.h"

#include "gtktooltip.h"

#include "gtkdebug.h"

#include "gtkalias.h"

#include "gtkmenu.h"

#include "gdk/gdkkeysyms.h"

#include "gdk/gdkprivate.h" /* for GDK_WINDOW_DESTROYED */

#ifdef G_OS_WIN32

static HMODULE gtk_dll;

BOOL WINAPI

DllMain (HINSTANCE hinstDLL,

	 DWORD     fdwReason,

	 LPVOID    lpvReserved)

{

  switch (fdwReason)

    {

    case DLL_PROCESS_ATTACH:

      gtk_dll = (HMODULE) hinstDLL;

      break;

    }

  return TRUE;

}

/* These here before inclusion of gtkprivate.h so that the original

 * GTK_LIBDIR and GTK_LOCALEDIR definitions are seen. Yeah, this is a

 * bit sucky.

 */

const gchar *

_gtk_get_libdir (void)

{

  static char *gtk_libdir = NULL;

  if (gtk_libdir == NULL)

    {

      gchar *root = g_win32_get_package_installation_directory_of_module (gtk_dll);

      gchar *slash = root ? strrchr (root, '\\') : NULL;

      if (slash != NULL &&

          g_ascii_strcasecmp (slash + 1, ".libs") == 0)

	gtk_libdir = GTK_LIBDIR;

      else

	gtk_libdir = g_build_filename (root, "lib", NULL);

      g_free (root);

    }

  return gtk_libdir;

}

const gchar *

_gtk_get_localedir (void)

{

  static char *gtk_localedir = NULL;

  if (gtk_localedir == NULL)

    {

      const gchar *p;

      gchar *root, *temp;

      /* GTK_LOCALEDIR ends in either /lib/locale or

       * /share/locale. Scan for that slash.

       */

      p = GTK_LOCALEDIR + strlen (GTK_LOCALEDIR);

      while (*--p != '/')

	;

      while (*--p != '/')

	;

      root = g_win32_get_package_installation_directory_of_module (gtk_dll);

      temp = g_build_filename (root, p, NULL);

      g_free (root);

      /* gtk_localedir is passed to bindtextdomain() which isn't

       * UTF-8-aware.

       */

      gtk_localedir = g_win32_locale_filename_from_utf8 (temp);

      g_free (temp);

    }

  return gtk_localedir;

}

#endif

#include "gtkprivate.h"

/* Private type definitions

 */

typedef struct _GtkInitFunction		 GtkInitFunction;

typedef struct _GtkQuitFunction		 GtkQuitFunction;

typedef struct _GtkClosure	         GtkClosure;

typedef struct _GtkKeySnooperData	 GtkKeySnooperData;

struct _GtkInitFunction

{

  GtkFunction function;

  gpointer data;

};

struct _GtkQuitFunction

{

  guint id;

  guint main_level;

  GtkCallbackMarshal marshal;

  GtkFunction function;

  gpointer data;

  GDestroyNotify destroy;

};

struct _GtkClosure

{

  GtkCallbackMarshal marshal;

  gpointer data;

  GDestroyNotify destroy;

};

struct _GtkKeySnooperData

{

  GtkKeySnoopFunc func;

  gpointer func_data;

  guint id;

};

static gint  gtk_quit_invoke_function	 (GtkQuitFunction    *quitf);

static void  gtk_quit_destroy		 (GtkQuitFunction    *quitf);

static gint  gtk_invoke_key_snoopers	 (GtkWidget	     *grab_widget,

					  GdkEvent	     *event);

static void     gtk_destroy_closure      (gpointer            data);

static gboolean gtk_invoke_idle_timeout  (gpointer            data);

static void     gtk_invoke_input         (gpointer            data,

					  gint                source,

					  GdkInputCondition   condition);

#if 0

static void  gtk_error			 (gchar		     *str);

static void  gtk_warning		 (gchar		     *str);

static void  gtk_message		 (gchar		     *str);

static void  gtk_print			 (gchar		     *str);

#endif

static GtkWindowGroup *gtk_main_get_window_group (GtkWidget   *widget);

const guint gtk_major_version = GTK_MAJOR_VERSION;

const guint gtk_minor_version = GTK_MINOR_VERSION;

const guint gtk_micro_version = GTK_MICRO_VERSION;

const guint gtk_binary_age = GTK_BINARY_AGE;

const guint gtk_interface_age = GTK_INTERFACE_AGE;

static guint gtk_main_loop_level = 0;

static gint pre_initialized = FALSE;

static gint gtk_initialized = FALSE;

static GList *current_events = NULL;

static GSList *main_loops = NULL;      /* stack of currently executing main loops */

static GList *init_functions = NULL;	   /* A list of init functions.

					    */

static GList *quit_functions = NULL;	   /* A list of quit functions.

					    */

static GSList *key_snoopers = NULL;

guint gtk_debug_flags = 0;		   /* Global GTK debug flag */

#ifdef G_ENABLE_DEBUG

static const GDebugKey gtk_debug_keys[] = {

  {"misc", GTK_DEBUG_MISC},

  {"plugsocket", GTK_DEBUG_PLUGSOCKET},

  {"text", GTK_DEBUG_TEXT},

  {"tree", GTK_DEBUG_TREE},

  {"updates", GTK_DEBUG_UPDATES},

  {"keybindings", GTK_DEBUG_KEYBINDINGS},

  {"multihead", GTK_DEBUG_MULTIHEAD},

  {"modules", GTK_DEBUG_MODULES},

  {"geometry", GTK_DEBUG_GEOMETRY},

  {"icontheme", GTK_DEBUG_ICONTHEME},

  {"printing", GTK_DEBUG_PRINTING},

  {"builder", GTK_DEBUG_BUILDER}

};

#endif /* G_ENABLE_DEBUG */

/**

 * gtk_check_version:

 * @required_major: the required major version.

 * @required_minor: the required minor version.

 * @required_micro: the required micro version.

 * 

 * Checks that the GTK+ library in use is compatible with the

 * given version. Generally you would pass in the constants

 * #GTK_MAJOR_VERSION, #GTK_MINOR_VERSION, #GTK_MICRO_VERSION

 * as the three arguments to this function; that produces

 * a check that the library in use is compatible with

 * the version of GTK+ the application or module was compiled

 * against.

 *

 * Compatibility is defined by two things: first the version

 * of the running library is newer than the version

 * @required_major.required_minor.@required_micro. Second

 * the running library must be binary compatible with the

 * version @required_major.required_minor.@required_micro

 * (same major version.)

 *

 * This function is primarily for GTK+ modules; the module

 * can call this function to check that it wasn't loaded

 * into an incompatible version of GTK+. However, such a

 * a check isn't completely reliable, since the module may be

 * linked against an old version of GTK+ and calling the

 * old version of gtk_check_version(), but still get loaded

 * into an application using a newer version of GTK+.

 *

 * Return value: %NULL if the GTK+ library is compatible with the

 *   given version, or a string describing the version mismatch.

 *   The returned string is owned by GTK+ and should not be modified

 *   or freed.

 **/

const gchar*

gtk_check_version (guint required_major,

		   guint required_minor,

		   guint required_micro)

{

  gint gtk_effective_micro = 100 * GTK_MINOR_VERSION + GTK_MICRO_VERSION;

  gint required_effective_micro = 100 * required_minor + required_micro;

  if (required_major > GTK_MAJOR_VERSION)

    return "Gtk+ version too old (major mismatch)";

  if (required_major < GTK_MAJOR_VERSION)

    return "Gtk+ version too new (major mismatch)";

  if (required_effective_micro < gtk_effective_micro - GTK_BINARY_AGE)

    return "Gtk+ version too new (micro mismatch)";

  if (required_effective_micro > gtk_effective_micro)

    return "Gtk+ version too old (micro mismatch)";

  return NULL;

}

/* This checks to see if the process is running suid or sgid

 * at the current time. If so, we don't allow GTK+ to be initialized.

 * This is meant to be a mild check - we only error out if we

 * can prove the programmer is doing something wrong, not if

 * they could be doing something wrong. For this reason, we

 * don't use issetugid() on BSD or prctl (PR_GET_DUMPABLE).

 */

static gboolean

check_setugid (void)

{

/* this isn't at all relevant on MS Windows and doesn't compile ... --hb */

#ifndef G_OS_WIN32

  uid_t ruid, euid, suid; /* Real, effective and saved user ID's */

  gid_t rgid, egid, sgid; /* Real, effective and saved group ID's */

#ifdef HAVE_GETRESUID

  /* These aren't in the header files, so we prototype them here.

   */

  int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);

  int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);

  if (getresuid (&ruid, &euid, &suid) != 0 ||

      getresgid (&rgid, &egid, &sgid) != 0)

#endif /* HAVE_GETRESUID */

    {

      suid = ruid = getuid ();

      sgid = rgid = getgid ();

      euid = geteuid ();

      egid = getegid ();

    }

  if (ruid != euid || ruid != suid ||

      rgid != egid || rgid != sgid)

    {

      g_warning ("This process is currently running setuid or setgid.\n"

		 "This is not a supported use of GTK+. You must create a helper\n"

		 "program instead. For further details, see:\n\n"

		 "    http://www.gtk.org/setuid.html\n\n"

		 "Refusing to initialize GTK+.");

      exit (1);

    }

#endif

  return TRUE;

}

#ifdef G_OS_WIN32

const gchar *

_gtk_get_datadir (void)

{

  static char *gtk_datadir = NULL;

  if (gtk_datadir == NULL)

    {

      gchar *root = g_win32_get_package_installation_directory_of_module (gtk_dll);

      gtk_datadir = g_build_filename (root, "share", NULL);

      g_free (root);

    }

  return gtk_datadir;

}

const gchar *

_gtk_get_sysconfdir (void)

{

  static char *gtk_sysconfdir = NULL;

  if (gtk_sysconfdir == NULL)

    {

      gchar *root = g_win32_get_package_installation_directory_of_module (gtk_dll);

      gtk_sysconfdir = g_build_filename (root, "etc", NULL);

      g_free (root);

    }

  return gtk_sysconfdir;

}

const gchar *

_gtk_get_data_prefix (void)

{

  static char *gtk_data_prefix = NULL;

  if (gtk_data_prefix == NULL)

    gtk_data_prefix = g_win32_get_package_installation_directory_of_module (gtk_dll);

  return gtk_data_prefix;

}

#endif /* G_OS_WIN32 */

static gboolean do_setlocale = TRUE;

/**

 * gtk_disable_setlocale:

 * 

 * Prevents gtk_init(), gtk_init_check(), gtk_init_with_args() and

 * gtk_parse_args() from automatically

 * calling <literal>setlocale (LC_ALL, "")</literal>. You would

 * want to use this function 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.

 *

 * Most programs should not need to call this function.

 **/

void

gtk_disable_setlocale (void)

{

  if (pre_initialized)

    g_warning ("gtk_disable_setlocale() must be called before gtk_init()");

  do_setlocale = FALSE;

}

#ifdef G_PLATFORM_WIN32

#undef gtk_init_check

#endif

static GString *gtk_modules_string = NULL;

static gboolean g_fatal_warnings = FALSE;

#ifdef G_ENABLE_DEBUG

static gboolean

gtk_arg_debug_cb (const char *key, const char *value, gpointer user_data)

{

  gtk_debug_flags |= g_parse_debug_string (value,

					   gtk_debug_keys,

					   G_N_ELEMENTS (gtk_debug_keys));

  return TRUE;

}

static gboolean

gtk_arg_no_debug_cb (const char *key, const char *value, gpointer user_data)

{

  gtk_debug_flags &= ~g_parse_debug_string (value,

					    gtk_debug_keys,

					    G_N_ELEMENTS (gtk_debug_keys));

  return TRUE;

}

#endif /* G_ENABLE_DEBUG */

static gboolean

gtk_arg_module_cb (const char *key, const char *value, gpointer user_data)

{

  if (value && *value)

    {

      if (gtk_modules_string)

	g_string_append_c (gtk_modules_string, G_SEARCHPATH_SEPARATOR);

      else

	gtk_modules_string = g_string_new (NULL);

      g_string_append (gtk_modules_string, value);

    }

  return TRUE;

}

static const GOptionEntry gtk_args[] = {

  { "gtk-module",       0, 0, G_OPTION_ARG_CALLBACK, gtk_arg_module_cb,   

    /* Description of --gtk-module=MODULES in --help output */ N_("Load additional GTK+ modules"), 

    /* Placeholder in --gtk-module=MODULES in --help output */ N_("MODULES") },

  { "g-fatal-warnings", 0, 0, G_OPTION_ARG_NONE, &g_fatal_warnings, 

    /* Description of --g-fatal-warnings in --help output */   N_("Make all warnings fatal"), NULL },

#ifdef G_ENABLE_DEBUG

  { "gtk-debug",        0, 0, G_OPTION_ARG_CALLBACK, gtk_arg_debug_cb,    

    /* Description of --gtk-debug=FLAGS in --help output */    N_("GTK+ debugging flags to set"), 

    /* Placeholder in --gtk-debug=FLAGS in --help output */    N_("FLAGS") },

  { "gtk-no-debug",     0, 0, G_OPTION_ARG_CALLBACK, gtk_arg_no_debug_cb, 

    /* Description of --gtk-no-debug=FLAGS in --help output */ N_("GTK+ debugging flags to unset"), 

    /* Placeholder in --gtk-no-debug=FLAGS in --help output */ N_("FLAGS") },

#endif 

  { NULL }

};

#ifdef G_OS_WIN32

static char *iso639_to_check = NULL;

static char *iso3166_to_check = NULL;

static char *script_to_check = NULL;

static gboolean setlocale_called = FALSE;

static BOOL CALLBACK

enum_locale_proc (LPTSTR locale)

{

  LCID lcid;

  char iso639[10];

  char iso3166[10];

  char *endptr;

  lcid = strtoul (locale, &endptr, 16);

  if (*endptr == '\0' &&

      GetLocaleInfo (lcid, LOCALE_SISO639LANGNAME, iso639, sizeof (iso639)) &&

      GetLocaleInfo (lcid, LOCALE_SISO3166CTRYNAME, iso3166, sizeof (iso3166)))

    {

      if (strcmp (iso639, iso639_to_check) == 0 &&

	  ((iso3166_to_check != NULL &&

	    strcmp (iso3166, iso3166_to_check) == 0) ||

	   (iso3166_to_check == NULL &&

	    SUBLANGID (LANGIDFROMLCID (lcid)) == SUBLANG_DEFAULT)))

	{

	  char language[100], country[100];

	  char locale[300];

	  if (script_to_check != NULL)

	    {

	      /* If lcid is the "other" script for this language,

	       * return TRUE, i.e. continue looking.

	       */

	      if (strcmp (script_to_check, "Latn") == 0)

		{

		  switch (LANGIDFROMLCID (lcid))

		    {

		    case MAKELANGID (LANG_AZERI, SUBLANG_AZERI_CYRILLIC):

		      return TRUE;

		    case MAKELANGID (LANG_UZBEK, SUBLANG_UZBEK_CYRILLIC):

		      return TRUE;

		    case MAKELANGID (LANG_SERBIAN, SUBLANG_SERBIAN_CYRILLIC):

		      return TRUE;

		    case MAKELANGID (LANG_SERBIAN, 0x07):

		      /* Serbian in Bosnia and Herzegovina, Cyrillic */

		      return TRUE;

		    }

		}

	      else if (strcmp (script_to_check, "Cyrl") == 0)

		{

		  switch (LANGIDFROMLCID (lcid))

		    {

		    case MAKELANGID (LANG_AZERI, SUBLANG_AZERI_LATIN):

		      return TRUE;

		    case MAKELANGID (LANG_UZBEK, SUBLANG_UZBEK_LATIN):

		      return TRUE;

		    case MAKELANGID (LANG_SERBIAN, SUBLANG_SERBIAN_LATIN):

		      return TRUE;

		    case MAKELANGID (LANG_SERBIAN, 0x06):

		      /* Serbian in Bosnia and Herzegovina, Latin */

		      return TRUE;

		    }

		}

	    }

	  SetThreadLocale (lcid);

	  if (GetLocaleInfo (lcid, LOCALE_SENGLANGUAGE, language, sizeof (language)) &&

	      GetLocaleInfo (lcid, LOCALE_SENGCOUNTRY, country, sizeof (country)))

	    {

	      strcpy (locale, language);

	      strcat (locale, "_");

	      strcat (locale, country);

	      if (setlocale (LC_ALL, locale) != NULL)

		setlocale_called = TRUE;

	    }

	  return FALSE;

	}

    }

  return TRUE;

}

#endif

static void

setlocale_initialization (void)

{

  static gboolean initialized = FALSE;

  if (initialized)

    return;

  initialized = TRUE;

  if (do_setlocale)

    {

#ifdef G_OS_WIN32

      /* If some of the POSIXish environment variables are set, set

       * the Win32 thread locale correspondingly.

       */ 

      char *p = getenv ("LC_ALL");

      if (p == NULL)

	p = getenv ("LANG");

      if (p != NULL)

	{

	  p = g_strdup (p);

	  if (strcmp (p, "C") == 0)

	    SetThreadLocale (LOCALE_SYSTEM_DEFAULT);

	  else

	    {

	      /* Check if one of the supported locales match the

	       * environment variable. If so, use that locale.

	       */

	      iso639_to_check = p;

	      iso3166_to_check = strchr (iso639_to_check, '_');

	      if (iso3166_to_check != NULL)

		{

		  *iso3166_to_check++ = '\0';

		  script_to_check = strchr (iso3166_to_check, '@');

		  if (script_to_check != NULL)

		    *script_to_check++ = '\0';

		  /* Handle special cases. */

		  /* The standard code for Serbia and Montenegro was

		   * "CS", but MSFT uses for some reason "SP". By now

		   * (October 2006), SP has split into two, "RS" and

		   * "ME", but don't bother trying to handle those

		   * yet. Do handle the even older "YU", though.

		   */

		  if (strcmp (iso3166_to_check, "CS") == 0 ||

		      strcmp (iso3166_to_check, "YU") == 0)

		    iso3166_to_check = "SP";

		}

	      else

		{

		  script_to_check = strchr (iso639_to_check, '@');

		  if (script_to_check != NULL)

		    *script_to_check++ = '\0';

		  /* LANG_SERBIAN == LANG_CROATIAN, recognize just "sr" */

		  if (strcmp (iso639_to_check, "sr") == 0)

		    iso3166_to_check = "SP";

		}

	      EnumSystemLocales (enum_locale_proc, LCID_SUPPORTED);

	    }

	  g_free (p);

	}

      if (!setlocale_called)

	setlocale (LC_ALL, "");

#else

      if (!setlocale (LC_ALL, ""))

	g_warning ("Locale not supported by C library.\n\tUsing the fallback 'C' locale.");

#endif

    }

}

/* Return TRUE if module_to_check causes version conflicts.

 * If module_to_check is NULL, check the main module.

 */

gboolean

_gtk_module_has_mixed_deps (GModule *module_to_check)

{

  GModule *module;

  gpointer func;

  gboolean result;

  if (!module_to_check)

    module = g_module_open (NULL, 0);

  else

    module = module_to_check;

  if (g_module_symbol (module, "gtk_widget_device_is_shadowed", &func))

    result = TRUE;

  else

    result = FALSE;

  if (!module_to_check)

    g_module_close (module);

  return result;

}

static void

do_pre_parse_initialization (int    *argc,

			     char ***argv)

{

  const gchar *env_string;

#if	0

  g_set_error_handler (gtk_error);

  g_set_warning_handler (gtk_warning);

  g_set_message_handler (gtk_message);

  g_set_print_handler (gtk_print);

#endif

  if (pre_initialized)

    return;

  pre_initialized = TRUE;

  if (_gtk_module_has_mixed_deps (NULL))

    g_error ("GTK+ 2.x symbols detected. Using GTK+ 2.x and GTK+ 3 in the same process is not supported");

  gdk_pre_parse_libgtk_only ();

  gdk_event_handler_set ((GdkEventFunc)gtk_main_do_event, NULL, NULL);

#ifdef G_ENABLE_DEBUG

  env_string = g_getenv ("GTK_DEBUG");

  if (env_string != NULL)

    {

      gtk_debug_flags = g_parse_debug_string (env_string,

					      gtk_debug_keys,

					      G_N_ELEMENTS (gtk_debug_keys));

      env_string = NULL;

    }

#endif	/* G_ENABLE_DEBUG */

  env_string = g_getenv ("GTK2_MODULES");

  if (env_string)

    gtk_modules_string = g_string_new (env_string);

  env_string = g_getenv ("GTK_MODULES");

  if (env_string)

    {

      if (gtk_modules_string)

        g_string_append_c (gtk_modules_string, G_SEARCHPATH_SEPARATOR);

      else

        gtk_modules_string = g_string_new (NULL);

      g_string_append (gtk_modules_string, env_string);

    }

}

static void

gettext_initialization (void)

{

  setlocale_initialization ();

#ifdef ENABLE_NLS

  bindtextdomain (GETTEXT_PACKAGE, GTK_LOCALEDIR);

  bindtextdomain (GETTEXT_PACKAGE "-properties", GTK_LOCALEDIR);

#    ifdef HAVE_BIND_TEXTDOMAIN_CODESET

  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");

  bind_textdomain_codeset (GETTEXT_PACKAGE "-properties", "UTF-8");

#    endif

#endif  

}

static void

do_post_parse_initialization (int    *argc,

			      char ***argv)

{

  if (gtk_initialized)

    return;

  gettext_initialization ();

#ifdef SIGPIPE

  signal (SIGPIPE, SIG_IGN);

#endif

  if (g_fatal_warnings)

    {

      GLogLevelFlags fatal_mask;

      fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);

      fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;

      g_log_set_always_fatal (fatal_mask);

    }

  if (gtk_debug_flags & GTK_DEBUG_UPDATES)

    gdk_window_set_debug_updates (TRUE);

  {

  /* Translate to default:RTL if you want your widgets

   * to be RTL, otherwise translate to default:LTR.

   * Do *not* translate it to "predefinito:LTR", if it

   * it isn't default:LTR or default:RTL it will not work 

   */

    char *e = _("default:LTR");

    if (strcmp (e, "default:RTL")==0) 

      gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);

    else if (strcmp (e, "default:LTR"))

      g_warning ("Whoever translated default:LTR did so wrongly.\n");

  }

  /* do what the call to gtk_type_init() used to do */

  g_type_init ();

  _gtk_accel_map_init ();

  _gtk_rc_init ();

  /* Set the 'initialized' flag.

   */

  gtk_initialized = TRUE;

  /* load gtk modules */

  if (gtk_modules_string)

    {

      _gtk_modules_init (argc, argv, gtk_modules_string->str);

      g_string_free (gtk_modules_string, TRUE);

    }

  else

    {

      _gtk_modules_init (argc, argv, NULL);

    }

}

typedef struct

{

  gboolean open_default_display;

} OptionGroupInfo;

static gboolean

pre_parse_hook (GOptionContext *context,

		GOptionGroup   *group,

		gpointer	data,

		GError        **error)

{

  do_pre_parse_initialization (NULL, NULL);

  return TRUE;

}

static gboolean

post_parse_hook (GOptionContext *context,

		 GOptionGroup   *group,

		 gpointer	data,

		 GError        **error)

{

  OptionGroupInfo *info = data;

  do_post_parse_initialization (NULL, NULL);

  if (info->open_default_display)

    {

      if (gdk_display_open_default_libgtk_only () == NULL)

	{

	  const char *display_name = gdk_get_display_arg_name ();

	  g_set_error (error, 

		       G_OPTION_ERROR, 

		       G_OPTION_ERROR_FAILED,

		       _("Cannot open display: %s"),

		       display_name ? display_name : "" );

	  return FALSE;

	}

    }

  return TRUE;

}

/**

 * gtk_get_option_group:

 * @open_default_display: whether to open the default display 

 *    when parsing the commandline arguments

 * 

 * Returns a #GOptionGroup for the commandline arguments recognized

 * by GTK+ and GDK. You should add this group to your #GOptionContext 

 * with g_option_context_add_group(), if you are using 

 * g_option_context_parse() to parse your commandline arguments.

 *

 * Returns: a #GOptionGroup for the commandline arguments recognized

 *   by GTK+

 *

 * Since: 2.6

 */

GOptionGroup *

gtk_get_option_group (gboolean open_default_display)

{

  GOptionGroup *group;

  OptionGroupInfo *info;

  gettext_initialization ();

  info = g_new0 (OptionGroupInfo, 1);

  info->open_default_display = open_default_display;

  group = g_option_group_new ("gtk", _("GTK+ Options"), _("Show GTK+ Options"), info, g_free);

  g_option_group_set_parse_hooks (group, pre_parse_hook, post_parse_hook);

  gdk_add_option_entries_libgtk_only (group);

  g_option_group_add_entries (group, gtk_args);

  g_option_group_set_translation_domain (group, GETTEXT_PACKAGE);

  return group;

}

/**

 * gtk_init_with_args:

 * @argc: a pointer to the number of command line arguments.

 * @argv: (inout) (array length=argc): a pointer to the array of

 *    command line arguments.

 * @parameter_string: a string which is displayed in

 *    the first line of <option>--help</option> output, after 

 *    <literal><replaceable>programname</replaceable> [OPTION...]</literal>

 * @entries: (array zero-terminated=1):  a %NULL-terminated array

 *    of #GOptionEntrys describing the options of your program

 * @translation_domain: a translation domain to use for translating

 *    the <option>--help</option> output for the options in @entries

 *    and the @parameter_string with gettext(), or %NULL

 * @error: a return location for errors