gdk.c 29.6 KB
Newer Older
Elliot Lee's avatar
Elliot Lee committed
1
2
3
4
5
6
7
8
9
10
/* 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
 * modify it under the terms of the GNU Library General Public
 * 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
Elliot Lee's avatar
Elliot Lee committed
12
13
14
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library 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
#include "config.h"
Elliot Lee's avatar
Elliot Lee committed
20

21
#include <X11/Xlocale.h>
Elliot Lee's avatar
Elliot Lee committed
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif /* HAVE_SYS_SELECT_H_ */

#define XLIB_ILLEGAL_ACCESS
#include <X11/Xatom.h>
#include <X11/Xlib.h>
#include <X11/Xos.h>
#include <X11/Xutil.h>
#include <X11/Xmu/WinUtil.h>
#include <X11/cursorfont.h>
#include "gdk.h"
#include "gdkprivate.h"
#include "gdkinput.h"
42
#include "gdkx.h"
43
#include "gdki18n.h"
Elliot Lee's avatar
Elliot Lee committed
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#ifndef X_GETTIMEOFDAY
#define X_GETTIMEOFDAY(tv)  gettimeofday (tv, NULL)
#endif /* X_GETTIMEOFDAY */


typedef struct _GdkPredicate  GdkPredicate;

struct _GdkPredicate
{
  GdkEventFunc func;
  gpointer data;
};

/* 
 * Private function declarations
 */
61

62
#ifndef HAVE_XCONVERTCASE
63
64
65
static void	 gdkx_XConvertCase	(KeySym	       symbol,
					 KeySym	      *lower,
					 KeySym	      *upper);
66
67
68
#define XConvertCase gdkx_XConvertCase
#endif

69
70
static void	    gdk_exit_func		 (void);
static int	    gdk_x_error			 (Display     *display, 
Elliot Lee's avatar
Elliot Lee committed
71
						  XErrorEvent *error);
72
static int	    gdk_x_io_error		 (Display     *display);
Elliot Lee's avatar
Elliot Lee committed
73

74
75
76
77
GdkFilterReturn gdk_wm_protocols_filter (GdkXEvent *xev,
					 GdkEvent  *event,
					 gpointer   data);

Elliot Lee's avatar
Elliot Lee committed
78
79
/* Private variable declarations
 */
80
static int gdk_initialized = 0;			    /* 1 if the library is initialized,
Elliot Lee's avatar
Elliot Lee committed
81
82
83
						     * 0 otherwise.
						     */

84
85
static struct timeval start;			    /* The time at which the library was
						     *	last initialized.
Elliot Lee's avatar
Elliot Lee committed
86
						     */
87
88
89
90
91
static struct timeval timer;			    /* Timeout interval to use in the call
						     *	to "select". This is used in
						     *	conjunction with "timerp" to create
						     *	a maximum time to wait for an event
						     *	to arrive.
Elliot Lee's avatar
Elliot Lee committed
92
						     */
93
94
95
96
static struct timeval *timerp;			    /* The actual timer passed to "select"
						     *	This may be NULL, in which case
						     *	"select" will block until an event
						     *	arrives.
Elliot Lee's avatar
Elliot Lee committed
97
						     */
98
99
static guint32 timer_val;			    /* The timeout length as specified by
						     *	the user in milliseconds.
Elliot Lee's avatar
Elliot Lee committed
100
						     */
101

Elliot Lee's avatar
Elliot Lee committed
102
103
static gint autorepeat;

104
#ifdef G_ENABLE_DEBUG
105
static const GDebugKey gdk_debug_keys[] = {
106
107
108
  {"events",	    GDK_DEBUG_EVENTS},
  {"misc",	    GDK_DEBUG_MISC},
  {"dnd",	    GDK_DEBUG_DND},
109
  {"color-context", GDK_DEBUG_COLOR_CONTEXT},
110
  {"xim",	    GDK_DEBUG_XIM}
111
};
112
113
114

static const int gdk_ndebug_keys = sizeof(gdk_debug_keys)/sizeof(GDebugKey);

115
#endif /* G_ENABLE_DEBUG */
Elliot Lee's avatar
Elliot Lee committed
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

/*
 *--------------------------------------------------------------
 * gdk_init
 *
 *   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).
 *
 * Side effects:
 *   The library is initialized.
 *
 *--------------------------------------------------------------
 */

