gdk.c 114 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 20
 */
#include "../config.h"

Elliot Lee's avatar
Elliot Lee committed
21 22 23
/* If you don't want to use gdk's signal handlers define this */
/* #define I_NEED_TO_ACTUALLY_DEBUG_MY_PROGRAMS 1 */

24
#include <X11/Xlocale.h>
Elliot Lee's avatar
Elliot Lee committed
25 26 27 28 29 30
#include <ctype.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
31 32 33
#ifdef USE_XIM
#include <stdarg.h>
#endif
Elliot Lee's avatar
Elliot Lee committed
34 35 36 37 38 39 40 41 42 43 44

#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>
45 46 47
#ifdef USE_XIM
#include <X11/Xresource.h>
#endif
Elliot Lee's avatar
Elliot Lee committed
48 49 50 51
#include <X11/cursorfont.h>
#include "gdk.h"
#include "gdkprivate.h"
#include "gdkinput.h"
52
#include "gdkx.h"
rodo's avatar
rodo committed
53
#include "gdkkeysyms.h"
54
#include "gdki18n.h"
Elliot Lee's avatar
Elliot Lee committed
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

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


#define DOUBLE_CLICK_TIME      250
#define TRIPLE_CLICK_TIME      500
#define DOUBLE_CLICK_DIST      5
#define TRIPLE_CLICK_DIST      5


#ifndef NO_FD_SET
#  define SELECT_MASK fd_set
#else
#  ifndef _AIX
71
typedef long fd_mask;
Elliot Lee's avatar
Elliot Lee committed
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
#  endif
#  if defined(_IBMR2)
#    define SELECT_MASK void
#  else
#    define SELECT_MASK int
#  endif
#endif


typedef struct _GdkInput      GdkInput;
typedef struct _GdkPredicate  GdkPredicate;

struct _GdkInput
{
  gint tag;
  gint source;
  GdkInputCondition condition;
  GdkInputFunction function;
  gpointer data;
91
  GdkDestroyNotify destroy;
Elliot Lee's avatar
Elliot Lee committed
92 93 94 95 96 97 98 99 100 101 102
};

struct _GdkPredicate
{
  GdkEventFunc func;
  gpointer data;
};

/* 
 * Private function declarations
 */
103

104 105 106
static GdkEvent *gdk_event_new		(void);
static gint	 gdk_event_wait		(void);
static gint	 gdk_event_apply_filters (XEvent *xevent,
107 108
					  GdkEvent *event,
					  GList *filters);
109 110
static gint	 gdk_event_translate	(GdkEvent     *event, 
					 XEvent	      *xevent);
111
#if 0
112 113
static Bool	 gdk_event_get_type	(Display      *display, 
					 XEvent	      *xevent, 
Elliot Lee's avatar
Elliot Lee committed
114
					 XPointer      arg);
115
#endif
116 117
static void	 gdk_synthesize_click	(GdkEvent     *event, 
					 gint	       nclicks);
Elliot Lee's avatar
Elliot Lee committed
118

119 120 121 122
static void	 gdk_dnd_drag_begin	(GdkWindow    *initial_window);
static void	 gdk_dnd_drag_enter	(Window	       dest);
static void	 gdk_dnd_drag_leave	(Window	       dest);
static void	 gdk_dnd_drag_end	(Window	       dest,
Elliot Lee's avatar
Elliot Lee committed
123
					 GdkPoint      coords);
124 125
static GdkAtom	 gdk_dnd_check_types	(GdkWindow    *window,
					 XEvent	      *xevent);
Elliot Lee's avatar
Elliot Lee committed
126
#ifdef DEBUG_DND
127
static void	 gdk_print_atom		(GdkAtom       anatom);
Elliot Lee's avatar
Elliot Lee committed
128
#endif
Elliot Lee's avatar
Elliot Lee committed
129

130
#ifndef HAVE_XCONVERTCASE
131 132 133
static void	 gdkx_XConvertCase	(KeySym	       symbol,
					 KeySym	      *lower,
					 KeySym	      *upper);
134 135 136
#define XConvertCase gdkx_XConvertCase
#endif

Elliot Lee's avatar
Elliot Lee committed
137 138 139
/* 
 * old junk from offix, we might use it though so leave it 
 */
140 141
Window	     gdk_get_client_window   (Display	  *dpy, 
				      Window	   win);
Elliot Lee's avatar
Elliot Lee committed
142
#ifdef WE_HAVE_MOTIF_DROPS_DONE
143
static GdkWindow *  gdk_drop_get_real_window	 (GdkWindow   *w, 
Elliot Lee's avatar
Elliot Lee committed
144 145
						  guint16     *x,
						  guint16     *y);
Elliot Lee's avatar
Elliot Lee committed
146
#endif
147 148
static void	    gdk_exit_func		 (void);
static int	    gdk_x_error			 (Display     *display, 
Elliot Lee's avatar
Elliot Lee committed
149
						  XErrorEvent *error);
150 151
static int	    gdk_x_io_error		 (Display     *display);
static RETSIGTYPE   gdk_signal			 (int	       signum);
Elliot Lee's avatar
Elliot Lee committed
152 153


