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 void
 284 gdk_parse_args (int    *argc,
 285                 char ***argv)
 286 {
 287   GdkArgContext *arg_context;
 288   gint i;
 289
 290   if (gdk_initialized)
 291     return;
 292
 293   gdk_initialized = TRUE;
 294
 295   if (argc && argv)
 296     {
 297       gdk_argc = *argc;
 298
 299       gdk_argv = g_malloc ((gdk_argc + 1) * sizeof (char*));
 300       for (i = 0; i < gdk_argc; i++)
 301         gdk_argv[i] = g_strdup ((*argv)[i]);
 302       gdk_argv[gdk_argc] = NULL;
 303
 304       if (*argc > 0)
 305         {
 306           gchar *d;
 307
 308           d = strrchr((*argv)[0], G_DIR_SEPARATOR);
 309           if (d != NULL)
 310             g_set_prgname (d + 1);
 311           else
 312             g_set_prgname ((*argv)[0]);
 313         }
 314     }
 315   else
 316     {
 317       g_set_prgname ("<unknown>");
 318     }
 319
 320   /* We set the fallback program class here, rather than lazily in
 321    * gdk_get_program_class, since we don't want -name to override it.
 322    */
 323   gdk_progclass = g_strdup (g_get_prgname ());
 324   if (gdk_progclass[0])
 325     gdk_progclass[0] = g_ascii_toupper (gdk_progclass[0]);
 326
 327 #ifdef G_ENABLE_DEBUG
 328   {
 329     gchar *debug_string = getenv("GDK_DEBUG");
 330     if (debug_string != NULL)
 331       _gdk_debug_flags = g_parse_debug_string (debug_string,
 332                                               (GDebugKey *) gdk_debug_keys,
 333                                               gdk_ndebug_keys);
 334   }
 335 #endif  /* G_ENABLE_DEBUG */
 336
 337   arg_context = gdk_arg_context_new (NULL);
 338   gdk_arg_context_add_table (arg_context, gdk_args);
 339   gdk_arg_context_add_table (arg_context, _gdk_windowing_args);
 340   gdk_arg_context_parse (arg_context, argc, argv);
 341   gdk_arg_context_destroy (arg_context);
 342
 343   GDK_NOTE (MISC, g_message ("progname: \"%s\"", g_get_prgname ()));
 344
 345   g_type_init ();
 346
 347   /* Do any setup particular to the windowing system
 348    */
 349   _gdk_windowing_init (argc, argv);
 350 }
 351
 352 /**
 353  * gdk_get_display_arg_name:
 354  *
 355  * Gets the display name specified in the command line arguments passed
 356  * to gdk_init() or gdk_parse_args(), if any.
 357  *
 358  * Returns: the display name, if specified explicitely, otherwise %NULL
 359  *   this string is owned by GTK+ and must not be modified or freed.
 360  */
 361 G_CONST_RETURN gchar *
 362 gdk_get_display_arg_name (void)
 363 {
 364   if (!_gdk_display_arg_name)
 365     {
 366       if (_gdk_screen_number >= 0)
 367         _gdk_display_arg_name = _gdk_windowing_substitute_screen_number (_gdk_display_name, _gdk_screen_number);
 368       else
 369         _gdk_display_arg_name = g_strdup (_gdk_display_name);
 370    }
 371
 372    return _gdk_display_arg_name;
 373 }
 374
 375 /**
 376  * gdk_display_open_default_libgtk_only:
 377  *
 378  * Opens the default display specified by command line arguments or
 379  * environment variables, sets it as the default display, and returns
 380  * it.  gdk_parse_args must have been called first. If the default
 381  * display has previously been set, simply returns that. An internal
 382  * function that should not be used by applications.
 383  *
 384  * Return value: the default display, if it could be opened,
 385  *   otherwise %NULL.
 386  **/
 387 GdkDisplay *
 388 gdk_display_open_default_libgtk_only (void)
 389 {
 390   GdkDisplay *display;
 391
 392   g_return_if_fail (gdk_initialized);
 393
 394   display = gdk_display_get_default ();
 395   if (display)
 396     return display;
 397
 398   display = gdk_display_open (gdk_get_display_arg_name ());
 399
 400   if (!display && _gdk_screen_number >= 0)
 401     {
 402       g_free (_gdk_display_arg_name);
 403       _gdk_display_arg_name = g_strdup (_gdk_display_name);
 404
 405       display = gdk_display_open (_gdk_display_name);
 406     }
 407
 408   if (display)
 409     gdk_display_manager_set_default_display (gdk_display_manager_get (),
 410                                              display);
 411
 412   return display;
 413 }
 414
 415 /*
 416  *--------------------------------------------------------------
 417  * gdk_init_check
 418  *
 419  *   Initialize the library for use.
 420  *
 421  * Arguments:
 422  *   "argc" is the number of arguments.
 423  *   "argv" is an array of strings.
 424  *
 425  * Results:
 426  *   "argc" and "argv" are modified to reflect any arguments
 427  *   which were not handled. (Such arguments should either
 428  *   be handled by the application or dismissed). If initialization
 429  *   fails, returns FALSE, otherwise TRUE.
 430  *
 431  * Side effects:
 432  *   The library is initialized.
 433  *
 434  *--------------------------------------------------------------
 435  */
 436
 437 gboolean
 438 gdk_init_check (int    *argc,
 439                 char ***argv)
 440 {
 441   GdkDisplay *display;
 442
 443   gdk_parse_args (argc, argv);
 444
 445   return gdk_display_open_default_libgtk_only () != NULL;
 446 }
 447
 448 void
 449 gdk_init (int *argc, char ***argv)
 450 {
 451   if (!gdk_init_check (argc, argv))
 452     {
 453       g_warning ("cannot open display: %s", gdk_get_display_arg_name ());
 454       exit(1);
 455     }
 456 }
 457
 458 /*
 459  *--------------------------------------------------------------
 460  * gdk_exit
 461  *
 462  *   Restores the library to an un-itialized state and exits
 463  *   the program using the "exit" system call.
 464  *
 465  * Arguments:
 466  *   "errorcode" is the error value to pass to "exit".
 467  *
 468  * Results:
 469  *   Allocated structures are freed and the program exits
 470  *   cleanly.
 471  *
 472  * Side effects:
 473  *
 474  *--------------------------------------------------------------
 475  */
 476
 477 void
 478 gdk_exit (gint errorcode)
 479 {
 480   /* de-initialisation is done by the gdk_exit_funct(),
 481      no need to do this here (Alex J.) */
 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 }