void
139
gdk_init (int	 *argc,
Elliot Lee's avatar
Elliot Lee committed
140
141
142
	  char ***argv)
{
  XKeyboardState keyboard_state;
143
144
  gint synchronize;
  gint i, j, k;
Elliot Lee's avatar
Elliot Lee committed
145
  XClassHint *class_hint;
146
147
  gchar **argv_orig = NULL;
  gint argc_orig = 0;
148
  
149
150
  if (gdk_initialized)
    return;
151
  
152
153
154
  if (g_thread_supported ())
    gdk_threads_mutex = g_mutex_new ();
  
155
156
157
158
159
160
161
162
163
  if (argc && argv)
    {
      argc_orig = *argc;
      
      argv_orig = g_malloc ((argc_orig + 1) * sizeof (char*));
      for (i = 0; i < argc_orig; i++)
	argv_orig[i] = g_strdup ((*argv)[i]);
      argv_orig[argc_orig] = NULL;
    }
164
  
Elliot Lee's avatar
Elliot Lee committed
165
  X_GETTIMEOFDAY (&start);
166
  
Elliot Lee's avatar
Elliot Lee committed
167
  gdk_display_name = NULL;
168
  
Elliot Lee's avatar
Elliot Lee committed
169
170
  XSetErrorHandler (gdk_x_error);
  XSetIOErrorHandler (gdk_x_io_error);
171
  
Elliot Lee's avatar
Elliot Lee committed
172
  synchronize = FALSE;
173
  
174
175
176
177
178
179
180
181
182
#ifdef G_ENABLE_DEBUG
  {
    gchar *debug_string = getenv("GDK_DEBUG");
    if (debug_string != NULL)
      gdk_debug_flags = g_parse_debug_string (debug_string,
					      gdk_debug_keys,
					      gdk_ndebug_keys);
  }
#endif	/* G_ENABLE_DEBUG */
183
  
Elliot Lee's avatar
Elliot Lee committed
184
185
186
  if (argc && argv)
    {
      if (*argc > 0)
187
188
	{
	  gchar *d;
189
	  
190
191
	  d = strrchr((*argv)[0],'/');
	  if (d != NULL)
192
	    g_set_prgname (d + 1);
193
	  else
194
	    g_set_prgname ((*argv)[0]);
195
	}
196
      
Elliot Lee's avatar
Elliot Lee committed
197
198
      for (i = 1; i < *argc;)
	{
199
#ifdef G_ENABLE_DEBUG	  
200
201
	  if ((strcmp ("--gdk-debug", (*argv)[i]) == 0) ||
	      (strncmp ("--gdk-debug=", (*argv)[i], 12) == 0))
Elliot Lee's avatar
Elliot Lee committed
202
	    {
203
204
205
206
207
208
209
210
211
	      gchar *equal_pos = strchr ((*argv)[i], '=');
	      
	      if (equal_pos != NULL)
		{
		  gdk_debug_flags |= g_parse_debug_string (equal_pos+1,
							   gdk_debug_keys,
							   gdk_ndebug_keys);
		}
	      else if ((i + 1) < *argc && (*argv)[i + 1])
Elliot Lee's avatar
Elliot Lee committed
212
		{
213
214
215
		  gdk_debug_flags |= g_parse_debug_string ((*argv)[i+1],
							   gdk_debug_keys,
							   gdk_ndebug_keys);
216
		  (*argv)[i] = NULL;
217
218
		  i += 1;
		}
219
	      (*argv)[i] = NULL;
220
	    }
221
222
	  else if ((strcmp ("--gdk-no-debug", (*argv)[i]) == 0) ||
		   (strncmp ("--gdk-no-debug=", (*argv)[i], 15) == 0))
223
	    {
224
	      gchar *equal_pos = strchr ((*argv)[i], '=');
225
	      
226
227
228
229
230
231
232
	      if (equal_pos != NULL)
		{
		  gdk_debug_flags &= ~g_parse_debug_string (equal_pos+1,
							    gdk_debug_keys,
							    gdk_ndebug_keys);
		}
	      else if ((i + 1) < *argc && (*argv)[i + 1])
233
234
235
236
		{
		  gdk_debug_flags &= ~g_parse_debug_string ((*argv)[i+1],
							    gdk_debug_keys,
							    gdk_ndebug_keys);
237
		  (*argv)[i] = NULL;
Elliot Lee's avatar
Elliot Lee committed
238
239
		  i += 1;
		}
240
	      (*argv)[i] = NULL;
Elliot Lee's avatar
Elliot Lee committed
241
	    }
Owen Taylor's avatar
Owen Taylor committed
242
	  else 
243
#endif /* G_ENABLE_DEBUG */
Owen Taylor's avatar
Owen Taylor committed
244
	    if (strcmp ("--display", (*argv)[i]) == 0)
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
	      {
		(*argv)[i] = NULL;
		
		if ((i + 1) < *argc && (*argv)[i + 1])
		  {
		    gdk_display_name = g_strdup ((*argv)[i + 1]);
		    (*argv)[i + 1] = NULL;
		    i += 1;
		  }
	      }
	    else if (strcmp ("--sync", (*argv)[i]) == 0)
	      {
		(*argv)[i] = NULL;
		synchronize = TRUE;
	      }
	    else if (strcmp ("--no-xshm", (*argv)[i]) == 0)
	      {
		(*argv)[i] = NULL;
		gdk_use_xshm = FALSE;
	      }
	    else if (strcmp ("--name", (*argv)[i]) == 0)
	      {
		if ((i + 1) < *argc && (*argv)[i + 1])
		  {
		    (*argv)[i++] = NULL;
270
		    g_set_prgname ((*argv)[i]);
271
272
273
274
275
276
277
278
279
280
281
282
		    (*argv)[i] = NULL;
		  }
	      }
	    else if (strcmp ("--class", (*argv)[i]) == 0)
	      {
		if ((i + 1) < *argc && (*argv)[i + 1])
		  {
		    (*argv)[i++] = NULL;
		    gdk_progclass = (*argv)[i];
		    (*argv)[i] = NULL;
		  }
	      }
Elliot Lee's avatar
Elliot Lee committed
283
#ifdef XINPUT_GXI
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
	    else if (strcmp ("--gxid_host", (*argv)[i]) == 0)
	      {
		if ((i + 1) < *argc && (*argv)[i + 1])
		  {
		    (*argv)[i++] = NULL;
		    gdk_input_gxid_host = ((*argv)[i]);
		    (*argv)[i] = NULL;
		  }
	      }
	    else if (strcmp ("--gxid_port", (*argv)[i]) == 0)
	      {
		if ((i + 1) < *argc && (*argv)[i + 1])
		  {
		    (*argv)[i++] = NULL;
		    gdk_input_gxid_port = atoi ((*argv)[i]);
		    (*argv)[i] = NULL;
		  }
	      }
Elliot Lee's avatar
Elliot Lee committed
302
#endif
303
#ifdef USE_XIM
304
305
306
307
308
309
	    else if (strcmp ("--xim-preedit", (*argv)[i]) == 0)
	      {
		if ((i + 1) < *argc && (*argv)[i + 1])
		  {
		    (*argv)[i++] = NULL;
		    if (strcmp ("none", (*argv)[i]) == 0)
310
		      gdk_im_set_best_style (GDK_IM_PREEDIT_NONE);
311
		    else if (strcmp ("nothing", (*argv)[i]) == 0)
312
		      gdk_im_set_best_style (GDK_IM_PREEDIT_NOTHING);
313
		    else if (strcmp ("area", (*argv)[i]) == 0)
314
		      gdk_im_set_best_style (GDK_IM_PREEDIT_AREA);
315
		    else if (strcmp ("position", (*argv)[i]) == 0)
316
		      gdk_im_set_best_style (GDK_IM_PREEDIT_POSITION);
317
		    else if (strcmp ("callbacks", (*argv)[i]) == 0)
318
		      gdk_im_set_best_style (GDK_IM_PREEDIT_CALLBACKS);
319
320
321
322
323
324
325
326
		  }
	      }
	    else if (strcmp ("--xim-status", (*argv)[i]) == 0)
	      {
		if ((i + 1) < *argc && (*argv)[i + 1])
		  {
		    (*argv)[i++] = NULL;
		    if (strcmp ("none", (*argv)[i]) == 0)
327
		      gdk_im_set_best_style (GDK_IM_STATUS_NONE);
328
		    else if (strcmp ("nothing", (*argv)[i]) == 0)
329
		      gdk_im_set_best_style (GDK_IM_STATUS_NOTHING);
330
		    else if (strcmp ("area", (*argv)[i]) == 0)
331
		      gdk_im_set_best_style (GDK_IM_STATUS_AREA);
332
		    else if (strcmp ("callbacks", (*argv)[i]) == 0)
333
		      gdk_im_set_best_style (GDK_IM_STATUS_CALLBACKS);
334
335
		  }
	      }
336
#endif
337
	  
Elliot Lee's avatar
Elliot Lee committed
338
339
	  i += 1;
	}
340
      
Elliot Lee's avatar
Elliot Lee committed
341
342
343
344
345
      for (i = 1; i < *argc; i++)
	{
	  for (k = i; k < *argc; k++)
	    if ((*argv)[k] != NULL)
	      break;
346
	  
Elliot Lee's avatar
Elliot Lee committed
347
348
349
350
351
352
353
354
355
356
357
	  if (k > i)
	    {
	      k -= i;
	      for (j = i + k; j < *argc; j++)
		(*argv)[j-k] = (*argv)[j];
	      *argc -= k;
	    }
	}
    }
  else
    {
358
      g_set_prgname ("<unknown>");
Elliot Lee's avatar
Elliot Lee committed
359
    }
360
  
361
  GDK_NOTE (MISC, g_message ("progname: \"%s\"", g_get_prgname ()));
362
  
Elliot Lee's avatar
Elliot Lee committed
363
364
  gdk_display = XOpenDisplay (gdk_display_name);
  if (!gdk_display)
365
366
367
368
    {
      g_warning ("cannot open display: %s", XDisplayName (gdk_display_name));
      exit(1);
    }
369
  
Elliot Lee's avatar
Elliot Lee committed
370
371
  if (synchronize)
    XSynchronize (gdk_display, True);
372
  
Elliot Lee's avatar
Elliot Lee committed
373
374
  gdk_screen = DefaultScreen (gdk_display);
  gdk_root_window = RootWindow (gdk_display, gdk_screen);
375
  
Elliot Lee's avatar
Elliot Lee committed
376
377
378
  gdk_leader_window = XCreateSimpleWindow(gdk_display, gdk_root_window,
					  10, 10, 10, 10, 0, 0 , 0);
  class_hint = XAllocClassHint();
379
  class_hint->res_name = g_get_prgname ();
380
381
  if (gdk_progclass == NULL)
    {
382
      gdk_progclass = g_strdup (g_get_prgname ());
383
384
      gdk_progclass[0] = toupper (gdk_progclass[0]);
    }
Elliot Lee's avatar
Elliot Lee committed
385
386
387
388
  class_hint->res_class = gdk_progclass;
  XSetClassHint(gdk_display, gdk_leader_window, class_hint);
  XSetCommand(gdk_display, gdk_leader_window, argv_orig, argc_orig);
  XFree (class_hint);
389
390
391
392
393
  
  for (i = 0; i < argc_orig; i++)
    g_free(argv_orig[i]);
  g_free(argv_orig);
  
Elliot Lee's avatar
Elliot Lee committed
394
395
396
397
398
399
  gdk_wm_delete_window = XInternAtom (gdk_display, "WM_DELETE_WINDOW", True);
  gdk_wm_take_focus = XInternAtom (gdk_display, "WM_TAKE_FOCUS", True);
  gdk_wm_protocols = XInternAtom (gdk_display, "WM_PROTOCOLS", True);
  gdk_wm_window_protocols[0] = gdk_wm_delete_window;
  gdk_wm_window_protocols[1] = gdk_wm_take_focus;
  gdk_selection_property = XInternAtom (gdk_display, "GDK_SELECTION", False);
400
  
Elliot Lee's avatar
Elliot Lee committed
401
402
  XGetKeyboardControl (gdk_display, &keyboard_state);
  autorepeat = keyboard_state.global_auto_repeat;
403
  
Elliot Lee's avatar
Elliot Lee committed
404
405
406
  timer.tv_sec = 0;
  timer.tv_usec = 0;
  timerp = NULL;
407
  
Tim Janik's avatar
Tim Janik committed
408
  g_atexit (gdk_exit_func);
409
  
410
  gdk_events_init ();
Elliot Lee's avatar
Elliot Lee committed
411
412
413
414
  gdk_visual_init ();
  gdk_window_init ();
  gdk_image_init ();
  gdk_input_init ();
415
416
  gdk_dnd_init ();

417
#ifdef USE_XIM
418
  gdk_im_open ();
419
#endif
420
  
421
  gdk_initialized = 1;
Elliot Lee's avatar
Elliot Lee committed
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
}