154
#ifdef USE_XIM
155
static guint	     gdk_im_va_count	 (va_list list);
156
static XVaNestedList gdk_im_va_to_nested (va_list list, 
157
					  guint	  count);
158

159 160 161 162 163
static GdkIM  gdk_im_get		(void);
static gint   gdk_im_open		(XrmDatabase db,
					 gchar* res_name,
					 gchar* rec_class);
static void   gdk_im_close		(void);
164
static void   gdk_ic_cleanup		(void);
165

166 167
#endif /* USE_XIM */

Elliot Lee's avatar
Elliot Lee committed
168 169
/* Private variable declarations
 */
170
static int gdk_initialized = 0;			    /* 1 if the library is initialized,
Elliot Lee's avatar
Elliot Lee committed
171 172
						     * 0 otherwise.
						     */
173 174 175 176 177
static int connection_number = 0;		    /* The file descriptor number of our
						     *	connection to the X server. This
						     *	is used so that we may determine
						     *	when events are pending by using
						     *	the "select" system call.
Elliot Lee's avatar
Elliot Lee committed
178 179 180
						     */


181 182
static struct timeval start;			    /* The time at which the library was
						     *	last initialized.
Elliot Lee's avatar
Elliot Lee committed
183
						     */
184 185 186 187 188
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
189
						     */
190 191 192 193
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
194
						     */
195 196
static guint32 timer_val;			    /* The timeout length as specified by
						     *	the user in milliseconds.
Elliot Lee's avatar
Elliot Lee committed
197
						     */
198 199 200 201 202 203 204
static GList *inputs;				    /* A list of the input file descriptors
						     *	that we care about. Each list node
						     *	contains a GdkInput struct that describes
						     *	when we are interested in the specified
						     *	file descriptor. That is, when it is
						     *	available for read, write or has an
						     *	exception pending.
Elliot Lee's avatar
Elliot Lee committed
205
						     */
206 207 208
static guint32 button_click_time[2];		    /* The last 2 button click times. Used
						     *	to determine if the latest button click
						     *	is part of a double or triple click.
Elliot Lee's avatar
Elliot Lee committed
209
						     */
210 211 212
static GdkWindow *button_window[2];		    /* The last 2 windows to receive button presses.
						     *	Also used to determine if the latest button
						     *	click is part of a double or triple click.
Elliot Lee's avatar
Elliot Lee committed
213
						     */
214
static guint button_number[2];			    /* The last 2 buttons to be pressed.
Elliot Lee's avatar
Elliot Lee committed
215
						     */
216
static GdkWindowPrivate *xgrab_window = NULL;	    /* Window that currently holds the
217
						     *	x pointer grab
218
						     */
Elliot Lee's avatar
Elliot Lee committed
219

220 221 222 223 224 225 226 227 228 229 230
#ifdef USE_XIM
static gint xim_using;				/* using XIM Protocol if TRUE */
static GdkIM xim_im;				/* global IM */
static XIMStyles* xim_styles;			/* im supports these styles */
static XIMStyle xim_best_allowed_style;
static GdkICPrivate *xim_ic;			/* currently using IC */
static GdkWindow* xim_window;			/* currently using Widow */
static GList* xim_ic_list;

#endif

Elliot Lee's avatar
Elliot Lee committed
231 232 233 234 235
static GList *putback_events = NULL;

static gulong base_id;
static gint autorepeat;

236 237
#ifdef G_ENABLE_DEBUG
static GDebugKey gdk_debug_keys[] = {
238 239 240
  {"events",	    GDK_DEBUG_EVENTS},
  {"misc",	    GDK_DEBUG_MISC},
  {"dnd",	    GDK_DEBUG_DND},
241
  {"color-context", GDK_DEBUG_COLOR_CONTEXT},
242
  {"xim",	    GDK_DEBUG_XIM}
243
};
244 245 246

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

247
#endif /* G_ENABLE_DEBUG */
Elliot Lee's avatar
Elliot Lee committed
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270

/*
 *--------------------------------------------------------------
 * 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
271
gdk_init (int	 *argc,
Elliot Lee's avatar
Elliot Lee committed
272 273 274
	  char ***argv)
{
  XKeyboardState keyboard_state;
275 276
  gint synchronize;
  gint i, j, k;
Elliot Lee's avatar
Elliot Lee committed
277
  XClassHint *class_hint;
278 279
  gchar **argv_orig = NULL;
  gint argc_orig = 0;
280
  
281 282
  if (gdk_initialized)
    return;
283
  
284 285 286 287 288 289 290 291 292
  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;
    }
293
  
Elliot Lee's avatar
Elliot Lee committed
294
  X_GETTIMEOFDAY (&start);
295
  
Elliot Lee's avatar
Elliot Lee committed
296
#ifndef I_NEED_TO_ACTUALLY_DEBUG_MY_PROGRAMS
Elliot Lee's avatar
Elliot Lee committed
297 298 299 300 301 302 303
  signal (SIGHUP, gdk_signal);
  signal (SIGINT, gdk_signal);
  signal (SIGQUIT, gdk_signal);
  signal (SIGBUS, gdk_signal);
  signal (SIGSEGV, gdk_signal);
  signal (SIGPIPE, gdk_signal);
  signal (SIGTERM, gdk_signal);
Elliot Lee's avatar
Elliot Lee committed
304
#endif
305
  
Elliot Lee's avatar
Elliot Lee committed
306
  gdk_display_name = NULL;
307
  
Elliot Lee's avatar
Elliot Lee committed
308 309
  XSetErrorHandler (gdk_x_error);
  XSetIOErrorHandler (gdk_x_io_error);
310
  
Elliot Lee's avatar
Elliot Lee committed
311
  synchronize = FALSE;
312
  
313 314 315 316 317 318 319 320 321
#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 */
322
  
