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
 243 #ifdef G_ENABLE_DEBUG
 244   { "gdk-debug",    GDK_ARG_CALLBACK, NULL, gdk_arg_debug_cb    },
 245   { "gdk-no-debug", GDK_ARG_CALLBACK, NULL, gdk_arg_no_debug_cb },
 246 #endif /* G_ENABLE_DEBUG */
 247   { NULL }
 248 };
 249
 250
 251 /**
 252  * _gdk_get_command_line_args:
 253  * @argv: location to store argv pointer
 254  * @argc: location
 255  *
 256  * Retrieve the command line arguments passed to gdk_init().
 257  * The returned argv pointer points to static storage ; no
 258  * copy is made.
 259  **/
 260 void
 261 _gdk_get_command_line_args (int    *argc,
 262                             char ***argv)
 263 {
 264   *argc = gdk_argc;
 265   *argv = gdk_argv;
 266 }
 267
 268 /**
 269  * gdk_parse_args:
 270  * @argc: the number of command line arguments.
 271  * @argv: the array of command line arguments.
 272  *
 273  * Parse command line arguments, and store for future
 274  * use by calls to gdk_display_open().
 275  *
 276  * Any arguments used by GDK are removed from the array and @argc and @argv are
 277  * updated accordingly.
 278  *
 279  * You shouldn't call this function explicitely if you are using
 280  * gtk_init(), gtk_init_check(), gdk_init(), or gdk_init_check().
 281  **/
 282 void
 283 gdk_parse_args (int    *argc,
 284                 char ***argv)
 285 {
 286   GdkArgContext *arg_context;
 287   gint i;
 288
 289   if (gdk_initialized)
 290     return;
 291
 292   gdk_initialized = TRUE;
 293
 294   if (argc && argv)
 295     {
 296       gdk_argc = *argc;
 297
 298       gdk_argv = g_malloc ((gdk_argc + 1) * sizeof (char*));
 299       for (i = 0; i < gdk_argc; i++)
 300         gdk_argv[i] = g_strdup ((*argv)[i]);
 301       gdk_argv[gdk_argc] = NULL;
 302
 303       if (*argc > 0)
 304         {
 305           gchar *d;
 306
 307           d = strrchr((*argv)[0], G_DIR_SEPARATOR);
 308           if (d != NULL)
 309             g_set_prgname (d + 1);
 310           else
 311             g_set_prgname ((*argv)[0]);
 312         }
 313     }
 314   else
 315     {
 316       g_set_prgname ("<unknown>");
 317     }
 318
 319   /* We set the fallback program class here, rather than lazily in
 320    * gdk_get_program_class, since we don't want -name to override it.
 321    */
 322   gdk_progclass = g_strdup (g_get_prgname ());
 323   if (gdk_progclass[0])
 324     gdk_progclass[0] = g_ascii_toupper (gdk_progclass[0]);
 325
 326 #ifdef G_ENABLE_DEBUG
 327   {
 328     gchar *debug_string = getenv("GDK_DEBUG");
 329     if (debug_string != NULL)
 330       _gdk_debug_flags = g_parse_debug_string (debug_string,
 331                                               (GDebugKey *) gdk_debug_keys,
 332                                               gdk_ndebug_keys);
 333   }
 334 #endif  /* G_ENABLE_DEBUG */
 335
 336   arg_context = gdk_arg_context_new (NULL);
 337   gdk_arg_context_add_table (arg_context, gdk_args);
 338   gdk_arg_context_add_table (arg_context, _gdk_windowing_args);
 339   gdk_arg_context_parse (arg_context, argc, argv);
 340   gdk_arg_context_destroy (arg_context);
 341
 342   GDK_NOTE (MISC, g_message ("progname: \"%s\"", g_get_prgname ()));
 343
 344   g_type_init ();
 345
 346   /* Do any setup particular to the windowing system
 347    */
 348   _gdk_windowing_init ();
 349 }
 350
 351 /**
 352  * gdk_get_display_arg_name:
 353  *
 354  * Gets the display name specified in the command line arguments passed
 355  * to gdk_init() or gdk_parse_args(), if any.
 356  *
 357  * Returns: the display name, if specified explicitely, otherwise %NULL
 358  */
 359 gchar *
 360 gdk_get_display_arg_name (void)
 361 {
 362   return _gdk_display_name;
 363 }
 364
 365 /*
 366  *--------------------------------------------------------------
 367  * gdk_init_check
 368  *
 369  *   Initialize the library for use.
 370  *
 371  * Arguments:
 372  *   "argc" is the number of arguments.
 373  *   "argv" is an array of strings.
 374  *
 375  * Results:
 376  *   "argc" and "argv" are modified to reflect any arguments
 377  *   which were not handled. (Such arguments should either
 378  *   be handled by the application or dismissed). If initialization
 379  *   fails, returns FALSE, otherwise TRUE.
 380  *
 381  * Side effects:
 382  *   The library is initialized.
 383  *
 384  *--------------------------------------------------------------
 385  */
 386
 387 gboolean
 388 gdk_init_check (int    *argc,
 389                 char ***argv)
 390 {
 391   GdkDisplay *display;
 392
 393   gdk_parse_args (argc, argv);
 394
 395   if (gdk_display_get_default ())
 396     return TRUE;
 397
 398   display = gdk_display_open (_gdk_display_name);
 399
 400   if (display)
 401     {
 402       gdk_display_manager_set_default_display (gdk_display_manager_get (),
 403                                                display);
 404       return TRUE;
 405     }
 406   else
 407     return FALSE;
 408 }
 409
 410 void
 411 gdk_init (int *argc, char ***argv)
 412 {
 413   if (!gdk_init_check (argc, argv))
 414     {
 415       g_warning ("cannot open display: %s", gdk_get_display_arg_name ());
 416       exit(1);
 417     }
 418 }
 419
 420 /*
 421  *--------------------------------------------------------------
 422  * gdk_exit
 423  *
 424  *   Restores the library to an un-itialized state and exits
 425  *   the program using the "exit" system call.
 426  *
 427  * Arguments:
 428  *   "errorcode" is the error value to pass to "exit".
 429  *
 430  * Results:
 431  *   Allocated structures are freed and the program exits
 432  *   cleanly.
 433  *
 434  * Side effects:
 435  *
 436  *--------------------------------------------------------------
 437  */
 438
 439 void
 440 gdk_exit (gint errorcode)
 441 {
 442   /* de-initialisation is done by the gdk_exit_funct(),
 443      no need to do this here (Alex J.) */
 444   exit (errorcode);
 445 }
 446
 447 #if 0
 448
 449 /* This is disabled, but the code isn't removed, because we might
 450  * want to have some sort of explicit way to shut down GDK cleanly
 451  * at some point in the future.
 452  */
 453
 454 /*
 455  *--------------------------------------------------------------
 456  * gdk_exit_func
 457  *
 458  *   This is the "atexit" function that makes sure the
 459  *   library gets a chance to cleanup.
 460  *
 461  * Arguments:
 462  *
 463  * Results:
 464  *
 465  * Side effects:
 466  *   The library is un-initialized and the program exits.
 467  *
 468  *--------------------------------------------------------------
 469  */
 470
 471 static void
 472 gdk_exit_func (void)
 473 {
 474   static gboolean in_gdk_exit_func = FALSE;
 475
 476   /* This is to avoid an infinite loop if a program segfaults in
 477      an atexit() handler (and yes, it does happen, especially if a program
 478      has trounced over memory too badly for even g_message to work) */
 479   if (in_gdk_exit_func == TRUE)
 480     return;
 481   in_gdk_exit_func = TRUE;
 482
 483   if (gdk_initialized)
 484     {
 485       _gdk_image_exit ();
 486       _gdk_input_exit ();
 487
 488       _gdk_windowing_exit ();
 489
 490       gdk_initialized = 0;
 491     }
 492 }
 493
 494 #endif
 495
 496 void
 497 gdk_threads_enter ()
 498 {
 499   GDK_THREADS_ENTER ();
 500 }
 501
 502 void
 503 gdk_threads_leave ()
 504 {
 505   GDK_THREADS_LEAVE ();
 506 }
 507
 508 /**
 509  * gdk_threads_init:
 510  *
 511  * Initializes GDK so that it can be used from multiple threads
 512  * in conjunction with gdk_threads_enter() and gdk_threads_leave().
 513  * g_thread_init() must be called previous to this function.
 514  *
 515  * This call must be made before any use of the main loop from
 516  * GTK+; to be safe, call it before gtk_init().
 517  **/
 518 void
 519 gdk_threads_init ()
 520 {
 521   if (!g_thread_supported ())
 522     g_error ("g_thread_init() must be called before gdk_threads_init()");
 523
 524   gdk_threads_mutex = g_mutex_new ();
 525 }
 526
 527 G_CONST_RETURN char *
 528 gdk_get_program_class (void)
 529 {
 530   return gdk_progclass;
 531 }
 532
 533 void
 534 gdk_set_program_class (const char *program_class)
 535 {
 536   if (gdk_progclass)
 537     g_free (gdk_progclass);
 538
 539   gdk_progclass = g_strdup (program_class);
 540 }