/*
 *--------------------------------------------------------------
 * 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
gdk_exit (int errorcode)
{
446
447
448
  /* de-initialisation is done by the gdk_exit_funct(),
     no need to do this here (Alex J.) */
  exit (errorcode);
Elliot Lee's avatar
Elliot Lee committed
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
}

/*
 *--------------------------------------------------------------
 * gdk_set_locale
 *
 * Arguments:
 *
 * Results:
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

gchar*
465
gdk_set_locale (void)
Elliot Lee's avatar
Elliot Lee committed
466
467
{
  if (!setlocale (LC_ALL,""))
468
469
    g_message ("locale not supported by C library");
  
Elliot Lee's avatar
Elliot Lee committed
470
471
  if (!XSupportsLocale ())
    {
472
      g_message ("locale not supported by Xlib, locale set to C");
Elliot Lee's avatar
Elliot Lee committed
473
474
      setlocale (LC_ALL, "C");
    }
475
  
Elliot Lee's avatar
Elliot Lee committed
476
477
  if (!XSetLocaleModifiers (""))
    {
478
      g_message ("can not set locale modifiers");
Elliot Lee's avatar
Elliot Lee committed
479
    }
480
  
Elliot Lee's avatar
Elliot Lee committed
481
482
483
  return setlocale (LC_ALL,NULL);
}

484
485
486
487
488
489
490
491
492
493
494
495
void
gdk_set_use_xshm (gint use_xshm)
{
  gdk_use_xshm = use_xshm;
}

gint
gdk_get_use_xshm (void)
{
  return gdk_use_xshm;
}

Elliot Lee's avatar
Elliot Lee committed
496
497
/*
 *--------------------------------------------------------------
498
 * gdk_time_get
Elliot Lee's avatar
Elliot Lee committed
499
 *
500
501
 *   Get the number of milliseconds since the library was
 *   initialized.
Elliot Lee's avatar
Elliot Lee committed
502
503
504
505
 *
 * Arguments:
 *
 * Results:
506
507
508
509
 *   The time since the library was initialized is returned.
 *   This time value is accurate to milliseconds even though
 *   a more accurate time down to the microsecond could be
 *   returned.
Elliot Lee's avatar
Elliot Lee committed
510
511
512
513
514
515
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

516
517
guint32
gdk_time_get (void)
Elliot Lee's avatar
Elliot Lee committed
518
{
519
520
521
  struct timeval end;
  struct timeval elapsed;
  guint32 milliseconds;
522
  
523
  X_GETTIMEOFDAY (&end);
524
  
525
  if (start.tv_usec > end.tv_usec)
Owen Taylor's avatar
Owen Taylor committed
526
    {
527
528
      end.tv_usec += 1000000;
      end.tv_sec--;
Owen Taylor's avatar
Owen Taylor committed
529
    }
530
531
  elapsed.tv_sec = end.tv_sec - start.tv_sec;
  elapsed.tv_usec = end.tv_usec - start.tv_usec;
Owen Taylor's avatar
Owen Taylor committed
532
  
533
534
535
  milliseconds = (elapsed.tv_sec * 1000) + (elapsed.tv_usec / 1000);
  
  return milliseconds;
Elliot Lee's avatar
Elliot Lee committed
536
537
}

538
539
/*
 *--------------------------------------------------------------
540
 * gdk_timer_get
541
 *
542
 *   Returns the current timer.
543
544
545
 *
 * Arguments:
 *
546
547
548
 * Results:
 *   Returns the current timer interval. This interval is
 *   in units of milliseconds.
549
550
551
 *
 * Side effects:
 *
552
 *--------------------------------------------------------------
553
554
 */