Elliot Lee's avatar
Elliot Lee committed
323 324 325
  if (argc && argv)
    {
      if (*argc > 0)
326 327
	{
	  gchar *d;
328
	  
329 330
	  d = strrchr((*argv)[0],'/');
	  if (d != NULL)
331
	    g_set_prgname (d + 1);
332
	  else
333
	    g_set_prgname ((*argv)[0]);
334
	}
335
      
Elliot Lee's avatar
Elliot Lee committed
336 337
      for (i = 1; i < *argc;)
	{
338
#ifdef G_ENABLE_DEBUG	  
339 340
	  if ((strcmp ("--gdk-debug", (*argv)[i]) == 0) ||
	      (strncmp ("--gdk-debug=", (*argv)[i], 12) == 0))
Elliot Lee's avatar
Elliot Lee committed
341
	    {
342 343 344 345 346 347 348 349 350
	      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
351
		{
352 353 354
		  gdk_debug_flags |= g_parse_debug_string ((*argv)[i+1],
							   gdk_debug_keys,
							   gdk_ndebug_keys);
355
		  (*argv)[i] = NULL;
356 357
		  i += 1;
		}
358
	      (*argv)[i] = NULL;
359
	    }
360 361
	  else if ((strcmp ("--gdk-no-debug", (*argv)[i]) == 0) ||
		   (strncmp ("--gdk-no-debug=", (*argv)[i], 15) == 0))
362
	    {
363
	      gchar *equal_pos = strchr ((*argv)[i], '=');
364
	      
365 366 367 368 369 370 371
	      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])
372 373 374 375
		{
		  gdk_debug_flags &= ~g_parse_debug_string ((*argv)[i+1],
							    gdk_debug_keys,
							    gdk_ndebug_keys);
376
		  (*argv)[i] = NULL;
Elliot Lee's avatar
Elliot Lee committed
377 378
		  i += 1;
		}
379
	      (*argv)[i] = NULL;
Elliot Lee's avatar
Elliot Lee committed
380
	    }
Owen Taylor's avatar
Owen Taylor committed
381
	  else 
