gdk.c 11.7 KB
Newer Older
Elliot Lee's avatar
Elliot Lee committed
1
2
3
4
/* GDK - The GIMP Drawing Kit
 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * This library is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
Elliot Lee's avatar
Elliot Lee committed
6
7
8
9
10
 * 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
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
12
 * Lesser General Public License for more details.
Elliot Lee's avatar
Elliot Lee committed
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15
16
17
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
Elliot Lee's avatar
Elliot Lee committed
18
 */
19
20

/*
21
 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
22
23
24
25
26
 * 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/. 
 */

27
#include <config.h>
Elliot Lee's avatar
Elliot Lee committed
28
29

#include <string.h>
30
#include <stdlib.h>
Elliot Lee's avatar
Elliot Lee committed
31

32
#include "gdkalias.h"
Owen Taylor's avatar
Started    
Owen Taylor committed
33
#include "gdk.h"
34
#include "gdkinternals.h"
Elliot Lee's avatar
Elliot Lee committed
35

36
37
38
39
#ifndef HAVE_XCONVERTCASE
#include "gdkkeysyms.h"
#endif

Elliot Lee's avatar
Elliot Lee committed
40
41
42
43
44
45
46
47
48
49
typedef struct _GdkPredicate  GdkPredicate;

struct _GdkPredicate
{
  GdkEventFunc func;
  gpointer data;
};

/* Private variable declarations
 */
50
static int gdk_initialized = 0;			    /* 1 if the library is initialized,
Elliot Lee's avatar
Elliot Lee committed
51
52
53
						     * 0 otherwise.
						     */

54
static gchar  *gdk_progclass = NULL;
55
56
static gint    gdk_argc = 0;
static gchar **gdk_argv = NULL;
57

58
#ifdef G_ENABLE_DEBUG
59
static const GDebugKey gdk_debug_keys[] = {
60
61
62
  {"events",	    GDK_DEBUG_EVENTS},
  {"misc",	    GDK_DEBUG_MISC},
  {"dnd",	    GDK_DEBUG_DND},
Jacob Berkman's avatar
Jacob Berkman committed
63
64
  {"xim",	    GDK_DEBUG_XIM},
  {"nograbs",       GDK_DEBUG_NOGRABS},
65
66
67
68
69
70
71
  {"colormap",	    GDK_DEBUG_COLORMAP},
  {"gdkrgb",	    GDK_DEBUG_GDKRGB},
  {"gc",	    GDK_DEBUG_GC},
  {"pixmap",	    GDK_DEBUG_PIXMAP},
  {"image",	    GDK_DEBUG_IMAGE},
  {"input",	    GDK_DEBUG_INPUT},
  {"cursor",	    GDK_DEBUG_CURSOR},
72
  {"multihead",	    GDK_DEBUG_MULTIHEAD},
73
  {"xinerama",	    GDK_DEBUG_XINERAMA}
74
};
75

76
static const int gdk_ndebug_keys = G_N_ELEMENTS (gdk_debug_keys);
77

78
#endif /* G_ENABLE_DEBUG */
Elliot Lee's avatar
Elliot Lee committed
79

80
#ifdef G_ENABLE_DEBUG
81
82
83
static void
gdk_arg_debug_cb (const char *key, const char *value, gpointer user_data)
{
84
85
86
  _gdk_debug_flags |= g_parse_debug_string (value,
					    (GDebugKey *) gdk_debug_keys,
					    gdk_ndebug_keys);
87
88
89
90
91
}

static void
gdk_arg_no_debug_cb (const char *key, const char *value, gpointer user_data)
{
92
93
94
  _gdk_debug_flags &= ~g_parse_debug_string (value,
					     (GDebugKey *) gdk_debug_keys,
					     gdk_ndebug_keys);
95
}
96
#endif /* G_ENABLE_DEBUG */
97

98
99
static gboolean
gdk_arg_class_cb (const char *key, const char *value, gpointer user_data, GError **error)
100
101
{
  gdk_set_program_class (value);
102
103

  return TRUE;
104
105
}