555
556
guint32
gdk_timer_get (void)
557
{
558
  return timer_val;
559
560
}

Elliot Lee's avatar
Elliot Lee committed
561
562
/*
 *--------------------------------------------------------------
563
 * gdk_timer_set
Elliot Lee's avatar
Elliot Lee committed
564
 *
565
 *   Sets the timer interval.
Elliot Lee's avatar
Elliot Lee committed
566
567
 *
 * Arguments:
568
 *   "milliseconds" is the new value for the timer.
Elliot Lee's avatar
Elliot Lee committed
569
570
571
572
 *
 * Results:
 *
 * Side effects:
573
574
575
576
 *   Calls to "gdk_event_get" will last for a maximum
 *   of time of "milliseconds". However, a value of 0
 *   milliseconds will cause "gdk_event_get" to block
 *   indefinately until an event is received.
Elliot Lee's avatar
Elliot Lee committed
577
578
579
580
 *
 *--------------------------------------------------------------
 */

581
582
void
gdk_timer_set (guint32 milliseconds)
Elliot Lee's avatar
Elliot Lee committed
583
{
584
585
586
  timer_val = milliseconds;
  timer.tv_sec = milliseconds / 1000;
  timer.tv_usec = (milliseconds % 1000) * 1000;
587
  
Elliot Lee's avatar
Elliot Lee committed
588
589
590
}

void
591
gdk_timer_enable (void)
Elliot Lee's avatar
Elliot Lee committed
592
{
593
594
595
596
597
598
599
  timerp = &timer;
}

void
gdk_timer_disable (void)
{
  timerp = NULL;
Elliot Lee's avatar
Elliot Lee committed
600
601
602
603
}