382
#endif /* G_ENABLE_DEBUG */
Owen Taylor's avatar
Owen Taylor committed
383
	    if (strcmp ("--display", (*argv)[i]) == 0)
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
	      {
		(*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;
409
		    g_set_prgname ((*argv)[i]);
410 411 412 413 414 415 416 417 418 419 420 421
		    (*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
422
#ifdef XINPUT_GXI
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440
	    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
441
#endif
442
#ifdef USE_XIM
443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
	    else if (strcmp ("--xim-preedit", (*argv)[i]) == 0)
	      {
		if ((i + 1) < *argc && (*argv)[i + 1])
		  {
		    (*argv)[i++] = NULL;
		    if (strcmp ("none", (*argv)[i]) == 0)
		      gdk_im_set_best_style (GdkIMPreeditNone);
		    else if (strcmp ("nothing", (*argv)[i]) == 0)
		      gdk_im_set_best_style (GdkIMPreeditNothing);
		    else if (strcmp ("area", (*argv)[i]) == 0)
		      gdk_im_set_best_style (GdkIMPreeditArea);
		    else if (strcmp ("position", (*argv)[i]) == 0)
		      gdk_im_set_best_style (GdkIMPreeditPosition);
		    else if (strcmp ("callbacks", (*argv)[i]) == 0)
		      gdk_im_set_best_style (GdkIMPreeditCallbacks);
		  }
	      }
	    else if (strcmp ("--xim-status", (*argv)[i]) == 0)
	      {
		if ((i + 1) < *argc && (*argv)[i + 1])
		  {
		    (*argv)[i++] = NULL;
		    if (strcmp ("none", (*argv)[i]) == 0)
		      gdk_im_set_best_style (GdkIMStatusNone);
		    else if (strcmp ("nothing", (*argv)[i]) == 0)
		      gdk_im_set_best_style (GdkIMStatusNothing);
		    else if (strcmp ("area", (*argv)[i]) == 0)
		      gdk_im_set_best_style (GdkIMStatusArea);
		    else if (strcmp ("callbacks", (*argv)[i]) == 0)
		      gdk_im_set_best_style (GdkIMStatusCallbacks);
		  }
	      }
475
#endif
476
	  
Elliot Lee's avatar
Elliot Lee committed
477 478
	  i += 1;
	}
479
      
Elliot Lee's avatar
Elliot Lee committed
480 481 482 483 484
      for (i = 1; i < *argc; i++)
	{
	  for (k = i; k < *argc; k++)
	    if ((*argv)[k] != NULL)
	      break;
485
	  
Elliot Lee's avatar
Elliot Lee committed
486 487 488 489 490 491 492 493 494 495 496
	  if (k > i)
	    {
	      k -= i;
	      for (j = i + k; j < *argc; j++)
		(*argv)[j-k] = (*argv)[j];
	      *argc -= k;
	    }
	}
    }
  else
    {
497
      g_set_prgname ("<unknown>");
Elliot Lee's avatar
Elliot Lee committed
498
    }
499
  
500
  GDK_NOTE (MISC, g_message ("progname: \"%s\"", g_get_prgname ()));
501
  
Elliot Lee's avatar
Elliot Lee committed
502 503
  gdk_display = XOpenDisplay (gdk_display_name);
  if (!gdk_display)
504 505 506 507
    {
      g_warning ("cannot open display: %s", XDisplayName (gdk_display_name));
      exit(1);
    }
508
  
Elliot Lee's avatar
Elliot Lee committed
509 510 511 512 513 514
  /* This is really crappy. We have to look into the display structure
   *  to find the base resource id. This is only needed for recording
   *  and playback of events.
   */
  /* base_id = RESOURCE_BASE; */
  base_id = 0;
515 516
  GDK_NOTE (EVENTS, g_message ("base id: %lu", base_id));
  
Elliot Lee's avatar
Elliot Lee committed
517
  connection_number = ConnectionNumber (gdk_display);
518
  GDK_NOTE (MISC,
519 520
	    g_message ("connection number: %d", connection_number));
  
Elliot Lee's avatar
Elliot Lee committed
521 522
  if (synchronize)
    XSynchronize (gdk_display, True);
523
  
Elliot Lee's avatar
Elliot Lee committed
524 525
  gdk_screen = DefaultScreen (gdk_display);
  gdk_root_window = RootWindow (gdk_display, gdk_screen);
526
  
Elliot Lee's avatar
Elliot Lee committed
527 528 529
  gdk_leader_window = XCreateSimpleWindow(gdk_display, gdk_root_window,
					  10, 10, 10, 10, 0, 0 , 0);
  class_hint = XAllocClassHint();
530
  class_hint->res_name = g_get_prgname ();
531 532
  if (gdk_progclass == NULL)
    {
533
      gdk_progclass = g_strdup (g_get_prgname ());
534 535
      gdk_progclass[0] = toupper (gdk_progclass[0]);
    }
Elliot Lee's avatar
Elliot Lee committed
536 537 538 539
  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);
540 541 542 543 544
  
  for (i = 0; i < argc_orig; i++)
    g_free(argv_orig[i]);
  g_free(argv_orig);
  
Elliot Lee's avatar
Elliot Lee committed
545 546 547 548 549 550
  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);
551
  
Elliot Lee's avatar
Elliot Lee committed
552 553 554 555 556
  gdk_dnd.gdk_XdeEnter = gdk_atom_intern("_XDE_ENTER", FALSE);
  gdk_dnd.gdk_XdeLeave = gdk_atom_intern("_XDE_LEAVE", FALSE);
  gdk_dnd.gdk_XdeRequest = gdk_atom_intern("_XDE_REQUEST", FALSE);
  gdk_dnd.gdk_XdeDataAvailable = gdk_atom_intern("_XDE_DATA_AVAILABLE", FALSE);
  gdk_dnd.gdk_XdeTypelist = gdk_atom_intern("_XDE_TYPELIST", FALSE);
557 558
  gdk_dnd.c->gdk_cursor_dragdefault = XCreateFontCursor(gdk_display, XC_bogosity);
  gdk_dnd.c->gdk_cursor_dragok = XCreateFontCursor(gdk_display, XC_heart);
559
  
Elliot Lee's avatar
Elliot Lee committed
560 561
  XGetKeyboardControl (gdk_display, &keyboard_state);
  autorepeat = keyboard_state.global_auto_repeat;
562
  
Elliot Lee's avatar
Elliot Lee committed
563 564 565
  timer.tv_sec = 0;
  timer.tv_usec = 0;
  timerp = NULL;
566
  
Elliot Lee's avatar
Elliot Lee committed
567 568 569 570 571 572
  button_click_time[0] = 0;
  button_click_time[1] = 0;
  button_window[0] = NULL;
  button_window[1] = NULL;
  button_number[0] = -1;
  button_number[1] = -1;
573
  
Elliot Lee's avatar
Elliot Lee committed
574 575
  if (ATEXIT (gdk_exit_func))
    g_warning ("unable to register exit function");
576
  
Elliot Lee's avatar
Elliot Lee committed
577 578 579 580
  gdk_visual_init ();
  gdk_window_init ();
  gdk_image_init ();
  gdk_input_init ();
581
  
582 583 584 585 586 587 588 589 590 591 592
#ifdef USE_XIM
  /* initialize XIM Protocol variables */
  xim_using = FALSE;
  xim_im = NULL;
  xim_styles = NULL;
  if (!(xim_best_allowed_style & GdkIMPreeditMask))
    gdk_im_set_best_style (GdkIMPreeditCallbacks);
  if (!(xim_best_allowed_style & GdkIMStatusMask))
    gdk_im_set_best_style (GdkIMStatusCallbacks);
  xim_ic = NULL;
  xim_window = (GdkWindow*)NULL;
