1997-11-24 22:37:52 +00:00
|
|
|
/* 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
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Library General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Library General Public
|
|
|
|
* License along with this library; if not, write to the Free
|
|
|
|
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
#include "../config.h"
|
|
|
|
|
1997-12-31 02:52:03 +00:00
|
|
|
/* If you don't want to use gdk's signal handlers define this */
|
|
|
|
/* #define I_NEED_TO_ACTUALLY_DEBUG_MY_PROGRAMS 1 */
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
#include <X11/Xlocale.h>
|
1997-11-24 22:37:52 +00:00
|
|
|
#include <ctype.h>
|
|
|
|
#include <signal.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <limits.h>
|
1997-11-27 04:16:39 +00:00
|
|
|
#ifdef USE_XIM
|
|
|
|
#include <stdarg.h>
|
|
|
|
#endif
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
#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>
|
1997-11-27 04:16:39 +00:00
|
|
|
#ifdef USE_XIM
|
|
|
|
#include <X11/Xresource.h>
|
|
|
|
#endif
|
1997-11-24 22:37:52 +00:00
|
|
|
#include <X11/cursorfont.h>
|
|
|
|
#include "gdk.h"
|
|
|
|
#include "gdkprivate.h"
|
|
|
|
#include "gdkinput.h"
|
1997-11-27 04:16:39 +00:00
|
|
|
#ifdef USE_XIM
|
|
|
|
#include "gdkx.h"
|
|
|
|
#include "gdkkeysyms.h"
|
|
|
|
#endif
|
1997-12-03 21:43:44 +00:00
|
|
|
#include "gdki18n.h"
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
#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
|
|
|
|
typedef long fd_mask;
|
|
|
|
# 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;
|
1997-12-18 02:17:14 +00:00
|
|
|
GdkDestroyNotify destroy;
|
1997-11-24 22:37:52 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct _GdkPredicate
|
|
|
|
{
|
|
|
|
GdkEventFunc func;
|
|
|
|
gpointer data;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Private function declarations
|
|
|
|
*/
|
1997-12-18 02:17:14 +00:00
|
|
|
|
|
|
|
static GdkEvent *gdk_event_new (void);
|
1997-11-24 22:37:52 +00:00
|
|
|
static gint gdk_event_wait (void);
|
1997-12-18 02:17:14 +00:00
|
|
|
static gint gdk_event_apply_filters (XEvent *xevent,
|
|
|
|
GdkEvent *event,
|
|
|
|
GList *filters);
|
1997-11-24 22:37:52 +00:00
|
|
|
static gint gdk_event_translate (GdkEvent *event,
|
|
|
|
XEvent *xevent);
|
1997-12-18 02:17:14 +00:00
|
|
|
#if 0
|
1997-11-24 22:37:52 +00:00
|
|
|
static Bool gdk_event_get_type (Display *display,
|
|
|
|
XEvent *xevent,
|
|
|
|
XPointer arg);
|
1997-12-18 02:17:14 +00:00
|
|
|
#endif
|
1997-11-24 22:37:52 +00:00
|
|
|
static void gdk_synthesize_click (GdkEvent *event,
|
|
|
|
gint nclicks);
|
|
|
|
|
|
|
|
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);
|
1997-12-06 22:12:10 +00:00
|
|
|
static void gdk_dnd_drag_end (Window dest,
|
1997-11-24 22:37:52 +00:00
|
|
|
GdkPoint coords);
|
|
|
|
static GdkAtom gdk_dnd_check_types (GdkWindow *window,
|
|
|
|
XEvent *xevent);
|
1997-12-06 22:12:10 +00:00
|
|
|
#ifdef DEBUG_DND
|
1997-11-24 22:37:52 +00:00
|
|
|
static void gdk_print_atom (GdkAtom anatom);
|
1997-12-06 22:12:10 +00:00
|
|
|
#endif
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* old junk from offix, we might use it though so leave it
|
|
|
|
*/
|
1997-12-06 22:12:10 +00:00
|
|
|
Window gdk_get_client_window (Display *dpy,
|
|
|
|
Window win);
|
|
|
|
#ifdef WE_HAVE_MOTIF_DROPS_DONE
|
1997-11-24 22:37:52 +00:00
|
|
|
static GdkWindow * gdk_drop_get_real_window (GdkWindow *w,
|
|
|
|
guint16 *x,
|
|
|
|
guint16 *y);
|
1997-12-06 22:12:10 +00:00
|
|
|
#endif
|
1997-11-24 22:37:52 +00:00
|
|
|
static void gdk_exit_func (void);
|
|
|
|
static int gdk_x_error (Display *display,
|
|
|
|
XErrorEvent *error);
|
|
|
|
static int gdk_x_io_error (Display *display);
|
|
|
|
static RETSIGTYPE gdk_signal (int signum);
|
|
|
|
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
#ifdef USE_XIM
|
|
|
|
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);
|
|
|
|
static void gdk_ic_cleanup (void);
|
|
|
|
#endif /* USE_XIM */
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
/* Private variable declarations
|
|
|
|
*/
|
|
|
|
static int initialized = 0; /* 1 if the library is initialized,
|
|
|
|
* 0 otherwise.
|
|
|
|
*/
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
static struct timeval start; /* The time at which the library was
|
|
|
|
* last initialized.
|
|
|
|
*/
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
static struct timeval *timerp; /* The actual timer passed to "select"
|
|
|
|
* This may be NULL, in which case
|
|
|
|
* "select" will block until an event
|
|
|
|
* arrives.
|
|
|
|
*/
|
|
|
|
static guint32 timer_val; /* The timeout length as specified by
|
|
|
|
* the user in milliseconds.
|
|
|
|
*/
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
static guint button_number[2]; /* The last 2 buttons to be pressed.
|
|
|
|
*/
|
1998-01-21 09:16:33 +00:00
|
|
|
static GdkWindowPrivate *xgrab_window = NULL; /* Window that currently holds the
|
|
|
|
* x pointer grab
|
1998-01-21 08:35:37 +00:00
|
|
|
*/
|
1997-11-24 22:37:52 +00:00
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
#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
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
#define OTHER_XEVENT_BUFSIZE 4
|
|
|
|
static XEvent other_xevent[OTHER_XEVENT_BUFSIZE]; /* XEvents passed along to user */
|
|
|
|
static int other_xevent_i = 0;
|
|
|
|
static GList *putback_events = NULL;
|
|
|
|
|
|
|
|
static gulong base_id;
|
|
|
|
static gint autorepeat;
|
|
|
|
|
1998-02-19 06:21:27 +00:00
|
|
|
#ifdef G_ENABLE_DEBUG
|
|
|
|
static GDebugKey gdk_debug_keys[] = {
|
|
|
|
{"events", GDK_DEBUG_EVENTS},
|
|
|
|
{"misc", GDK_DEBUG_MISC},
|
|
|
|
{"dnd", GDK_DEBUG_DND},
|
|
|
|
{"color-context", GDK_DEBUG_COLOR_CONTEXT},
|
|
|
|
{"xim", GDK_DEBUG_XIM}
|
|
|
|
};
|
1998-02-19 18:02:03 +00:00
|
|
|
|
|
|
|
static const int gdk_ndebug_keys = sizeof(gdk_debug_keys)/sizeof(GDebugKey);
|
|
|
|
|
1998-02-19 06:21:27 +00:00
|
|
|
#endif /* G_ENABLE_DEBUG */
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* 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
|
|
|
|
gdk_init (int *argc,
|
|
|
|
char ***argv)
|
|
|
|
{
|
|
|
|
XKeyboardState keyboard_state;
|
1998-03-08 03:32:05 +00:00
|
|
|
gint synchronize;
|
|
|
|
gint i, j, k;
|
1997-11-24 22:37:52 +00:00
|
|
|
XClassHint *class_hint;
|
1998-03-08 03:32:05 +00:00
|
|
|
gint argc_orig = *argc;
|
|
|
|
gchar **argv_orig;
|
1997-11-24 22:37:52 +00:00
|
|
|
|
1998-03-08 02:04:26 +00:00
|
|
|
argv_orig = g_malloc ((argc_orig + 1) * sizeof (char*));
|
1997-11-24 22:37:52 +00:00
|
|
|
for (i = 0; i < argc_orig; i++)
|
|
|
|
argv_orig[i] = g_strdup ((*argv)[i]);
|
|
|
|
argv_orig[argc_orig] = NULL;
|
|
|
|
|
|
|
|
X_GETTIMEOFDAY (&start);
|
|
|
|
|
1997-12-31 02:52:03 +00:00
|
|
|
#ifndef I_NEED_TO_ACTUALLY_DEBUG_MY_PROGRAMS
|
1997-11-24 22:37:52 +00:00
|
|
|
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);
|
1997-12-31 02:52:03 +00:00
|
|
|
#endif
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
gdk_display_name = NULL;
|
|
|
|
|
|
|
|
XSetErrorHandler (gdk_x_error);
|
|
|
|
XSetIOErrorHandler (gdk_x_io_error);
|
|
|
|
|
|
|
|
synchronize = FALSE;
|
|
|
|
|
1998-02-19 18:02:03 +00:00
|
|
|
#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 */
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (argc && argv)
|
|
|
|
{
|
|
|
|
if (*argc > 0)
|
|
|
|
gdk_progname = (*argv)[0];
|
|
|
|
|
|
|
|
for (i = 1; i < *argc;)
|
|
|
|
{
|
1998-02-19 06:21:27 +00:00
|
|
|
if ((*argv)[i] == NULL)
|
1998-02-19 18:02:03 +00:00
|
|
|
{
|
|
|
|
i += 1;
|
|
|
|
continue;
|
|
|
|
}
|
1998-02-19 06:21:27 +00:00
|
|
|
|
|
|
|
#ifdef G_ENABLE_DEBUG
|
|
|
|
if (strcmp ("--gdk-debug", (*argv)[i]) == 0)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
(*argv)[i] = NULL;
|
|
|
|
|
1998-02-19 06:21:27 +00:00
|
|
|
if ((i + 1) < *argc && (*argv)[i + 1])
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-02-19 18:02:03 +00:00
|
|
|
gdk_debug_flags |= g_parse_debug_string ((*argv)[i+1],
|
|
|
|
gdk_debug_keys,
|
|
|
|
gdk_ndebug_keys);
|
|
|
|
(*argv)[i + 1] = NULL;
|
|
|
|
i += 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (strcmp ("--gdk-no-debug", (*argv)[i]) == 0)
|
|
|
|
{
|
|
|
|
(*argv)[i] = NULL;
|
|
|
|
|
|
|
|
if ((i + 1) < *argc && (*argv)[i + 1])
|
|
|
|
{
|
|
|
|
gdk_debug_flags &= ~g_parse_debug_string ((*argv)[i+1],
|
|
|
|
gdk_debug_keys,
|
|
|
|
gdk_ndebug_keys);
|
1997-11-24 22:37:52 +00:00
|
|
|
(*argv)[i + 1] = NULL;
|
|
|
|
i += 1;
|
|
|
|
}
|
|
|
|
}
|
1998-02-19 18:02:03 +00:00
|
|
|
#endif /* G_ENABLE_DEBUG */
|
1998-02-19 06:21:27 +00:00
|
|
|
else if (strcmp ("--display", (*argv)[i]) == 0)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
(*argv)[i] = NULL;
|
1998-02-19 06:21:27 +00:00
|
|
|
|
|
|
|
if ((i + 1) < *argc && (*argv)[i + 1])
|
|
|
|
{
|
|
|
|
gdk_display_name = g_strdup ((*argv)[i + 1]);
|
|
|
|
(*argv)[i + 1] = NULL;
|
|
|
|
i += 1;
|
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1998-02-19 06:21:27 +00:00
|
|
|
else if (strcmp ("--sync", (*argv)[i]) == 0)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
(*argv)[i] = NULL;
|
1998-02-19 06:21:27 +00:00
|
|
|
synchronize = TRUE;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
else if (strcmp ("--no-xshm", (*argv)[i]) == 0)
|
|
|
|
{
|
|
|
|
(*argv)[i] = NULL;
|
|
|
|
gdk_use_xshm = FALSE;
|
|
|
|
}
|
new function to perform the same actions as gtk_list_remove_items, but
Thu Feb 5 02:13:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtklist.h:
* gtk/gtklist.c (gtk_list_remove_items_no_unref): new function
to perform the same actions as gtk_list_remove_items, but
supply the removed widgets with an additional reference count.
* gtk/gtkmain.c (gtk_main_iteration_do): ignore events
with event_widget == NULL, since they are bogus events
from destroyed GdkWindows, exept for the case where
event->type==GDK_PROPERTY_NOTIFY. Always handle expired
timeout functions when returning from this function.
* gtk/gtkwidget.c (gtk_widget_event): ignore GDK_EXPOSE events
if event->window == NULL. Also, if this function couldn't handle
the event for any reason (including failing assumptions), make
the return value to look as if the event had been handled to
avoid further processing (and warnings).
* gtk/gtkwidget.h:
* gtk/gtkwidget.c: remove gtk_widget_sink, because there is
no point in providing such a function.
* gdk/gdk.c (gdk_init): changed options `-name' and `-class'
to `--name' and `--class', because the old names would
confuse getopt(). these arguments have been introduced in the
changes from gtk+970916 to gtk+970925 without a ChangeLog entry,
changing argument names is painful, it would be nice if people
would care about compatibility and consistency in the first place!
1998-02-05 03:53:41 +00:00
|
|
|
else if (strcmp ("--name", (*argv)[i]) == 0)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-02-19 06:21:27 +00:00
|
|
|
if ((i + 1) < *argc && (*argv)[i + 1])
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
(*argv)[i++] = NULL;
|
|
|
|
gdk_progname = (*argv)[i];
|
|
|
|
(*argv)[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
new function to perform the same actions as gtk_list_remove_items, but
Thu Feb 5 02:13:08 1998 Tim Janik <timj@gimp.org>
* gtk/gtklist.h:
* gtk/gtklist.c (gtk_list_remove_items_no_unref): new function
to perform the same actions as gtk_list_remove_items, but
supply the removed widgets with an additional reference count.
* gtk/gtkmain.c (gtk_main_iteration_do): ignore events
with event_widget == NULL, since they are bogus events
from destroyed GdkWindows, exept for the case where
event->type==GDK_PROPERTY_NOTIFY. Always handle expired
timeout functions when returning from this function.
* gtk/gtkwidget.c (gtk_widget_event): ignore GDK_EXPOSE events
if event->window == NULL. Also, if this function couldn't handle
the event for any reason (including failing assumptions), make
the return value to look as if the event had been handled to
avoid further processing (and warnings).
* gtk/gtkwidget.h:
* gtk/gtkwidget.c: remove gtk_widget_sink, because there is
no point in providing such a function.
* gdk/gdk.c (gdk_init): changed options `-name' and `-class'
to `--name' and `--class', because the old names would
confuse getopt(). these arguments have been introduced in the
changes from gtk+970916 to gtk+970925 without a ChangeLog entry,
changing argument names is painful, it would be nice if people
would care about compatibility and consistency in the first place!
1998-02-05 03:53:41 +00:00
|
|
|
else if (strcmp ("--class", (*argv)[i]) == 0)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-02-19 06:21:27 +00:00
|
|
|
if ((i + 1) < *argc && (*argv)[i + 1])
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
(*argv)[i++] = NULL;
|
|
|
|
gdk_progclass = (*argv)[i];
|
|
|
|
(*argv)[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef XINPUT_GXI
|
|
|
|
else if (strcmp ("--gxid_host", (*argv)[i]) == 0)
|
|
|
|
{
|
1998-02-19 06:21:27 +00:00
|
|
|
if ((i + 1) < *argc && (*argv)[i + 1])
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
(*argv)[i++] = NULL;
|
|
|
|
gdk_input_gxid_host = ((*argv)[i]);
|
|
|
|
(*argv)[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (strcmp ("--gxid_port", (*argv)[i]) == 0)
|
|
|
|
{
|
1998-02-19 06:21:27 +00:00
|
|
|
if ((i + 1) < *argc && (*argv)[i + 1])
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
(*argv)[i++] = NULL;
|
|
|
|
gdk_input_gxid_port = atoi ((*argv)[i]);
|
|
|
|
(*argv)[i] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
1997-11-27 04:16:39 +00:00
|
|
|
#ifdef USE_XIM
|
|
|
|
else if (strcmp ("--xim-preedit", (*argv)[i]) == 0)
|
|
|
|
{
|
1998-02-19 06:21:27 +00:00
|
|
|
if ((i + 1) < *argc && (*argv)[i + 1])
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
(*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)
|
|
|
|
{
|
1998-02-19 06:21:27 +00:00
|
|
|
if ((i + 1) < *argc && (*argv)[i + 1])
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
(*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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
i += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 1; i < *argc; i++)
|
|
|
|
{
|
|
|
|
for (k = i; k < *argc; k++)
|
|
|
|
if ((*argv)[k] != NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (k > i)
|
|
|
|
{
|
|
|
|
k -= i;
|
|
|
|
for (j = i + k; j < *argc; j++)
|
|
|
|
(*argv)[j-k] = (*argv)[j];
|
|
|
|
*argc -= k;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
gdk_progname = "<unknown>";
|
|
|
|
}
|
|
|
|
|
|
|
|
gdk_display = XOpenDisplay (gdk_display_name);
|
|
|
|
if (!gdk_display)
|
1997-12-05 23:14:41 +00:00
|
|
|
{
|
|
|
|
g_warning ("cannot open display: %s", XDisplayName (gdk_display_name));
|
|
|
|
exit(1);
|
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
/* 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;
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS, g_print ("base id: %lu\n", base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
connection_number = ConnectionNumber (gdk_display);
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (MISC,
|
|
|
|
g_print ("connection number: %d\n", connection_number));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
if (synchronize)
|
|
|
|
XSynchronize (gdk_display, True);
|
|
|
|
|
|
|
|
gdk_screen = DefaultScreen (gdk_display);
|
|
|
|
gdk_root_window = RootWindow (gdk_display, gdk_screen);
|
|
|
|
|
|
|
|
gdk_leader_window = XCreateSimpleWindow(gdk_display, gdk_root_window,
|
|
|
|
10, 10, 10, 10, 0, 0 , 0);
|
|
|
|
class_hint = XAllocClassHint();
|
|
|
|
class_hint->res_name = gdk_progname;
|
1997-12-11 08:39:21 +00:00
|
|
|
if (gdk_progclass == NULL)
|
|
|
|
{
|
1998-01-21 05:13:01 +00:00
|
|
|
gdk_progclass = g_strdup (gdk_progname);
|
1997-12-11 08:39:21 +00:00
|
|
|
gdk_progclass[0] = toupper (gdk_progclass[0]);
|
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
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);
|
1998-03-08 03:32:05 +00:00
|
|
|
|
|
|
|
for (i = 0; i < argc_orig; i++)
|
|
|
|
g_free(argv_orig[i]);
|
|
|
|
g_free(argv_orig);
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
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);
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd.c->gdk_cursor_dragdefault = XCreateFontCursor(gdk_display, XC_bogosity);
|
|
|
|
gdk_dnd.c->gdk_cursor_dragok = XCreateFontCursor(gdk_display, XC_heart);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
XGetKeyboardControl (gdk_display, &keyboard_state);
|
|
|
|
autorepeat = keyboard_state.global_auto_repeat;
|
|
|
|
|
|
|
|
timer.tv_sec = 0;
|
|
|
|
timer.tv_usec = 0;
|
|
|
|
timerp = NULL;
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (ATEXIT (gdk_exit_func))
|
|
|
|
g_warning ("unable to register exit function");
|
|
|
|
|
|
|
|
gdk_visual_init ();
|
|
|
|
gdk_window_init ();
|
|
|
|
gdk_image_init ();
|
|
|
|
gdk_input_init ();
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
#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;
|
|
|
|
|
|
|
|
gdk_im_open (NULL, NULL, NULL);
|
|
|
|
#endif
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
initialized = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* 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)
|
|
|
|
{
|
|
|
|
/* de-initialisation is done by the gdk_exit_funct(),
|
|
|
|
no need to do this here (Alex J.) */
|
|
|
|
exit (errorcode);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* gdk_set_locale
|
|
|
|
*
|
|
|
|
* Arguments:
|
|
|
|
*
|
|
|
|
* Results:
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
gchar*
|
|
|
|
gdk_set_locale ()
|
|
|
|
{
|
|
|
|
if (!setlocale (LC_ALL,""))
|
|
|
|
g_print ("locale not supported by C library\n");
|
|
|
|
|
|
|
|
if (!XSupportsLocale ())
|
|
|
|
{
|
|
|
|
g_print ("locale not supported by Xlib, locale set to C\n");
|
|
|
|
setlocale (LC_ALL, "C");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!XSetLocaleModifiers (""))
|
|
|
|
{
|
|
|
|
g_print ("can not set locale modifiers\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
gdk_events_pending ()
|
|
|
|
{
|
1998-01-17 23:24:09 +00:00
|
|
|
gint result;
|
|
|
|
GList *tmp_list;
|
|
|
|
|
|
|
|
result = XPending (gdk_display);
|
|
|
|
|
|
|
|
tmp_list = putback_events;
|
|
|
|
while (tmp_list)
|
|
|
|
{
|
|
|
|
result++;
|
|
|
|
tmp_list = tmp_list->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* 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;
|
1998-02-13 18:41:18 +00:00
|
|
|
|
|
|
|
g_return_val_if_fail (private != NULL, False);
|
1997-12-18 02:17:14 +00:00
|
|
|
|
|
|
|
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;
|
1998-02-13 18:41:18 +00:00
|
|
|
|
|
|
|
g_return_val_if_fail (window != NULL, NULL);
|
1997-12-18 02:17:14 +00:00
|
|
|
|
|
|
|
XIfEvent (gdk_display, &xevent, graphics_expose_predicate, (XPointer)window);
|
|
|
|
|
|
|
|
if (xevent.xany.type == GraphicsExpose)
|
|
|
|
{
|
|
|
|
event = gdk_event_new ();
|
|
|
|
|
|
|
|
if (gdk_event_translate (event, &xevent))
|
|
|
|
return event;
|
|
|
|
else
|
|
|
|
gdk_event_free (event);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* gdk_event_get
|
|
|
|
*
|
|
|
|
* Gets the next event.
|
|
|
|
*
|
|
|
|
* Arguments:
|
|
|
|
*
|
|
|
|
* Results:
|
1997-12-18 02:17:14 +00:00
|
|
|
* 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
|
1997-11-24 22:37:52 +00:00
|
|
|
* before an event is received if the timeout interval
|
|
|
|
* runs out.
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
GdkEvent *
|
|
|
|
gdk_event_get (void)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1997-12-18 02:17:14 +00:00
|
|
|
GdkEvent *event;
|
1997-11-24 22:37:52 +00:00
|
|
|
GList *temp_list;
|
|
|
|
XEvent xevent;
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
#if 0
|
1997-11-24 22:37:52 +00:00
|
|
|
if (pred)
|
|
|
|
{
|
|
|
|
temp_list = putback_events;
|
|
|
|
while (temp_list)
|
|
|
|
{
|
|
|
|
temp_event = temp_list->data;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
temp_list = temp_list->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
event_pred.func = pred;
|
|
|
|
event_pred.data = data;
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
if (XCheckIfEvent (gdk_display, &xevent, gdk_event_get_type, (XPointer) & event_pred))
|
1997-11-24 22:37:52 +00:00
|
|
|
if (event)
|
|
|
|
return gdk_event_translate (event, &xevent);
|
|
|
|
}
|
|
|
|
else
|
1997-12-18 02:17:14 +00:00
|
|
|
#endif
|
|
|
|
if (putback_events)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1997-12-18 02:17:14 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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.
|
1997-11-24 22:37:52 +00:00
|
|
|
*/
|
1997-11-27 04:16:39 +00:00
|
|
|
#ifdef USE_XIM
|
1997-12-18 02:17:14 +00:00
|
|
|
gint filter_status;
|
|
|
|
if (xim_using && xim_window)
|
|
|
|
do
|
|
|
|
{ /* don't dispatch events used by IM */
|
1997-11-27 04:16:39 +00:00
|
|
|
XNextEvent (gdk_display, &xevent);
|
1997-12-18 02:17:14 +00:00
|
|
|
filter_status = XFilterEvent (&xevent,
|
|
|
|
GDK_WINDOW_XWINDOW (xim_window));
|
|
|
|
} while (filter_status == True);
|
|
|
|
else
|
|
|
|
XNextEvent (gdk_display, &xevent);
|
1997-11-27 04:16:39 +00:00
|
|
|
#else
|
1997-12-18 02:17:14 +00:00
|
|
|
XNextEvent (gdk_display, &xevent);
|
1997-11-27 04:16:39 +00:00
|
|
|
#endif
|
1997-12-18 02:17:14 +00:00
|
|
|
event = gdk_event_new ();
|
1997-11-24 22:37:52 +00:00
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
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);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
return NULL;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_event_put (GdkEvent *event)
|
|
|
|
{
|
|
|
|
GdkEvent *new_event;
|
|
|
|
|
|
|
|
g_return_if_fail (event != NULL);
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
new_event = gdk_event_copy (event);
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
static GdkEvent*
|
|
|
|
gdk_event_new (void)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
GdkEvent *new_event;
|
|
|
|
|
|
|
|
if (event_chunk == NULL)
|
|
|
|
event_chunk = g_mem_chunk_new ("events",
|
|
|
|
sizeof (GdkEvent),
|
|
|
|
4096,
|
|
|
|
G_ALLOC_AND_FREE);
|
|
|
|
|
|
|
|
new_event = g_chunk_new (GdkEvent, event_chunk);
|
1997-12-18 02:17:14 +00:00
|
|
|
|
|
|
|
return new_event;
|
|
|
|
}
|
|
|
|
|
|
|
|
GdkEvent*
|
|
|
|
gdk_event_copy (GdkEvent *event)
|
|
|
|
{
|
|
|
|
GdkEvent *new_event;
|
|
|
|
|
|
|
|
g_return_val_if_fail (event != NULL, NULL);
|
|
|
|
|
|
|
|
new_event = gdk_event_new ();
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
*new_event = *event;
|
|
|
|
gdk_window_ref (new_event->any.window);
|
1997-12-18 02:17:14 +00:00
|
|
|
|
1998-01-17 23:24:09 +00:00
|
|
|
switch (event->any.type)
|
|
|
|
{
|
|
|
|
case GDK_KEY_PRESS:
|
|
|
|
case GDK_KEY_RELEASE:
|
|
|
|
new_event->key.string = g_strdup (event->key.string);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDK_ENTER_NOTIFY:
|
|
|
|
case GDK_LEAVE_NOTIFY:
|
|
|
|
if (event->crossing.subwindow != NULL)
|
|
|
|
gdk_window_ref (event->crossing.subwindow);
|
|
|
|
break;
|
|
|
|
|
|
|
|
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;
|
1997-12-18 02:17:14 +00:00
|
|
|
|
1998-01-17 23:24:09 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
1997-12-18 02:17:14 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
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);
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
if (event->any.window)
|
|
|
|
gdk_window_unref (event->any.window);
|
|
|
|
|
1998-01-17 23:24:09 +00:00
|
|
|
switch (event->any.type)
|
|
|
|
{
|
|
|
|
case GDK_KEY_PRESS:
|
|
|
|
case GDK_KEY_RELEASE:
|
|
|
|
g_free (event->key.string);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDK_ENTER_NOTIFY:
|
|
|
|
case GDK_LEAVE_NOTIFY:
|
|
|
|
if (event->crossing.subwindow != NULL)
|
|
|
|
gdk_window_unref (event->crossing.subwindow);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GDK_DROP_DATA_AVAIL:
|
|
|
|
g_free (event->dropdataavailable.data_type);
|
|
|
|
g_free (event->dropdataavailable.data);
|
|
|
|
break;
|
|
|
|
|
1998-02-16 22:04:52 +00:00
|
|
|
case GDK_DRAG_REQUEST:
|
|
|
|
g_free (event->dragrequest.data_type);
|
|
|
|
break;
|
|
|
|
|
1998-01-17 23:24:09 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
1997-12-18 02:17:14 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
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)
|
|
|
|
{
|
1998-02-19 06:21:27 +00:00
|
|
|
if (show_events)
|
|
|
|
gdk_debug_flags |= GDK_DEBUG_EVENTS;
|
|
|
|
else
|
|
|
|
gdk_debug_flags &= ~GDK_DEBUG_EVENTS;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_set_use_xshm (gint use_xshm)
|
|
|
|
{
|
|
|
|
gdk_use_xshm = use_xshm;
|
|
|
|
}
|
|
|
|
|
|
|
|
gint
|
|
|
|
gdk_get_show_events ()
|
|
|
|
{
|
1998-02-19 06:21:27 +00:00
|
|
|
return gdk_debug_flags & GDK_DEBUG_EVENTS;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
gint
|
|
|
|
gdk_get_use_xshm ()
|
|
|
|
{
|
|
|
|
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
|
|
|
|
gdk_time_get ()
|
|
|
|
{
|
|
|
|
struct timeval end;
|
|
|
|
struct timeval elapsed;
|
|
|
|
guint32 milliseconds;
|
|
|
|
|
|
|
|
X_GETTIMEOFDAY (&end);
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
milliseconds = (elapsed.tv_sec * 1000) + (elapsed.tv_usec / 1000);
|
|
|
|
|
|
|
|
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
|
|
|
|
gdk_timer_get ()
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_timer_enable ()
|
|
|
|
{
|
|
|
|
timerp = &timer;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_timer_disable ()
|
|
|
|
{
|
|
|
|
timerp = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
gint
|
1998-02-13 05:19:06 +00:00
|
|
|
gdk_input_add_full (gint source,
|
|
|
|
GdkInputCondition condition,
|
|
|
|
GdkInputFunction function,
|
|
|
|
gpointer data,
|
|
|
|
GdkDestroyNotify destroy)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
static gint next_tag = 1;
|
|
|
|
GList *list;
|
|
|
|
GdkInput *input;
|
|
|
|
gint tag;
|
|
|
|
|
|
|
|
tag = 0;
|
|
|
|
list = inputs;
|
|
|
|
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
input = list->data;
|
|
|
|
list = list->next;
|
|
|
|
|
|
|
|
if ((input->source == source) && (input->condition == condition))
|
|
|
|
{
|
1997-12-18 02:17:14 +00:00
|
|
|
if (input->destroy)
|
|
|
|
(input->destroy) (input->data);
|
1997-11-24 22:37:52 +00:00
|
|
|
input->function = function;
|
|
|
|
input->data = data;
|
1997-12-18 02:17:14 +00:00
|
|
|
input->destroy = destroy;
|
1997-11-24 22:37:52 +00:00
|
|
|
tag = input->tag;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!tag)
|
|
|
|
{
|
|
|
|
input = g_new (GdkInput, 1);
|
|
|
|
input->tag = next_tag++;
|
|
|
|
input->source = source;
|
|
|
|
input->condition = condition;
|
|
|
|
input->function = function;
|
|
|
|
input->data = data;
|
1997-12-18 02:17:14 +00:00
|
|
|
input->destroy = destroy;
|
1997-11-24 22:37:52 +00:00
|
|
|
tag = input->tag;
|
|
|
|
|
|
|
|
inputs = g_list_prepend (inputs, input);
|
|
|
|
}
|
|
|
|
|
|
|
|
return tag;
|
|
|
|
}
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
gint
|
|
|
|
gdk_input_add (gint source,
|
|
|
|
GdkInputCondition condition,
|
|
|
|
GdkInputFunction function,
|
|
|
|
gpointer data)
|
|
|
|
{
|
|
|
|
return gdk_input_add_interp (source, condition, function, data, NULL);
|
|
|
|
}
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
void
|
|
|
|
gdk_input_remove (gint tag)
|
|
|
|
{
|
|
|
|
GList *list;
|
|
|
|
GList *temp_list;
|
|
|
|
GdkInput *input;
|
|
|
|
|
|
|
|
list = inputs;
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
input = list->data;
|
|
|
|
|
|
|
|
if (input->tag == tag)
|
|
|
|
{
|
1997-12-18 02:17:14 +00:00
|
|
|
if (input->destroy)
|
|
|
|
(input->destroy) (input->data);
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
temp_list = list;
|
|
|
|
|
|
|
|
if (list->next)
|
|
|
|
list->next->prev = list->prev;
|
|
|
|
if (list->prev)
|
|
|
|
list->prev->next = list->next;
|
|
|
|
if (inputs == list)
|
|
|
|
inputs = list->next;
|
|
|
|
|
|
|
|
temp_list->next = NULL;
|
|
|
|
temp_list->prev = NULL;
|
|
|
|
|
|
|
|
g_free (temp_list->data);
|
|
|
|
g_list_free (temp_list);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
gdk_pointer_grab (GdkWindow * window,
|
|
|
|
gint owner_events,
|
|
|
|
GdkEventMask event_mask,
|
|
|
|
GdkWindow * confine_to,
|
|
|
|
GdkCursor * cursor,
|
|
|
|
guint32 time)
|
|
|
|
{
|
|
|
|
/* From gdkwindow.c */
|
|
|
|
extern int nevent_masks;
|
|
|
|
extern int event_mask_table[];
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
g_return_val_if_fail (window != NULL, 0);
|
|
|
|
|
|
|
|
window_private = (GdkWindowPrivate*) window;
|
|
|
|
confine_to_private = (GdkWindowPrivate*) confine_to;
|
|
|
|
cursor_private = (GdkCursorPrivate*) cursor;
|
|
|
|
|
|
|
|
xwindow = window_private->xwindow;
|
|
|
|
|
1998-01-26 01:20:14 +00:00
|
|
|
if (!confine_to || confine_to_private->destroyed)
|
1997-11-24 22:37:52 +00:00
|
|
|
xconfine_to = None;
|
|
|
|
else
|
|
|
|
xconfine_to = confine_to_private->xwindow;
|
|
|
|
|
|
|
|
if (!cursor)
|
|
|
|
xcursor = None;
|
|
|
|
else
|
|
|
|
xcursor = cursor_private->xcursor;
|
|
|
|
|
|
|
|
|
|
|
|
xevent_mask = 0;
|
|
|
|
for (i = 0; i < nevent_masks; i++)
|
|
|
|
{
|
|
|
|
if (event_mask & (1 << (i + 1)))
|
|
|
|
xevent_mask |= event_mask_table[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (((GdkWindowPrivate *)window)->extension_events &&
|
|
|
|
gdk_input_vtable.grab_pointer)
|
|
|
|
return_val = gdk_input_vtable.grab_pointer (window,
|
|
|
|
owner_events,
|
|
|
|
event_mask,
|
|
|
|
confine_to,
|
|
|
|
time);
|
|
|
|
else
|
1998-02-18 10:03:54 +00:00
|
|
|
return_val = Success;
|
1998-01-21 08:35:37 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (return_val == Success)
|
1998-02-18 10:03:54 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
1998-01-21 08:35:37 +00:00
|
|
|
if (return_val == GrabSuccess)
|
1998-01-21 09:16:33 +00:00
|
|
|
xgrab_window = window_private;
|
1998-01-21 08:35:37 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return return_val;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* gdk_pointer_ungrab
|
|
|
|
*
|
|
|
|
* Releases any pointer grab
|
|
|
|
*
|
|
|
|
* Arguments:
|
|
|
|
*
|
|
|
|
* Results:
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_pointer_ungrab (guint32 time)
|
|
|
|
{
|
|
|
|
if (gdk_input_vtable.ungrab_pointer)
|
|
|
|
gdk_input_vtable.ungrab_pointer (time);
|
|
|
|
|
|
|
|
XUngrabPointer (gdk_display, time);
|
1998-01-21 09:16:33 +00:00
|
|
|
xgrab_window = NULL;
|
1998-01-21 08:35:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* gdk_pointer_is_grabbed
|
|
|
|
*
|
|
|
|
* Tell wether there is an active x pointer grab in effect
|
|
|
|
*
|
|
|
|
* Arguments:
|
|
|
|
*
|
|
|
|
* Results:
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
gint
|
|
|
|
gdk_pointer_is_grabbed (void)
|
|
|
|
{
|
1998-01-21 09:16:33 +00:00
|
|
|
return xgrab_window != NULL;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* gdk_keyboard_grab
|
|
|
|
*
|
|
|
|
* Grabs the keyboard 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"
|
|
|
|
* "time" specifies the time
|
|
|
|
*
|
|
|
|
* Results:
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
* requires a corresponding call to gdk_keyboard_ungrab
|
|
|
|
*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
gint
|
|
|
|
gdk_keyboard_grab (GdkWindow * window,
|
|
|
|
gint owner_events,
|
|
|
|
guint32 time)
|
|
|
|
{
|
|
|
|
GdkWindowPrivate *window_private;
|
|
|
|
Window xwindow;
|
|
|
|
|
|
|
|
g_return_val_if_fail (window != NULL, 0);
|
|
|
|
|
|
|
|
window_private = (GdkWindowPrivate*) window;
|
|
|
|
xwindow = window_private->xwindow;
|
|
|
|
|
1998-01-26 01:20:14 +00:00
|
|
|
if (!window_private->destroyed)
|
|
|
|
return XGrabKeyboard (window_private->xdisplay,
|
|
|
|
xwindow,
|
|
|
|
owner_events,
|
|
|
|
GrabModeAsync, GrabModeAsync,
|
|
|
|
time);
|
|
|
|
else
|
|
|
|
return AlreadyGrabbed;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* gdk_keyboard_ungrab
|
|
|
|
*
|
|
|
|
* Releases any keyboard grab
|
|
|
|
*
|
|
|
|
* Arguments:
|
|
|
|
*
|
|
|
|
* Results:
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_keyboard_ungrab (guint32 time)
|
|
|
|
{
|
|
|
|
XUngrabKeyboard (gdk_display, time);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* gdk_screen_width
|
|
|
|
*
|
|
|
|
* Return the width of the screen.
|
|
|
|
*
|
|
|
|
* Arguments:
|
|
|
|
*
|
|
|
|
* Results:
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
gint
|
|
|
|
gdk_screen_width ()
|
|
|
|
{
|
|
|
|
gint return_val;
|
|
|
|
|
|
|
|
return_val = DisplayWidth (gdk_display, gdk_screen);
|
|
|
|
|
|
|
|
return return_val;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* gdk_screen_height
|
|
|
|
*
|
|
|
|
* Return the height of the screen.
|
|
|
|
*
|
|
|
|
* Arguments:
|
|
|
|
*
|
|
|
|
* Results:
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
gint
|
|
|
|
gdk_screen_height ()
|
|
|
|
{
|
|
|
|
gint return_val;
|
|
|
|
|
|
|
|
return_val = DisplayHeight (gdk_display, gdk_screen);
|
|
|
|
|
|
|
|
return return_val;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_key_repeat_disable ()
|
|
|
|
{
|
|
|
|
XAutoRepeatOff (gdk_display);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_key_repeat_restore ()
|
|
|
|
{
|
|
|
|
if (autorepeat)
|
|
|
|
XAutoRepeatOn (gdk_display);
|
|
|
|
else
|
|
|
|
XAutoRepeatOff (gdk_display);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* gdk_flush
|
|
|
|
*
|
|
|
|
* Flushes the Xlib output buffer and then waits
|
|
|
|
* until all requests have been received and processed
|
|
|
|
* by the X server. The only real use for this function
|
|
|
|
* is in dealing with XShm.
|
|
|
|
*
|
|
|
|
* Arguments:
|
|
|
|
*
|
|
|
|
* Results:
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
void gdk_flush ()
|
|
|
|
{
|
|
|
|
XSync (gdk_display, False);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_beep ()
|
|
|
|
{
|
|
|
|
XBell(gdk_display, 100);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* gdk_event_wait
|
|
|
|
*
|
|
|
|
* Waits until an event occurs or the timer runs out.
|
|
|
|
*
|
|
|
|
* Arguments:
|
|
|
|
*
|
|
|
|
* Results:
|
|
|
|
* Returns TRUE if an event is ready to be read and FALSE
|
|
|
|
* if the timer ran out.
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
static gint
|
|
|
|
gdk_event_wait ()
|
|
|
|
{
|
|
|
|
GList *list;
|
|
|
|
GdkInput *input;
|
|
|
|
GdkInputCondition condition;
|
|
|
|
SELECT_MASK readfds;
|
|
|
|
SELECT_MASK writefds;
|
|
|
|
SELECT_MASK exceptfds;
|
|
|
|
int max_input;
|
|
|
|
int nfd;
|
|
|
|
|
|
|
|
/* If there are no events pending we will wait for an event.
|
|
|
|
* The time we wait is dependant on the "timer". If no timer
|
|
|
|
* has been specified then we'll block until an event arrives.
|
|
|
|
* If a timer has been specified we'll block until an event
|
|
|
|
* arrives or the timer expires. (This is all done using the
|
|
|
|
* "select" system call).
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (XPending (gdk_display) == 0)
|
|
|
|
{
|
|
|
|
FD_ZERO (&readfds);
|
|
|
|
FD_ZERO (&writefds);
|
|
|
|
FD_ZERO (&exceptfds);
|
|
|
|
|
|
|
|
FD_SET (connection_number, &readfds);
|
|
|
|
max_input = connection_number;
|
|
|
|
|
|
|
|
list = inputs;
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
input = list->data;
|
|
|
|
list = list->next;
|
|
|
|
|
|
|
|
if (input->condition & GDK_INPUT_READ)
|
|
|
|
FD_SET (input->source, &readfds);
|
|
|
|
if (input->condition & GDK_INPUT_WRITE)
|
|
|
|
FD_SET (input->source, &writefds);
|
|
|
|
if (input->condition & GDK_INPUT_EXCEPTION)
|
|
|
|
FD_SET (input->source, &exceptfds);
|
|
|
|
|
|
|
|
max_input = MAX (max_input, input->source);
|
|
|
|
}
|
|
|
|
|
|
|
|
nfd = select (max_input+1, &readfds, &writefds, &exceptfds, timerp);
|
|
|
|
|
|
|
|
timerp = NULL;
|
|
|
|
timer_val = 0;
|
|
|
|
|
|
|
|
if (nfd > 0)
|
|
|
|
{
|
|
|
|
if (FD_ISSET (connection_number, &readfds))
|
|
|
|
{
|
|
|
|
if (XPending (gdk_display) == 0)
|
|
|
|
{
|
|
|
|
if (nfd == 1)
|
|
|
|
{
|
|
|
|
XNoOp (gdk_display);
|
|
|
|
XFlush (gdk_display);
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
list = inputs;
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
input = list->data;
|
|
|
|
list = list->next;
|
|
|
|
|
|
|
|
condition = 0;
|
|
|
|
if (FD_ISSET (input->source, &readfds))
|
|
|
|
condition |= GDK_INPUT_READ;
|
|
|
|
if (FD_ISSET (input->source, &writefds))
|
|
|
|
condition |= GDK_INPUT_WRITE;
|
|
|
|
if (FD_ISSET (input->source, &exceptfds))
|
|
|
|
condition |= GDK_INPUT_EXCEPTION;
|
|
|
|
|
|
|
|
if (condition && input->function)
|
|
|
|
(* input->function) (input->data, input->source, condition);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
static gint
|
|
|
|
gdk_event_apply_filters (XEvent *xevent,
|
|
|
|
GdkEvent *event,
|
|
|
|
GList *filters)
|
|
|
|
{
|
|
|
|
GdkEventFilter *filter;
|
|
|
|
GList *tmp_list;
|
|
|
|
GdkFilterReturn result;
|
|
|
|
|
|
|
|
tmp_list = filters;
|
|
|
|
|
|
|
|
while (tmp_list)
|
|
|
|
{
|
|
|
|
filter = (GdkEventFilter *)tmp_list->data;
|
|
|
|
|
|
|
|
result = (*filter->function)(xevent, event, filter->data);
|
|
|
|
if (result != GDK_FILTER_CONTINUE)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
tmp_list = tmp_list->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return GDK_FILTER_CONTINUE;
|
|
|
|
}
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
static gint
|
|
|
|
gdk_event_translate (GdkEvent *event,
|
|
|
|
XEvent *xevent)
|
|
|
|
{
|
|
|
|
|
|
|
|
GdkWindow *window;
|
|
|
|
GdkWindowPrivate *window_private;
|
|
|
|
XComposeStatus compose;
|
|
|
|
int charcount;
|
1997-11-27 04:16:39 +00:00
|
|
|
#ifdef USE_XIM
|
|
|
|
static gchar* buf = NULL;
|
|
|
|
static gint buf_len= 0;
|
|
|
|
#else
|
1997-11-24 22:37:52 +00:00
|
|
|
char buf[16];
|
1997-11-27 04:16:39 +00:00
|
|
|
#endif
|
1997-11-24 22:37:52 +00:00
|
|
|
gint return_val;
|
|
|
|
|
|
|
|
/* Are static variables used for this purpose thread-safe? */
|
|
|
|
|
|
|
|
return_val = FALSE;
|
|
|
|
|
|
|
|
/* Find the GdkWindow that this event occurred in.
|
|
|
|
* All events occur in some GdkWindow (otherwise, why
|
|
|
|
* would we be receiving them). It really is an error
|
|
|
|
* to receive an event for which we cannot find the
|
|
|
|
* corresponding GdkWindow. We handle events with window=None
|
|
|
|
* specially - they are generated by XFree86's XInput under
|
|
|
|
* some circumstances.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if ((xevent->xany.window == None) &&
|
|
|
|
gdk_input_vtable.window_none_event)
|
|
|
|
{
|
|
|
|
return_val = gdk_input_vtable.window_none_event (event,xevent);
|
|
|
|
|
|
|
|
if (return_val >= 0) /* was handled */
|
|
|
|
return return_val;
|
|
|
|
else
|
|
|
|
return_val = FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
window = gdk_window_lookup (xevent->xany.window);
|
|
|
|
window_private = (GdkWindowPrivate *) window;
|
|
|
|
|
1998-03-01 22:37:30 +00:00
|
|
|
if (window != NULL)
|
1997-12-18 02:17:14 +00:00
|
|
|
gdk_window_ref (window);
|
1998-03-01 22:37:30 +00:00
|
|
|
else if(gdk_null_window_warnings) /* Special purpose programs that
|
|
|
|
get events for other windows may
|
|
|
|
want to disable this */
|
|
|
|
g_warning ("%#lx -> NULL\n", xevent->xany.window);
|
1997-12-18 02:17:14 +00:00
|
|
|
|
|
|
|
/* Check for filters for this window */
|
|
|
|
|
1998-03-01 22:37:30 +00:00
|
|
|
{
|
|
|
|
GdkFilterReturn result;
|
|
|
|
result = gdk_event_apply_filters (xevent, event,
|
|
|
|
window_private
|
|
|
|
?window_private->filters
|
1998-03-06 00:39:11 +00:00
|
|
|
:gdk_default_filters);
|
1998-03-01 22:37:30 +00:00
|
|
|
|
|
|
|
if (result != GDK_FILTER_CONTINUE)
|
|
|
|
{
|
|
|
|
return (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
|
|
|
|
}
|
|
|
|
}
|
1997-12-18 02:17:14 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
/* We do a "manual" conversion of the XEvent to a
|
|
|
|
* GdkEvent. The structures are mostly the same so
|
|
|
|
* the conversion is fairly straightforward. We also
|
|
|
|
* optionally print debugging info regarding events
|
|
|
|
* received.
|
|
|
|
*/
|
|
|
|
/* Addendum:
|
|
|
|
* During drag & drop you get events where the pointer is
|
|
|
|
* in other windows. Need to just do finer-grained checking
|
|
|
|
*/
|
|
|
|
switch (xevent->type)
|
|
|
|
{
|
|
|
|
case KeyPress:
|
|
|
|
/* Lookup the string corresponding to the given keysym.
|
|
|
|
*/
|
1997-11-27 04:16:39 +00:00
|
|
|
#ifdef USE_XIM
|
|
|
|
if (buf_len == 0)
|
|
|
|
{
|
|
|
|
buf_len = 128;
|
|
|
|
buf = g_new (gchar, buf_len);
|
|
|
|
}
|
|
|
|
if (xim_using == TRUE && xim_ic)
|
|
|
|
{
|
|
|
|
Status status;
|
|
|
|
|
|
|
|
/* Clear keyval. Depending on status, may not be set */
|
|
|
|
event->key.keyval = GDK_VoidSymbol;
|
|
|
|
charcount = XmbLookupString(xim_ic->xic,
|
|
|
|
&xevent->xkey, buf, buf_len-1,
|
|
|
|
(KeySym*) &event->key.keyval,
|
|
|
|
&status);
|
|
|
|
if (status == XBufferOverflow)
|
|
|
|
{ /* retry */
|
|
|
|
/* alloc adequate size of buffer */
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (XIM,
|
|
|
|
g_print("XIM: overflow (required %i)\n", charcount));
|
1997-11-27 04:16:39 +00:00
|
|
|
|
|
|
|
while (buf_len <= charcount)
|
|
|
|
buf_len *= 2;
|
|
|
|
buf = (gchar *) g_realloc (buf, buf_len);
|
|
|
|
|
|
|
|
charcount = XmbLookupString (xim_ic->xic,
|
|
|
|
&xevent->xkey, buf, buf_len-1,
|
|
|
|
(KeySym*) &event->key.keyval,
|
|
|
|
&status);
|
|
|
|
}
|
|
|
|
if (status == XLookupNone)
|
|
|
|
{
|
|
|
|
return_val = FALSE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
charcount = XLookupString (&xevent->xkey, buf, buf_len,
|
|
|
|
(KeySym*) &event->key.keyval,
|
|
|
|
&compose);
|
|
|
|
#else
|
1997-11-24 22:37:52 +00:00
|
|
|
charcount = XLookupString (&xevent->xkey, buf, 16,
|
|
|
|
(KeySym*) &event->key.keyval,
|
|
|
|
&compose);
|
1997-11-27 04:16:39 +00:00
|
|
|
#endif
|
|
|
|
if (charcount > 0 && buf[charcount-1] == '\0')
|
|
|
|
charcount --;
|
|
|
|
else
|
|
|
|
buf[charcount] = '\0';
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
#ifdef G_ENABLE_DEBUG
|
|
|
|
if (gdk_debug_flags & GDK_DEBUG_EVENTS)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
g_print ("key press:\twindow: %ld key: %12s %d\n",
|
|
|
|
xevent->xkey.window - base_id,
|
|
|
|
event->key.keyval ? XKeysymToString (event->key.keyval) : "(none)",
|
|
|
|
event->key.keyval);
|
|
|
|
if (charcount > 0)
|
|
|
|
g_print ("\t\tlength: %4d string: \"%s\"\n",
|
|
|
|
charcount, buf);
|
|
|
|
}
|
1998-02-19 06:21:27 +00:00
|
|
|
#endif /* G_ENABLE_DEBUG */
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
event->key.type = GDK_KEY_PRESS;
|
|
|
|
event->key.window = window;
|
|
|
|
event->key.time = xevent->xkey.time;
|
|
|
|
event->key.state = (GdkModifierType) xevent->xkey.state;
|
1997-12-18 02:17:14 +00:00
|
|
|
event->key.string = g_strdup (buf);
|
1997-11-27 04:16:39 +00:00
|
|
|
event->key.length = charcount;
|
1997-11-24 22:37:52 +00:00
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-12-18 02:17:14 +00:00
|
|
|
|
|
|
|
if (!return_val)
|
|
|
|
g_free (event->key.string);
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case KeyRelease:
|
|
|
|
/* Lookup the string corresponding to the given keysym.
|
|
|
|
*/
|
|
|
|
charcount = XLookupString (&xevent->xkey, buf, 16,
|
|
|
|
(KeySym*) &event->key.keyval,
|
|
|
|
&compose);
|
|
|
|
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("key release:\t\twindow: %ld key: %12s %d\n",
|
|
|
|
xevent->xkey.window - base_id,
|
|
|
|
XKeysymToString (event->key.keyval),
|
1998-02-19 06:21:27 +00:00
|
|
|
event->key.keyval));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
event->key.type = GDK_KEY_RELEASE;
|
|
|
|
event->key.window = window;
|
|
|
|
event->key.time = xevent->xkey.time;
|
|
|
|
event->key.state = (GdkModifierType) xevent->xkey.state;
|
1997-11-27 04:16:39 +00:00
|
|
|
event->key.length = 0;
|
|
|
|
event->key.string = NULL;
|
1997-11-24 22:37:52 +00:00
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ButtonPress:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("button press[%d]:\t\twindow: %ld x,y: %d %d button: %d\n",
|
|
|
|
window_private?window_private->dnd_drag_enabled:0,
|
|
|
|
xevent->xbutton.window - base_id,
|
|
|
|
xevent->xbutton.x, xevent->xbutton.y,
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xbutton.button));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
if (window_private &&
|
|
|
|
(window_private->extension_events != 0) &&
|
|
|
|
gdk_input_ignore_core)
|
|
|
|
break;
|
|
|
|
|
|
|
|
event->button.type = GDK_BUTTON_PRESS;
|
|
|
|
event->button.window = window;
|
|
|
|
event->button.time = xevent->xbutton.time;
|
|
|
|
event->button.x = xevent->xbutton.x;
|
|
|
|
event->button.y = xevent->xbutton.y;
|
1997-12-19 21:06:39 +00:00
|
|
|
event->button.x_root = (gfloat)xevent->xbutton.x_root;
|
|
|
|
event->button.y_root = (gfloat)xevent->xbutton.y_root;
|
1997-11-24 22:37:52 +00:00
|
|
|
event->button.pressure = 0.5;
|
|
|
|
event->button.xtilt = 0;
|
|
|
|
event->button.ytilt = 0;
|
|
|
|
event->button.state = (GdkModifierType) xevent->xbutton.state;
|
|
|
|
event->button.button = xevent->xbutton.button;
|
|
|
|
event->button.source = GDK_SOURCE_MOUSE;
|
|
|
|
event->button.deviceid = GDK_CORE_POINTER;
|
|
|
|
|
|
|
|
if ((event->button.time < (button_click_time[1] + TRIPLE_CLICK_TIME)) &&
|
|
|
|
(event->button.window == button_window[1]) &&
|
|
|
|
(event->button.button == button_number[1]))
|
|
|
|
{
|
|
|
|
gdk_synthesize_click (event, 3);
|
|
|
|
|
|
|
|
button_click_time[1] = 0;
|
|
|
|
button_click_time[0] = 0;
|
|
|
|
button_window[1] = NULL;
|
|
|
|
button_window[0] = 0;
|
|
|
|
button_number[1] = -1;
|
|
|
|
button_number[0] = -1;
|
|
|
|
}
|
|
|
|
else if ((event->button.time < (button_click_time[0] + DOUBLE_CLICK_TIME)) &&
|
|
|
|
(event->button.window == button_window[0]) &&
|
|
|
|
(event->button.button == button_number[0]))
|
|
|
|
{
|
|
|
|
gdk_synthesize_click (event, 2);
|
|
|
|
|
|
|
|
button_click_time[1] = button_click_time[0];
|
|
|
|
button_click_time[0] = event->button.time;
|
|
|
|
button_window[1] = button_window[0];
|
|
|
|
button_window[0] = event->button.window;
|
|
|
|
button_number[1] = button_number[0];
|
|
|
|
button_number[0] = event->button.button;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
button_click_time[1] = 0;
|
|
|
|
button_click_time[0] = event->button.time;
|
|
|
|
button_window[1] = NULL;
|
|
|
|
button_window[0] = event->button.window;
|
|
|
|
button_number[1] = -1;
|
|
|
|
button_number[0] = event->button.button;
|
|
|
|
}
|
|
|
|
if(window_private
|
|
|
|
&& window_private->dnd_drag_enabled
|
1998-02-26 21:28:00 +00:00
|
|
|
&& !gdk_dnd.drag_perhaps
|
1998-03-05 02:01:47 +00:00
|
|
|
&& event->button.button == 1
|
1997-11-24 22:37:52 +00:00
|
|
|
&& !gdk_dnd.drag_really)
|
|
|
|
{
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd.drag_perhaps = 1;
|
1998-03-06 05:14:09 +00:00
|
|
|
gdk_dnd.dnd_drag_start.x = xevent->xbutton.x_root;
|
|
|
|
gdk_dnd.dnd_drag_start.y = xevent->xbutton.y_root;
|
|
|
|
gdk_dnd.real_sw = window_private;
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
if(gdk_dnd.drag_startwindows)
|
|
|
|
{
|
|
|
|
g_free(gdk_dnd.drag_startwindows);
|
|
|
|
gdk_dnd.drag_startwindows = NULL;
|
|
|
|
}
|
|
|
|
gdk_dnd.drag_numwindows = gdk_dnd.drag_really = 0;
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd.dnd_grabbed = FALSE;
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
{
|
|
|
|
/* Set motion mask for first DnD'd window, since it
|
|
|
|
will be the one that is actually dragged */
|
|
|
|
XWindowAttributes dnd_winattr;
|
|
|
|
XSetWindowAttributes dnd_setwinattr;
|
|
|
|
|
|
|
|
/* We need to get motion events while the button is down, so
|
|
|
|
we can know whether to really start dragging or not... */
|
|
|
|
XGetWindowAttributes(gdk_display, (Window)window_private->xwindow,
|
|
|
|
&dnd_winattr);
|
|
|
|
|
|
|
|
window_private->dnd_drag_savedeventmask = dnd_winattr.your_event_mask;
|
|
|
|
dnd_setwinattr.event_mask =
|
1998-03-06 05:14:09 +00:00
|
|
|
window_private->dnd_drag_eventmask = ButtonMotionMask |
|
|
|
|
EnterWindowMask | LeaveWindowMask;
|
1997-11-24 22:37:52 +00:00
|
|
|
XChangeWindowAttributes(gdk_display, window_private->xwindow,
|
|
|
|
CWEventMask, &dnd_setwinattr);
|
|
|
|
}
|
|
|
|
}
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ButtonRelease:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("button release[%d]:\twindow: %ld x,y: %d %d button: %d\n",
|
|
|
|
window_private?window_private->dnd_drag_enabled:0,
|
|
|
|
xevent->xbutton.window - base_id,
|
|
|
|
xevent->xbutton.x, xevent->xbutton.y,
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xbutton.button));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
if (window_private &&
|
|
|
|
(window_private->extension_events != 0) &&
|
|
|
|
gdk_input_ignore_core)
|
|
|
|
break;
|
|
|
|
|
|
|
|
event->button.type = GDK_BUTTON_RELEASE;
|
|
|
|
event->button.window = window;
|
|
|
|
event->button.time = xevent->xbutton.time;
|
|
|
|
event->button.x = xevent->xbutton.x;
|
|
|
|
event->button.y = xevent->xbutton.y;
|
1997-12-19 21:06:39 +00:00
|
|
|
event->button.x_root = (gfloat)xevent->xbutton.x_root;
|
|
|
|
event->button.y_root = (gfloat)xevent->xbutton.y_root;
|
1997-11-24 22:37:52 +00:00
|
|
|
event->button.pressure = 0.5;
|
|
|
|
event->button.xtilt = 0;
|
|
|
|
event->button.ytilt = 0;
|
|
|
|
event->button.state = (GdkModifierType) xevent->xbutton.state;
|
|
|
|
event->button.button = xevent->xbutton.button;
|
|
|
|
event->button.source = GDK_SOURCE_MOUSE;
|
|
|
|
event->button.deviceid = GDK_CORE_POINTER;
|
|
|
|
|
1998-03-10 02:48:02 +00:00
|
|
|
gdk_dnd.last_drop_time = xevent->xbutton.time;
|
1998-02-26 21:28:00 +00:00
|
|
|
if(gdk_dnd.drag_perhaps)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1997-12-18 23:38:39 +00:00
|
|
|
{
|
|
|
|
XSetWindowAttributes attrs;
|
|
|
|
/* Reset event mask to pre-drag value, assuming event_mask
|
|
|
|
doesn't change during drag */
|
1998-03-06 05:14:09 +00:00
|
|
|
attrs.event_mask = gdk_dnd.real_sw->dnd_drag_savedeventmask;
|
|
|
|
XChangeWindowAttributes(gdk_display, gdk_dnd.real_sw->xwindow,
|
1997-12-18 23:38:39 +00:00
|
|
|
CWEventMask, &attrs);
|
|
|
|
}
|
1998-01-17 23:24:09 +00:00
|
|
|
|
1998-02-26 21:28:00 +00:00
|
|
|
if (gdk_dnd.dnd_grabbed)
|
1998-01-17 23:24:09 +00:00
|
|
|
{
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd_display_drag_cursor(-2,
|
|
|
|
-2,
|
|
|
|
FALSE, TRUE);
|
1998-01-17 23:24:09 +00:00
|
|
|
XUngrabPointer(gdk_display, CurrentTime);
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd.dnd_grabbed = FALSE;
|
1998-01-17 23:24:09 +00:00
|
|
|
}
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if(gdk_dnd.drag_really)
|
|
|
|
{
|
1997-12-03 21:43:44 +00:00
|
|
|
GdkPoint foo;
|
|
|
|
foo.x = xevent->xbutton.x_root;
|
|
|
|
foo.y = xevent->xbutton.y_root;
|
|
|
|
|
1998-02-26 21:28:00 +00:00
|
|
|
if(gdk_dnd.dnd_drag_target != None)
|
|
|
|
gdk_dnd_drag_end(gdk_dnd.dnd_drag_target, foo);
|
1997-11-24 22:37:52 +00:00
|
|
|
gdk_dnd.drag_really = 0;
|
|
|
|
|
|
|
|
gdk_dnd.drag_numwindows = 0;
|
|
|
|
if(gdk_dnd.drag_startwindows)
|
|
|
|
{
|
|
|
|
g_free(gdk_dnd.drag_startwindows);
|
|
|
|
gdk_dnd.drag_startwindows = NULL;
|
|
|
|
}
|
|
|
|
|
1998-03-06 05:14:09 +00:00
|
|
|
gdk_dnd.real_sw = NULL;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd.drag_perhaps = 0;
|
1998-03-06 05:14:09 +00:00
|
|
|
gdk_dnd.dnd_drag_start.x = gdk_dnd.dnd_drag_start.y = 0;
|
|
|
|
gdk_dnd.dnd_drag_dropzone.x = gdk_dnd.dnd_drag_dropzone.y = 0;
|
|
|
|
gdk_dnd.dnd_drag_dropzone.width = gdk_dnd.dnd_drag_dropzone.height = 0;
|
|
|
|
gdk_dnd.dnd_drag_curwin = None;
|
1997-12-18 23:38:39 +00:00
|
|
|
return_val = window_private?TRUE:FALSE;
|
|
|
|
} else
|
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MotionNotify:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("motion notify:\t\twindow: %ld x,y: %d %d hint: %s d:%d r%d\n",
|
|
|
|
xevent->xmotion.window - base_id,
|
|
|
|
xevent->xmotion.x, xevent->xmotion.y,
|
|
|
|
(xevent->xmotion.is_hint) ? "true" : "false",
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd.drag_perhaps, gdk_dnd.drag_really));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
if (window_private &&
|
|
|
|
(window_private->extension_events != 0) &&
|
|
|
|
gdk_input_ignore_core)
|
|
|
|
break;
|
|
|
|
|
|
|
|
event->motion.type = GDK_MOTION_NOTIFY;
|
|
|
|
event->motion.window = window;
|
|
|
|
event->motion.time = xevent->xmotion.time;
|
|
|
|
event->motion.x = xevent->xmotion.x;
|
|
|
|
event->motion.y = xevent->xmotion.y;
|
1997-12-19 21:06:39 +00:00
|
|
|
event->motion.x_root = (gfloat)xevent->xmotion.x_root;
|
|
|
|
event->motion.y_root = (gfloat)xevent->xmotion.y_root;
|
1997-11-24 22:37:52 +00:00
|
|
|
event->motion.pressure = 0.5;
|
|
|
|
event->motion.xtilt = 0;
|
|
|
|
event->motion.ytilt = 0;
|
|
|
|
event->motion.state = (GdkModifierType) xevent->xmotion.state;
|
|
|
|
event->motion.is_hint = xevent->xmotion.is_hint;
|
|
|
|
event->motion.source = GDK_SOURCE_MOUSE;
|
|
|
|
event->motion.deviceid = GDK_CORE_POINTER;
|
|
|
|
|
1998-03-06 05:14:09 +00:00
|
|
|
#define IS_IN_ZONE(cx, cy) (cx >= gdk_dnd.dnd_drag_dropzone.x \
|
|
|
|
&& cy >= gdk_dnd.dnd_drag_dropzone.y \
|
|
|
|
&& cx < (gdk_dnd.dnd_drag_dropzone.x + gdk_dnd.dnd_drag_dropzone.width) \
|
|
|
|
&& cy < (gdk_dnd.dnd_drag_dropzone.y + gdk_dnd.dnd_drag_dropzone.height))
|
1997-11-24 22:37:52 +00:00
|
|
|
|
1998-03-06 05:14:09 +00:00
|
|
|
if(gdk_dnd.drag_perhaps && gdk_dnd.drag_really
|
|
|
|
/* && event->motion.is_hint */ /* HINTME */)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
/* First, we have to find what window the motion was in... */
|
|
|
|
/* XXX there has to be a better way to do this, perhaps with
|
|
|
|
XTranslateCoordinates or XQueryTree - I don't know how,
|
|
|
|
and this sort of works */
|
1998-03-10 21:57:05 +00:00
|
|
|
static Window lastwin = None, curwin = None;
|
|
|
|
#if 0
|
|
|
|
Window twin;
|
|
|
|
#endif
|
1997-12-06 22:12:10 +00:00
|
|
|
Window childwin = gdk_root_window;
|
1997-12-18 23:03:26 +00:00
|
|
|
int x, y, ox, oy;
|
1998-02-26 21:28:00 +00:00
|
|
|
|
|
|
|
/* Interlude - display cursor for the drag ASAP */
|
|
|
|
gdk_dnd_display_drag_cursor(xevent->xmotion.x_root,
|
|
|
|
xevent->xmotion.y_root,
|
|
|
|
gdk_dnd.dnd_drag_target?TRUE:FALSE,
|
|
|
|
FALSE);
|
|
|
|
|
1997-12-06 22:12:10 +00:00
|
|
|
lastwin = curwin;
|
1997-12-18 23:03:26 +00:00
|
|
|
curwin = gdk_root_window;
|
|
|
|
ox = x = xevent->xmotion.x_root;
|
|
|
|
oy = y = xevent->xmotion.y_root;
|
1998-03-10 21:57:05 +00:00
|
|
|
#if 1
|
|
|
|
curwin = gdk_window_xid_at_coords(xevent->xmotion.x_root,
|
|
|
|
xevent->xmotion.y_root,
|
|
|
|
gdk_dnd.c->xids);
|
|
|
|
XTranslateCoordinates(gdk_display, gdk_root_window, curwin,
|
|
|
|
x, y, &x, &y, &childwin);
|
|
|
|
#else
|
1997-11-24 22:37:52 +00:00
|
|
|
while(childwin != None)
|
|
|
|
{
|
1998-01-17 23:24:09 +00:00
|
|
|
ox = x; oy = y;
|
|
|
|
curwin = childwin;
|
|
|
|
XTranslateCoordinates(gdk_display, curwin, curwin,
|
|
|
|
x, y, &x, &y, &childwin);
|
|
|
|
if(childwin != None)
|
|
|
|
{
|
|
|
|
XTranslateCoordinates(gdk_display, curwin, childwin,
|
|
|
|
x, y, &x, &y, &twin);
|
1997-12-18 23:03:26 +00:00
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1998-03-10 21:57:05 +00:00
|
|
|
#endif
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (DND,
|
|
|
|
g_print("Drag is now in window %#lx, lastwin was %#lx, ddc = %#lx\n",
|
1998-03-06 05:14:09 +00:00
|
|
|
curwin, lastwin, gdk_dnd.dnd_drag_curwin));
|
|
|
|
if(curwin != gdk_dnd.dnd_drag_curwin && curwin != lastwin)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
/* We have left one window and entered another
|
|
|
|
(do leave & enter bits) */
|
1998-03-06 05:14:09 +00:00
|
|
|
if(gdk_dnd.dnd_drag_curwin != None)
|
|
|
|
gdk_dnd_drag_leave(gdk_dnd.dnd_drag_curwin);
|
|
|
|
gdk_dnd.dnd_drag_curwin = curwin;
|
|
|
|
gdk_dnd_drag_enter(gdk_dnd.dnd_drag_curwin);
|
|
|
|
gdk_dnd.dnd_drag_dropzone.x = gdk_dnd.dnd_drag_dropzone.y = 0;
|
|
|
|
gdk_dnd.dnd_drag_dropzone.width = gdk_dnd.dnd_drag_dropzone.height = 0;
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd.dnd_drag_target = None;
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (DND,
|
|
|
|
g_print("curwin = %#lx, lastwin = %#lx, dnd_drag_curwin = %#lx\n",
|
1998-03-06 05:14:09 +00:00
|
|
|
curwin, lastwin, gdk_dnd.dnd_drag_curwin));
|
1998-02-19 06:21:27 +00:00
|
|
|
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd_display_drag_cursor(xevent->xmotion.x_root,
|
|
|
|
xevent->xmotion.y_root,
|
|
|
|
FALSE, TRUE);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1998-03-06 05:14:09 +00:00
|
|
|
else if(gdk_dnd.dnd_drag_dropzone.width > 0
|
|
|
|
&& gdk_dnd.dnd_drag_dropzone.height > 0
|
|
|
|
&& curwin == gdk_dnd.dnd_drag_curwin)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
|
|
|
/* Handle all that dropzone stuff - thanks John ;-) */
|
1998-02-26 21:28:00 +00:00
|
|
|
if (gdk_dnd.dnd_drag_target != None)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-01-17 23:24:09 +00:00
|
|
|
gboolean in_zone = IS_IN_ZONE(xevent->xmotion.x_root,
|
|
|
|
xevent->xmotion.y_root);
|
1998-03-06 05:14:09 +00:00
|
|
|
gboolean old_in_zone = IS_IN_ZONE(gdk_dnd.dnd_drag_oldpos.x,
|
|
|
|
gdk_dnd.dnd_drag_oldpos.y);
|
1998-01-17 23:24:09 +00:00
|
|
|
|
|
|
|
if (!in_zone && old_in_zone)
|
|
|
|
{
|
|
|
|
/* We were in the drop zone and moved out */
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd.dnd_drag_target = None;
|
1998-01-17 23:24:09 +00:00
|
|
|
gdk_dnd_drag_leave(curwin);
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd_display_drag_cursor(xevent->xmotion.x_root,
|
|
|
|
xevent->xmotion.y_root,
|
|
|
|
FALSE, TRUE);
|
1998-01-17 23:24:09 +00:00
|
|
|
}
|
|
|
|
else if (!in_zone && !old_in_zone)
|
|
|
|
{
|
|
|
|
/* We were outside drop zone but in the window
|
|
|
|
- have to send enter events */
|
|
|
|
gdk_dnd_drag_enter(curwin);
|
1998-03-06 05:14:09 +00:00
|
|
|
gdk_dnd.dnd_drag_curwin = curwin;
|
|
|
|
gdk_dnd.dnd_drag_dropzone.x = gdk_dnd.dnd_drag_dropzone.y = 0;
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd.dnd_drag_target = None;
|
1998-01-17 23:24:09 +00:00
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1998-02-16 22:04:52 +00:00
|
|
|
} /* else
|
|
|
|
dnd_drag_curwin = None; */
|
1997-11-24 22:37:52 +00:00
|
|
|
return_val = FALSE;
|
|
|
|
}
|
|
|
|
else
|
1997-12-06 22:12:10 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case EnterNotify:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("enter notify:\t\twindow: %ld detail: %d subwin: %ld\n",
|
|
|
|
xevent->xcrossing.window - base_id,
|
|
|
|
xevent->xcrossing.detail,
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xcrossing.subwindow - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
/* Tell XInput stuff about it if appropriate */
|
|
|
|
if (window_private &&
|
|
|
|
(window_private->extension_events != 0) &&
|
|
|
|
gdk_input_vtable.enter_event)
|
|
|
|
gdk_input_vtable.enter_event (&xevent->xcrossing, window);
|
|
|
|
|
|
|
|
event->crossing.type = GDK_ENTER_NOTIFY;
|
|
|
|
event->crossing.window = window;
|
|
|
|
|
|
|
|
/* If the subwindow field of the XEvent is non-NULL, then
|
|
|
|
* lookup the corresponding GdkWindow.
|
|
|
|
*/
|
|
|
|
if (xevent->xcrossing.subwindow != None)
|
|
|
|
event->crossing.subwindow = gdk_window_lookup (xevent->xcrossing.subwindow);
|
|
|
|
else
|
|
|
|
event->crossing.subwindow = NULL;
|
|
|
|
|
|
|
|
/* Translate the crossing detail into Gdk terms.
|
|
|
|
*/
|
|
|
|
switch (xevent->xcrossing.detail)
|
|
|
|
{
|
|
|
|
case NotifyInferior:
|
|
|
|
event->crossing.detail = GDK_NOTIFY_INFERIOR;
|
|
|
|
break;
|
|
|
|
case NotifyAncestor:
|
|
|
|
event->crossing.detail = GDK_NOTIFY_ANCESTOR;
|
|
|
|
break;
|
|
|
|
case NotifyVirtual:
|
|
|
|
event->crossing.detail = GDK_NOTIFY_VIRTUAL;
|
|
|
|
break;
|
|
|
|
case NotifyNonlinear:
|
|
|
|
event->crossing.detail = GDK_NOTIFY_NONLINEAR;
|
|
|
|
break;
|
|
|
|
case NotifyNonlinearVirtual:
|
|
|
|
event->crossing.detail = GDK_NOTIFY_NONLINEAR_VIRTUAL;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
event->crossing.detail = GDK_NOTIFY_UNKNOWN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
1998-02-19 18:02:03 +00:00
|
|
|
#ifdef G_ENABLE_DEBUG
|
1998-02-26 21:28:00 +00:00
|
|
|
if ((gdk_debug_flags & GDK_DEBUG_DND) & gdk_dnd.drag_perhaps)
|
1998-02-19 06:21:27 +00:00
|
|
|
{
|
|
|
|
g_print("We may[%d] have a drag into %#lx = %#lx\n",
|
|
|
|
gdk_dnd.drag_really,
|
1998-03-06 05:14:09 +00:00
|
|
|
xevent->xcrossing.window, gdk_dnd.real_sw->xwindow);
|
1998-02-19 06:21:27 +00:00
|
|
|
}
|
1998-02-19 18:02:03 +00:00
|
|
|
#endif /* G_ENABLE_DEBUG */
|
1998-02-19 06:21:27 +00:00
|
|
|
|
1998-02-26 21:28:00 +00:00
|
|
|
if (gdk_dnd.drag_perhaps && gdk_dnd.drag_really &&
|
1998-03-06 05:14:09 +00:00
|
|
|
(xevent->xcrossing.window == gdk_dnd.real_sw->xwindow))
|
1997-12-06 22:12:10 +00:00
|
|
|
{
|
|
|
|
gdk_dnd.drag_really = 0;
|
1998-02-19 06:21:27 +00:00
|
|
|
|
|
|
|
GDK_NOTE (DND, g_print("Ungrabbed\n"));
|
|
|
|
|
1997-12-06 22:12:10 +00:00
|
|
|
gdk_dnd.drag_numwindows = 0;
|
|
|
|
g_free(gdk_dnd.drag_startwindows);
|
|
|
|
gdk_dnd.drag_startwindows = NULL;
|
1998-01-17 23:24:09 +00:00
|
|
|
/* We don't want to ungrab the pointer here, or we'll
|
|
|
|
* start getting spurious enter/leave events */
|
1998-02-26 21:28:00 +00:00
|
|
|
#if 0
|
1998-01-17 23:24:09 +00:00
|
|
|
XChangeActivePointerGrab (gdk_display, 0, None, CurrentTime);
|
1998-02-26 21:28:00 +00:00
|
|
|
#endif
|
1997-12-06 22:12:10 +00:00
|
|
|
}
|
1998-01-17 23:24:09 +00:00
|
|
|
|
|
|
|
return_val = window_private && !window_private->destroyed;
|
|
|
|
break;
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
case LeaveNotify:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("leave notify:\t\twindow: %ld detail: %d subwin: %ld\n",
|
|
|
|
xevent->xcrossing.window - base_id,
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xcrossing.detail, xevent->xcrossing.subwindow - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
event->crossing.type = GDK_LEAVE_NOTIFY;
|
|
|
|
event->crossing.window = window;
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
/* If the subwindow field of the XEvent is non-NULL, then
|
|
|
|
* lookup the corresponding GdkWindow.
|
|
|
|
*/
|
|
|
|
if (xevent->xcrossing.subwindow != None)
|
|
|
|
event->crossing.subwindow = gdk_window_lookup (xevent->xcrossing.subwindow);
|
|
|
|
else
|
|
|
|
event->crossing.subwindow = NULL;
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
/* Translate the crossing detail into Gdk terms.
|
|
|
|
*/
|
|
|
|
switch (xevent->xcrossing.detail)
|
|
|
|
{
|
|
|
|
case NotifyInferior:
|
|
|
|
event->crossing.detail = GDK_NOTIFY_INFERIOR;
|
|
|
|
break;
|
|
|
|
case NotifyAncestor:
|
|
|
|
event->crossing.detail = GDK_NOTIFY_ANCESTOR;
|
|
|
|
break;
|
|
|
|
case NotifyVirtual:
|
|
|
|
event->crossing.detail = GDK_NOTIFY_VIRTUAL;
|
|
|
|
break;
|
|
|
|
case NotifyNonlinear:
|
|
|
|
event->crossing.detail = GDK_NOTIFY_NONLINEAR;
|
|
|
|
break;
|
|
|
|
case NotifyNonlinearVirtual:
|
|
|
|
event->crossing.detail = GDK_NOTIFY_NONLINEAR_VIRTUAL;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
event->crossing.detail = GDK_NOTIFY_UNKNOWN;
|
|
|
|
break;
|
|
|
|
}
|
1998-02-19 18:02:03 +00:00
|
|
|
#ifdef G_ENABLE_DEBUG
|
1998-02-26 21:28:00 +00:00
|
|
|
if ((gdk_debug_flags & GDK_DEBUG_DND) & gdk_dnd.drag_perhaps)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1998-02-19 06:21:27 +00:00
|
|
|
g_print("We may[%d] have a drag out of %#lx = %#lx\n",
|
1997-12-06 22:12:10 +00:00
|
|
|
gdk_dnd.drag_really,
|
1998-03-06 05:14:09 +00:00
|
|
|
xevent->xcrossing.window, gdk_dnd.real_sw->xwindow);
|
1997-12-06 22:12:10 +00:00
|
|
|
}
|
1998-02-19 18:02:03 +00:00
|
|
|
#endif /* G_ENABLE_DEBUG */
|
1998-02-26 21:28:00 +00:00
|
|
|
if (gdk_dnd.drag_perhaps && !gdk_dnd.drag_really &&
|
1998-03-06 05:14:09 +00:00
|
|
|
(xevent->xcrossing.window == gdk_dnd.real_sw->xwindow))
|
1998-01-17 23:24:09 +00:00
|
|
|
{
|
1998-03-06 05:14:09 +00:00
|
|
|
gboolean xgpret;
|
|
|
|
gdk_dnd_drag_addwindow((GdkWindow *) gdk_dnd.real_sw);
|
|
|
|
gdk_dnd_drag_begin((GdkWindow *) gdk_dnd.real_sw);
|
|
|
|
xgpret =
|
|
|
|
XGrabPointer(gdk_display, gdk_dnd.real_sw->xwindow, False,
|
|
|
|
ButtonMotionMask | PointerMotionMask |
|
|
|
|
/* PointerMotionHintMask | */ /* HINTME */
|
1998-01-17 23:24:09 +00:00
|
|
|
ButtonPressMask | ButtonReleaseMask,
|
|
|
|
GrabModeAsync, GrabModeAsync, gdk_root_window,
|
1998-02-26 21:28:00 +00:00
|
|
|
None, CurrentTime);
|
1998-03-06 05:14:09 +00:00
|
|
|
#ifdef G_ENABLE_DEBUG
|
|
|
|
GDK_NOTE(DND, g_print("xgpret = %d\n", xgpret));
|
|
|
|
#endif
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd.dnd_grabbed = TRUE;
|
1998-01-17 23:24:09 +00:00
|
|
|
gdk_dnd.drag_really = 1;
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd_display_drag_cursor(xevent->xmotion.x_root,
|
|
|
|
xevent->xmotion.y_root,
|
|
|
|
FALSE, TRUE);
|
1998-01-17 23:24:09 +00:00
|
|
|
}
|
1997-12-06 22:12:10 +00:00
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FocusIn:
|
|
|
|
case FocusOut:
|
1997-12-18 02:17:14 +00:00
|
|
|
/* We only care about focus events that indicate that _this_
|
|
|
|
* window (not a ancestor or child) got or lost the focus
|
1997-11-24 22:37:52 +00:00
|
|
|
*/
|
1997-12-18 02:17:14 +00:00
|
|
|
switch (xevent->xfocus.detail)
|
|
|
|
{
|
|
|
|
case NotifyAncestor:
|
|
|
|
case NotifyInferior:
|
|
|
|
case NotifyNonlinear:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-12-18 02:17:14 +00:00
|
|
|
g_print ("focus %s:\t\twindow: %ld\n",
|
|
|
|
(xevent->xany.type == FocusIn) ? "in" : "out",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xfocus.window - base_id));
|
1997-12-18 02:17:14 +00:00
|
|
|
|
|
|
|
event->focus_change.type = GDK_FOCUS_CHANGE;
|
|
|
|
event->focus_change.window = window;
|
|
|
|
event->focus_change.in = (xevent->xany.type == FocusIn);
|
|
|
|
|
|
|
|
return_val = window_private && !window_private->destroyed;
|
|
|
|
break;
|
|
|
|
default:
|
1998-01-03 05:46:58 +00:00
|
|
|
;
|
1997-12-18 02:17:14 +00:00
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case KeymapNotify:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
|
|
|
g_print ("keymap notify\n"));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
/* Not currently handled */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Expose:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("expose:\t\twindow: %ld %d x,y: %d %d w,h: %d %d\n",
|
|
|
|
xevent->xexpose.window - base_id, xevent->xexpose.count,
|
|
|
|
xevent->xexpose.x, xevent->xexpose.y,
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xexpose.width, xevent->xexpose.height));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
event->expose.type = GDK_EXPOSE;
|
|
|
|
event->expose.window = window;
|
|
|
|
event->expose.area.x = xevent->xexpose.x;
|
|
|
|
event->expose.area.y = xevent->xexpose.y;
|
|
|
|
event->expose.area.width = xevent->xexpose.width;
|
|
|
|
event->expose.area.height = xevent->xexpose.height;
|
|
|
|
event->expose.count = xevent->xexpose.count;
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case GraphicsExpose:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("graphics expose:\tdrawable: %ld\n",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xgraphicsexpose.drawable - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
event->expose.type = GDK_EXPOSE;
|
|
|
|
event->expose.window = window;
|
|
|
|
event->expose.area.x = xevent->xgraphicsexpose.x;
|
|
|
|
event->expose.area.y = xevent->xgraphicsexpose.y;
|
|
|
|
event->expose.area.width = xevent->xgraphicsexpose.width;
|
|
|
|
event->expose.area.height = xevent->xgraphicsexpose.height;
|
|
|
|
event->expose.count = xevent->xexpose.count;
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NoExpose:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("no expose:\t\tdrawable: %ld\n",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xnoexpose.drawable - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
1997-12-26 08:54:12 +00:00
|
|
|
event->no_expose.type = GDK_NO_EXPOSE;
|
|
|
|
event->no_expose.window = window;
|
|
|
|
|
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case VisibilityNotify:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 18:02:03 +00:00
|
|
|
#ifdef G_ENABLE_DEBUG
|
1998-02-19 06:21:27 +00:00
|
|
|
if (gdk_debug_flags & GDK_DEBUG_EVENTS)
|
1997-11-24 22:37:52 +00:00
|
|
|
switch (xevent->xvisibility.state)
|
|
|
|
{
|
|
|
|
case VisibilityFullyObscured:
|
|
|
|
g_print ("visibility notify:\twindow: %ld none\n",
|
|
|
|
xevent->xvisibility.window - base_id);
|
|
|
|
break;
|
|
|
|
case VisibilityPartiallyObscured:
|
|
|
|
g_print ("visibility notify:\twindow: %ld partial\n",
|
|
|
|
xevent->xvisibility.window - base_id);
|
|
|
|
break;
|
|
|
|
case VisibilityUnobscured:
|
|
|
|
g_print ("visibility notify:\twindow: %ld full\n",
|
|
|
|
xevent->xvisibility.window - base_id);
|
|
|
|
break;
|
|
|
|
}
|
1998-02-19 18:02:03 +00:00
|
|
|
#endif /* G_ENABLE_DEBUG */
|
1997-11-24 22:37:52 +00:00
|
|
|
|
1997-12-26 08:54:12 +00:00
|
|
|
event->visibility.type = GDK_VISIBILITY_NOTIFY;
|
|
|
|
event->visibility.window = window;
|
|
|
|
|
|
|
|
switch (xevent->xvisibility.state)
|
|
|
|
{
|
|
|
|
case VisibilityFullyObscured:
|
|
|
|
event->visibility.state = GDK_VISIBILITY_FULLY_OBSCURED;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VisibilityPartiallyObscured:
|
|
|
|
event->visibility.state = GDK_VISIBILITY_PARTIAL;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VisibilityUnobscured:
|
|
|
|
event->visibility.state = GDK_VISIBILITY_UNOBSCURED;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case CreateNotify:
|
|
|
|
/* Not currently handled */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DestroyNotify:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("destroy notify:\twindow: %ld\n",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xdestroywindow.window - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
event->any.type = GDK_DESTROY;
|
|
|
|
event->any.window = window;
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-12-18 02:17:14 +00:00
|
|
|
|
|
|
|
gdk_window_destroy_notify (window);
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case UnmapNotify:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("unmap notify:\t\twindow: %ld\n",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xmap.window - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
event->any.type = GDK_UNMAP;
|
|
|
|
event->any.window = window;
|
|
|
|
|
1998-01-21 09:16:33 +00:00
|
|
|
if (xgrab_window == window_private)
|
|
|
|
xgrab_window = NULL;
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MapNotify:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("map notify:\t\twindow: %ld\n",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xmap.window - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
event->any.type = GDK_MAP;
|
|
|
|
event->any.window = window;
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ReparentNotify:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("reparent notify:\twindow: %ld\n",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xreparent.window - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
/* Not currently handled */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ConfigureNotify:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-07 02:26:09 +00:00
|
|
|
while ((XPending (gdk_display) > 0) &&
|
|
|
|
XCheckTypedWindowEvent(gdk_display, xevent->xany.window,
|
|
|
|
ConfigureNotify, xevent))
|
|
|
|
/*XSync (gdk_display, 0)*/;
|
|
|
|
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1998-02-07 02:26:09 +00:00
|
|
|
g_print ("configure notify:\twindow: %ld x,y: %d %d w,h: %d %d b-w: %d above: %ld ovr: %d\n",
|
1997-11-24 22:37:52 +00:00
|
|
|
xevent->xconfigure.window - base_id,
|
1998-02-07 02:26:09 +00:00
|
|
|
xevent->xconfigure.x,
|
|
|
|
xevent->xconfigure.y,
|
|
|
|
xevent->xconfigure.width,
|
|
|
|
xevent->xconfigure.height,
|
|
|
|
xevent->xconfigure.border_width,
|
|
|
|
xevent->xconfigure.above - base_id,
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xconfigure.override_redirect));
|
1998-02-07 02:26:09 +00:00
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
if (window_private)
|
1997-11-24 22:37:52 +00:00
|
|
|
{
|
1997-11-27 04:16:39 +00:00
|
|
|
if ((window_private->extension_events != 0) &&
|
|
|
|
gdk_input_vtable.configure_event)
|
|
|
|
gdk_input_vtable.configure_event (&xevent->xconfigure, window);
|
1998-02-07 02:26:09 +00:00
|
|
|
|
|
|
|
if (window_private->window_type != GDK_WINDOW_CHILD)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
event->configure.type = GDK_CONFIGURE;
|
|
|
|
event->configure.window = window;
|
|
|
|
event->configure.width = xevent->xconfigure.width;
|
|
|
|
event->configure.height = xevent->xconfigure.height;
|
1998-02-07 02:26:09 +00:00
|
|
|
|
|
|
|
if (!xevent->xconfigure.x &&
|
|
|
|
!xevent->xconfigure.y)
|
|
|
|
{
|
|
|
|
gint tx = 0;
|
|
|
|
gint ty = 0;
|
|
|
|
Window child_window = 0;
|
|
|
|
|
|
|
|
if (!XTranslateCoordinates (window_private->xdisplay,
|
|
|
|
window_private->xwindow,
|
|
|
|
gdk_root_window,
|
|
|
|
0, 0,
|
|
|
|
&tx, &ty,
|
|
|
|
&child_window))
|
|
|
|
g_warning ("GdkWindow %ld doesn't share root windows display?",
|
|
|
|
window_private->xwindow - base_id);
|
|
|
|
event->configure.x = tx;
|
|
|
|
event->configure.y = ty;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
event->configure.x = xevent->xconfigure.x;
|
|
|
|
event->configure.y = xevent->xconfigure.y;
|
|
|
|
}
|
|
|
|
window_private->x = event->configure.x;
|
|
|
|
window_private->y = event->configure.y;
|
1997-11-27 04:16:39 +00:00
|
|
|
window_private->width = xevent->xconfigure.width;
|
|
|
|
window_private->height = xevent->xconfigure.height;
|
|
|
|
if (window_private->resize_count > 1)
|
|
|
|
window_private->resize_count -= 1;
|
1998-02-07 02:26:09 +00:00
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = !window_private->destroyed;
|
|
|
|
}
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
break;
|
1998-02-07 02:26:09 +00:00
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
case PropertyNotify:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("property notify:\twindow: %ld\n",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xproperty.window - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
event->property.type = GDK_PROPERTY_NOTIFY;
|
|
|
|
event->property.window = window;
|
|
|
|
event->property.atom = xevent->xproperty.atom;
|
|
|
|
event->property.time = xevent->xproperty.time;
|
|
|
|
event->property.state = xevent->xproperty.state;
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SelectionClear:
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("selection clear:\twindow: %ld\n",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xproperty.window - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
event->selection.type = GDK_SELECTION_CLEAR;
|
|
|
|
event->selection.window = window;
|
|
|
|
event->selection.selection = xevent->xselectionclear.selection;
|
|
|
|
event->selection.time = xevent->xselectionclear.time;
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SelectionRequest:
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("selection request:\twindow: %ld\n",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xproperty.window - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
event->selection.type = GDK_SELECTION_REQUEST;
|
|
|
|
event->selection.window = window;
|
|
|
|
event->selection.selection = xevent->xselectionrequest.selection;
|
|
|
|
event->selection.target = xevent->xselectionrequest.target;
|
|
|
|
event->selection.property = xevent->xselectionrequest.property;
|
|
|
|
event->selection.requestor = xevent->xselectionrequest.requestor;
|
|
|
|
event->selection.time = xevent->xselectionrequest.time;
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SelectionNotify:
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("selection notify:\twindow: %ld\n",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xproperty.window - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
|
|
|
|
event->selection.type = GDK_SELECTION_NOTIFY;
|
|
|
|
event->selection.window = window;
|
|
|
|
event->selection.selection = xevent->xselection.selection;
|
|
|
|
event->selection.target = xevent->xselection.target;
|
|
|
|
event->selection.property = xevent->xselection.property;
|
|
|
|
event->selection.time = xevent->xselection.time;
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ColormapNotify:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("colormap notify:\twindow: %ld\n",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xcolormap.window - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
/* Not currently handled */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ClientMessage:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("client message:\twindow: %ld\n",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xclient.window - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
/* Client messages are the means of the window manager
|
|
|
|
* communicating with a program. We'll first check to
|
|
|
|
* see if this is really the window manager talking
|
|
|
|
* to us.
|
|
|
|
*/
|
|
|
|
if (xevent->xclient.message_type == gdk_wm_protocols)
|
|
|
|
{
|
|
|
|
if ((Atom) xevent->xclient.data.l[0] == gdk_wm_delete_window)
|
|
|
|
{
|
|
|
|
/* The delete window request specifies a window
|
|
|
|
* to delete. We don't actually destroy the
|
|
|
|
* window because "it is only a request". (The
|
|
|
|
* window might contain vital data that the
|
|
|
|
* program does not want destroyed). Instead
|
|
|
|
* the event is passed along to the program,
|
|
|
|
* which should then destroy the window.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("delete window:\t\twindow: %ld\n",
|
1998-02-19 06:21:27 +00:00
|
|
|
xevent->xclient.window - base_id));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
event->any.type = GDK_DELETE;
|
|
|
|
event->any.window = window;
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
return_val = window_private && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
else if ((Atom) xevent->xclient.data.l[0] == gdk_wm_take_focus)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (xevent->xclient.message_type == gdk_dnd.gdk_XdeEnter)
|
|
|
|
{
|
|
|
|
Atom reptype = 0;
|
|
|
|
|
|
|
|
event->dropenter.u.allflags = xevent->xclient.data.l[1];
|
1998-02-19 06:21:27 +00:00
|
|
|
|
|
|
|
GDK_NOTE (DND, g_print ("GDK_DROP_ENTER [%d][%d]\n",
|
|
|
|
window_private->dnd_drop_enabled, event->dropenter.u.flags.sendreply));
|
1997-11-24 22:37:52 +00:00
|
|
|
return_val = FALSE;
|
|
|
|
|
|
|
|
/* Now figure out if we really want this drop...
|
|
|
|
* If someone is trying funky clipboard stuff, ignore
|
|
|
|
*/
|
|
|
|
if (window_private
|
|
|
|
&& window_private->dnd_drop_enabled
|
|
|
|
&& event->dropenter.u.flags.sendreply
|
|
|
|
&& (reptype = gdk_dnd_check_types (window, xevent)))
|
|
|
|
{
|
|
|
|
XEvent replyev;
|
|
|
|
|
|
|
|
replyev.xclient.type = ClientMessage;
|
|
|
|
replyev.xclient.window = xevent->xclient.data.l[0];
|
|
|
|
replyev.xclient.format = 32;
|
|
|
|
replyev.xclient.message_type = gdk_dnd.gdk_XdeRequest;
|
|
|
|
replyev.xclient.data.l[0] = window_private->xwindow;
|
|
|
|
|
|
|
|
event->dragrequest.u.allflags = 0;
|
|
|
|
event->dragrequest.u.flags.protocol_version =
|
|
|
|
DND_PROTOCOL_VERSION;
|
|
|
|
event->dragrequest.u.flags.willaccept = 1;
|
|
|
|
event->dragrequest.u.flags.delete_data =
|
|
|
|
(window_private->dnd_drop_destructive_op) ? 1 : 0;
|
|
|
|
|
|
|
|
replyev.xclient.data.l[1] = event->dragrequest.u.allflags;
|
|
|
|
replyev.xclient.data.l[2] = replyev.xclient.data.l[3] = 0;
|
|
|
|
replyev.xclient.data.l[4] = reptype;
|
|
|
|
|
1998-03-08 21:47:14 +00:00
|
|
|
if (!gdk_send_xevent (replyev.xclient.window, False,
|
|
|
|
NoEventMask, &replyev))
|
|
|
|
GDK_NOTE (DND, g_print("Sending XdeRequest to %#lx failed\n",
|
|
|
|
replyev.xclient.window));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
event->any.type = GDK_DROP_ENTER;
|
1998-02-16 22:04:52 +00:00
|
|
|
event->any.window = window;
|
1997-11-24 22:37:52 +00:00
|
|
|
event->dropenter.requestor = replyev.xclient.window;
|
|
|
|
event->dropenter.u.allflags = xevent->xclient.data.l[1];
|
1998-02-19 06:21:27 +00:00
|
|
|
|
|
|
|
GDK_NOTE (DND, g_print("We sent a GDK_DROP_ENTER on to Gtk\n"));
|
1998-02-16 22:04:52 +00:00
|
|
|
return_val = TRUE;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (xevent->xclient.message_type == gdk_dnd.gdk_XdeLeave)
|
|
|
|
{
|
1998-02-19 06:21:27 +00:00
|
|
|
#ifdef G_ENABLE_DEBUG
|
|
|
|
if (gdk_debug_flags & (GDK_DEBUG_EVENTS | GDK_DEBUG_DND))
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("GDK_DROP_LEAVE\n");
|
1998-02-19 06:21:27 +00:00
|
|
|
#endif
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (window_private && window_private->dnd_drop_enabled)
|
|
|
|
{
|
|
|
|
event->dropleave.type = GDK_DROP_LEAVE;
|
|
|
|
event->dropleave.window = window;
|
|
|
|
event->dropleave.requestor = xevent->xclient.data.l[0];
|
|
|
|
event->dropleave.u.allflags = xevent->xclient.data.l[1];
|
|
|
|
return_val = TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return_val = FALSE;
|
|
|
|
}
|
|
|
|
else if (xevent->xclient.message_type == gdk_dnd.gdk_XdeRequest)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* make sure to only handle requests from the window the cursor is
|
|
|
|
* over
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
#ifdef G_ENABLE_DEBUG
|
|
|
|
if (gdk_debug_flags & (GDK_DEBUG_EVENTS | GDK_DEBUG_DND))
|
1997-11-24 22:37:52 +00:00
|
|
|
g_print ("GDK_DRAG_REQUEST\n");
|
1998-02-19 06:21:27 +00:00
|
|
|
#endif
|
1997-11-24 22:37:52 +00:00
|
|
|
event->dragrequest.u.allflags = xevent->xclient.data.l[1];
|
|
|
|
return_val = FALSE;
|
|
|
|
|
|
|
|
if (window && gdk_dnd.drag_really &&
|
1998-03-06 05:14:09 +00:00
|
|
|
xevent->xclient.data.l[0] == gdk_dnd.dnd_drag_curwin &&
|
1997-11-24 22:37:52 +00:00
|
|
|
event->dragrequest.u.flags.sendreply == 0)
|
|
|
|
{
|
|
|
|
/* Got request - do we need to ask user? */
|
|
|
|
if (!event->dragrequest.u.flags.willaccept
|
|
|
|
&& event->dragrequest.u.flags.senddata)
|
|
|
|
{
|
|
|
|
/* Yes we do :) */
|
|
|
|
event->dragrequest.type = GDK_DRAG_REQUEST;
|
|
|
|
event->dragrequest.window = window;
|
|
|
|
event->dragrequest.requestor = xevent->xclient.data.l[0];
|
|
|
|
event->dragrequest.isdrop = 0;
|
|
|
|
event->dragrequest.drop_coords.x =
|
|
|
|
event->dragrequest.drop_coords.y = 0;
|
|
|
|
return_val = TRUE;
|
|
|
|
}
|
|
|
|
else if (event->dragrequest.u.flags.willaccept)
|
|
|
|
{
|
|
|
|
window_private->dnd_drag_destructive_op =
|
|
|
|
event->dragrequest.u.flags.delete_data;
|
|
|
|
window_private->dnd_drag_accepted = 1;
|
|
|
|
window_private->dnd_drag_data_type =
|
|
|
|
xevent->xclient.data.l[4];
|
|
|
|
|
1998-03-06 05:14:09 +00:00
|
|
|
gdk_dnd.dnd_drag_target = gdk_dnd.dnd_drag_curwin;
|
1998-02-26 21:28:00 +00:00
|
|
|
gdk_dnd_display_drag_cursor(-1, -1, TRUE, TRUE);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1998-03-06 05:14:09 +00:00
|
|
|
gdk_dnd.dnd_drag_dropzone.x = xevent->xclient.data.l[2] & 65535;
|
|
|
|
gdk_dnd.dnd_drag_dropzone.y =
|
1997-11-24 22:37:52 +00:00
|
|
|
(xevent->xclient.data.l[2] >> 16) & 65535;
|
1998-03-06 05:14:09 +00:00
|
|
|
gdk_dnd.dnd_drag_dropzone.width = xevent->xclient.data.l[3] & 65535;
|
|
|
|
gdk_dnd.dnd_drag_dropzone.height =
|
1997-11-24 22:37:52 +00:00
|
|
|
(xevent->xclient.data.l[3] >> 16) & 65535;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(xevent->xclient.message_type == gdk_dnd.gdk_XdeDataAvailable)
|
|
|
|
{
|
|
|
|
gint tmp_int; Atom tmp_atom;
|
|
|
|
gulong tmp_long;
|
|
|
|
guchar *tmp_charptr;
|
1997-12-06 22:12:10 +00:00
|
|
|
|
1998-02-19 06:21:27 +00:00
|
|
|
#ifdef G_ENABLE_DEBUG
|
|
|
|
if (gdk_debug_flags & (GDK_DEBUG_EVENTS | GDK_DEBUG_DND))
|
|
|
|
g_print("GDK_DROP_DATA_AVAIL\n");
|
|
|
|
#endif
|
1997-11-24 22:37:52 +00:00
|
|
|
event->dropdataavailable.u.allflags = xevent->xclient.data.l[1];
|
1998-03-10 02:48:02 +00:00
|
|
|
event->dropdataavailable.timestamp = xevent->xclient.data.l[4];
|
|
|
|
event->dropdataavailable.coords.x =
|
|
|
|
xevent->xclient.data.l[3] & 0xffff;
|
|
|
|
event->dropdataavailable.coords.y =
|
|
|
|
(xevent->xclient.data.l[3] >> 16) & 0xffff;
|
1997-11-24 22:37:52 +00:00
|
|
|
if(window
|
|
|
|
/* No preview of data ATM */
|
|
|
|
&& event->dropdataavailable.u.flags.isdrop)
|
|
|
|
{
|
|
|
|
event->dropdataavailable.type = GDK_DROP_DATA_AVAIL;
|
|
|
|
event->dropdataavailable.window = window;
|
|
|
|
event->dropdataavailable.requestor = xevent->xclient.data.l[0];
|
|
|
|
event->dropdataavailable.data_type =
|
|
|
|
gdk_atom_name(xevent->xclient.data.l[2]);
|
|
|
|
if(XGetWindowProperty (gdk_display,
|
|
|
|
event->dropdataavailable.requestor,
|
|
|
|
xevent->xclient.data.l[2],
|
|
|
|
0, LONG_MAX - 1,
|
|
|
|
False, XA_PRIMARY, &tmp_atom,
|
|
|
|
&tmp_int,
|
|
|
|
&event->dropdataavailable.data_numbytes,
|
|
|
|
&tmp_long,
|
|
|
|
&tmp_charptr)
|
|
|
|
!= Success)
|
|
|
|
{
|
|
|
|
g_warning("XGetWindowProperty on %#x may have failed\n",
|
|
|
|
event->dropdataavailable.requestor);
|
|
|
|
event->dropdataavailable.data = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (DND, g_print("XGetWindowProperty got us %ld bytes\n",
|
|
|
|
event->dropdataavailable.data_numbytes));
|
1997-11-24 22:37:52 +00:00
|
|
|
event->dropdataavailable.data =
|
1998-01-17 23:24:09 +00:00
|
|
|
g_malloc (event->dropdataavailable.data_numbytes);
|
|
|
|
memcpy (event->dropdataavailable.data,
|
1997-11-24 22:37:52 +00:00
|
|
|
tmp_charptr, event->dropdataavailable.data_numbytes);
|
|
|
|
XFree(tmp_charptr);
|
|
|
|
return_val = TRUE;
|
|
|
|
}
|
|
|
|
return_val = TRUE;
|
|
|
|
}
|
1997-12-06 22:12:10 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
1997-11-24 22:37:52 +00:00
|
|
|
/* Send unknown ClientMessage's on to Gtk for it to use */
|
|
|
|
event->client.type = GDK_CLIENT_EVENT;
|
|
|
|
event->client.window = window;
|
|
|
|
event->client.message_type = xevent->xclient.message_type;
|
|
|
|
event->client.data_format = xevent->xclient.format;
|
|
|
|
memcpy(&event->client.data, &xevent->xclient.data,
|
|
|
|
sizeof(event->client.data));
|
1997-11-28 06:47:01 +00:00
|
|
|
if(window)
|
|
|
|
return_val = TRUE;
|
|
|
|
else
|
|
|
|
return_val = FALSE;
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
1997-11-28 06:47:01 +00:00
|
|
|
if(window_private)
|
|
|
|
return_val = return_val && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MappingNotify:
|
|
|
|
/* Print debugging info.
|
|
|
|
*/
|
1998-02-19 06:21:27 +00:00
|
|
|
GDK_NOTE (EVENTS,
|
|
|
|
g_print ("mapping notify\n"));
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
/* Let XLib know that there is a new keyboard mapping.
|
|
|
|
*/
|
|
|
|
XRefreshKeyboardMapping (&xevent->xmapping);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
/* something else - (e.g., a Xinput event) */
|
|
|
|
|
|
|
|
if (window_private &&
|
|
|
|
(window_private->extension_events != 0) &&
|
|
|
|
gdk_input_vtable.other_event)
|
|
|
|
return_val = gdk_input_vtable.other_event(event, xevent, window);
|
1997-11-27 04:16:39 +00:00
|
|
|
else
|
|
|
|
return_val = -1;
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
if (return_val < 0) /* not an XInput event, convert */
|
|
|
|
{
|
|
|
|
event->other.type = GDK_OTHER_EVENT;
|
|
|
|
event->other.window = window;
|
1997-12-03 21:43:44 +00:00
|
|
|
event->other.xevent = (GdkXEvent *)&other_xevent[other_xevent_i];
|
1997-11-24 22:37:52 +00:00
|
|
|
memcpy (&other_xevent[other_xevent_i], xevent, sizeof (XEvent));
|
|
|
|
other_xevent_i = (other_xevent_i+1) % OTHER_XEVENT_BUFSIZE;
|
|
|
|
return_val = TRUE;
|
|
|
|
}
|
1997-11-27 04:16:39 +00:00
|
|
|
else
|
|
|
|
return_val = return_val && !window_private->destroyed;
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
if (return_val)
|
|
|
|
{
|
|
|
|
if (event->any.window)
|
|
|
|
gdk_window_ref (event->any.window);
|
|
|
|
if (((event->any.type == GDK_ENTER_NOTIFY) ||
|
|
|
|
(event->any.type == GDK_LEAVE_NOTIFY)) &&
|
|
|
|
(event->crossing.subwindow != NULL))
|
|
|
|
gdk_window_ref (event->crossing.subwindow);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Mark this event as having no resources to be freed */
|
|
|
|
event->any.window = NULL;
|
|
|
|
event->any.type = GDK_NOTHING;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (window)
|
|
|
|
gdk_window_unref (window);
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
return return_val;
|
|
|
|
}
|
|
|
|
|
1997-12-18 02:17:14 +00:00
|
|
|
#if 0
|
1997-11-24 22:37:52 +00:00
|
|
|
static Bool
|
|
|
|
gdk_event_get_type (Display *display,
|
|
|
|
XEvent *xevent,
|
|
|
|
XPointer arg)
|
|
|
|
{
|
|
|
|
GdkEvent event;
|
|
|
|
GdkPredicate *pred;
|
|
|
|
|
|
|
|
if (gdk_event_translate (&event, xevent))
|
|
|
|
{
|
|
|
|
pred = (GdkPredicate*) arg;
|
|
|
|
return (* pred->func) (&event, pred->data);
|
|
|
|
}
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
1997-12-18 02:17:14 +00:00
|
|
|
#endif
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
gdk_synthesize_click (GdkEvent *event,
|
|
|
|
gint nclicks)
|
|
|
|
{
|
|
|
|
GdkEvent temp_event;
|
|
|
|
|
|
|
|
g_return_if_fail (event != NULL);
|
|
|
|
|
|
|
|
temp_event = *event;
|
|
|
|
temp_event.type = (nclicks == 2) ? GDK_2BUTTON_PRESS : GDK_3BUTTON_PRESS;
|
|
|
|
|
|
|
|
gdk_event_put (&temp_event);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* 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
|
|
|
|
gdk_exit_func ()
|
|
|
|
{
|
1998-01-02 03:43:24 +00:00
|
|
|
static gboolean in_gdk_exit_func = FALSE;
|
|
|
|
|
|
|
|
/* This is to avoid an infinite loop if a program segfaults in
|
|
|
|
an atexit() handler (and yes, it does happen, especially if a program
|
|
|
|
has trounced over memory too badly for even g_print to work) */
|
|
|
|
if(in_gdk_exit_func == TRUE) return;
|
|
|
|
in_gdk_exit_func = TRUE;
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
if (initialized)
|
|
|
|
{
|
1997-11-27 04:16:39 +00:00
|
|
|
#ifdef USE_XIM
|
|
|
|
/* cleanup IC */
|
|
|
|
gdk_ic_cleanup ();
|
|
|
|
/* close IM */
|
|
|
|
gdk_im_close ();
|
|
|
|
#endif
|
1997-11-24 22:37:52 +00:00
|
|
|
gdk_image_exit ();
|
|
|
|
gdk_input_exit ();
|
|
|
|
gdk_key_repeat_restore ();
|
|
|
|
|
|
|
|
XCloseDisplay (gdk_display);
|
|
|
|
initialized = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* 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
|
|
|
|
gdk_x_error (Display *display,
|
|
|
|
XErrorEvent *error)
|
|
|
|
{
|
|
|
|
char buf[64];
|
|
|
|
|
|
|
|
if (gdk_error_warnings)
|
|
|
|
{
|
|
|
|
XGetErrorText (display, error->error_code, buf, 63);
|
|
|
|
g_error ("%s", buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* gdk_signal
|
|
|
|
*
|
|
|
|
* The signal handler.
|
|
|
|
*
|
|
|
|
* Arguments:
|
|
|
|
* "sig_num" is the number of the signal we received.
|
|
|
|
*
|
|
|
|
* Results:
|
|
|
|
* The signals we catch are all fatal. So we simply build
|
|
|
|
* up a nice little error message and print it and exit.
|
|
|
|
* If in the process of doing so another signal is received
|
|
|
|
* we notice that we are already exiting and simply kill
|
|
|
|
* our process.
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
static RETSIGTYPE
|
|
|
|
gdk_signal (int sig_num)
|
|
|
|
{
|
|
|
|
static int caught_fatal_sig = 0;
|
|
|
|
char *sig;
|
|
|
|
|
|
|
|
if (caught_fatal_sig)
|
|
|
|
kill (getpid (), sig_num);
|
|
|
|
caught_fatal_sig = 1;
|
|
|
|
|
|
|
|
switch (sig_num)
|
|
|
|
{
|
|
|
|
case SIGHUP:
|
|
|
|
sig = "sighup";
|
|
|
|
break;
|
|
|
|
case SIGINT:
|
|
|
|
sig = "sigint";
|
|
|
|
break;
|
|
|
|
case SIGQUIT:
|
|
|
|
sig = "sigquit";
|
|
|
|
break;
|
|
|
|
case SIGBUS:
|
|
|
|
sig = "sigbus";
|
|
|
|
break;
|
|
|
|
case SIGSEGV:
|
|
|
|
sig = "sigsegv";
|
|
|
|
break;
|
|
|
|
case SIGPIPE:
|
|
|
|
sig = "sigpipe";
|
|
|
|
break;
|
|
|
|
case SIGTERM:
|
|
|
|
sig = "sigterm";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
sig = "unknown signal";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_print ("\n** ERROR **: %s caught\n", sig);
|
1998-03-07 20:32:59 +00:00
|
|
|
#ifdef G_ENABLE_DEBUG
|
|
|
|
abort ();
|
|
|
|
#else /* !G_ENABLE_DEBUG */
|
1997-11-24 22:37:52 +00:00
|
|
|
gdk_exit (1);
|
1998-03-07 20:32:59 +00:00
|
|
|
#endif /* !G_ENABLE_DEBUG */
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gdk_dnd_drag_begin (GdkWindow *initial_window)
|
|
|
|
{
|
|
|
|
GdkEventDragBegin tev;
|
|
|
|
tev.type = GDK_DRAG_BEGIN;
|
|
|
|
tev.window = initial_window;
|
|
|
|
tev.u.allflags = 0;
|
|
|
|
tev.u.flags.protocol_version = DND_PROTOCOL_VERSION;
|
|
|
|
|
|
|
|
gdk_event_put ((GdkEvent *) &tev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
gdk_dnd_drag_enter (Window dest)
|
|
|
|
{
|
|
|
|
XEvent sev;
|
|
|
|
GdkEventDropEnter tev;
|
|
|
|
int i;
|
|
|
|
GdkWindowPrivate *wp;
|
|
|
|
|
|
|
|
sev.xclient.type = ClientMessage;
|
|
|
|
sev.xclient.format = 32;
|
|
|
|
sev.xclient.message_type = gdk_dnd.gdk_XdeEnter;
|
|
|
|
sev.xclient.window = dest;
|
|
|
|
|
|
|
|
tev.u.allflags = 0;
|
|
|
|
tev.u.flags.protocol_version = DND_PROTOCOL_VERSION;
|
|
|
|
tev.u.flags.sendreply = 1;
|
|
|
|
for (i = 0; i < gdk_dnd.drag_numwindows; i++)
|
|
|
|
{
|
|
|
|
wp = (GdkWindowPrivate *) gdk_dnd.drag_startwindows[i];
|
|
|
|
if (wp->dnd_drag_data_numtypesavail)
|
|
|
|
{
|
|
|
|
sev.xclient.data.l[0] = wp->xwindow;
|
|
|
|
tev.u.flags.extended_typelist = (wp->dnd_drag_data_numtypesavail > 3)?1:0;
|
|
|
|
sev.xclient.data.l[1] = tev.u.allflags;
|
|
|
|
sev.xclient.data.l[2] = wp->dnd_drag_data_typesavail[0];
|
|
|
|
if (wp->dnd_drag_data_numtypesavail > 1)
|
|
|
|
{
|
|
|
|
sev.xclient.data.l[3] = wp->dnd_drag_data_typesavail[1];
|
|
|
|
if (wp->dnd_drag_data_numtypesavail > 2)
|
|
|
|
{
|
|
|
|
sev.xclient.data.l[4] = wp->dnd_drag_data_typesavail[2];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
sev.xclient.data.l[4] = None;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
sev.xclient.data.l[3] = sev.xclient.data.l[4] = None;
|
1998-03-08 21:47:14 +00:00
|
|
|
if (!gdk_send_xevent (dest, False, NoEventMask, &sev))
|
|
|
|
GDK_NOTE (DND, g_print("Sending XdeEnter to %#lx failed\n",
|
|
|
|
dest));
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
|
|
|
|
#ifdef USE_XIM
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* gdk_im_begin
|
|
|
|
*
|
|
|
|
* Begin using input method with XIM Protocol(X11R6 standard)
|
|
|
|
*
|
|
|
|
* Arguments:
|
|
|
|
* "ic" is the "Input Context" which is created by gtk_ic_new.
|
|
|
|
* The input area is specified with "window".
|
|
|
|
*
|
|
|
|
* Results:
|
|
|
|
* The gdk's event handling routine is switched to XIM based routine.
|
|
|
|
* XIM based routine uses XFilterEvent to get rid of events used by IM,
|
|
|
|
* and uses XmbLookupString instead of XLookupString.
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
1997-12-07 16:36:36 +00:00
|
|
|
void
|
|
|
|
gdk_im_begin (GdkIC ic, GdkWindow* window)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
GdkICPrivate *private;
|
|
|
|
Window xwin;
|
|
|
|
|
|
|
|
g_return_if_fail (ic != NULL);
|
|
|
|
g_return_if_fail (window);
|
|
|
|
|
|
|
|
private = (GdkICPrivate *) ic;
|
|
|
|
|
|
|
|
xim_using = TRUE;
|
|
|
|
xim_ic = private;
|
|
|
|
xim_window = window;
|
|
|
|
if (gdk_im_ready())
|
|
|
|
{
|
|
|
|
XGetICValues (private->xic, XNFocusWindow, &xwin, NULL);
|
|
|
|
if (xwin != GDK_WINDOW_XWINDOW(window))
|
|
|
|
XSetICValues (private->xic, XNFocusWindow,
|
|
|
|
GDK_WINDOW_XWINDOW(window), NULL);
|
|
|
|
if (private != xim_ic)
|
|
|
|
XSetICFocus (private->xic);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
* gdk_im_end
|
|
|
|
*
|
|
|
|
* End using input method with XIM Protocol(X11R6 standard)
|
|
|
|
*
|
|
|
|
* Arguments:
|
|
|
|
*
|
|
|
|
* Results:
|
|
|
|
* The gdk's event handling routine is switched to normal routine.
|
|
|
|
* User should call this function before ic and window will be destroyed.
|
|
|
|
*
|
|
|
|
* Side effects:
|
|
|
|
*
|
|
|
|
*--------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
1997-12-07 16:36:36 +00:00
|
|
|
void
|
|
|
|
gdk_im_end (void)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
xim_using = FALSE;
|
|
|
|
xim_ic = NULL;
|
|
|
|
xim_window = NULL;
|
|
|
|
}
|
|
|
|
|
1997-12-07 16:36:36 +00:00
|
|
|
static GdkIM
|
|
|
|
gdk_im_get (void)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
return xim_im;
|
|
|
|
}
|
|
|
|
|
|
|
|
static GdkIMStyle
|
|
|
|
gdk_im_choose_better_style (GdkIMStyle style1, GdkIMStyle style2)
|
|
|
|
{
|
|
|
|
GdkIMStyle s1, s2, u;
|
|
|
|
|
|
|
|
if (style1 == 0) return style2;
|
|
|
|
if (style2 == 0) return style1;
|
|
|
|
if ((style1 & (GdkIMPreeditMask | GdkIMStatusMask))
|
|
|
|
== (style2 & (GdkIMPreeditMask | GdkIMStatusMask)))
|
|
|
|
return style1;
|
|
|
|
|
|
|
|
s1 = style1 & GdkIMPreeditMask;
|
|
|
|
s2 = style2 & GdkIMPreeditMask;
|
|
|
|
u = s1 | s2;
|
|
|
|
if (s1 != s2) {
|
|
|
|
if (u & GdkIMPreeditCallbacks)
|
|
|
|
return (s1 == GdkIMPreeditCallbacks)? style1:style2;
|
|
|
|
else if (u & GdkIMPreeditPosition)
|
|
|
|
return (s1 == GdkIMPreeditPosition)? style1:style2;
|
|
|
|
else if (u & GdkIMPreeditArea)
|
|
|
|
return (s1 == GdkIMPreeditArea)? style1:style2;
|
|
|
|
else if (u & GdkIMPreeditNothing)
|
|
|
|
return (s1 == GdkIMPreeditNothing)? style1:style2;
|
|
|
|
} else {
|
|
|
|
s1 = style1 & GdkIMStatusMask;
|
|
|
|
s2 = style2 & GdkIMStatusMask;
|
|
|
|
u = s1 | s2;
|
|
|
|
if ( u & GdkIMStatusCallbacks)
|
|
|
|
return (s1 == GdkIMStatusCallbacks)? style1:style2;
|
|
|
|
else if ( u & GdkIMStatusArea)
|
|
|
|
return (s1 == GdkIMStatusArea)? style1:style2;
|
|
|
|
else if ( u & GdkIMStatusNothing)
|
|
|
|
return (s1 == GdkIMStatusNothing)? style1:style2;
|
|
|
|
else if ( u & GdkIMStatusNone)
|
|
|
|
return (s1 == GdkIMStatusNone)? style1:style2;
|
|
|
|
}
|
1997-12-06 22:12:10 +00:00
|
|
|
return 0; /* Get rid of stupid warning */
|
1997-11-27 04:16:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GdkIMStyle
|
|
|
|
gdk_im_decide_style (GdkIMStyle supported_style)
|
|
|
|
{
|
|
|
|
gint i;
|
|
|
|
GdkIMStyle style, tmp;
|
|
|
|
|
|
|
|
g_return_val_if_fail (xim_styles != NULL, 0);
|
|
|
|
|
|
|
|
style = 0;
|
|
|
|
for (i=0; i<xim_styles->count_styles; i++)
|
|
|
|
{
|
|
|
|
tmp = xim_styles->supported_styles[i];
|
|
|
|
if (tmp == (tmp & supported_style & xim_best_allowed_style))
|
|
|
|
style = gdk_im_choose_better_style (style, tmp);
|
|
|
|
}
|
|
|
|
return style;
|
|
|
|
}
|
|
|
|
|
|
|
|
GdkIMStyle
|
|
|
|
gdk_im_set_best_style (GdkIMStyle style)
|
|
|
|
{
|
|
|
|
if (style & GdkIMPreeditMask)
|
|
|
|
{
|
|
|
|
xim_best_allowed_style &= ~GdkIMPreeditMask;
|
|
|
|
|
|
|
|
xim_best_allowed_style |= GdkIMPreeditNone;
|
|
|
|
if (!(style & GdkIMPreeditNone))
|
|
|
|
{
|
|
|
|
xim_best_allowed_style |= GdkIMPreeditNothing;
|
|
|
|
if (!(style & GdkIMPreeditNothing))
|
|
|
|
{
|
|
|
|
xim_best_allowed_style |= GdkIMPreeditArea;
|
|
|
|
if (!(style & GdkIMPreeditArea))
|
|
|
|
{
|
|
|
|
xim_best_allowed_style |= GdkIMPreeditPosition;
|
|
|
|
if (!(style & GdkIMPreeditPosition))
|
|
|
|
xim_best_allowed_style |= GdkIMPreeditCallbacks;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (style & GdkIMStatusMask)
|
|
|
|
{
|
|
|
|
xim_best_allowed_style &= ~GdkIMStatusMask;
|
|
|
|
|
|
|
|
xim_best_allowed_style |= GdkIMStatusNone;
|
|
|
|
if (!(style & GdkIMStatusNone))
|
|
|
|
{
|
|
|
|
xim_best_allowed_style |= GdkIMStatusNothing;
|
|
|
|
if (!(style & GdkIMStatusNothing))
|
|
|
|
{
|
|
|
|
xim_best_allowed_style |= GdkIMStatusArea;
|
|
|
|
if (!(style & GdkIMStatusArea))
|
|
|
|
xim_best_allowed_style |= GdkIMStatusCallbacks;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return xim_best_allowed_style;
|
|
|
|
}
|
|
|
|
|
1997-12-07 16:36:36 +00:00
|
|
|
static gint
|
|
|
|
gdk_im_open (XrmDatabase db, gchar* res_name, gchar* res_class)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
xim_im = XOpenIM (GDK_DISPLAY(), db, res_name, res_class);
|
|
|
|
if (xim_im == NULL)
|
|
|
|
{
|
1998-03-05 06:32:42 +00:00
|
|
|
GDK_NOTE (XIM, g_warning ("Unable to open open IM."));
|
1997-11-27 04:16:39 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
XGetIMValues (xim_im, XNQueryInputStyle, &xim_styles, NULL, NULL);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
1997-12-07 16:36:36 +00:00
|
|
|
static void
|
|
|
|
gdk_im_close (void)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
if (xim_im)
|
|
|
|
{
|
|
|
|
XCloseIM (xim_im);
|
|
|
|
xim_im = NULL;
|
|
|
|
}
|
|
|
|
if (xim_styles)
|
|
|
|
{
|
|
|
|
XFree (xim_styles);
|
|
|
|
xim_styles = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1997-12-07 16:36:36 +00:00
|
|
|
gint
|
|
|
|
gdk_im_ready (void)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
return (xim_im != NULL);
|
|
|
|
}
|
|
|
|
|
1997-12-07 16:36:36 +00:00
|
|
|
GdkIC
|
|
|
|
gdk_ic_new (GdkWindow* client_window,
|
|
|
|
GdkWindow* focus_window,
|
|
|
|
GdkIMStyle style, ...)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
va_list list;
|
|
|
|
GdkICPrivate *private;
|
|
|
|
XVaNestedList preedit_attr;
|
|
|
|
|
|
|
|
g_return_val_if_fail (client_window != NULL, NULL);
|
|
|
|
g_return_val_if_fail (focus_window != NULL, NULL);
|
|
|
|
g_return_val_if_fail (gdk_im_ready(), NULL);
|
|
|
|
|
|
|
|
private = g_new (GdkICPrivate, 1);
|
|
|
|
|
|
|
|
va_start (list, style);
|
|
|
|
preedit_attr = (XVaNestedList) & (va_arg (list, void *));
|
|
|
|
va_end (list);
|
|
|
|
|
|
|
|
private->style = gdk_im_decide_style (style);
|
|
|
|
if (private->style != style)
|
|
|
|
{
|
|
|
|
g_warning ("can not create input context with specified input style.");
|
|
|
|
g_free (private);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
private->xic = XCreateIC(gdk_im_get (),
|
|
|
|
XNInputStyle, style,
|
|
|
|
XNClientWindow, GDK_WINDOW_XWINDOW (client_window),
|
|
|
|
XNFocusWindow, GDK_WINDOW_XWINDOW (focus_window),
|
|
|
|
preedit_attr? XNPreeditAttributes : NULL, preedit_attr,
|
|
|
|
NULL);
|
|
|
|
if (!private->xic)
|
|
|
|
{
|
|
|
|
g_free (private);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
xim_ic_list = g_list_append (xim_ic_list, private);
|
|
|
|
return private;
|
|
|
|
}
|
|
|
|
|
1997-12-07 16:36:36 +00:00
|
|
|
void
|
|
|
|
gdk_ic_destroy (GdkIC ic)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
GdkICPrivate *private;
|
|
|
|
|
|
|
|
g_return_if_fail (ic != NULL);
|
|
|
|
|
|
|
|
private = (GdkICPrivate *) ic;
|
|
|
|
|
|
|
|
if (xim_ic == private)
|
|
|
|
gdk_im_end ();
|
|
|
|
|
|
|
|
XDestroyIC (private->xic);
|
|
|
|
xim_ic_list = g_list_remove (xim_ic_list, private);
|
1998-03-10 04:37:26 +00:00
|
|
|
g_free (private);
|
1997-11-27 04:16:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GdkIMStyle
|
|
|
|
gdk_ic_get_style (GdkIC ic)
|
|
|
|
{
|
|
|
|
GdkICPrivate *private;
|
|
|
|
|
|
|
|
g_return_val_if_fail (ic != NULL, 0);
|
|
|
|
|
|
|
|
private = (GdkICPrivate *) ic;
|
|
|
|
|
|
|
|
return private->style;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_ic_set_values (GdkIC ic, ...)
|
|
|
|
{
|
|
|
|
va_list list;
|
|
|
|
XVaNestedList args;
|
|
|
|
GdkICPrivate *private;
|
|
|
|
|
|
|
|
g_return_if_fail (ic != NULL);
|
|
|
|
|
|
|
|
private = (GdkICPrivate *) ic;
|
|
|
|
|
|
|
|
va_start (list, ic);
|
|
|
|
args = (XVaNestedList) & (va_arg (list, void *));
|
|
|
|
va_end (list);
|
|
|
|
|
|
|
|
XSetICValues (private->xic, XNVaNestedList, args, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_ic_get_values (GdkIC ic, ...)
|
|
|
|
{
|
|
|
|
va_list list;
|
|
|
|
XVaNestedList args;
|
|
|
|
GdkICPrivate *private;
|
|
|
|
|
|
|
|
g_return_if_fail (ic != NULL);
|
|
|
|
|
|
|
|
private = (GdkICPrivate *) ic;
|
|
|
|
|
|
|
|
va_start (list, ic);
|
|
|
|
args = (XVaNestedList) & (va_arg (list, void *));
|
|
|
|
va_end (list);
|
|
|
|
|
|
|
|
XGetICValues (private->xic, XNVaNestedList, args, NULL);
|
|
|
|
}
|
|
|
|
|
1997-12-07 16:36:36 +00:00
|
|
|
void
|
|
|
|
gdk_ic_set_attr (GdkIC ic, const char *target, ...)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
va_list list;
|
|
|
|
XVaNestedList attr;
|
|
|
|
GdkICPrivate *private;
|
|
|
|
|
|
|
|
g_return_if_fail (ic != NULL);
|
|
|
|
g_return_if_fail (target != NULL);
|
|
|
|
|
|
|
|
private = (GdkICPrivate *) ic;
|
|
|
|
|
|
|
|
va_start (list, target);
|
|
|
|
attr = (XVaNestedList) & (va_arg (list, void *));
|
|
|
|
va_end (list);
|
|
|
|
|
|
|
|
XSetICValues (private->xic, target, attr, NULL);
|
|
|
|
}
|
|
|
|
|
1997-12-07 16:36:36 +00:00
|
|
|
void
|
|
|
|
gdk_ic_get_attr (GdkIC ic, const char *target, ...)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
va_list list;
|
|
|
|
XVaNestedList attr;
|
|
|
|
GdkICPrivate *private;
|
|
|
|
|
|
|
|
g_return_if_fail (ic != NULL);
|
|
|
|
g_return_if_fail (target != NULL);
|
|
|
|
|
|
|
|
private = (GdkICPrivate *) ic;
|
|
|
|
|
|
|
|
va_start (list, target);
|
|
|
|
attr = (XVaNestedList) & (va_arg (list, void *));
|
|
|
|
va_end (list);
|
|
|
|
|
|
|
|
XGetICValues (private->xic, target, attr, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
GdkEventMask
|
|
|
|
gdk_ic_get_events (GdkIC ic)
|
|
|
|
{
|
|
|
|
GdkEventMask mask;
|
|
|
|
glong xmask;
|
|
|
|
glong bit;
|
|
|
|
GdkICPrivate *private;
|
|
|
|
gint i;
|
|
|
|
|
|
|
|
/* From gdkwindow.c */
|
|
|
|
extern int nevent_masks;
|
|
|
|
extern int event_mask_table[];
|
|
|
|
|
|
|
|
g_return_val_if_fail (ic != NULL, 0);
|
|
|
|
|
|
|
|
private = (GdkICPrivate *) ic;
|
|
|
|
|
1998-02-25 03:43:10 +00:00
|
|
|
if (XGetICValues (private->xic, XNFilterEvents, &xmask, NULL) != NULL)
|
|
|
|
{
|
|
|
|
GDK_NOTE (XIM, g_warning ("Call to XGetICValues: %s failed", XNFilterEvents));
|
|
|
|
return 0;
|
|
|
|
}
|
1997-11-27 04:16:39 +00:00
|
|
|
|
|
|
|
mask = 0;
|
|
|
|
for (i=0, bit=2; i < nevent_masks; i++, bit <<= 1)
|
|
|
|
if (xmask & event_mask_table [i])
|
|
|
|
{
|
|
|
|
mask |= bit;
|
|
|
|
xmask &= ~ event_mask_table [i];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (xmask)
|
1998-02-25 03:43:10 +00:00
|
|
|
g_warning ("ic requires events not supported by the application (%#04lx)", xmask);
|
1997-11-27 04:16:39 +00:00
|
|
|
|
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
1997-12-07 16:36:36 +00:00
|
|
|
static void
|
|
|
|
gdk_ic_cleanup (void)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
|
|
|
GList* node;
|
|
|
|
gint destroyed;
|
|
|
|
GdkICPrivate *private;
|
|
|
|
|
|
|
|
destroyed = 0;
|
|
|
|
for (node = xim_ic_list; node != NULL; node = node->next)
|
|
|
|
{
|
|
|
|
if (node->data)
|
|
|
|
{
|
|
|
|
private = (GdkICPrivate *) (node->data);
|
|
|
|
XDestroyIC (private->xic);
|
|
|
|
g_free (private);
|
|
|
|
destroyed++;
|
|
|
|
}
|
|
|
|
}
|
1998-02-19 18:02:03 +00:00
|
|
|
#ifdef G_ENABLE_DEBUG
|
1998-02-19 06:21:27 +00:00
|
|
|
if ((gdk_debug_flags & GDK_DEBUG_XIM) && destroyed > 0)
|
1997-11-27 04:16:39 +00:00
|
|
|
{
|
1998-02-19 06:21:27 +00:00
|
|
|
g_warning ("Cleaned up %i IC(s)\n", destroyed);
|
1997-11-27 04:16:39 +00:00
|
|
|
}
|
1998-02-19 18:02:03 +00:00
|
|
|
#endif /* G_ENABLE_DEBUG */
|
1997-11-27 04:16:39 +00:00
|
|
|
g_list_free(xim_ic_list);
|
|
|
|
xim_ic_list = NULL;
|
|
|
|
}
|
|
|
|
|
1997-12-07 16:36:36 +00:00
|
|
|
#else /* !USE_XIM */
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_im_begin (GdkIC ic, GdkWindow* window)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_im_end (void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
GdkIMStyle
|
|
|
|
gdk_im_decide_style (GdkIMStyle supported_style)
|
|
|
|
{
|
|
|
|
return GdkIMPreeditNone | GdkIMStatusNone;
|
|
|
|
}
|
|
|
|
|
|
|
|
GdkIMStyle
|
|
|
|
gdk_im_set_best_style (GdkIMStyle style)
|
|
|
|
{
|
|
|
|
return GdkIMPreeditNone | GdkIMStatusNone;
|
|
|
|
}
|
|
|
|
|
|
|
|
gint
|
|
|
|
gdk_im_ready (void)
|
|
|
|
{
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
GdkIC
|
|
|
|
gdk_ic_new (GdkWindow* client_window,
|
|
|
|
GdkWindow* focus_window,
|
|
|
|
GdkIMStyle style, ...)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_ic_destroy (GdkIC ic)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
GdkIMStyle
|
|
|
|
gdk_ic_get_style (GdkIC ic)
|
|
|
|
{
|
|
|
|
return GdkIMPreeditNone | GdkIMStatusNone;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_ic_set_values (GdkIC ic, ...)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_ic_get_values (GdkIC ic, ...)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_ic_set_attr (GdkIC ic, const char *target, ...)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_ic_get_attr (GdkIC ic, const char *target, ...)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
GdkEventMask
|
|
|
|
gdk_ic_get_events (GdkIC ic)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* USE_XIM */
|
|
|
|
|
1997-11-27 04:16:39 +00:00
|
|
|
#ifdef X_LOCALE
|
|
|
|
|
|
|
|
gint
|
|
|
|
_g_mbtowc (wchar_t *wstr, const char *str, size_t len)
|
|
|
|
{
|
|
|
|
static wchar_t wcs[MB_CUR_MAX + 1];
|
|
|
|
static gchar mbs[MB_CUR_MAX + 1];
|
|
|
|
|
|
|
|
wcs[0] = (wchar_t) NULL;
|
|
|
|
mbs[0] = '\0';
|
|
|
|
|
|
|
|
len = _Xmbstowcs (wcs, str, (len<MB_CUR_MAX)? len:MB_CUR_MAX);
|
|
|
|
if (len < 1)
|
|
|
|
return len;
|
|
|
|
else if (wcs[0] == (wchar_t) NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
len = _Xwctomb (mbs, wcs[0]);
|
|
|
|
if (mbs[0] == '\0')
|
|
|
|
return -1;
|
|
|
|
if (wstr)
|
|
|
|
*wstr = wcs[0];
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* X_LOCALE */
|
|
|
|
|
1997-11-24 22:37:52 +00:00
|
|
|
static void
|
|
|
|
gdk_dnd_drag_leave (Window dest)
|
|
|
|
{
|
|
|
|
XEvent sev;
|
|
|
|
GdkEventDropLeave tev;
|
|
|
|
int i;
|
|
|
|
GdkWindowPrivate *wp;
|
|
|
|
|
|
|
|
tev.u.allflags = 0;
|
|
|
|
|
|
|
|
tev.u.flags.protocol_version = DND_PROTOCOL_VERSION;
|
|
|
|
sev.xclient.type = ClientMessage;
|
|
|
|
sev.xclient.window = dest;
|
|
|
|
sev.xclient.format = 32;
|
|
|
|
sev.xclient.message_type = gdk_dnd.gdk_XdeLeave;
|
|
|
|
sev.xclient.data.l[1] = tev.u.allflags;
|
|
|
|
for (i = 0; i < gdk_dnd.drag_numwindows; i++)
|
|
|
|
{
|
|
|
|
wp = (GdkWindowPrivate *) gdk_dnd.drag_startwindows[i];
|
|
|
|
sev.xclient.data.l[0] = wp->xwindow;
|
1998-03-08 21:47:14 +00:00
|
|
|
if (!gdk_send_xevent (dest, False, NoEventMask, &sev))
|
|
|
|
GDK_NOTE (DND, g_print("Sending XdeLeave to %#lx failed\n",
|
|
|
|
dest));
|
1997-11-24 22:37:52 +00:00
|
|
|
wp->dnd_drag_accepted = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* when a drop occurs, we go through the list of windows being dragged and
|
|
|
|
* tell them that it has occurred, so that they can set things up and reply
|
|
|
|
* to 'dest' window
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
gdk_dnd_drag_end (Window dest,
|
|
|
|
GdkPoint coords)
|
|
|
|
{
|
|
|
|
GdkWindowPrivate *wp;
|
|
|
|
GdkEventDragRequest tev;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
tev.type = GDK_DRAG_REQUEST;
|
|
|
|
tev.drop_coords = coords;
|
|
|
|
tev.requestor = dest;
|
|
|
|
tev.u.allflags = 0;
|
|
|
|
tev.u.flags.protocol_version = DND_PROTOCOL_VERSION;
|
|
|
|
tev.isdrop = 1;
|
|
|
|
|
|
|
|
for (i = 0; i < gdk_dnd.drag_numwindows; i++)
|
|
|
|
{
|
|
|
|
wp = (GdkWindowPrivate *) gdk_dnd.drag_startwindows[i];
|
|
|
|
if (wp->dnd_drag_accepted)
|
|
|
|
{
|
|
|
|
tev.window = (GdkWindow *) wp;
|
|
|
|
tev.u.flags.delete_data = wp->dnd_drag_destructive_op;
|
1998-03-10 02:48:02 +00:00
|
|
|
tev.timestamp = gdk_dnd.last_drop_time;
|
1997-11-24 22:37:52 +00:00
|
|
|
tev.data_type =
|
|
|
|
gdk_atom_name(wp->dnd_drag_data_type);
|
|
|
|
|
|
|
|
gdk_event_put((GdkEvent *) &tev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static GdkAtom
|
|
|
|
gdk_dnd_check_types (GdkWindow *window,
|
|
|
|
XEvent *xevent)
|
|
|
|
{
|
|
|
|
GdkWindowPrivate *wp = (GdkWindowPrivate *) window;
|
|
|
|
int i, j;
|
|
|
|
GdkEventDropEnter event;
|
|
|
|
|
|
|
|
g_return_val_if_fail(window != NULL, 0);
|
|
|
|
g_return_val_if_fail(xevent != NULL, 0);
|
|
|
|
g_return_val_if_fail(xevent->type == ClientMessage, 0);
|
|
|
|
g_return_val_if_fail(xevent->xclient.message_type == gdk_dnd.gdk_XdeEnter, 0);
|
|
|
|
|
|
|
|
if(wp->dnd_drop_data_numtypesavail <= 0 ||
|
|
|
|
!wp->dnd_drop_data_typesavail)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (i = 2; i <= 4; i++)
|
|
|
|
{
|
|
|
|
for (j = 0; j < wp->dnd_drop_data_numtypesavail; j++)
|
|
|
|
{
|
|
|
|
if (xevent->xclient.data.l[i] == wp->dnd_drop_data_typesavail[j])
|
|
|
|
return xevent->xclient.data.l[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now we get the extended type list if it's available */
|
|
|
|
event.u.allflags = xevent->xclient.data.l[1];
|
|
|
|
if (event.u.flags.extended_typelist)
|
|
|
|
{
|
|
|
|
Atom *exttypes, realtype;
|
|
|
|
gulong nitems, nbar;
|
|
|
|
gint realfmt;
|
|
|
|
|
|
|
|
if (XGetWindowProperty(gdk_display, xevent->xclient.data.l[0],
|
|
|
|
gdk_dnd.gdk_XdeTypelist, 0L, LONG_MAX - 1,
|
|
|
|
False, AnyPropertyType, &realtype, &realfmt,
|
|
|
|
&nitems, &nbar, (unsigned char **) &exttypes)
|
|
|
|
!= Success)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (realfmt != (sizeof(Atom) * 8))
|
|
|
|
{
|
|
|
|
g_warning("XdeTypelist property had format of %d instead of the expected %d, on window %#lx\n",
|
|
|
|
realfmt, sizeof(Atom) * 8, xevent->xclient.data.l[0]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i <= nitems; i++)
|
|
|
|
{
|
|
|
|
for (j = 0; j < wp->dnd_drop_data_numtypesavail; j++)
|
|
|
|
{
|
|
|
|
if (exttypes[i] == wp->dnd_drop_data_typesavail[j])
|
|
|
|
{
|
|
|
|
XFree (exttypes);
|
|
|
|
return exttypes[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
XFree (exttypes);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* used for debugging only
|
|
|
|
*/
|
1997-12-06 22:12:10 +00:00
|
|
|
#ifdef DEBUG_DND
|
1997-11-24 22:37:52 +00:00
|
|
|
static void
|
|
|
|
gdk_print_atom (GdkAtom anatom)
|
|
|
|
{
|
|
|
|
gchar *tmpstr = NULL;
|
|
|
|
tmpstr = (anatom!=None)?gdk_atom_name(anatom):"(none)";
|
|
|
|
g_print("Atom %lu has name %s\n", anatom, tmpstr);
|
|
|
|
if(tmpstr)
|
|
|
|
g_free(tmpstr);
|
|
|
|
}
|
1997-12-06 22:12:10 +00:00
|
|
|
#endif
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* used only by below routine and itself
|
|
|
|
*/
|
|
|
|
static Window
|
|
|
|
getchildren (Display *dpy,
|
|
|
|
Window win,
|
|
|
|
Atom WM_STATE)
|
|
|
|
{
|
|
|
|
Window root, parent, *children, inf = 0;
|
|
|
|
Atom type = None;
|
|
|
|
unsigned int nchildren, i;
|
|
|
|
int format;
|
|
|
|
unsigned long nitems, after;
|
|
|
|
unsigned char *data;
|
|
|
|
|
|
|
|
if (XQueryTree(dpy, win, &root, &parent, &children, &nchildren) == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (i = 0; !inf && (i < nchildren); i++)
|
|
|
|
{
|
|
|
|
XGetWindowProperty (dpy, children[i], WM_STATE, 0, 0, False,
|
|
|
|
AnyPropertyType, &type, &format, &nitems,
|
|
|
|
&after, &data);
|
|
|
|
if (type != 0)
|
|
|
|
inf = children[i];
|
1997-11-28 06:47:01 +00:00
|
|
|
XFree(data);
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; !inf && (i < nchildren); i++)
|
|
|
|
inf = getchildren (dpy, children[i], WM_STATE);
|
|
|
|
|
1997-11-28 06:47:01 +00:00
|
|
|
if (children != None)
|
1997-11-24 22:37:52 +00:00
|
|
|
XFree ((char *) children);
|
|
|
|
|
|
|
|
return inf;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* find a window with WM_STATE, else return win itself, as per ICCCM
|
|
|
|
*
|
|
|
|
* modification of the XmuClientWindow() routine from X11R6.3
|
|
|
|
*/
|
|
|
|
Window
|
|
|
|
gdk_get_client_window (Display *dpy,
|
|
|
|
Window win)
|
|
|
|
{
|
|
|
|
Atom WM_STATE;
|
|
|
|
Atom type = None;
|
|
|
|
int format;
|
|
|
|
unsigned long nitems, after;
|
|
|
|
unsigned char *data;
|
|
|
|
Window inf;
|
|
|
|
|
|
|
|
if (win == 0)
|
|
|
|
return DefaultRootWindow(dpy);
|
|
|
|
|
|
|
|
if ((WM_STATE = XInternAtom (dpy, "WM_STATE", True)) == 0)
|
|
|
|
return win;
|
|
|
|
|
|
|
|
XGetWindowProperty (dpy, win, WM_STATE, 0, 0, False, AnyPropertyType,
|
|
|
|
&type, &format, &nitems, &after, &data);
|
|
|
|
if (type)
|
|
|
|
return win;
|
|
|
|
|
|
|
|
inf = getchildren (dpy, win, WM_STATE);
|
|
|
|
|
|
|
|
if (inf == 0)
|
|
|
|
return win;
|
|
|
|
else
|
|
|
|
return inf;
|
|
|
|
}
|
|
|
|
|
1997-12-06 22:12:10 +00:00
|
|
|
#ifdef WE_HAVE_MOTIF_DROPS_DONE
|
1997-11-24 22:37:52 +00:00
|
|
|
static GdkWindow *
|
|
|
|
gdk_drop_get_real_window (GdkWindow *w,
|
|
|
|
guint16 *x,
|
|
|
|
guint16 *y)
|
|
|
|
{
|
|
|
|
GdkWindow *retval = w;
|
|
|
|
GdkWindowPrivate *awin;
|
|
|
|
GList *children;
|
|
|
|
gint16 myx = *x, myy = *y;
|
|
|
|
|
|
|
|
g_return_val_if_fail(w != NULL && x != NULL && y != NULL, NULL);
|
|
|
|
|
|
|
|
myx = *x;
|
|
|
|
myy = *y;
|
|
|
|
|
|
|
|
descend:
|
|
|
|
for (children = gdk_window_get_children(retval);
|
|
|
|
children && children->next;
|
|
|
|
children = children->next)
|
|
|
|
{
|
|
|
|
awin = (GdkWindowPrivate *) children->data;
|
|
|
|
if ((myx >= awin->x) && (myy >= awin->y)
|
|
|
|
&& (myx < (awin->x + awin->width))
|
|
|
|
&& (myy < (awin->y + awin->height)))
|
|
|
|
{
|
|
|
|
retval = (GdkWindow *) awin;
|
|
|
|
myx -= awin->x;
|
|
|
|
myy -= awin->y;
|
|
|
|
goto descend;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*x = myx;
|
|
|
|
*y = myy;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
1997-12-06 22:12:10 +00:00
|
|
|
#endif
|
1997-11-24 22:37:52 +00:00
|
|
|
|
|
|
|
/* Sends a ClientMessage to all toplevel client windows */
|
|
|
|
void
|
|
|
|
gdk_event_send_clientmessage_toall(GdkEvent *event)
|
|
|
|
{
|
|
|
|
XEvent sev;
|
|
|
|
Window *ret_children, ret_root, ret_parent, curwin;
|
|
|
|
unsigned int ret_nchildren;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
g_return_if_fail(event != NULL);
|
|
|
|
|
|
|
|
/* Set up our event to send, with the exception of its target window */
|
|
|
|
sev.xclient.type = ClientMessage;
|
|
|
|
sev.xclient.display = gdk_display;
|
|
|
|
sev.xclient.format = event->client.data_format;
|
|
|
|
sev.xclient.serial = CurrentTime;
|
|
|
|
memcpy(&sev.xclient.data, &event->client.data, sizeof(sev.xclient.data));
|
|
|
|
sev.xclient.message_type = event->client.message_type;
|
|
|
|
|
|
|
|
/* OK, we're all set, now let's find some windows to send this to */
|
|
|
|
if(XQueryTree(gdk_display, gdk_root_window, &ret_root, &ret_parent,
|
|
|
|
&ret_children, &ret_nchildren) != True)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* foreach true child window of the root window, send an event to it */
|
|
|
|
for(i = 0; i < ret_nchildren; i++) {
|
|
|
|
curwin = gdk_get_client_window(gdk_display, ret_children[i]);
|
|
|
|
sev.xclient.window = curwin;
|
1998-03-08 21:47:14 +00:00
|
|
|
if (!gdk_send_xevent (curwin, False, NoEventMask, &sev))
|
|
|
|
GDK_NOTE (MISC, g_print("Sending client message %ld to %#lx failed\n",
|
|
|
|
event->client.message_type, curwin));
|
1997-11-24 22:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
XFree(ret_children);
|
|
|
|
}
|
1997-12-17 22:40:07 +00:00
|
|
|
|
|
|
|
gchar *
|
|
|
|
gdk_get_display(void)
|
|
|
|
{
|
|
|
|
return (gchar *)XDisplayName (gdk_display_name);
|
|
|
|
}
|
1998-03-08 21:47:14 +00:00
|
|
|
|
|
|
|
gint
|
|
|
|
gdk_send_xevent (Window window, gboolean propagate, glong event_mask,
|
|
|
|
XEvent *event_send)
|
|
|
|
{
|
|
|
|
Status result;
|
|
|
|
|
|
|
|
gdk_error_code = 0;
|
|
|
|
|
|
|
|
gdk_error_warnings = 0;
|
|
|
|
result = XSendEvent (gdk_display, window, propagate, event_mask, event_send);
|
|
|
|
XSync (gdk_display, False);
|
|
|
|
gdk_error_warnings = 1;
|
|
|
|
|
|
|
|
return result && (gdk_error_code != -1);
|
|
|
|
}
|