/*
 *--------------------------------------------------------------
604
 * gdk_pointer_grab
Elliot Lee's avatar
Elliot Lee committed
605
 *
606
 *   Grabs the pointer to a specific window
Elliot Lee's avatar
Elliot Lee committed
607
608
 *
 * Arguments:
609
610
611
612
613
614
615
 *   "window" is the window which will receive the grab
 *   "owner_events" specifies whether events will be reported as is,
 *     or relative to "window"
 *   "event_mask" masks only interesting events
 *   "confine_to" limits the cursor movement to the specified window
 *   "cursor" changes the cursor for the duration of the grab
 *   "time" specifies the time
Elliot Lee's avatar
Elliot Lee committed
616
617
618
619
 *
 * Results:
 *
 * Side effects:
620
 *   requires a corresponding call to gdk_pointer_ungrab
Elliot Lee's avatar
Elliot Lee committed
621
622
623
624
 *
 *--------------------------------------------------------------
 */

625
626
627
628
629
630
631
gint
gdk_pointer_grab (GdkWindow *	  window,
		  gint		  owner_events,
		  GdkEventMask	  event_mask,
		  GdkWindow *	  confine_to,
		  GdkCursor *	  cursor,
		  guint32	  time)
Elliot Lee's avatar
Elliot Lee committed
632
{
633
634
635
636
637
638
639
640
641
642
  /*  From gdkwindow.c	*/
  gint return_val;
  GdkWindowPrivate *window_private;
  GdkWindowPrivate *confine_to_private;
  GdkCursorPrivate *cursor_private;
  guint xevent_mask;
  Window xwindow;
  Window xconfine_to;
  Cursor xcursor;
  int i;
Elliot Lee's avatar
Elliot Lee committed
643
  
644
  g_return_val_if_fail (window != NULL, 0);
645
  
646
647
648
  window_private = (GdkWindowPrivate*) window;
  confine_to_private = (GdkWindowPrivate*) confine_to;
  cursor_private = (GdkCursorPrivate*) cursor;
649
  
650
  xwindow = window_private->xwindow;
651
  
652
653
654
655
  if (!confine_to || confine_to_private->destroyed)
    xconfine_to = None;
  else
    xconfine_to = confine_to_private->xwindow;
656
  
657
658
659
660
  if (!cursor)
    xcursor = None;
  else
    xcursor = cursor_private->xcursor;
661
662
  
  
663
664
  xevent_mask = 0;
  for (i = 0; i < gdk_nevent_masks; i++)
Owen Taylor's avatar
Owen Taylor committed
665
    {
666
667
      if (event_mask & (1 << (i + 1)))
	xevent_mask |= gdk_event_mask_table[i];
Owen Taylor's avatar
Owen Taylor committed
668
    }
669
  
670
671
672
673
674
675
  if (gdk_input_vtable.grab_pointer)
    return_val = gdk_input_vtable.grab_pointer (window,
						owner_events,
						event_mask,
						confine_to,
						time);
676
  else
677
    return_val = Success;
678
  
679
  if (return_val == Success)
Elliot Lee's avatar
Elliot Lee committed
680
    {
681
682
683
684
685
686
687
688
689
690
691
      if (!window_private->destroyed)
	return_val = XGrabPointer (window_private->xdisplay,
				   xwindow,
				   owner_events,
				   xevent_mask,
				   GrabModeAsync, GrabModeAsync,
				   xconfine_to,
				   xcursor,
				   time);
      else
	return_val = AlreadyGrabbed;
Elliot Lee's avatar
Elliot Lee committed
692
    }
693
  
694
695
  if (return_val == GrabSuccess)
    gdk_xgrab_window = window_private;
696
  
697
  return return_val;
Elliot Lee's avatar
Elliot Lee committed
698
699
700
701
}

/*
 *--------------------------------------------------------------
702
 * gdk_pointer_ungrab
Elliot Lee's avatar
Elliot Lee committed
703
 *
704
 *   Releases any pointer grab
Elliot Lee's avatar
Elliot Lee committed
705
706
707
708
709
710
711
712
713
714
 *
 * Arguments:
 *
 * Results:
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

715
716
void
gdk_pointer_ungrab (guint32 time)
Elliot Lee's avatar
Elliot Lee committed
717
{
718
719
720
721
722
  if (gdk_input_vtable.ungrab_pointer)
    gdk_input_vtable.ungrab_pointer (time);
  
  XUngrabPointer (gdk_display, time);
  gdk_xgrab_window = NULL;
Elliot Lee's avatar
Elliot Lee committed
723
724
725
726
}

/*
 *--------------------------------------------------------------
727
 * gdk_pointer_is_grabbed
Elliot Lee's avatar
Elliot Lee committed
728
 *
729
 *   Tell wether there is an active x pointer grab in effect
Elliot Lee's avatar
Elliot Lee committed
730
731
732
733
734
735
736
737
738
739
 *
 * Arguments:
 *
 * Results:
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

740
gint
741
gdk_pointer_is_grabbed (void)
Elliot Lee's avatar
Elliot Lee committed
742
{
743
  return gdk_xgrab_window != NULL;
Elliot Lee's avatar
Elliot Lee committed
744
745
746
747
}

/*
 *--------------------------------------------------------------
748
 * gdk_keyboard_grab
Elliot Lee's avatar
Elliot Lee committed
749
 *
750
 *   Grabs the keyboard to a specific window
Elliot Lee's avatar
Elliot Lee committed
751
752
753
754
755
756
757
758
759
760
 *
 * Arguments:
 *   "window" is the window which will receive the grab
 *   "owner_events" specifies whether events will be reported as is,
 *     or relative to "window"
 *   "time" specifies the time
 *
 * Results:
 *
 * Side effects:
761
 *   requires a corresponding call to gdk_keyboard_ungrab
Elliot Lee's avatar
Elliot Lee committed
762
 *
763
764
 *--------------------------------------------------------------
 */
765