593
  
594 595
  gdk_im_open (NULL, NULL, NULL);
#endif
596
  
597
  gdk_initialized = 1;
Elliot Lee's avatar
Elliot Lee committed
598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
}

/*
 *--------------------------------------------------------------
 * 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)
{
622 623 624
  /* 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
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
}

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

gchar*
641
gdk_set_locale (void)
Elliot Lee's avatar
Elliot Lee committed
642 643
{
  if (!setlocale (LC_ALL,""))
644 645
    g_message ("locale not supported by C library");
  
Elliot Lee's avatar
Elliot Lee committed
646 647
  if (!XSupportsLocale ())
    {
648
      g_message ("locale not supported by Xlib, locale set to C");
Elliot Lee's avatar
Elliot Lee committed
649 650
      setlocale (LC_ALL, "C");
    }
651
  
Elliot Lee's avatar
Elliot Lee committed
652 653
  if (!XSetLocaleModifiers (""))
    {
654
      g_message ("can not set locale modifiers");
Elliot Lee's avatar
Elliot Lee committed
655
    }
656
  
Elliot Lee's avatar
Elliot Lee committed
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
  return setlocale (LC_ALL,NULL);
}

/*
 *--------------------------------------------------------------
 * gdk_events_pending
 *
 *   Returns the number of events pending on the queue.
 *   These events have already been read from the server
 *   connection.
 *
 * Arguments:
 *
 * Results:
 *   Returns the number of events on XLib's event queue.
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

gint
679
gdk_events_pending (void)
Elliot Lee's avatar
Elliot Lee committed
680
{
Owen Taylor's avatar
Owen Taylor committed
681 682
  gint result;
  GList *tmp_list;
683
  
Owen Taylor's avatar
Owen Taylor committed
684
  result = XPending (gdk_display);
685
  
Owen Taylor's avatar
Owen Taylor committed
686 687 688 689 690 691 692 693
  tmp_list = putback_events;
  while (tmp_list)
    {
      result++;
      tmp_list = tmp_list->next;
    }
  
  return result;
Elliot Lee's avatar
Elliot Lee committed
694 695
}

696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
/*
 *--------------------------------------------------------------
 * gdk_event_get_graphics_expose
 *
 *   Waits for a GraphicsExpose or NoExpose event
 *
 * Arguments:
 *
 * Results: 
 *   For GraphicsExpose events, returns a pointer to the event
 *   converted into a GdkEvent Otherwise, returns NULL.
 *
 * Side effects:
 *
 *-------------------------------------------------------------- */

static Bool
graphics_expose_predicate  (Display  *display,
			    XEvent   *xevent,
			    XPointer  arg)
{
  GdkWindowPrivate *private = (GdkWindowPrivate *)arg;
718 719
  
  g_return_val_if_fail (private != NULL, False);
720
  
721 722 723 724 725 726 727 728 729 730 731 732 733
  if ((xevent->xany.window == private->xwindow) &&
      ((xevent->xany.type == GraphicsExpose) ||
       (xevent->xany.type == NoExpose)))
    return True;
  else
    return False;
}

GdkEvent *
gdk_event_get_graphics_expose (GdkWindow *window)
{
  XEvent xevent;
  GdkEvent *event;
734 735
  
  g_return_val_if_fail (window != NULL, NULL);
736
  
737
  XIfEvent (gdk_display, &xevent, graphics_expose_predicate, (XPointer)window);
738
  
739 740 741
  if (xevent.xany.type == GraphicsExpose)
    {
      event = gdk_event_new ();
742
      
743 744 745 746 747 748
      if (gdk_event_translate (event, &xevent))
	return event;
      else
	gdk_event_free (event);
    }
  
749
  return NULL;	
750 751
}

