Pileus Git - ~andy/gtk/blob - gdk/gdk.c

   1 /* GDK - The GIMP Drawing Kit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include "config.h"
  28
  29 #include <string.h>
  30 #include <stdlib.h>
  31
  32 #include "gdk.h"
  33 #include "gdkinternals.h"
  34
  35 #ifndef HAVE_XCONVERTCASE
  36 #include "gdkkeysyms.h"
  37 #endif
  38
  39 typedef struct _GdkPredicate  GdkPredicate;
  40
  41 struct _GdkPredicate
  42 {
  43   GdkEventFunc func;
  44   gpointer data;
  45 };
  46
  47 /* Private variable declarations
  48  */
  49 static int gdk_initialized = 0;                     /* 1 if the library is initialized,
  50                                                      * 0 otherwise.
  51                                                      */
  52
  53 static gchar  *gdk_progclass = NULL;
  54 static gint    gdk_argc = 0;
  55 static gchar **gdk_argv = NULL;
  56
  57 #ifdef G_ENABLE_DEBUG
  58 static const GDebugKey gdk_debug_keys[] = {
  59   {"events",        GDK_DEBUG_EVENTS},
  60   {"misc",          GDK_DEBUG_MISC},
  61   {"dnd",           GDK_DEBUG_DND},
  62   {"xim",           GDK_DEBUG_XIM},
  63   {"nograbs",       GDK_DEBUG_NOGRABS},
  64   {"colormap",      GDK_DEBUG_COLORMAP},
  65   {"gdkrgb",        GDK_DEBUG_GDKRGB},
  66   {"gc",            GDK_DEBUG_GC},
  67   {"pixmap",        GDK_DEBUG_PIXMAP},
  68   {"image",         GDK_DEBUG_IMAGE},
  69   {"input",         GDK_DEBUG_INPUT},
  70   {"cursor",        GDK_DEBUG_CURSOR},
  71   {"multihead",     GDK_DEBUG_MULTIHEAD},
  72 };
  73
  74 static const int gdk_ndebug_keys = G_N_ELEMENTS (gdk_debug_keys);
  75
  76 #endif /* G_ENABLE_DEBUG */
  77
  78 static GdkArgContext *
  79 gdk_arg_context_new (gpointer cb_data)
  80 {
  81   GdkArgContext *result = g_new (GdkArgContext, 1);
  82   result->tables = g_ptr_array_new ();
  83   result->cb_data = cb_data;
  84
  85   return result;
  86 }
  87
  88 static void
  89 gdk_arg_context_destroy (GdkArgContext *context)
  90 {
  91   g_ptr_array_free (context->tables, TRUE);
  92   g_free (context);
  93 }
  94
  95 static void
  96 gdk_arg_context_add_table (GdkArgContext *context, GdkArgDesc *table)
  97 {
  98   g_ptr_array_add (context->tables, table);
  99 }
 100
 101 static void
 102 gdk_arg_context_parse (GdkArgContext *context, gint *argc, gchar ***argv)
 103 {
 104   int i, j, k;
 105
 106   /* Save a copy of the original argc and argv */
 107   if (argc && argv)
 108     {
 109       for (i = 1; i < *argc; i++)
 110         {
 111           char *arg;
 112
 113           if (!(*argv)[i][0] == '-' && (*argv)[i][1] == '-')
 114             continue;
 115
 116           arg = (*argv)[i] + 2;
 117
 118           /* '--' terminates list of arguments */
 119           if (arg == 0)
 120             {
 121               (*argv)[i] = NULL;
 122               break;
 123             }
 124
 125           for (j = 0; j < context->tables->len; j++)
 126             {
 127               GdkArgDesc *table = context->tables->pdata[j];
 128               for (k = 0; table[k].name; k++)
 129                 {
 130                   switch (table[k].type)
 131                     {
 132                     case GDK_ARG_STRING:
 133                     case GDK_ARG_CALLBACK:
 134                     case GDK_ARG_INT:
 135                       {
 136                         int len = strlen (table[k].name);
 137
 138                         if (strncmp (arg, table[k].name, len) == 0 &&
 139                             (arg[len] == '=' || arg[len] == 0))
 140                           {
 141                             char *value = NULL;
 142
 143                             (*argv)[i] = NULL;
 144
 145                             if (arg[len] == '=')
 146                               value = arg + len + 1;
 147                             else if (i < *argc - 1)
 148                               {
 149                                 value = (*argv)[i + 1];
 150                                 (*argv)[i+1] = NULL;
 151                                 i++;
 152                               }
 153                             else
 154                               value = "";
 155
 156                             switch (table[k].type)
 157                               {
 158                               case GDK_ARG_STRING:
 159                                 *(gchar **)table[k].location = g_strdup (value);
 160                                 break;
 161                               case GDK_ARG_INT:
 162                                 *(gint *)table[k].location = atoi (value);
 163                                 break;
 164                               case GDK_ARG_CALLBACK:
 165                                 (*table[k].callback)(table[k].name, value, context->cb_data);
 166                                 break;
 167                               default:
 168                                 ;
 169                               }
 170
 171                             goto next_arg;
 172                           }
 173                         break;
 174                       }
 175                     case GDK_ARG_BOOL:
 176                     case GDK_ARG_NOBOOL:
 177                       if (strcmp (arg, table[k].name) == 0)
 178                         {
 179                           (*argv)[i] = NULL;
 180
 181                           *(gboolean *)table[k].location = (table[k].type == GDK_ARG_BOOL) ? TRUE : FALSE;
 182                           goto next_arg;
 183                         }
 184                     }
 185                 }
 186             }
 187         next_arg:
 188           ;
 189         }
 190
 191       for (i = 1; i < *argc; i++)
 192         {
 193           for (k = i; k < *argc; k++)
 194             if ((*argv)[k] != NULL)
 195               break;
 196
 197           if (k > i)
 198             {
 199               k -= i;
 200               for (j = i + k; j < *argc; j++)
 201                 (*argv)[j-k] = (*argv)[j];
 202               *argc -= k;
 203             }
 204         }
 205     }
 206 }
 207
 208 #ifdef G_ENABLE_DEBUG
 209 static void
 210 gdk_arg_debug_cb (const char *key, const char *value, gpointer user_data)
 211 {
 212   _gdk_debug_flags |= g_parse_debug_string (value,
 213                                             (GDebugKey *) gdk_debug_keys,
 214                                             gdk_ndebug_keys);
 215 }
 216
 217 static void
 218 gdk_arg_no_debug_cb (const char *key, const char *value, gpointer user_data)
 219 {
 220   _gdk_debug_flags &= ~g_parse_debug_string (value,
 221                                              (GDebugKey *) gdk_debug_keys,
 222                                              gdk_ndebug_keys);
 223 }
 224 #endif /* G_ENABLE_DEBUG */
 225
 226 static void
 227 gdk_arg_class_cb (const char *key, const char *value, gpointer user_data)
 228 {
 229   gdk_set_program_class (value);
 230 }
 231
 232 static void
 233 gdk_arg_name_cb (const char *key, const char *value, gpointer user_data)
 234 {
 235   g_set_prgname (value);
 236 }
 237
 238 static GdkArgDesc gdk_args[] = {
 239   { "class" ,       GDK_ARG_CALLBACK, NULL, gdk_arg_class_cb                   },
 240   { "name",         GDK_ARG_CALLBACK, NULL, gdk_arg_name_cb                    },
 241   { "display",      GDK_ARG_STRING,   &_gdk_display_name,     (GdkArgFunc)NULL },
 242   { "screen",       GDK_ARG_INT,      &_gdk_screen_number,    (GdkArgFunc)NULL },
 243
 244 #ifdef G_ENABLE_DEBUG
 245   { "gdk-debug",    GDK_ARG_CALLBACK, NULL, gdk_arg_debug_cb    },
 246   { "gdk-no-debug", GDK_ARG_CALLBACK, NULL, gdk_arg_no_debug_cb },
 247 #endif /* G_ENABLE_DEBUG */
 248   { NULL }
 249 };
 250
 251
 252 /**
 253  * _gdk_get_command_line_args:
 254  * @argv: location to store argv pointer
 255  * @argc: location
 256  *
 257  * Retrieve the command line arguments passed to gdk_init().
 258  * The returned argv pointer points to static storage ; no
 259  * copy is made.
 260  **/
 261 void
 262 _gdk_get_command_line_args (int    *argc,
 263                             char ***argv)
 264 {
 265   *argc = gdk_argc;
 266   *argv = gdk_argv;
 267 }
 268
 269 /**
 270  * gdk_parse_args:
 271  * @argc: the number of command line arguments.
 272  * @argv: the array of command line arguments.
 273  *
 274  * Parse command line arguments, and store for future
 275  * use by calls to gdk_display_open().
 276  *
 277  * Any arguments used by GDK are removed from the array and @argc and @argv are
 278  * updated accordingly.
 279  *
 280  * You shouldn't call this function explicitely if you are using
 281  * gtk_init(), gtk_init_check(), gdk_init(), or gdk_init_check().
 282  *
 283  * Since: 2.2
 284  **/
 285 void
 286 gdk_parse_args (int    *argc,
 287                 char ***argv)
 288 {
 289   GdkArgContext *arg_context;
 290   gint i;
 291
 292   if (gdk_initialized)
 293     return;
 294
 295   gdk_initialized = TRUE;
 296
 297   if (argc && argv)
 298     {
 299       gdk_argc = *argc;
 300
 301       gdk_argv = g_malloc ((gdk_argc + 1) * sizeof (char*));
 302       for (i = 0; i < gdk_argc; i++)
 303         gdk_argv[i] = g_strdup ((*argv)[i]);
 304       gdk_argv[gdk_argc] = NULL;
 305
 306       if (*argc > 0)
 307         {
 308           gchar *d;
 309
 310           d = strrchr((*argv)[0], G_DIR_SEPARATOR);
 311           if (d != NULL)
 312             g_set_prgname (d + 1);
 313           else
 314             g_set_prgname ((*argv)[0]);
 315         }
 316     }
 317   else
 318     {
 319       g_set_prgname ("<unknown>");
 320     }
 321
 322   /* We set the fallback program class here, rather than lazily in
 323    * gdk_get_program_class, since we don't want -name to override it.
 324    */
 325   gdk_progclass = g_strdup (g_get_prgname ());
 326   if (gdk_progclass[0])
 327     gdk_progclass[0] = g_ascii_toupper (gdk_progclass[0]);
 328
 329 #ifdef G_ENABLE_DEBUG
 330   {
 331     gchar *debug_string = getenv("GDK_DEBUG");
 332     if (debug_string != NULL)
 333       _gdk_debug_flags = g_parse_debug_string (debug_string,
 334                                               (GDebugKey *) gdk_debug_keys,
 335                                               gdk_ndebug_keys);
 336   }
 337 #endif  /* G_ENABLE_DEBUG */
 338
 339   arg_context = gdk_arg_context_new (NULL);
 340   gdk_arg_context_add_table (arg_context, gdk_args);
 341   gdk_arg_context_add_table (arg_context, _gdk_windowing_args);
 342   gdk_arg_context_parse (arg_context, argc, argv);
 343   gdk_arg_context_destroy (arg_context);
 344
 345   GDK_NOTE (MISC, g_message ("progname: \"%s\"", g_get_prgname ()));
 346
 347   g_type_init ();
 348
 349   /* Do any setup particular to the windowing system
 350    */
 351   _gdk_windowing_init (argc, argv);
 352 }
 353
 354 /**
 355  * gdk_get_display_arg_name:
 356  *
 357  * Gets the display name specified in the command line arguments passed
 358  * to gdk_init() or gdk_parse_args(), if any.
 359  *
 360  * Returns: the display name, if specified explicitely, otherwise %NULL
 361  *   this string is owned by GTK+ and must not be modified or freed.
 362  *
 363  * Since: 2.2
 364  */
 365 G_CONST_RETURN gchar *
 366 gdk_get_display_arg_name (void)
 367 {
 368   if (!_gdk_display_arg_name)
 369     {
 370       if (_gdk_screen_number >= 0)
 371         _gdk_display_arg_name = _gdk_windowing_substitute_screen_number (_gdk_display_name, _gdk_screen_number);
 372       else
 373         _gdk_display_arg_name = g_strdup (_gdk_display_name);
 374    }
 375
 376    return _gdk_display_arg_name;
 377 }
 378
 379 /**
 380  * gdk_display_open_default_libgtk_only:
 381  *
 382  * Opens the default display specified by command line arguments or
 383  * environment variables, sets it as the default display, and returns
 384  * it.  gdk_parse_args must have been called first. If the default
 385  * display has previously been set, simply returns that. An internal
 386  * function that should not be used by applications.
 387  *
 388  * Return value: the default display, if it could be opened,
 389  *   otherwise %NULL.
 390  **/
 391 GdkDisplay *
 392 gdk_display_open_default_libgtk_only (void)
 393 {
 394   GdkDisplay *display;
 395
 396   g_return_val_if_fail (gdk_initialized, NULL);
 397
 398   display = gdk_display_get_default ();
 399   if (display)
 400     return display;
 401
 402   display = gdk_display_open (gdk_get_display_arg_name ());
 403
 404   if (!display && _gdk_screen_number >= 0)
 405     {
 406       g_free (_gdk_display_arg_name);
 407       _gdk_display_arg_name = g_strdup (_gdk_display_name);
 408
 409       display = gdk_display_open (_gdk_display_name);
 410     }
 411
 412   if (display)
 413     gdk_display_manager_set_default_display (gdk_display_manager_get (),
 414                                              display);
 415
 416   return display;
 417 }
 418
 419 /*
 420  *--------------------------------------------------------------
 421  * gdk_init_check
 422  *
 423  *   Initialize the library for use.
 424  *
 425  * Arguments:
 426  *   "argc" is the number of arguments.
 427  *   "argv" is an array of strings.
 428  *
 429  * Results:
 430  *   "argc" and "argv" are modified to reflect any arguments
 431  *   which were not handled. (Such arguments should either
 432  *   be handled by the application or dismissed). If initialization
 433  *   fails, returns FALSE, otherwise TRUE.
 434  *
 435  * Side effects:
 436  *   The library is initialized.
 437  *
 438  *--------------------------------------------------------------
 439  */
 440
 441 gboolean
 442 gdk_init_check (int    *argc,
 443                 char ***argv)
 444 {
 445   gdk_parse_args (argc, argv);
 446
 447   return gdk_display_open_default_libgtk_only () != NULL;
 448 }
 449
 450 void
 451 gdk_init (int *argc, char ***argv)
 452 {
 453   if (!gdk_init_check (argc, argv))
 454     {
 455       g_warning ("cannot open display: %s", gdk_get_display_arg_name ());
 456       exit(1);
 457     }
 458 }
 459
 460 /*
 461  *--------------------------------------------------------------
 462  * gdk_exit
 463  *
 464  *   Restores the library to an un-itialized state and exits
 465  *   the program using the "exit" system call.
 466  *
 467  * Arguments:
 468  *   "errorcode" is the error value to pass to "exit".
 469  *
 470  * Results:
 471  *   Allocated structures are freed and the program exits
 472  *   cleanly.
 473  *
 474  * Side effects:
 475  *
 476  *--------------------------------------------------------------
 477  */
 478
 479 void
 480 gdk_exit (gint errorcode)
 481 {
 482   exit (errorcode);
 483 }
 484
 485 void
 486 gdk_threads_enter ()
 487 {
 488   GDK_THREADS_ENTER ();
 489 }
 490
 491 void
 492 gdk_threads_leave ()
 493 {
 494   GDK_THREADS_LEAVE ();
 495 }
 496
 497 /**
 498  * gdk_threads_init:
 499  *
 500  * Initializes GDK so that it can be used from multiple threads
 501  * in conjunction with gdk_threads_enter() and gdk_threads_leave().
 502  * g_thread_init() must be called previous to this function.
 503  *
 504  * This call must be made before any use of the main loop from
 505  * GTK+; to be safe, call it before gtk_init().
 506  **/
 507 void
 508 gdk_threads_init ()
 509 {
 510   if (!g_thread_supported ())
 511     g_error ("g_thread_init() must be called before gdk_threads_init()");
 512
 513   gdk_threads_mutex = g_mutex_new ();
 514 }
 515
 516 G_CONST_RETURN char *
 517 gdk_get_program_class (void)
 518 {
 519   return gdk_progclass;
 520 }
 521
 522 void
 523 gdk_set_program_class (const char *program_class)
 524 {
 525   if (gdk_progclass)
 526     g_free (gdk_progclass);
 527
 528   gdk_progclass = g_strdup (program_class);
 529 }