106
107
static gboolean
gdk_arg_name_cb (const char *key, const char *value, gpointer user_data, GError **error)
108
109
110
{
  g_set_prgname (value);

111
112
  return TRUE;
}
113

114
115
116
117
118
static GOptionEntry gdk_args[] = {
  { "class",        0, 0,                     G_OPTION_ARG_CALLBACK, gdk_arg_class_cb,    NULL, NULL },
  { "name",         0, 0,                     G_OPTION_ARG_CALLBACK, gdk_arg_name_cb,     NULL, NULL },
  { "display",      0, G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_STRING,   &_gdk_display_name,  NULL, NULL },
  { "screen",       0, 0,                     G_OPTION_ARG_INT,      &_gdk_screen_number, NULL, NULL },
119
#ifdef G_ENABLE_DEBUG
120
121
  { "gdk-debug",    0, 0, 		      G_OPTION_ARG_CALLBACK, gdk_arg_debug_cb,    NULL, NULL },
  { "gdk-no-debug", 0, 0, 		      G_OPTION_ARG_CALLBACK, gdk_arg_no_debug_cb, NULL, NULL },
122
123
124
125
#endif /* G_ENABLE_DEBUG */
  { NULL }
};

126
/**
127
128
 * gdk_add_option_entries_libgtk_only:
 * @group: An option group.
129
 * 
130
131
 * Appends gdk option entries to the passed in option group. This is
 * not public API and must not be used by applications.
132
133
 **/
void
134
gdk_add_option_entries_libgtk_only (GOptionGroup *group)
135
{
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
  g_option_group_add_entries (group, gdk_args);
  g_option_group_add_entries (group, _gdk_windowing_args);
}

void
gdk_pre_parse_libgtk_only (void)
{
  gdk_initialized = TRUE;

  /* We set the fallback program class here, rather than lazily in
   * gdk_get_program_class, since we don't want -name to override it.
   */
  gdk_progclass = g_strdup (g_get_prgname ());
  if (gdk_progclass && gdk_progclass[0])
    gdk_progclass[0] = g_ascii_toupper (gdk_progclass[0]);
  
#ifdef G_ENABLE_DEBUG
  {
    gchar *debug_string = getenv("GDK_DEBUG");
    if (debug_string != NULL)
      _gdk_debug_flags = g_parse_debug_string (debug_string,
					      (GDebugKey *) gdk_debug_keys,
					      gdk_ndebug_keys);
  }
#endif	/* G_ENABLE_DEBUG */

  g_type_init ();

  /* Do any setup particular to the windowing system
   */
  _gdk_windowing_init ();  
167
168
}

169
  
170
171
172
173
174
175
/**
 * gdk_parse_args:
 * @argc: the number of command line arguments.
 * @argv: the array of command line arguments.
 * 
 * Parse command line arguments, and store for future
Owen Taylor's avatar
Owen Taylor committed
176
 * use by calls to gdk_display_open().
Elliot Lee's avatar
Elliot Lee committed
177
 *
178
179
 * Any arguments used by GDK are removed from the array and @argc and @argv are
 * updated accordingly.
Elliot Lee's avatar
Elliot Lee committed
180
 *
181
182
 * You shouldn't call this function explicitely if you are using
 * gtk_init(), gtk_init_check(), gdk_init(), or gdk_init_check().
Matthias Clasen's avatar
Matthias Clasen committed
183
184
 *
 * Since: 2.2
185
186
187
 **/
void
gdk_parse_args (int    *argc,
188
		char ***argv)