Elliot Lee's avatar
Elliot Lee committed
752 753 754 755 756 757 758 759 760
/*
 *--------------------------------------------------------------
 * gdk_event_get
 *
 *   Gets the next event.
 *
 * Arguments:
 *
 * Results:
761 762 763
 *   If an event was received that we care about, returns 
 *   a pointer to that event, to be freed with gdk_event_free.
 *   Otherwise, returns NULL. This function will also return
Elliot Lee's avatar
Elliot Lee committed
764 765 766 767 768 769 770 771
 *   before an event is received if the timeout interval
 *   runs out.
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

772 773
GdkEvent *
gdk_event_get (void)
Elliot Lee's avatar
Elliot Lee committed
774
{
775
  GdkEvent *event;
Elliot Lee's avatar
Elliot Lee committed
776 777
  GList *temp_list;
  XEvent xevent;
778
  
779
#if 0
Elliot Lee's avatar
Elliot Lee committed
780 781 782 783 784 785
  if (pred)
    {
      temp_list = putback_events;
      while (temp_list)
	{
	  temp_event = temp_list->data;
786
	  
Elliot Lee's avatar
Elliot Lee committed
787 788 789 790 791 792 793 794
	  if ((* pred) (temp_event, data))
	    {
	      if (event)
		*event = *temp_event;
	      putback_events = g_list_remove_link (putback_events, temp_list);
	      g_list_free (temp_list);
	      return TRUE;
	    }
795
	  
Elliot Lee's avatar
Elliot Lee committed
796 797
	  temp_list = temp_list->next;
	}
798
      
Elliot Lee's avatar
Elliot Lee committed
799 800
      event_pred.func = pred;
      event_pred.data = data;
801
      
802
      if (XCheckIfEvent (gdk_display, &xevent, gdk_event_get_type, (XPointer) & event_pred))
Elliot Lee's avatar
Elliot Lee committed
803 804 805 806
	if (event)
	  return gdk_event_translate (event, &xevent);
    }
  else
807
#endif
808 809 810 811 812 813 814 815 816 817
    if (putback_events)
      {
	event = putback_events->data;
	
	temp_list = putback_events;
	putback_events = g_list_remove_link (putback_events, temp_list);
	g_list_free_1 (temp_list);
	
	return event;
      }
818 819 820 821 822 823 824 825 826 827
  
  /* Wait for an event to occur or the timeout to elapse.
   * If an event occurs "gdk_event_wait" will return TRUE.
   *  If the timeout elapses "gdk_event_wait" will return
   *  FALSE.
   */
  if (gdk_event_wait ())
    {
      /* If we get here we can rest assurred that an event
       *  has occurred. Read it.
Elliot Lee's avatar
Elliot Lee committed
828
       */
829
#ifdef USE_XIM
830 831 832 833
      gint filter_status;
      if (xim_using && xim_window)
	do
	  {		/* don't dispatch events used by IM */
834
	    XNextEvent (gdk_display, &xevent);
835 836 837 838 839
	    filter_status = XFilterEvent (&xevent, 
					  GDK_WINDOW_XWINDOW (xim_window));
	  } while (filter_status == True);
      else
	XNextEvent (gdk_display, &xevent);
840
#else
841
      XNextEvent (gdk_display, &xevent);
842
#endif
843
      event = gdk_event_new ();
844
      
845 846 847 848 849 850 851 852 853
      event->any.type = GDK_NOTHING;
      event->any.window = NULL;
      event->any.send_event = FALSE;
      event->any.send_event = xevent.xany.send_event;
      
      if (gdk_event_translate (event, &xevent))
	return event;
      else
	gdk_event_free (event);
Elliot Lee's avatar
Elliot Lee committed
854
    }
855
  
856
  return NULL;
Elliot Lee's avatar
Elliot Lee committed
857 858 859 860 861 862
}

void
gdk_event_put (GdkEvent *event)
{
  GdkEvent *new_event;
863
  
Elliot Lee's avatar
Elliot Lee committed
864
  g_return_if_fail (event != NULL);
865
  
866
  new_event = gdk_event_copy (event);
867
  
Elliot Lee's avatar
Elliot Lee committed
868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890
  putback_events = g_list_prepend (putback_events, new_event);
}

/*
 *--------------------------------------------------------------
 * gdk_event_copy
 *
 *   Copy a event structure into new storage.
 *
 * Arguments:
 *   "event" is the event struct to copy.
 *
 * Results:
 *   A new event structure.  Free it with gdk_event_free.
 *
 * Side effects:
 *   The reference count of the window in the event is increased.
 *
 *--------------------------------------------------------------
 */

static GMemChunk *event_chunk;

891 892
static GdkEvent*
gdk_event_new (void)
Elliot Lee's avatar
Elliot Lee committed
893 894 895 896 897 898 899 900
{
  GdkEvent *new_event;
  
  if (event_chunk == NULL)
    event_chunk = g_mem_chunk_new ("events",
				   sizeof (GdkEvent),
				   4096,
				   G_ALLOC_AND_FREE);
901
  
Elliot Lee's avatar
Elliot Lee committed
902
  new_event = g_chunk_new (GdkEvent, event_chunk);
903
  
904 905 906 907 908 909 910 911 912
  return new_event;
}

GdkEvent*
gdk_event_copy (GdkEvent *event)
{
  GdkEvent *new_event;
  
  g_return_val_if_fail (event != NULL, NULL);
913
  
914
  new_event = gdk_event_new ();
915
  
Elliot Lee's avatar
Elliot Lee committed
916 917
  *new_event = *event;
  gdk_window_ref (new_event->any.window);
918
  
Owen Taylor's avatar
Owen Taylor committed
919 920 921 922 923 924
  switch (event->any.type)
    {
    case GDK_KEY_PRESS:
    case GDK_KEY_RELEASE:
      new_event->key.string = g_strdup (event->key.string);
      break;
925
      
Owen Taylor's avatar
Owen Taylor committed
926 927 928 929 930
    case GDK_ENTER_NOTIFY:
    case GDK_LEAVE_NOTIFY:
      if (event->crossing.subwindow != NULL)
	gdk_window_ref (event->crossing.subwindow);
      break;
931
      
Owen Taylor's avatar
Owen Taylor committed
932 933 934 935 936 937 938
    case GDK_DROP_DATA_AVAIL:
      new_event->dropdataavailable.data_type = g_strdup (event->dropdataavailable.data_type);
      new_event->dropdataavailable.data = g_malloc (event->dropdataavailable.data_numbytes);
      memcpy (new_event->dropdataavailable.data,
	      event->dropdataavailable.data, 
	      event->dropdataavailable.data_numbytes);
      break;
939
      
Owen Taylor's avatar
Owen Taylor committed
940 941 942
    default:
      break;
    }
943
  
Elliot Lee's avatar
Elliot Lee committed
944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969
  return new_event;
}