766
767
768
769
770
771
772
gint
gdk_keyboard_grab (GdkWindow *	   window,
		   gint		   owner_events,
		   guint32	   time)
{
  GdkWindowPrivate *window_private;
  Window xwindow;
773
  
774
  g_return_val_if_fail (window != NULL, 0);
775
  
776
777
  window_private = (GdkWindowPrivate*) window;
  xwindow = window_private->xwindow;
778
  
779
780
781
782
783
784
785
786
  if (!window_private->destroyed)
    return XGrabKeyboard (window_private->xdisplay,
			  xwindow,
			  owner_events,
			  GrabModeAsync, GrabModeAsync,
			  time);
  else
    return AlreadyGrabbed;
Elliot Lee's avatar
Elliot Lee committed
787
788
}

789
790
791
792
793
794
795
796
797
798
799
800
801
802
/*
 *--------------------------------------------------------------
 * gdk_keyboard_ungrab
 *
 *   Releases any keyboard grab
 *
 * Arguments:
 *
 * Results:
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */
803

804
805
806
807
808
void
gdk_keyboard_ungrab (guint32 time)
{
  XUngrabKeyboard (gdk_display, time);
}
809

810
811
812
813
814
815
816
817
818
819
820
821
822
823
/*
 *--------------------------------------------------------------
 * gdk_screen_width
 *
 *   Return the width of the screen.
 *
 * Arguments:
 *
 * Results:
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */
824

825
826
827
828
829
830
831
832
gint
gdk_screen_width (void)
{
  gint return_val;
  
  return_val = DisplayWidth (gdk_display, gdk_screen);
  
  return return_val;
833
834
}

835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
/*
 *--------------------------------------------------------------
 * gdk_screen_height
 *
 *   Return the height of the screen.
 *
 * Arguments:
 *
 * Results:
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

gint
gdk_screen_height (void)
Elliot Lee's avatar
Elliot Lee committed
852
{
853
  gint return_val;
854
  
855
  return_val = DisplayHeight (gdk_display, gdk_screen);
856
  
857
  return return_val;
Elliot Lee's avatar
Elliot Lee committed
858
859
}

860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
/*
 *--------------------------------------------------------------
 * gdk_screen_width_mm
 *
 *   Return the width of the screen in millimeters.
 *
 * Arguments:
 *
 * Results:
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

gint
gdk_screen_width_mm (void)
Elliot Lee's avatar
Elliot Lee committed
877
{
878
879
880
  gint return_val;
  
  return_val = DisplayWidthMM (gdk_display, gdk_screen);
881
  
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
  return return_val;
}

/*
 *--------------------------------------------------------------
 * gdk_screen_height
 *
 *   Return the height of the screen in millimeters.
 *
 * Arguments:
 *
 * Results:
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

gint
gdk_screen_height_mm (void)
{
  gint return_val;
904
  
905
  return_val = DisplayHeightMM (gdk_display, gdk_screen);
906
  
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
  return return_val;
}

void
gdk_key_repeat_disable (void)
{
  XAutoRepeatOff (gdk_display);
}

void
gdk_key_repeat_restore (void)
{
  if (autorepeat)
    XAutoRepeatOn (gdk_display);
  else
    XAutoRepeatOff (gdk_display);
}


void
gdk_beep (void)
{
  XBell(gdk_display, 100);
Elliot Lee's avatar
Elliot Lee committed
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
}

/*
 *--------------------------------------------------------------
 * gdk_exit_func
 *
 *   This is the "atexit" function that makes sure the
 *   library gets a chance to cleanup.
 *
 * Arguments:
 *
 * Results:
 *
 * Side effects:
 *   The library is un-initialized and the program exits.
 *
 *--------------------------------------------------------------
 */

static void
950
gdk_exit_func (void)
Elliot Lee's avatar
Elliot Lee committed
951
{
952
  static gboolean in_gdk_exit_func = FALSE;
953
  
954
955
  /* This is to avoid an infinite loop if a program segfaults in
     an atexit() handler (and yes, it does happen, especially if a program
956
     has trounced over memory too badly for even g_message to work) */
957
958
  if (in_gdk_exit_func == TRUE)
    return;
959
  in_gdk_exit_func = TRUE;
960
  
961
  if (gdk_initialized)
Elliot Lee's avatar
Elliot Lee committed
962
    {
963
964
965
966
967
968
#ifdef USE_XIM
      /* cleanup IC */
      gdk_ic_cleanup ();
      /* close IM */
      gdk_im_close ();
#endif
Elliot Lee's avatar
Elliot Lee committed
969
970
971
      gdk_image_exit ();
      gdk_input_exit ();
      gdk_key_repeat_restore ();
972
      
Elliot Lee's avatar
Elliot Lee committed
973
      XCloseDisplay (gdk_display);
974
      gdk_initialized = 0;
Elliot Lee's avatar
Elliot Lee committed
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
    }
}