Elliot Lee's avatar
Elliot Lee committed
189
{
190
191
  GOptionContext *option_context;
  GOptionGroup *option_group;
192

193
  if (gdk_initialized)
194
    return;
195

196
  gdk_pre_parse_libgtk_only ();
197
  
198
199
200
201
202
  option_context = g_option_context_new (NULL);
  g_option_context_set_ignore_unknown_options (option_context, TRUE);
  g_option_context_set_help_enabled (option_context, FALSE);
  option_group = g_option_group_new (NULL, NULL, NULL, NULL, NULL);
  g_option_context_set_main_group (option_context, option_group);
203
  
204
205
206
207
208
  g_option_group_add_entries (option_group, gdk_args);
  g_option_group_add_entries (option_group, _gdk_windowing_args);

  g_option_context_parse (option_context, argc, argv, NULL);
  g_option_context_free (option_context);
209
  
210
  GDK_NOTE (MISC, g_message ("progname: \"%s\"", g_get_prgname ()));
211
}
212

213
214
215
216
217
218
219
/** 
 * gdk_get_display_arg_name:
 *
 * Gets the display name specified in the command line arguments passed
 * to gdk_init() or gdk_parse_args(), if any.
 *
 * Returns: the display name, if specified explicitely, otherwise %NULL
220
 *   this string is owned by GTK+ and must not be modified or freed.
Matthias Clasen's avatar
Matthias Clasen committed
221
222
 *
 * Since: 2.2
223
 */
224
G_CONST_RETURN gchar *
225
226
gdk_get_display_arg_name (void)
{
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
  if (!_gdk_display_arg_name)
    {
      if (_gdk_screen_number >= 0)
	_gdk_display_arg_name = _gdk_windowing_substitute_screen_number (_gdk_display_name, _gdk_screen_number);
      else
	_gdk_display_arg_name = g_strdup (_gdk_display_name);
   }

   return _gdk_display_arg_name;
}

/**
 * gdk_display_open_default_libgtk_only:
 * 
 * Opens the default display specified by command line arguments or
 * environment variables, sets it as the default display, and returns
 * it.  gdk_parse_args must have been called first. If the default
 * display has previously been set, simply returns that. An internal
 * function that should not be used by applications.
 * 
 * Return value: the default display, if it could be opened,
 *   otherwise %NULL.
 **/
GdkDisplay *
gdk_display_open_default_libgtk_only (void)
{
  GdkDisplay *display;

255
  g_return_val_if_fail (gdk_initialized, NULL);
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
  
  display = gdk_display_get_default ();
  if (display)
    return display;

  display = gdk_display_open (gdk_get_display_arg_name ());

  if (!display && _gdk_screen_number >= 0)
    {
      g_free (_gdk_display_arg_name);
      _gdk_display_arg_name = g_strdup (_gdk_display_name);
      
      display = gdk_display_open (_gdk_display_name);
    }
  
  if (display)
    gdk_display_manager_set_default_display (gdk_display_manager_get (),
					     display);
  
  return display;
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
}

/*
 *--------------------------------------------------------------
 * gdk_init_check
 *
 *   Initialize the library for use.
 *
 * Arguments:
 *   "argc" is the number of arguments.
 *   "argv" is an array of strings.
 *
 * Results:
 *   "argc" and "argv" are modified to reflect any arguments
 *   which were not handled. (Such arguments should either
 *   be handled by the application or dismissed). If initialization
 *   fails, returns FALSE, otherwise TRUE.
 *
 * Side effects:
 *   The library is initialized.
 *
 *--------------------------------------------------------------
 */

gboolean
gdk_init_check (int    *argc,
		char ***argv)
{
  gdk_parse_args (argc, argv);
305

306
  return gdk_display_open_default_libgtk_only () != NULL;
307
308
309
310
311
312
313
}

void
gdk_init (int *argc, char ***argv)
{
  if (!gdk_init_check (argc, argv))
    {
314
      g_warning ("cannot open display: %s", gdk_get_display_arg_name ());
315
316
      exit(1);
    }
Elliot Lee's avatar
Elliot Lee committed
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
}

