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   {"xinerama",      GDK_DEBUG_XINERAMA}
  73 };
  74
  75 static const int gdk_ndebug_keys = G_N_ELEMENTS (gdk_debug_keys);
  76
  77 #endif /* G_ENABLE_DEBUG */
  78
  79 static GdkArgContext *
  80 gdk_arg_context_new (gpointer cb_data)
  81 {
  82   GdkArgContext *result = g_new (GdkArgContext, 1);
  83   result->tables = g_ptr_array_new ();
  84   result->cb_data = cb_data;
  85
  86   return result;
  87 }
  88
  89 static void
  90 gdk_arg_context_destroy (GdkArgContext *context)
  91 {
  92   g_ptr_array_free (context->tables, TRUE);
  93   g_free (context);
  94 }
  95
  96 static void
  97 gdk_arg_context_add_table (GdkArgContext *context, GdkArgDesc *table)
  98 {
  99   g_ptr_array_add (context->tables, table);
 100 }
 101
 102 static void
 103 gdk_arg_context_parse (GdkArgContext *context, gint *argc, gchar ***argv)
 104 {
 105   int i, j, k;
 106
 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   /* Save a copy of the original argc and argv */
 298   if (argc && argv)
 299     {
 300       gdk_argc = *argc;
 301
 302       gdk_argv = g_malloc ((gdk_argc + 1) * sizeof (char*));
 303       for (i = 0; i < gdk_argc; i++)
 304         gdk_argv[i] = g_strdup ((*argv)[i]);
 305       gdk_argv[gdk_argc] = NULL;
 306     }
 307
 308   if (argc && argv && *argc > 0)
 309     {
 310       gchar *d;
 311
 312       d = strrchr((*argv)[0], G_DIR_SEPARATOR);
 313       if (d != NULL)
 314         g_set_prgname (d + 1);
 315       else
 316         g_set_prgname ((*argv)[0]);
 317     }
 318   else
 319     {
 320       g_set_prgname ("<unknown>");
 321     }
 322
 323   /* We set the fallback program class here, rather than lazily in
 324    * gdk_get_program_class, since we don't want -name to override it.
 325    */
 326   gdk_progclass = g_strdup (g_get_prgname ());
 327   if (gdk_progclass[0])
 328     gdk_progclass[0] = g_ascii_toupper (gdk_progclass[0]);
 329
 330 #ifdef G_ENABLE_DEBUG
 331   {
 332     gchar *debug_string = getenv("GDK_DEBUG");
 333     if (debug_string != NULL)
 334       _gdk_debug_flags = g_parse_debug_string (debug_string,
 335                                               (GDebugKey *) gdk_debug_keys,
 336                                               gdk_ndebug_keys);
 337   }
 338 #endif  /* G_ENABLE_DEBUG */
 339
 340   arg_context = gdk_arg_context_new (NULL);
 341   gdk_arg_context_add_table (arg_context, gdk_args);
 342   gdk_arg_context_add_table (arg_context, _gdk_windowing_args);
 343   gdk_arg_context_parse (arg_context, argc, argv);
 344   gdk_arg_context_destroy (arg_context);
 345
 346   GDK_NOTE (MISC, g_message ("progname: \"%s\"", g_get_prgname ()));
 347
 348   g_type_init ();
 349
 350   /* Do any setup particular to the windowing system
 351    */
 352   _gdk_windowing_init (argc, argv);
 353 }
 354
 355 /**
 356  * gdk_get_display_arg_name:
 357  *
 358  * Gets the display name specified in the command line arguments passed
 359  * to gdk_init() or gdk_parse_args(), if any.
 360  *
 361  * Returns: the display name, if specified explicitely, otherwise %NULL
 362  *   this string is owned by GTK+ and must not be modified or freed.
 363  *
 364  * Since: 2.2
 365  */
 366 G_CONST_RETURN gchar *
 367 gdk_get_display_arg_name (void)
 368 {
 369   if (!_gdk_display_arg_name)
 370     {
 371       if (_gdk_screen_number >= 0)
 372         _gdk_display_arg_name = _gdk_windowing_substitute_screen_number (_gdk_display_name, _gdk_screen_number);
 373       else
 374         _gdk_display_arg_name = g_strdup (_gdk_display_name);
 375    }
 376
 377    return _gdk_display_arg_name;
 378 }
 379
 380 /**
 381  * gdk_display_open_default_libgtk_only:
 382  *
 383  * Opens the default display specified by command line arguments or
 384  * environment variables, sets it as the default display, and returns
 385  * it.  gdk_parse_args must have been called first. If the default
 386  * display has previously been set, simply returns that. An internal
 387  * function that should not be used by applications.
 388  *
 389  * Return value: the default display, if it could be opened,
 390  *   otherwise %NULL.
 391  **/
 392 GdkDisplay *
 393 gdk_display_open_default_libgtk_only (void)
 394 {
 395   GdkDisplay *display;
 396
 397   g_return_val_if_fail (gdk_initialized, NULL);
 398
 399   display = gdk_display_get_default ();
 400   if (display)
 401     return display;
 402
 403   display = gdk_display_open (gdk_get_display_arg_name ());
 404
 405   if (!display && _gdk_screen_number >= 0)
 406     {
 407       g_free (_gdk_display_arg_name);
 408       _gdk_display_arg_name = g_strdup (_gdk_display_name);
 409
 410       display = gdk_display_open (_gdk_display_name);
 411     }
 412
 413   if (display)
 414     gdk_display_manager_set_default_display (gdk_display_manager_get (),
 415                                              display);
 416
 417   return display;
 418 }
 419
 420 /*
 421  *--------------------------------------------------------------
 422  * gdk_init_check
 423  *
 424  *   Initialize the library for use.
 425  *
 426  * Arguments:
 427  *   "argc" is the number of arguments.
 428  *   "argv" is an array of strings.
 429  *
 430  * Results:
 431  *   "argc" and "argv" are modified to reflect any arguments
 432  *   which were not handled. (Such arguments should either
 433  *   be handled by the application or dismissed). If initialization
 434  *   fails, returns FALSE, otherwise TRUE.
 435  *
 436  * Side effects:
 437  *   The library is initialized.
 438  *
 439  *--------------------------------------------------------------
 440  */
 441
 442 gboolean
 443 gdk_init_check (int    *argc,
 444                 char ***argv)
 445 {
 446   gdk_parse_args (argc, argv);
 447
 448   return gdk_display_open_default_libgtk_only () != NULL;
 449 }
 450
 451 void
 452 gdk_init (int *argc, char ***argv)
 453 {
 454   if (!gdk_init_check (argc, argv))
 455     {
 456       g_warning ("cannot open display: %s", gdk_get_display_arg_name ());
 457       exit(1);
 458     }
 459 }
 460
 461 /*
 462  *--------------------------------------------------------------
 463  * gdk_exit
 464  *
 465  *   Restores the library to an un-itialized state and exits
 466  *   the program using the "exit" system call.
 467  *
 468  * Arguments:
 469  *   "errorcode" is the error value to pass to "exit".
 470  *
 471  * Results:
 472  *   Allocated structures are freed and the program exits
 473  *   cleanly.
 474  *
 475  * Side effects:
 476  *
 477  *--------------------------------------------------------------
 478  */
 479
 480 void
 481 gdk_exit (gint errorcode)
 482 {
 483   exit (errorcode);
 484 }
 485
 486 void
 487 gdk_threads_enter ()
 488 {
 489   GDK_THREADS_ENTER ();
 490 }
 491
 492 void
 493 gdk_threads_leave ()
 494 {
 495   GDK_THREADS_LEAVE ();
 496 }
 497
 498 static void
 499 gdk_threads_impl_lock (void)
 500 {
 501   if (gdk_threads_mutex)
 502     g_mutex_lock (gdk_threads_mutex);
 503 }
 504
 505 static void
 506 gdk_threads_impl_unlock (void)
 507 {
 508   if (gdk_threads_mutex)
 509     g_mutex_unlock (gdk_threads_mutex);
 510 }
 511
 512 /**
 513  * gdk_threads_init:
 514  *
 515  * Initializes GDK so that it can be used from multiple threads
 516  * in conjunction with gdk_threads_enter() and gdk_threads_leave().
 517  * g_thread_init() must be called previous to this function.
 518  *
 519  * This call must be made before any use of the main loop from
 520  * GTK+; to be safe, call it before gtk_init().
 521  **/
 522 void
 523 gdk_threads_init ()
 524 {
 525   if (!g_thread_supported ())
 526     g_error ("g_thread_init() must be called before gdk_threads_init()");
 527
 528   gdk_threads_mutex = g_mutex_new ();
 529   if (!gdk_threads_lock)
 530     gdk_threads_lock = gdk_threads_impl_lock;
 531   if (!gdk_threads_unlock)
 532     gdk_threads_unlock = gdk_threads_impl_unlock;
 533 }
 534
 535 /**
 536  * gdk_threads_set_lock_functions:
 537  * @enter_fn:   function called to guard GDK
 538  * @leave_fn: function called to release the guard
 539  *
 540  * Allows the application to replace the standard method that
 541  * GDK uses to protect its data structures. Normally, GDK
 542  * creates a single #GMutex that is locked by gdk_threads_enter(),
 543  * and released by gdk_threads_leave(); using this function an
 544  * application provides, instead, a function @enter_fn that is
 545  * called by gdk_threads_enter() and a function @leave_fn that is
 546  * called by gdk_threads_leave().
 547  *
 548  * The functions must provide at least same locking functionality
 549  * as the default implementation, but can also do extra application
 550  * specific processing.
 551  *
 552  * As an example, consider an application that has its own recursive
 553  * lock that when held, holds the GTK+ lock as well. When GTK+ unlocks
 554  * the GTK+ lock when entering a recursive main loop, the application
 555  * must temporarily release its lock as well.
 556  *
 557  * Most threaded GTK+ apps won't need to use this method.
 558  *
 559  * This method must be called before gdk_threads_init(), and cannot
 560  * be called multiple times.
 561  *
 562  * Since: 2.4
 563  **/
 564 void
 565 gdk_threads_set_lock_functions (GCallback enter_fn,
 566                                 GCallback leave_fn)
 567 {
 568   g_return_if_fail (gdk_threads_lock == NULL &&
 569                     gdk_threads_unlock == NULL);
 570
 571   gdk_threads_lock = enter_fn;
 572   gdk_threads_unlock = leave_fn;
 573 }
 574
 575 G_CONST_RETURN char *
 576 gdk_get_program_class (void)
 577 {
 578   return gdk_progclass;
 579 }
 580
 581 void
 582 gdk_set_program_class (const char *program_class)
 583 {
 584   if (gdk_progclass)
 585     g_free (gdk_progclass);
 586
 587   gdk_progclass = g_strdup (program_class);
 588 }