/*
 *--------------------------------------------------------------
 * gdk_event_free
 *
 *   Free a event structure obtained from gdk_event_copy.  Do not use
 *   with other event structures.
 *
 * Arguments:
 *   "event" is the event struct to free.
 *
 * Results:
 *
 * Side effects:
 *   The reference count of the window in the event is decreased and
 *   might be freed, too.
 *
 *-------------------------------------------------------------- */

void
gdk_event_free (GdkEvent *event)
{
  g_assert (event_chunk != NULL);
  g_return_if_fail (event != NULL);
970
  
971 972
  if (event->any.window)
    gdk_window_unref (event->any.window);
973
  
Owen Taylor's avatar
Owen Taylor committed
974 975 976 977 978 979
  switch (event->any.type)
    {
    case GDK_KEY_PRESS:
    case GDK_KEY_RELEASE:
      g_free (event->key.string);
      break;
980
      
Owen Taylor's avatar
Owen Taylor committed
981 982 983 984 985
    case GDK_ENTER_NOTIFY:
    case GDK_LEAVE_NOTIFY:
      if (event->crossing.subwindow != NULL)
	gdk_window_unref (event->crossing.subwindow);
      break;
986
      
Owen Taylor's avatar
Owen Taylor committed
987 988 989 990
    case GDK_DROP_DATA_AVAIL:
      g_free (event->dropdataavailable.data_type);
      g_free (event->dropdataavailable.data);
      break;
991
      
Elliot Lee's avatar
Elliot Lee committed
992 993 994
    case GDK_DRAG_REQUEST:
      g_free (event->dragrequest.data_type);
      break;
995
      
Owen Taylor's avatar
Owen Taylor committed
996 997 998
    default:
      break;
    }
999
  
Elliot Lee's avatar
Elliot Lee committed
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
  g_mem_chunk_free (event_chunk, event);
}

/*
 *--------------------------------------------------------------
 * gdk_set_show_events
 *
 *   Turns on/off the showing of events.
 *
 * Arguments:
 *   "show_events" is a boolean describing whether or
 *   not to show the events gdk receives.
 *
 * Results:
 *
 * Side effects:
 *   When "show_events" is TRUE, calls to "gdk_event_get"
 *   will output debugging informatin regarding the event
 *   received to stdout.
 *
 *--------------------------------------------------------------
 */

void
gdk_set_show_events (int show_events)
{
1026 1027 1028 1029
  if (show_events)
    gdk_debug_flags |= GDK_DEBUG_EVENTS;
  else
    gdk_debug_flags &= ~GDK_DEBUG_EVENTS;
Elliot Lee's avatar
Elliot Lee committed
1030 1031 1032 1033 1034 1035 1036 1037 1038
}

void
gdk_set_use_xshm (gint use_xshm)
{
  gdk_use_xshm = use_xshm;
}

gint
1039
gdk_get_show_events (void)
Elliot Lee's avatar
Elliot Lee committed
1040
{
1041
  return gdk_debug_flags & GDK_DEBUG_EVENTS;
Elliot Lee's avatar
Elliot Lee committed
1042 1043 1044
}

gint
1045
gdk_get_use_xshm (void)
Elliot Lee's avatar
Elliot Lee committed
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
{
  return gdk_use_xshm;
}

/*
 *--------------------------------------------------------------
 * gdk_time_get
 *
 *   Get the number of milliseconds since the library was
 *   initialized.
 *
 * Arguments:
 *
 * Results:
 *   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.
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

guint32
1071
gdk_time_get (void)
Elliot Lee's avatar
Elliot Lee committed
1072 1073 1074 1075
{
  struct timeval end;
  struct timeval elapsed;
  guint32 milliseconds;
1076
  
Elliot Lee's avatar
Elliot Lee committed
1077
  X_GETTIMEOFDAY (&end);
1078
  
Elliot Lee's avatar
Elliot Lee committed
1079 1080 1081 1082 1083 1084 1085
  if (start.tv_usec > end.tv_usec)
    {
      end.tv_usec += 1000000;
      end.tv_sec--;
    }
  elapsed.tv_sec = end.tv_sec - start.tv_sec;
  elapsed.tv_usec = end.tv_usec - start.tv_usec;
1086
  
Elliot Lee's avatar
Elliot Lee committed
1087
  milliseconds = (elapsed.tv_sec * 1000) + (elapsed.tv_usec / 1000);
1088
  
Elliot Lee's avatar
Elliot Lee committed
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109
  return milliseconds;
}

/*
 *--------------------------------------------------------------
 * gdk_timer_get
 *
 *   Returns the current timer.
 *
 * Arguments:
 *
 * Results:
 *   Returns the current timer interval. This interval is
 *   in units of milliseconds.
 *
 * Side effects:
 *
 *--------------------------------------------------------------
 */