/*
 *--------------------------------------------------------------
 * gdk_exit
 *
 *   Restores the library to an un-itialized state and exits
 *   the program using the "exit" system call.
 *
 * Arguments:
 *   "errorcode" is the error value to pass to "exit".
 *
 * Results:
 *   Allocated structures are freed and the program exits
 *   cleanly.
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

void
Tor Lillqvist's avatar
Tor Lillqvist committed
339
gdk_exit (gint errorcode)
Elliot Lee's avatar
Elliot Lee committed
340
{
341
  exit (errorcode);
Elliot Lee's avatar
Elliot Lee committed
342
343
}

344
345
346
347
348
349
350
351
352
353
354
355
void
gdk_threads_enter ()
{
  GDK_THREADS_ENTER ();
}

void
gdk_threads_leave ()
{
  GDK_THREADS_LEAVE ();
}

356
357
358
359
360
361
362
363
364
365
366
367
368
369
static void
gdk_threads_impl_lock (void)
{
  if (gdk_threads_mutex)
    g_mutex_lock (gdk_threads_mutex);
}

static void
gdk_threads_impl_unlock (void)
{
  if (gdk_threads_mutex)
    g_mutex_unlock (gdk_threads_mutex);
}

370
371
372
373
374
/**
 * gdk_threads_init:
 * 
 * Initializes GDK so that it can be used from multiple threads
 * in conjunction with gdk_threads_enter() and gdk_threads_leave().
375
 * g_thread_init() must be called previous to this function.
376
377
378
379
380
381
382
383
 *
 * This call must be made before any use of the main loop from
 * GTK+; to be safe, call it before gtk_init().
 **/
void
gdk_threads_init ()
{
  if (!g_thread_supported ())
384
    g_error ("g_thread_init() must be called before gdk_threads_init()");
385
386

  gdk_threads_mutex = g_mutex_new ();
387
388
389
390
391
392
393
394
  if (!gdk_threads_lock)
    gdk_threads_lock = gdk_threads_impl_lock;
  if (!gdk_threads_unlock)
    gdk_threads_unlock = gdk_threads_impl_unlock;
}

/**
 * gdk_threads_set_lock_functions:
Matthias Clasen's avatar
Matthias Clasen committed
395
 * @enter_fn:   function called to guard GDK
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
 * @leave_fn: function called to release the guard
 *
 * Allows the application to replace the standard method that
 * GDK uses to protect its data structures. Normally, GDK
 * creates a single #GMutex that is locked by gdk_threads_enter(),
 * and released by gdk_threads_leave(); using this function an
 * application provides, instead, a function @enter_fn that is
 * called by gdk_threads_enter() and a function @leave_fn that is
 * called by gdk_threads_leave().
 *
 * The functions must provide at least same locking functionality
 * as the default implementation, but can also do extra application
 * specific processing.
 *
 * As an example, consider an application that has its own recursive
 * lock that when held, holds the GTK+ lock as well. When GTK+ unlocks
 * the GTK+ lock when entering a recursive main loop, the application
 * must temporarily release its lock as well.
 *
 * Most threaded GTK+ apps won't need to use this method.
 *
Matthias Clasen's avatar
Matthias Clasen committed
417
 * This method must be called before gdk_threads_init(), and cannot
418
 * be called multiple times.
Matthias Clasen's avatar
Matthias Clasen committed
419
420
 *
 * Since: 2.4
421
422
423
424
425
426
427
428
429
430
 **/
void
gdk_threads_set_lock_functions (GCallback enter_fn,
				GCallback leave_fn)
{
  g_return_if_fail (gdk_threads_lock == NULL &&
		    gdk_threads_unlock == NULL);

  gdk_threads_lock = enter_fn;
  gdk_threads_unlock = leave_fn;
431
432
}

433
434
435
436
437
438
439
440
441
442
443
444
445
446
G_CONST_RETURN char *
gdk_get_program_class (void)
{
  return gdk_progclass;
}

void
gdk_set_program_class (const char *program_class)
{
  if (gdk_progclass)
    g_free (gdk_progclass);

  gdk_progclass = g_strdup (program_class);
}