/*
 *--------------------------------------------------------------
 * gdk_x_error
 *
 *   The X error handling routine.
 *
 * Arguments:
 *   "display" is the X display the error orignated from.
 *   "error" is the XErrorEvent that we are handling.
 *
 * Results:
 *   Either we were expecting some sort of error to occur,
 *   in which case we set the "gdk_error_code" flag, or this
 *   error was unexpected, in which case we will print an
 *   error message and exit. (Since trying to continue will
 *   most likely simply lead to more errors).
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

static int
1001
gdk_x_error (Display	 *display,
Elliot Lee's avatar
Elliot Lee committed
1002
1003
1004
	     XErrorEvent *error)
{
  char buf[64];
1005
  
Elliot Lee's avatar
Elliot Lee committed
1006
1007
1008
  if (gdk_error_warnings)
    {
      XGetErrorText (display, error->error_code, buf, 63);
Owen Taylor's avatar
Owen Taylor committed
1009
1010
1011
1012
1013
1014
      g_error ("%s\n  serial %ld error_code %d request_code %d minor_code %d\n", 
	       buf, 
	       error->serial, 
	       error->error_code, 
	       error->request_code,
	       error->minor_code);
Elliot Lee's avatar
Elliot Lee committed
1015
    }
1016
  
Elliot Lee's avatar
Elliot Lee committed
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
  gdk_error_code = -1;
  return 0;
}

/*
 *--------------------------------------------------------------
 * gdk_x_io_error
 *
 *   The X I/O error handling routine.
 *
 * Arguments:
 *   "display" is the X display the error orignated from.
 *
 * Results:
 *   An X I/O error basically means we lost our connection
 *   to the X server. There is not much we can do to
 *   continue, so simply print an error message and exit.
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

static int
gdk_x_io_error (Display *display)
{
  g_error ("an x io error occurred");
  return 0;
}

Manish Singh's avatar
Manish Singh committed
1047
1048
1049
1050
1051
gchar *
gdk_get_display(void)
{
  return (gchar *)XDisplayName (gdk_display_name);
}
1052
1053
1054
1055
1056
1057

gint 
gdk_send_xevent (Window window, gboolean propagate, glong event_mask,
		 XEvent *event_send)
{
  Status result;
1058
  gint old_warnings = gdk_error_warnings;
1059
1060
1061
1062
1063
1064
  
  gdk_error_code = 0;
  
  gdk_error_warnings = 0;
  result = XSendEvent (gdk_display, window, propagate, event_mask, event_send);
  XSync (gdk_display, False);
1065
  gdk_error_warnings = old_warnings;
1066
  
1067
1068
  return result && (gdk_error_code != -1);
}
Tim Janik's avatar
Tim Janik committed
1069

1070
#ifndef HAVE_XCONVERTCASE
1071
1072
1073
1074
1075
1076
1077
1078
1079
/* compatibility function from X11R6.3, since XConvertCase is not
 * supplied by X11R5.
 */
static void
gdkx_XConvertCase (KeySym symbol,
		   KeySym *lower,
		   KeySym *upper)
{
  register KeySym sym = symbol;
1080
  
1081
1082
  g_return_if_fail (lower != NULL);
  g_return_if_fail (upper != NULL);
1083
  
1084
1085
  *lower = sym;
  *upper = sym;
1086
  
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
  switch (sym >> 8)
    {
#if	defined (GDK_A) && defined (GDK_Ooblique)
    case 0: /* Latin 1 */
      if ((sym >= GDK_A) && (sym <= GDK_Z))
	*lower += (GDK_a - GDK_A);
      else if ((sym >= GDK_a) && (sym <= GDK_z))
	*upper -= (GDK_a - GDK_A);
      else if ((sym >= GDK_Agrave) && (sym <= GDK_Odiaeresis))
	*lower += (GDK_agrave - GDK_Agrave);
      else if ((sym >= GDK_agrave) && (sym <= GDK_odiaeresis))
	*upper -= (GDK_agrave - GDK_Agrave);
      else if ((sym >= GDK_Ooblique) && (sym <= GDK_Thorn))
	*lower += (GDK_oslash - GDK_Ooblique);
      else if ((sym >= GDK_oslash) && (sym <= GDK_thorn))
	*upper -= (GDK_oslash - GDK_Ooblique);
      break;
#endif	/* LATIN1 */
      
#if	defined (GDK_Aogonek) && defined (GDK_tcedilla)
    case 1: /* Latin 2 */
      /* Assume the KeySym is a legal value (ignore discontinuities) */
      if (sym == GDK_Aogonek)
	*lower = GDK_aogonek;
      else if (sym >= GDK_Lstroke && sym <= GDK_Sacute)
	*lower += (GDK_lstroke - GDK_Lstroke);
      else if (sym >= GDK_Scaron && sym <= GDK_Zacute)
	*lower += (GDK_scaron - GDK_Scaron);
      else if (sym >= GDK_Zcaron && sym <= GDK_Zabovedot)
	*lower += (GDK_zcaron - GDK_Zcaron);
      else if (sym == GDK_aogonek)
	*upper = GDK_Aogonek;
      else if (sym >= GDK_lstroke && sym <= GDK_sacute)
	*upper -= (GDK_lstroke - GDK_Lstroke);
      else if (sym >= GDK_scaron && sym <= GDK_zacute)
	*upper -= (GDK_scaron - GDK_Scaron);
      else if (sym >= GDK_zcaron && sym <= GDK_zabovedot)
	*upper -= (GDK_zcaron - GDK_Zcaron);
      else if (sym >= GDK_Racute && sym <= GDK_Tcedilla)
	*lower += (GDK_racute - GDK_Racute);
      else if (sym >= GDK_racute && sym <= GDK_tcedilla)
	*upper -= (GDK_racute - GDK_Racute);
      break;
#endif	/* LATIN2 */
      
#if	defined (GDK_Hstroke) && defined (GDK_Cabovedot)
    case 2: /* Latin 3 */
      /* Assume the KeySym is a legal value (ignore discontinuities) */
      if (sym >= GDK_Hstroke && sym <= GDK_Hcircumflex)
	*lower += (GDK_hstroke - GDK_Hstroke);
      else if (sym >= GDK_Gbreve && sym <= GDK_Jcircumflex)
	*lower += (GDK_gbreve - GDK_Gbreve);
      else if (sym >= GDK_hstroke && sym <= GDK_hcircumflex)
	*upper -= (GDK_hstroke - GDK_Hstroke);
      else if (sym >= GDK_gbreve && sym <= GDK_jcircumflex)
	*upper -= (GDK_gbreve - GDK_Gbreve);
      else if (sym >= GDK_Cabovedot && sym <= GDK_Scircumflex)
	*lower += (GDK_cabovedot - GDK_Cabovedot);
      else if (sym >= GDK_cabovedot && sym <= GDK_scircumflex)
	*upper -= (GDK_cabovedot - GDK_Cabovedot);
      break;
#endif	/* LATIN3 */
      
#if	defined (GDK_Rcedilla) && defined (GDK_Amacron)
    case 3: /* Latin 4 */
      /* Assume the KeySym is a legal value (ignore discontinuities) */
      if (sym >= GDK_Rcedilla && sym <= GDK_Tslash)
	*lower += (GDK_rcedilla - GDK_Rcedilla);
      else if (sym >= GDK_rcedilla && sym <= GDK_tslash)
	*upper -= (GDK_rcedilla - GDK_Rcedilla);
      else if (sym == GDK_ENG)
	*lower = GDK_eng;
      else if (sym == GDK_eng)
	*upper = GDK_ENG;
      else if (sym >= GDK_Amacron && sym <= GDK_Umacron)
	*lower += (GDK_amacron - GDK_Amacron);
      else if (sym >= GDK_amacron && sym <= GDK_umacron)
	*upper -= (GDK_amacron - GDK_Amacron);
      break;
#endif	/* LATIN4 */
      
#if	defined (GDK_Serbian_DJE) && defined (GDK_Cyrillic_yu)
    case 6: /* Cyrillic */
      /* Assume the KeySym is a legal value (ignore discontinuities) */
      if (sym >= GDK_Serbian_DJE && sym <= GDK_Serbian_DZE)
	*lower -= (GDK_Serbian_DJE - GDK_Serbian_dje);
      else if (sym >= GDK_Serbian_dje && sym <= GDK_Serbian_dze)
	*upper += (GDK_Serbian_DJE - GDK_Serbian_dje);
      else if (sym >= GDK_Cyrillic_YU && sym <= GDK_Cyrillic_HARDSIGN)
	*lower -= (GDK_Cyrillic_YU - GDK_Cyrillic_yu);
      else if (sym >= GDK_Cyrillic_yu && sym <= GDK_Cyrillic_hardsign)
	*upper += (GDK_Cyrillic_YU - GDK_Cyrillic_yu);
      break;
#endif	/* CYRILLIC */
1181
      
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
#if	defined (GDK_Greek_ALPHAaccent) && defined (GDK_Greek_finalsmallsigma)
    case 7: /* Greek */
      /* Assume the KeySym is a legal value (ignore discontinuities) */
      if (sym >= GDK_Greek_ALPHAaccent && sym <= GDK_Greek_OMEGAaccent)
	*lower += (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent);
      else if (sym >= GDK_Greek_alphaaccent && sym <= GDK_Greek_omegaaccent &&
	       sym != GDK_Greek_iotaaccentdieresis &&
	       sym != GDK_Greek_upsilonaccentdieresis)
	*upper -= (GDK_Greek_alphaaccent - GDK_Greek_ALPHAaccent);
      else if (sym >= GDK_Greek_ALPHA && sym <= GDK_Greek_OMEGA)
	*lower += (GDK_Greek_alpha - GDK_Greek_ALPHA);
      else if (sym >= GDK_Greek_alpha && sym <= GDK_Greek_omega &&
	       sym != GDK_Greek_finalsmallsigma)
	*upper -= (GDK_Greek_alpha - GDK_Greek_ALPHA);
      break;
#endif	/* GREEK */
    }
}
1200
#endif
1201