guint32
1110
gdk_timer_get (void)
Elliot Lee's avatar
Elliot Lee committed
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
{
  return timer_val;
}

/*
 *--------------------------------------------------------------
 * gdk_timer_set
 *
 *   Sets the timer interval.
 *
 * Arguments:
 *   "milliseconds" is the new value for the timer.
 *
 * Results:
 *
 * Side effects:
 *   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.
 *
 *--------------------------------------------------------------
 */

void
gdk_timer_set (guint32 milliseconds)
{
  timer_val = milliseconds;
  timer.tv_sec = milliseconds / 1000;
  timer.tv_usec = (milliseconds % 1000) * 1000;
1141
  
Elliot Lee's avatar
Elliot Lee committed
1142 1143 1144
}

void
1145
gdk_timer_enable (void)
Elliot Lee's avatar
Elliot Lee committed
1146 1147 1148 1149 1150
{
  timerp = &timer;
}

void
1151
gdk_timer_disable (void)
Elliot Lee's avatar
Elliot Lee committed
1152 1153 1154 1155 1156
{
  timerp = NULL;
}

gint
1157
gdk_input_add_full (gint	      source,
1158 1159
		    GdkInputCondition condition,
		    GdkInputFunction  function,
1160
		    gpointer	      data,
1161
		    GdkDestroyNotify  destroy)
Elliot Lee's avatar
Elliot Lee committed
1162 1163 1164 1165 1166
{
  static gint next_tag = 1;
  GList *list;
  GdkInput *input;
  gint tag;
1167
  
Elliot Lee's avatar
Elliot Lee committed
1168 1169
  tag = 0;
  list = inputs;
1170
  
Elliot Lee's avatar
Elliot Lee committed
1171 1172 1173 1174
  while (list)
    {
      input = list->data;
      list = list->next;
1175
      
Elliot Lee's avatar
Elliot Lee committed
1176 1177
      if ((input->source == source) && (input->condition == condition))
	{
1178 1179
	  if (input->destroy)
	    (input->destroy) (input->data);
Elliot Lee's avatar
Elliot Lee committed
1180 1181
	  input->function = function;
	  input->data = data;
1182
	  input->destroy = destroy;
Elliot Lee's avatar
Elliot Lee committed
1183 1184 1185
	  tag = input->tag;
	}
    }
1186
  
Elliot Lee's avatar
Elliot Lee committed
1187 1188 1189 1190 1191 1192 1193 1194
  if (!tag)
    {
      input = g_new (GdkInput, 1);
      input->tag = next_tag++;
      input->source = source;
      input->condition = condition;
      input->function = function;
      input->data = data;
1195
      input->destroy = destroy;
Elliot Lee's avatar
Elliot Lee committed
1196
      tag = input->tag;
1197
      
Elliot Lee's avatar
Elliot Lee committed
1198 1199
      inputs = g_list_prepend (inputs, input);
    }
1200
  
Elliot Lee's avatar
Elliot Lee committed
1201 1202 1203
  return tag;
}

1204
gint
1205
gdk_input_add (gint		 source,
1206
	       GdkInputCondition condition,
1207 1208
	       GdkInputFunction	 function,
	       gpointer		 data)
1209 1210 1211 1212
{
  return gdk_input_add_interp (source, condition, function, data, NULL);
}

Elliot Lee's avatar
Elliot Lee committed
1213 1214 1215 1216 1217
void
gdk_input_remove (gint tag)
{
  GList *list;
  GdkInput *input;
1218
  
Elliot Lee's avatar
Elliot Lee committed
1219 1220 1221 1222
  list = inputs;
  while (list)
    {
      input = list->data;
1223
      
Elliot Lee's avatar
Elliot Lee committed
1224 1225
      if (input->tag == tag)
	{
1226 1227
	  if (input->destroy)
	    (input->destroy) (input->data);
1228 1229 1230 1231
	  
	  input->tag = 0;	      /* do not free it here */
	  input->condition = 0;	      /* it's done in gdk_event_wait */
	  
Elliot Lee's avatar
Elliot Lee committed
1232 1233
	  break;
	}
1234
      
Elliot Lee's avatar
Elliot Lee committed
1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
      list = list->next;
    }
}

/*
 *--------------------------------------------------------------
 * gdk_pointer_grab
 *
 *   Grabs the pointer to a specific window
 *
 * Arguments:
 *   "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
 *
 * Results:
 *
 * Side effects:
 *   requires a corresponding call to gdk_pointer_ungrab
 *
 *--------------------------------------------------------------
 */

gint
1263 1264 1265 1266 1267 1268
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
1269
{
1270
  /*  From gdkwindow.c	*/
Elliot Lee's avatar
Elliot Lee committed
1271 1272
  extern int nevent_masks;
  extern int event_mask_table[];
1273
  
Elliot Lee's avatar
Elliot Lee committed
1274 1275 1276 1277 1278 1279 1280 1281 1282
  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;
Tim Janik's avatar