Tim Janik's avatar
Tim Janik committed
1202
gchar*
1203
gdk_keyval_name (guint	      keyval)
Tim Janik's avatar
Tim Janik committed
1204
1205
1206
1207
1208
1209
1210
1211
{
  return XKeysymToString (keyval);
}

guint
gdk_keyval_from_name (const gchar *keyval_name)
{
  g_return_val_if_fail (keyval_name != NULL, 0);
1212
  
Tim Janik's avatar
Tim Janik committed
1213
1214
1215
1216
  return XStringToKeysym (keyval_name);
}

guint
1217
gdk_keyval_to_upper (guint	  keyval)
Tim Janik's avatar
Tim Janik committed
1218
1219
1220
1221
1222
{
  if (keyval)
    {
      KeySym lower_val = 0;
      KeySym upper_val = 0;
1223
      
1224
      XConvertCase (keyval, &lower_val, &upper_val);
Tim Janik's avatar
Tim Janik committed
1225
1226
1227
1228
1229
1230
      return upper_val;
    }
  return 0;
}

guint
1231
gdk_keyval_to_lower (guint	  keyval)
Tim Janik's avatar
Tim Janik committed
1232
1233
1234
1235
1236
{
  if (keyval)
    {
      KeySym lower_val = 0;
      KeySym upper_val = 0;
1237
      
1238
      XConvertCase (keyval, &lower_val, &upper_val);
Tim Janik's avatar
Tim Janik committed
1239
1240
1241
1242
1243
1244
      return lower_val;
    }
  return 0;
}

gboolean
1245
gdk_keyval_is_upper (guint	  keyval)
Tim Janik's avatar
Tim Janik committed
1246
1247
1248
1249
1250
{
  if (keyval)
    {
      KeySym lower_val = 0;
      KeySym upper_val = 0;
1251
      
1252
      XConvertCase (keyval, &lower_val, &upper_val);
Tim Janik's avatar
Tim Janik committed
1253
1254
1255
1256
1257
1258
      return upper_val == keyval;
    }
  return TRUE;
}

gboolean
1259
gdk_keyval_is_lower (guint	  keyval)
Tim Janik's avatar
Tim Janik committed
1260
1261
1262
1263
1264
{
  if (keyval)
    {
      KeySym lower_val = 0;
      KeySym upper_val = 0;
1265
      
1266
      XConvertCase (keyval, &lower_val, &upper_val);
Tim Janik's avatar
Tim Janik committed
1267
1268
1269
1270
      return lower_val == keyval;
    }
  return TRUE;
}
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283

void
gdk_threads_enter ()
{
  GDK_THREADS_ENTER ();
}

void
gdk_threads_leave ()
{
  GDK_THREADS_LEAVE ();
}