diff options
Diffstat (limited to 'gdk')
57 files changed, 24318 insertions, 0 deletions
diff --git a/gdk/.cvsignore b/gdk/.cvsignore new file mode 100644 index 000000000..79680c82c --- /dev/null +++ b/gdk/.cvsignore @@ -0,0 +1,6 @@ +*.lo +Makefile +.deps +_libs +libgdk.la + diff --git a/gdk/Makefile.am b/gdk/Makefile.am new file mode 100644 index 000000000..f298e2c3a --- /dev/null +++ b/gdk/Makefile.am @@ -0,0 +1,75 @@ +## Process this file with automake to produce Makefile.in + +gdkincludedir = $(includedir)/gdk + +lib_LTLIBRARIES = libgdk.la + +libgdk_la_SOURCES = \ + gdk.c \ + gdkcolor.c \ + gdkcursor.c \ + gdkdraw.c \ + gdkfont.c \ + gdkgc.c \ + gdkglobals.c \ + gdkimage.c \ + gdkinput.c \ + gdkpixmap.c \ + gdkproperty.c \ + gdkrectangle.c \ + gdkselection.c \ + gdkvisual.c \ + gdkwindow.c \ + gdkxid.c \ + gxid_lib.c +## this last one is ifdef'd out unless XINPUT_GXI is defined +## It's easier than trying to get automake to handle compiling +## it conditionally + +gdkinclude_HEADERS = \ + gdk.h \ + gdkcursors.h \ + gdkkeysyms.h \ + gdkprivate.h \ + gdktypes.h \ + gdkinput.h \ + gdkinputnone.h \ + gdkinputcommon.h\ + gdkinputgxi.h \ + gdkinputxfree.h \ + gxid_lib.h \ + gxid_proto.h \ + gdkx.h + +libgdk_la_LDFLAGS = -version-info 1:0:0 \ + @x_ldflags@ @x_libs@ + +INCLUDES = -I$(top_srcdir) -I$(top_srcdir)/glib @x_cflags@ + +EXTRA_PROGRAMS = gxid + +bin_PROGRAMS = @xinput_progs@ + +gxid_SOURCES = gxid.c + +gxid_LDADD = \ + @x_ldflags@ \ + @x_libs@ \ + -lm + +BUILT_SOURCES = gdkcursors.h gdkkeysyms.h + +EXTRA_DIST = makecursors makecursors.sed makekeysyms makekeysyms.sed + +gdkcursors.h: + $(srcdir)/makecursors @x_includes@/X11/cursorfont.h > $@ + +gdkkeysyms.h: + $(srcdir)/makekeysyms @x_includes@/X11/keysymdef.h > $@ + +.PHONY: files + +files: + @files=`ls $(DISTFILES) 2> /dev/null `; for p in $$files; do \ + echo $$p; \ + done diff --git a/gdk/gdk.c b/gdk/gdk.c new file mode 100644 index 000000000..d5f85dd1e --- /dev/null +++ b/gdk/gdk.c @@ -0,0 +1,2897 @@ +/* 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" + +#include <ctype.h> +#include <locale.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <limits.h> + +#ifdef HAVE_SYS_SELECT_H +#include <sys/select.h> +#endif /* HAVE_SYS_SELECT_H_ */ + +#define XLIB_ILLEGAL_ACCESS +#include <X11/Xatom.h> +#include <X11/Xlib.h> +#include <X11/Xos.h> +#include <X11/Xutil.h> +#include <X11/Xmu/WinUtil.h> +#include <X11/cursorfont.h> +#include "gdk.h" +#include "gdkprivate.h" +#include "gdkinput.h" + + +#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; +}; + +struct _GdkPredicate +{ + GdkEventFunc func; + gpointer data; +}; + +/* + * Private function declarations + */ +static gint gdk_event_wait (void); +static gint gdk_event_translate (GdkEvent *event, + XEvent *xevent); +static Bool gdk_event_get_type (Display *display, + XEvent *xevent, + XPointer arg); +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); +static void gdk_dnd_drag_end (Window dest, + GdkPoint coords); +static GdkAtom gdk_dnd_check_types (GdkWindow *window, + XEvent *xevent); +static void gdk_print_atom (GdkAtom anatom); + +/* + * old junk from offix, we might use it though so leave it + */ +static Window gdk_drop_get_client_window (Display *dpy, + Window win); +static GdkWindow * gdk_drop_get_real_window (GdkWindow *w, + guint16 *x, + guint16 *y); +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); + + +/* 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 gint received_destroy_notify = FALSE; /* Did we just receive a destroy notify + * event? If so, we need to actually + * destroy the window which received + * it now. + */ +static GdkWindow *window_to_destroy = NULL; /* If we previously received a destroy + * notify event then this is the window + * which received that event. + */ + +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. + */ + +#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; + + +/* + *-------------------------------------------------------------- + * 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; + int synchronize; + int i, j, k; + XClassHint *class_hint; + int argc_orig = *argc; + char **argv_orig; + + argv_orig = malloc ((argc_orig + 1) * sizeof (char*)); + for (i = 0; i < argc_orig; i++) + argv_orig[i] = g_strdup ((*argv)[i]); + argv_orig[argc_orig] = NULL; + + X_GETTIMEOFDAY (&start); + + 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); + + gdk_display_name = NULL; + + XSetErrorHandler (gdk_x_error); + XSetIOErrorHandler (gdk_x_io_error); + + synchronize = FALSE; + + if (argc && argv) + { + if (*argc > 0) + gdk_progname = (*argv)[0]; + + for (i = 1; i < *argc;) + { + if (strcmp ("--display", (*argv)[i]) == 0) + { + (*argv)[i] = NULL; + + if ((i + 1) < *argc) + { + gdk_display_name = g_strdup ((*argv)[i + 1]); + (*argv)[i + 1] = NULL; + i += 1; + } + } + else if (strcmp ("--sync", (*argv)[i]) == 0) + { + (*argv)[i] = NULL; + synchronize = TRUE; + } + else if (strcmp ("--show-events", (*argv)[i]) == 0) + { + (*argv)[i] = NULL; + gdk_show_events = TRUE; + } + else if (strcmp ("--no-show-events", (*argv)[i]) == 0) + { + (*argv)[i] = NULL; + gdk_show_events = FALSE; + } + else if (strcmp ("--no-xshm", (*argv)[i]) == 0) + { + (*argv)[i] = NULL; + gdk_use_xshm = FALSE; + } + else if (strcmp ("--debug-level", (*argv)[i]) == 0) + { + if ((i + 1) < *argc) + { + (*argv)[i++] = NULL; + gdk_debug_level = atoi ((*argv)[i]); + (*argv)[i] = NULL; + } + } + else if (strcmp ("-name", (*argv)[i]) == 0) + { + if ((i + 1) < *argc) + { + (*argv)[i++] = NULL; + gdk_progname = (*argv)[i]; + (*argv)[i] = NULL; + } + } + else if (strcmp ("-class", (*argv)[i]) == 0) + { + if ((i + 1) < *argc) + { + (*argv)[i++] = NULL; + gdk_progclass = (*argv)[i]; + (*argv)[i] = NULL; + } + } +#ifdef XINPUT_GXI + else if (strcmp ("--gxid_host", (*argv)[i]) == 0) + { + if ((i + 1) < *argc) + { + (*argv)[i++] = NULL; + gdk_input_gxid_host = ((*argv)[i]); + (*argv)[i] = NULL; + } + } + else if (strcmp ("--gxid_port", (*argv)[i]) == 0) + { + if ((i + 1) < *argc) + { + (*argv)[i++] = NULL; + gdk_input_gxid_port = atoi ((*argv)[i]); + (*argv)[i] = NULL; + } + } +#endif + 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) + g_error ("cannot open display: %s", XDisplayName (gdk_display_name)); + + /* 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; + if (gdk_show_events) + g_print ("base id: %lu\n", base_id); + + connection_number = ConnectionNumber (gdk_display); + if (gdk_debug_level >= 1) + g_print ("connection number: %d\n", connection_number); + + 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; + 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); + + 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); + gdk_dnd.gdk_cursor_dragdefault = XCreateFontCursor(gdk_display, XC_bogosity); + gdk_dnd.gdk_cursor_dragok = XCreateFontCursor(gdk_display, XC_heart); + + 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 (); + + 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 () +{ + return XPending (gdk_display); +} + +/* + *-------------------------------------------------------------- + * gdk_event_get + * + * Gets the next event. + * + * Arguments: + * "event" is used to hold the received event. + * If "event" is NULL an event is received as normal + * however it is not placed in "event" (and thus no + * error occurs). + * + * Results: + * Returns TRUE if an event was received that we care about + * and FALSE otherwise. This function will also return + * before an event is received if the timeout interval + * runs out. + * + * Side effects: + * + *-------------------------------------------------------------- + */ + +gint +gdk_event_get (GdkEvent *event, + GdkEventFunc pred, + gpointer data) +{ + GdkEvent *temp_event; + GdkPredicate event_pred; + GList *temp_list; + XEvent xevent; + + /* If the last event we received was a destroy notify + * event then we will actually destroy the "gdk" data + * structures now. We don't want to destroy them at the + * time of receiving the event since the main program + * may try to access them and may need to destroy user + * data that has been attached to the window + */ + if (received_destroy_notify) + { + if (gdk_show_events) + g_print ("destroying window:\twindow: %ld\n", + ((GdkWindowPrivate*) window_to_destroy)->xwindow - base_id); + + gdk_window_real_destroy (window_to_destroy); + received_destroy_notify = FALSE; + window_to_destroy = NULL; + } + + /* Initially we haven't received an event and want to + * return FALSE. If "event" is non-NULL, then initialize + * it to the nothing event. + */ + if (event) + { + event->any.type = GDK_NOTHING; + event->any.window = NULL; + event->any.send_event = FALSE; + } + + 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; + + if (XCheckIfEvent (gdk_display, &xevent, gdk_event_get_type, (XPointer) &event_pred)) + if (event) + return gdk_event_translate (event, &xevent); + } + else + { + if (putback_events) + { + temp_event = putback_events->data; + *event = *temp_event; + + temp_list = putback_events; + putback_events = putback_events->next; + if (putback_events) + putback_events->prev = NULL; + + temp_list->next = NULL; + temp_list->prev = NULL; + g_list_free (temp_list); + g_free (temp_event); + + return TRUE; + } + + /* 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. + */ + XNextEvent (gdk_display, &xevent); + + event->any.send_event = xevent.xany.send_event; + + /* If "event" non-NULL. + */ + if (event) + return gdk_event_translate (event, &xevent); + } + } + + return FALSE; +} + +void +gdk_event_put (GdkEvent *event) +{ + GdkEvent *new_event; + + g_return_if_fail (event != NULL); + + new_event = g_new (GdkEvent, 1); + *new_event = *event; + + 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; + +GdkEvent* +gdk_event_copy (GdkEvent *event) +{ + GdkEvent *new_event; + + g_return_val_if_fail (event != NULL, NULL); + + 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); + *new_event = *event; + gdk_window_ref (new_event->any.window); + 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); + + gdk_window_unref (event->any.window); + g_mem_chunk_free (event_chunk, event); +} + +/* + *-------------------------------------------------------------- + * gdk_set_debug_level + * + * Sets the debugging level. + * + * Arguments: + * "level" is the new debugging level. + * + * Results: + * + * Side effects: + * Other function calls to "gdk" use the debugging + * level to determine what kind of debugging information + * to print out. + * + *-------------------------------------------------------------- + */ + +void +gdk_set_debug_level (int level) +{ + gdk_debug_level = level; +} + +/* + *-------------------------------------------------------------- + * 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) +{ + gdk_show_events = show_events; +} + +void +gdk_set_use_xshm (gint use_xshm) +{ + gdk_use_xshm = use_xshm; +} + +gint +gdk_get_debug_level () +{ + return gdk_debug_level; +} + +gint +gdk_get_show_events () +{ + return gdk_show_events; +} + +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 +gdk_input_add (gint source, + GdkInputCondition condition, + GdkInputFunction function, + gpointer data) +{ + 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)) + { + input->function = function; + input->data = data; + 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; + tag = input->tag; + + inputs = g_list_prepend (inputs, input); + } + + return tag; +} + +void +gdk_input_remove (gint tag) +{ + GList *list; + GList *temp_list; + GdkInput *input; + + list = inputs; + while (list) + { + input = list->data; + + if (input->tag == tag) + { + 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; + + if (!confine_to) + 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 + return_val = Success;; + + if (return_val == Success) + return_val = XGrabPointer (window_private->xdisplay, + xwindow, + owner_events, + xevent_mask, + GrabModeAsync, GrabModeAsync, + xconfine_to, + xcursor, + time); + + 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); +} + +/* + *-------------------------------------------------------------- + * 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; + + return XGrabKeyboard (window_private->xdisplay, + xwindow, + owner_events, + GrabModeAsync, GrabModeAsync, + time); +} + +/* + *-------------------------------------------------------------- + * 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; +} + +static gint +gdk_event_translate (GdkEvent *event, + XEvent *xevent) +{ + + GdkWindow *window; + GdkWindowPrivate *window_private; + XComposeStatus compose; + int charcount; + char buf[16]; + gint return_val; + + /* Are static variables used for this purpose thread-safe? */ + static GdkPoint dnd_drag_start = {0,0}, + dnd_drag_oldpos = {0,0}; + static GdkRectangle dnd_drag_dropzone = {0,0,0,0}; + static gint dnd_drag_perhaps = 0; + static GdkWindowPrivate *real_sw = NULL; + static Window dnd_drag_curwin = None, dnd_drag_target = None; + + 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; + + /* 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. + */ + charcount = XLookupString (&xevent->xkey, buf, 16, + (KeySym*) &event->key.keyval, + &compose); + + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("key press:\t\twindow: %ld key: %12s %d\n", + xevent->xkey.window - base_id, + XKeysymToString (event->key.keyval), + event->key.keyval); + + event->key.type = GDK_KEY_PRESS; + event->key.window = window; + event->key.time = xevent->xkey.time; + event->key.state = (GdkModifierType) xevent->xkey.state; + + return_val = !window_private->destroyed; + 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. + */ + if (gdk_show_events) + g_print ("key release:\t\twindow: %ld key: %12s %d\n", + xevent->xkey.window - base_id, + XKeysymToString (event->key.keyval), + event->key.keyval); + + event->key.type = GDK_KEY_RELEASE; + event->key.window = window; + event->key.time = xevent->xkey.time; + event->key.state = (GdkModifierType) xevent->xkey.state; + + return_val = !window_private->destroyed; + break; + + case ButtonPress: + /* Print debugging info. + */ + if (gdk_show_events) + 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, + xevent->xbutton.button); + + 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; + 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 + && !dnd_drag_perhaps + && !gdk_dnd.drag_really) + { + dnd_drag_perhaps = 1; + dnd_drag_start.x = xevent->xbutton.x_root; + dnd_drag_start.y = xevent->xbutton.y_root; + real_sw = window_private; + + 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; + + { + /* Set motion mask for first DnD'd window, since it + will be the one that is actually dragged */ + XWindowAttributes dnd_winattr; + XSetWindowAttributes dnd_setwinattr; + Status rv; + + /* 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 = + window_private->dnd_drag_eventmask = ButtonMotionMask; + XChangeWindowAttributes(gdk_display, window_private->xwindow, + CWEventMask, &dnd_setwinattr); + } + } + return_val = window_private?(!window_private->destroyed):FALSE; + break; + + case ButtonRelease: + /* Print debugging info. + */ + if (gdk_show_events) + 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, + xevent->xbutton.button); + + 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; + 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(dnd_drag_perhaps) + { + if(gdk_dnd.drag_really) + { + GdkPoint foo = {xevent->xbutton.x_root, + xevent->xbutton.y_root}; + XUngrabPointer(gdk_display, CurrentTime); + + if(dnd_drag_target != None) + gdk_dnd_drag_end(dnd_drag_target, foo); + gdk_dnd.drag_really = 0; + + if(gdk_dnd.drag_numwindows) + { + XSetWindowAttributes attrs; + /* Reset event mask to pre-drag value, assuming event_mask + doesn't change during drag */ + attrs.event_mask = real_sw->dnd_drag_savedeventmask; + XChangeWindowAttributes(gdk_display, real_sw->xwindow, + CWEventMask, &attrs); + } + + gdk_dnd.drag_numwindows = 0; + if(gdk_dnd.drag_startwindows) + { + g_free(gdk_dnd.drag_startwindows); + gdk_dnd.drag_startwindows = NULL; + } + + real_sw = NULL; + } + + dnd_drag_perhaps = 0; + dnd_drag_start.x = dnd_drag_start.y = 0; + dnd_drag_dropzone.x = dnd_drag_dropzone.y = 0; + dnd_drag_dropzone.width = dnd_drag_dropzone.height = 0; + dnd_drag_curwin = None; + } + return_val = window ? (!window_private->destroyed) : FALSE; + break; + + case MotionNotify: + /* Print debugging info. + */ + if (gdk_show_events) + 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", + dnd_drag_perhaps, gdk_dnd.drag_really); + + 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; + 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; + +#define IS_IN_ZONE(cx, cy) (cx >= dnd_drag_dropzone.x \ + && cy >= dnd_drag_dropzone.y \ + && cx < (dnd_drag_dropzone.x + dnd_drag_dropzone.width) \ + && cy < (dnd_drag_dropzone.y + dnd_drag_dropzone.height)) + + if(dnd_drag_perhaps && gdk_dnd.drag_really) + { + /* 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 */ + Window curwin, childwin = gdk_root_window, rootwinret; + int x, y; + unsigned int mask; + while(childwin != None) + { + curwin = childwin; + XQueryPointer(gdk_display, curwin, &rootwinret, &childwin, + &x, &y, &x, &y, &mask); + } + if(curwin != dnd_drag_curwin) + { + /* We have left one window and entered another + (do leave & enter bits) */ + if(dnd_drag_curwin != real_sw->xwindow && dnd_drag_curwin != None) + gdk_dnd_drag_leave(dnd_drag_curwin); + dnd_drag_curwin = curwin; + gdk_dnd_drag_enter(dnd_drag_curwin); + dnd_drag_dropzone.x = dnd_drag_dropzone.y = 0; + dnd_drag_dropzone.width = dnd_drag_dropzone.height = 0; + dnd_drag_target = None; + XChangeActivePointerGrab(gdk_display, + ButtonMotionMask | + ButtonPressMask | ButtonReleaseMask | + EnterWindowMask | LeaveWindowMask, + gdk_dnd.gdk_cursor_dragdefault, + CurrentTime); + } + else if(dnd_drag_dropzone.width > 0 + && dnd_drag_dropzone.height > 0) + { + /* Handle all that dropzone stuff - thanks John ;-) */ + if(dnd_drag_target != None + && IS_IN_ZONE(dnd_drag_oldpos.x, dnd_drag_oldpos.y) + && !IS_IN_ZONE(xevent->xmotion.x_root, + xevent->xmotion.y_root)) + { + /* We were in the drop zone and moved out */ + dnd_drag_target = None; + gdk_dnd_drag_leave(curwin); + } + else + { + /* We were outside drop zone but in the window + - have to send enter events */ + gdk_dnd_drag_enter(curwin); + dnd_drag_curwin = curwin; + dnd_drag_dropzone.x = dnd_drag_dropzone.y = 0; + dnd_drag_target = None; + } + } else + dnd_drag_curwin = None; + return_val = FALSE; + } + else + return_val = window?(!window_private->destroyed):FALSE; + break; + + case EnterNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("enter notify:\t\twindow: %ld detail: %d subwin: %ld\n", + xevent->xcrossing.window - base_id, + xevent->xcrossing.detail, + xevent->xcrossing.subwindow - base_id); + + /* 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; + } + + if(dnd_drag_perhaps + && gdk_dnd.drag_really + && xevent->xcrossing.window == real_sw->xwindow) + { + gdk_dnd.drag_really = 0; + XUngrabPointer(gdk_display, CurrentTime); + } + + return_val = (window ? !window_private->destroyed : FALSE); + break; + + case LeaveNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("leave notify:\t\twindow: %ld detail: %d subwin: %ld\n", + xevent->xcrossing.window - base_id, + xevent->xcrossing.detail, xevent->xcrossing.subwindow - base_id); + + event->crossing.type = GDK_LEAVE_NOTIFY; + event->crossing.window = window; + + /* 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; + } + if(dnd_drag_perhaps + && !gdk_dnd.drag_really) + { + gdk_dnd_drag_addwindow((GdkWindow *) real_sw); + gdk_dnd_drag_begin((GdkWindow *) real_sw); + XGrabPointer(gdk_display, real_sw->xwindow, False, + ButtonMotionMask | + ButtonPressMask | ButtonReleaseMask | + EnterWindowMask | LeaveWindowMask, + GrabModeAsync, GrabModeAsync, gdk_root_window, + gdk_dnd.gdk_cursor_dragdefault, CurrentTime); + gdk_dnd.drag_really = 1; + } + return_val = window ? (!window_private->destroyed) : FALSE; + break; + + case FocusIn: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("focus in:\t\twindow: %ld\n", + xevent->xfocus.window - base_id); + + event->focus_change.type = GDK_FOCUS_CHANGE; + event->focus_change.window = window; + event->focus_change.in = TRUE; + + return_val = !window_private->destroyed; + break; + + case FocusOut: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("focus out:\t\twindow: %ld\n", + xevent->xfocus.window - base_id); + + event->focus_change.type = GDK_FOCUS_CHANGE; + event->focus_change.window = window; + event->focus_change.in = FALSE; + + return_val = !window_private->destroyed; + break; + + case KeymapNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("keymap notify\n"); + + /* Not currently handled */ + break; + + case Expose: + /* Print debugging info. + */ + if (gdk_show_events) + 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, + xevent->xexpose.width, xevent->xexpose.height); + + 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; + + return_val = !window_private->destroyed; + break; + + case GraphicsExpose: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("graphics expose:\tdrawable: %ld\n", + xevent->xgraphicsexpose.drawable - base_id); + + 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; + + return_val = !window_private->destroyed; + break; + + case NoExpose: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("no expose:\t\tdrawable: %ld\n", + xevent->xnoexpose.drawable - base_id); + + /* Not currently handled */ + break; + + case VisibilityNotify: + /* Print debugging info. + */ + if (gdk_show_events) + 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; + } + + /* Not currently handled */ + break; + + case CreateNotify: + /* Not currently handled */ + break; + + case DestroyNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("destroy notify:\twindow: %ld\n", + xevent->xdestroywindow.window - base_id); + + event->any.type = GDK_DESTROY; + event->any.window = window; + + /* Remeber which window received the destroy notify + * event so that we can destroy our associated + * data structures the next time the user asks + * us for an event. + */ + received_destroy_notify = TRUE; + window_to_destroy = window; + + return_val = !window_private->destroyed; + break; + + case UnmapNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("unmap notify:\t\twindow: %ld\n", + xevent->xmap.window - base_id); + + event->any.type = GDK_UNMAP; + event->any.window = window; + + return_val = !window_private->destroyed; + break; + + case MapNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("map notify:\t\twindow: %ld\n", + xevent->xmap.window - base_id); + + event->any.type = GDK_MAP; + event->any.window = window; + + return_val = !window_private->destroyed; + break; + + case ReparentNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("reparent notify:\twindow: %ld\n", + xevent->xreparent.window - base_id); + + /* Not currently handled */ + break; + + case ConfigureNotify: + /* Print debugging info. + */ + while ((XPending(gdk_display) > 0) && + XCheckTypedWindowEvent(gdk_display, xevent->xany.window, + ConfigureNotify, xevent)) + /*XSync(gdk_display, 0)*/; + + if (gdk_show_events) + g_print ("configure notify:\twindow: %ld x,y: %d %d w,h: %d %d\n", + xevent->xconfigure.window - base_id, + xevent->xconfigure.x, xevent->xconfigure.y, + xevent->xconfigure.width, xevent->xconfigure.height); + + if (window_private && + (window_private->extension_events != 0) && + gdk_input_vtable.configure_event) + gdk_input_vtable.configure_event (&xevent->xconfigure, window); + + if ((window_private->window_type != GDK_WINDOW_CHILD) && + ((window_private->width != xevent->xconfigure.width) || + (window_private->height != xevent->xconfigure.height))) + { + event->configure.type = GDK_CONFIGURE; + event->configure.window = window; + event->configure.x = xevent->xconfigure.x; + event->configure.y = xevent->xconfigure.y; + event->configure.width = xevent->xconfigure.width; + event->configure.height = xevent->xconfigure.height; + + window_private->x = xevent->xconfigure.x; + window_private->y = xevent->xconfigure.y; + window_private->width = xevent->xconfigure.width; + window_private->height = xevent->xconfigure.height; + if (window_private->resize_count > 1) + window_private->resize_count -= 1; + + return_val = !window_private->destroyed; + } + break; + + case PropertyNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("property notify:\twindow: %ld\n", + xevent->xproperty.window - base_id); + + 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; + + return_val = !window_private->destroyed; + break; + + case SelectionClear: + if (gdk_show_events) + g_print ("selection clear:\twindow: %ld\n", + xevent->xproperty.window - base_id); + + event->selection.type = GDK_SELECTION_CLEAR; + event->selection.window = window; + event->selection.selection = xevent->xselectionclear.selection; + event->selection.time = xevent->xselectionclear.time; + + return_val = !((GdkWindowPrivate*) window)->destroyed; + break; + + case SelectionRequest: + if (gdk_show_events) + g_print ("selection request:\twindow: %ld\n", + xevent->xproperty.window - base_id); + + 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; + + return_val = !((GdkWindowPrivate*) window)->destroyed; + break; + + case SelectionNotify: + if (gdk_show_events) + g_print ("selection notify:\twindow: %ld\n", + xevent->xproperty.window - base_id); + + + 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; + + return_val = !((GdkWindowPrivate*) window)->destroyed; + break; + + case ColormapNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("colormap notify:\twindow: %ld\n", + xevent->xcolormap.window - base_id); + + /* Not currently handled */ + break; + + case ClientMessage: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("client message:\twindow: %ld\n", + xevent->xclient.window - base_id); + + /* 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. + */ + if (gdk_show_events) + g_print ("delete window:\t\twindow: %ld\n", + xevent->xclient.window - base_id); + + event->any.type = GDK_DELETE; + event->any.window = window; + + return_val = !window_private->destroyed; + } + 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]; + if (gdk_show_events) + g_print ("GDK_DROP_ENTER\n"); + 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; + + XSendEvent (gdk_display, replyev.xclient.window, + False, NoEventMask, &replyev); + + event->any.type = GDK_DROP_ENTER; + event->dropenter.requestor = replyev.xclient.window; + event->dropenter.u.allflags = xevent->xclient.data.l[1]; + } + } + else if (xevent->xclient.message_type == gdk_dnd.gdk_XdeLeave) + { + if (gdk_show_events) + g_print ("GDK_DROP_LEAVE\n"); + 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 + */ + if (gdk_show_events) + g_print ("GDK_DRAG_REQUEST\n"); + event->dragrequest.u.allflags = xevent->xclient.data.l[1]; + return_val = FALSE; + + if (window && gdk_dnd.drag_really && + xevent->xclient.data.l[0] == dnd_drag_curwin && + 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]; + + dnd_drag_target = dnd_drag_curwin; + XChangeActivePointerGrab (gdk_display, + ButtonMotionMask | + ButtonPressMask | + ButtonReleaseMask | + EnterWindowMask | LeaveWindowMask, + gdk_dnd.gdk_cursor_dragok, + CurrentTime); + } + dnd_drag_dropzone.x = xevent->xclient.data.l[2] & 65535; + dnd_drag_dropzone.y = + (xevent->xclient.data.l[2] >> 16) & 65535; + dnd_drag_dropzone.width = xevent->xclient.data.l[3] & 65535; + dnd_drag_dropzone.height = + (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; + gpointer tmp_ptr; + + if(gdk_show_events) + g_print("GDK_DROP_DATA_AVAIL\n"); + event->dropdataavailable.u.allflags = xevent->xclient.data.l[1]; + 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 + { + g_print("XGetWindowProperty got us %d bytes\n", + event->dropdataavailable.data_numbytes); + event->dropdataavailable.data = + g_malloc(event->dropdataavailable.data_numbytes); + memcpy(event->dropdataavailable.data, + tmp_charptr, event->dropdataavailable.data_numbytes); + XFree(tmp_charptr); + return_val = TRUE; + } + return_val = TRUE; + } + } else { + /* 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)); + return_val = TRUE; + } + return_val = return_val && !window_private->destroyed; + break; + + case MappingNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("mapping notify\n"); + + /* 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); + + if (return_val < 0) /* not an XInput event, convert */ + { + event->other.type = GDK_OTHER_EVENT; + event->other.window = window; + event->other.xevent = &other_xevent[other_xevent_i]; + memcpy (&other_xevent[other_xevent_i], xevent, sizeof (XEvent)); + other_xevent_i = (other_xevent_i+1) % OTHER_XEVENT_BUFSIZE; + return_val = TRUE; + } + + return_val = return_val && !window_private->destroyed; + break; + } + + return return_val; +} + +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; +} + +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 () +{ + if (initialized) + { + 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); + gdk_exit (1); +} + +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; + XSendEvent (gdk_display, dest, False, NoEventMask, &sev); + } + + } +} + +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; + XSendEvent(gdk_display, dest, False, NoEventMask, &sev); + 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; + gchar *tmp_cptr; + 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; + 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 + */ +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); +} + +/* + * 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]; + } + + for (i = 0; !inf && (i < nchildren); i++) + inf = getchildren (dpy, children[i], WM_STATE); + + if (children != 0) + 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; +} + +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; +} + +/* 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; + XSendEvent(gdk_display, curwin, False, NoEventMask, &sev); + } + + XFree(ret_children); +} diff --git a/gdk/gdk.h b/gdk/gdk.h new file mode 100644 index 000000000..ac341b206 --- /dev/null +++ b/gdk/gdk.h @@ -0,0 +1,614 @@ +/* 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. + */ +#ifndef __GDK_H__ +#define __GDK_H__ + + +#include <gdk/gdktypes.h> + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + + +/* Initialization, exit and events + */ +void gdk_init (int *argc, + char ***argv); +void gdk_exit (int error_code); +gchar* gdk_set_locale (void); + +gint gdk_events_pending (void); +gint gdk_event_get (GdkEvent *event, + GdkEventFunc pred, + gpointer data); +void gdk_event_put (GdkEvent *event); + +GdkEvent *gdk_event_copy (GdkEvent *event); +void gdk_event_free (GdkEvent *event); + +void gdk_set_debug_level (gint level); +void gdk_set_show_events (gint show_events); +void gdk_set_use_xshm (gint use_xshm); + +gint gdk_get_debug_level (void); +gint gdk_get_show_events (void); +gint gdk_get_use_xshm (void); + +guint32 gdk_time_get (void); +guint32 gdk_timer_get (void); +void gdk_timer_set (guint32 milliseconds); +void gdk_timer_enable (void); +void gdk_timer_disable (void); + +gint gdk_input_add (gint source, + GdkInputCondition condition, + GdkInputFunction function, + gpointer data); +void gdk_input_remove (gint tag); + +gint gdk_pointer_grab (GdkWindow * window, + gint owner_events, + GdkEventMask event_mask, + GdkWindow * confine_to, + GdkCursor * cursor, + guint32 time); +void gdk_pointer_ungrab (guint32 time); + +gint gdk_keyboard_grab (GdkWindow * window, + gint owner_events, + guint32 time); +void gdk_keyboard_ungrab (guint32 time); + +gint gdk_screen_width (void); +gint gdk_screen_height (void); + +void gdk_flush (void); +void gdk_beep (void); + +void gdk_key_repeat_disable (void); +void gdk_key_repeat_restore (void); + + +/* Visuals + */ +gint gdk_visual_get_best_depth (void); +GdkVisualType gdk_visual_get_best_type (void); +GdkVisual* gdk_visual_get_system (void); +GdkVisual* gdk_visual_get_best (void); +GdkVisual* gdk_visual_get_best_with_depth (gint depth); +GdkVisual* gdk_visual_get_best_with_type (GdkVisualType visual_type); +GdkVisual* gdk_visual_get_best_with_both (gint depth, + GdkVisualType visual_type); + +/* Actually, these are no-ops... */ +GdkVisual* gdk_visual_ref (GdkVisual *visual); +void gdk_visual_unref (GdkVisual *visual); + +void gdk_query_depths (gint **depths, + gint *count); +void gdk_query_visual_types (GdkVisualType **visual_types, + gint *count); +void gdk_query_visuals (GdkVisual **visuals, + gint *count); + + +/* Windows + */ +GdkWindow* gdk_window_new (GdkWindow *parent, + GdkWindowAttr *attributes, + gint attributes_mask); + +GdkWindow * gdk_window_foreign_new (guint32 anid); +void gdk_window_destroy (GdkWindow *window); +GdkWindow* gdk_window_ref (GdkWindow *window); +void gdk_window_unref (GdkWindow *window); + +void gdk_window_show (GdkWindow *window); +void gdk_window_hide (GdkWindow *window); +void gdk_window_move (GdkWindow *window, + gint x, + gint y); +void gdk_window_resize (GdkWindow *window, + gint width, + gint height); +void gdk_window_move_resize (GdkWindow *window, + gint x, + gint y, + gint width, + gint height); +void gdk_window_reparent (GdkWindow *window, + GdkWindow *new_parent, + gint x, + gint y); +void gdk_window_clear (GdkWindow *window); +void gdk_window_clear_area (GdkWindow *window, + gint x, + gint y, + gint width, + gint height); +void gdk_window_clear_area_e(GdkWindow *window, + gint x, + gint y, + gint width, + gint height); +void gdk_window_copy_area (GdkWindow *window, + GdkGC *gc, + gint x, + gint y, + GdkWindow *source_window, + gint source_x, + gint source_y, + gint width, + gint height); +void gdk_window_raise (GdkWindow *window); +void gdk_window_lower (GdkWindow *window); + +void gdk_window_set_user_data (GdkWindow *window, + gpointer user_data); + + +/* + * This allows for making shaped (partially transparent) windows + * - cool feature, needed for Drag and Drag for example. + * The shape_mask can be the mask + * from gdk_pixmap_create_from_xpm. Stefan Wille + */ +void gdk_window_shape_combine_mask (GdkWindow *window, + GdkBitmap *shape_mask, + gint offset_x, + gint offset_y); + +/* + * Drag & Drop + * Algorithm (drop source): + * A window being dragged will be sent a GDK_DRAG_BEGIN message. + * It will then do gdk_dnd_drag_addwindow() for any other windows that are to be + * dragged. + * When we get a DROP_ENTER incoming, we send it on to the window in question. + * That window needs to use gdk_dnd_drop_enter_reply() to indicate the state of + * things (it must call that even if it's not going to accept the drop) + * + * These two turn on/off drag or drop, and if enabling it also + * sets the list of types supported. The list of types passed in + * should be in order of decreasing preference. + */ +void gdk_window_dnd_drag_set (GdkWindow *window, + guint8 drag_enable, + gchar **typelist, + guint numtypes); + +/* + *XXX todo: add a GDK_DROP_ENTER which can look at actual data + */ +void gdk_window_dnd_drop_set (GdkWindow *window, + guint8 drop_enable, + gchar **typelist, + guint numtypes, + guint8 destructive_op); + +/* + * This is used by the GDK_DRAG_BEGIN handler. An example of usage would be a + * file manager where multiple icons were selected and the drag began. + * The icon that the drag actually began on would gdk_dnd_drag_addwindow + * for all the other icons that were being dragged... + */ +void gdk_dnd_drag_addwindow (GdkWindow *window); +void gdk_window_dnd_data_set (GdkWindow *window, + GdkEvent *event, + gpointer data, + gulong data_numbytes); + + +void gdk_window_set_hints (GdkWindow *window, + gint x, + gint y, + gint min_width, + gint min_height, + gint max_width, + gint max_height, + gint flags); +void gdk_window_set_title (GdkWindow *window, + const gchar *title); +void gdk_window_set_background (GdkWindow *window, + GdkColor *color); +void gdk_window_set_back_pixmap (GdkWindow *window, + GdkPixmap *pixmap, + gint parent_relative); +void gdk_window_set_cursor (GdkWindow *window, + GdkCursor *cursor); +void gdk_window_set_colormap (GdkWindow *window, + GdkColormap *colormap); +void gdk_window_get_user_data (GdkWindow *window, + gpointer *data); +void gdk_window_get_geometry (GdkWindow *window, + gint *x, + gint *y, + gint *width, + gint *height, + gint *depth); +void gdk_window_get_position (GdkWindow *window, + gint *x, + gint *y); +void gdk_window_get_size (GdkWindow *window, + gint *width, + gint *height); +GdkVisual* gdk_window_get_visual (GdkWindow *window); +GdkColormap* gdk_window_get_colormap (GdkWindow *window); +GdkWindowType gdk_window_get_type (GdkWindow *window); +gint gdk_window_get_origin (GdkWindow *window, + gint *x, + gint *y); +GdkWindow* gdk_window_get_pointer (GdkWindow *window, + gint *x, + gint *y, + GdkModifierType *mask); +GdkWindow* gdk_window_get_parent (GdkWindow *window); +GdkWindow* gdk_window_get_toplevel (GdkWindow *window); +GList* gdk_window_get_children (GdkWindow *window); +GdkEventMask gdk_window_get_events (GdkWindow *window); +void gdk_window_set_events (GdkWindow *window, + GdkEventMask event_mask); + +/* Cursors + */ +GdkCursor* gdk_cursor_new (GdkCursorType cursor_type); +void gdk_cursor_destroy (GdkCursor *cursor); + + +/* GCs + */ +GdkGC* gdk_gc_new (GdkWindow *window); +GdkGC* gdk_gc_new_with_values (GdkWindow *window, + GdkGCValues *values, + GdkGCValuesMask values_mask); +void gdk_gc_destroy (GdkGC *gc); +void gdk_gc_get_values (GdkGC *gc, + GdkGCValues *values); +void gdk_gc_set_foreground (GdkGC *gc, + GdkColor *color); +void gdk_gc_set_background (GdkGC *gc, + GdkColor *color); +void gdk_gc_set_font (GdkGC *gc, + GdkFont *font); +void gdk_gc_set_function (GdkGC *gc, + GdkFunction function); +void gdk_gc_set_fill (GdkGC *gc, + GdkFill fill); +void gdk_gc_set_tile (GdkGC *gc, + GdkPixmap *tile); +void gdk_gc_set_stipple (GdkGC *gc, + GdkPixmap *stipple); +void gdk_gc_set_ts_origin (GdkGC *gc, + gint x, + gint y); +void gdk_gc_set_clip_origin (GdkGC *gc, + gint x, + gint y); +void gdk_gc_set_clip_mask (GdkGC *gc, + GdkBitmap *mask); +void gdk_gc_set_clip_rectangle (GdkGC *gc, + GdkRectangle *rectangle); +void gdk_gc_set_subwindow (GdkGC *gc, + GdkSubwindowMode mode); +void gdk_gc_set_exposures (GdkGC *gc, + gint exposures); +void gdk_gc_set_line_attributes (GdkGC *gc, + gint line_width, + GdkLineStyle line_style, + GdkCapStyle cap_style, + GdkJoinStyle join_style); + + +/* Pixmaps + */ +GdkPixmap* gdk_pixmap_new (GdkWindow *window, + gint width, + gint height, + gint depth); +GdkBitmap* gdk_bitmap_create_from_data (GdkWindow *window, + gchar *data, + gint width, + gint height); +GdkPixmap* gdk_pixmap_create_from_data (GdkWindow *window, + gchar *data, + gint width, + gint height, + gint depth, + GdkColor *fg, + GdkColor *bg); +GdkPixmap* gdk_pixmap_create_from_xpm (GdkWindow *window, + GdkBitmap **mask, + GdkColor *transparent_color, + const gchar *filename); +GdkPixmap* gdk_pixmap_create_from_xpm_d (GdkWindow *window, + GdkBitmap **mask, + GdkColor *transparent_color, + gchar **data); +void gdk_pixmap_destroy (GdkPixmap *pixmap); + + + +/* Images + */ +GdkImage* gdk_image_new_bitmap(GdkVisual *, + gpointer, + gint, + gint); +GdkImage* gdk_image_new (GdkImageType type, + GdkVisual *visual, + gint width, + gint height); +GdkImage* gdk_image_get (GdkWindow *window, + gint x, + gint y, + gint width, + gint height); +void gdk_image_put_pixel (GdkImage *image, + gint x, + gint y, + guint32 pixel); +guint32 gdk_image_get_pixel (GdkImage *image, + gint x, + gint y); +void gdk_image_destroy (GdkImage *image); + + +/* Color + */ +GdkColormap* gdk_colormap_new (GdkVisual *visual, + gint allocate); +void gdk_colormap_destroy (GdkColormap *colormap); + +GdkColormap* gdk_colormap_ref (GdkColormap *cmap); +void gdk_colormap_unref (GdkColormap *cmap); + +GdkColormap* gdk_colormap_get_system (void); +gint gdk_colormap_get_system_size (void); + +void gdk_colormap_change (GdkColormap *colormap, + gint ncolors); +void gdk_colors_store (GdkColormap *colormap, + GdkColor *colors, + gint ncolors); +gint gdk_colors_alloc (GdkColormap *colormap, + gint contiguous, + gulong *planes, + gint nplanes, + gulong *pixels, + gint npixels); +void gdk_colors_free (GdkColormap *colormap, + gulong *pixels, + gint npixels, + gulong planes); +gint gdk_color_white (GdkColormap *colormap, + GdkColor *color); +gint gdk_color_black (GdkColormap *colormap, + GdkColor *color); +gint gdk_color_parse (const gchar *spec, + GdkColor *color); +gint gdk_color_alloc (GdkColormap *colormap, + GdkColor *color); +gint gdk_color_change (GdkColormap *colormap, + GdkColor *color); +gint gdk_color_equal (GdkColor *colora, + GdkColor *colorb); + + +/* Fonts + */ +GdkFont* gdk_font_load (const gchar *font_name); +GdkFont* gdk_fontset_load (gchar *fontset_name); +void gdk_font_free (GdkFont *font); +void gdk_fontset_free (GdkFont *font); +GdkFont* gdk_font_ref (GdkFont *font); +gint gdk_font_id (GdkFont *font); +gint gdk_font_equal (GdkFont *fonta, + GdkFont *fontb); +gint gdk_string_width (GdkFont *font, + const gchar *string); +gint gdk_text_width (GdkFont *font, + const gchar *text, + gint text_length); +gint gdk_char_width (GdkFont *font, + gchar character); +gint gdk_string_measure (GdkFont *font, + const gchar *string); +gint gdk_text_measure (GdkFont *font, + const gchar *text, + gint text_length); +gint gdk_char_measure (GdkFont *font, + gchar character); + + +/* Drawing + */ +void gdk_draw_point (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y); +void gdk_draw_line (GdkDrawable *drawable, + GdkGC *gc, + gint x1, + gint y1, + gint x2, + gint y2); +void gdk_draw_rectangle (GdkDrawable *drawable, + GdkGC *gc, + gint filled, + gint x, + gint y, + gint width, + gint height); +void gdk_draw_arc (GdkDrawable *drawable, + GdkGC *gc, + gint filled, + gint x, + gint y, + gint width, + gint height, + gint angle1, + gint angle2); +void gdk_draw_polygon (GdkDrawable *drawable, + GdkGC *gc, + gint filled, + GdkPoint *points, + gint npoints); +void gdk_draw_string (GdkDrawable *drawable, + GdkFont *font, + GdkGC *gc, + gint x, + gint y, + const gchar *string); +void gdk_draw_text (GdkDrawable *drawable, + GdkFont *font, + GdkGC *gc, + gint x, + gint y, + const gchar *text, + gint text_length); +void gdk_draw_pixmap (GdkDrawable *drawable, + GdkGC *gc, + GdkDrawable *src, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height); +void gdk_draw_bitmap (GdkDrawable *drawable, + GdkGC *gc, + GdkDrawable *src, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height); +void gdk_draw_image (GdkDrawable *drawable, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height); +void gdk_draw_points (GdkDrawable *drawable, + GdkGC *gc, + GdkPoint *points, + gint npoints); +void gdk_draw_segments (GdkDrawable *drawable, + GdkGC *gc, + GdkSegment *segs, + gint nsegs); + + +/* Selections + */ +gint gdk_selection_owner_set (GdkWindow *owner, + GdkAtom selection, + guint32 time, + gint send_event); +GdkWindow* gdk_selection_owner_get (GdkAtom selection); +void gdk_selection_convert (GdkWindow *requestor, + GdkAtom selection, + GdkAtom target, + guint32 time); +gint gdk_selection_property_get (GdkWindow *requestor, + guchar **data, + GdkAtom *prop_type, + gint *prop_format); +void gdk_selection_send_notify (guint32 requestor, + GdkAtom selection, + GdkAtom target, + GdkAtom property, + guint32 time); + +/* Properties + */ +GdkAtom gdk_atom_intern (const gchar *atom_name, + gint only_if_exists); +gchar* gdk_atom_name (GdkAtom atom); +gint gdk_property_get (GdkWindow *window, + GdkAtom property, + GdkAtom type, + gulong offset, + gulong length, + gint pdelete, + GdkAtom *actual_property_type, + gint *actual_format, + gint *actual_length, + guchar **data); + +void gdk_property_change (GdkWindow *window, + GdkAtom property, + GdkAtom type, + gint format, + GdkPropMode mode, + guchar *data, + gint nelements); +void gdk_property_delete (GdkWindow *window, + GdkAtom property); + + +/* Rectangle utilities + */ +gint gdk_rectangle_intersect (GdkRectangle *src1, + GdkRectangle *src2, + GdkRectangle *dest); + +/* XInput support + */ + +void gdk_input_init (void); +void gdk_input_exit (void); +GList *gdk_input_list_devices (void); +void gdk_input_set_extension_events (GdkWindow *window, + gint mask, + GdkExtensionMode mode); +void gdk_input_set_source (guint32 deviceid, + GdkInputSource source); +gint gdk_input_set_mode (guint32 deviceid, + GdkInputMode mode); +void gdk_input_set_axes (guint32 deviceid, + GdkAxisUse *axes); +void gdk_input_window_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask); + +GdkTimeCoord *gdk_input_motion_events (GdkWindow *window, + guint32 deviceid, + guint32 start, + guint32 stop, + gint *nevents_return); + +/* Miscellaneous */ +void gdk_event_send_clientmessage_toall(GdkEvent *event); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +#endif /* __GDK_H__ */ diff --git a/gdk/gdkcolor.c b/gdk/gdkcolor.c new file mode 100644 index 000000000..5e66f089b --- /dev/null +++ b/gdk/gdkcolor.c @@ -0,0 +1,718 @@ +/* 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 <X11/Xlib.h> +#include "gdk.h" +#include "gdkprivate.h" + + +static gint gdk_colormap_match_color (GdkColormap *cmap, + GdkColor *color, + const gchar *available); +static void gdk_colormap_add (GdkColormap *cmap); +static void gdk_colormap_remove (GdkColormap *cmap); +static guint gdk_colormap_hash (Colormap *cmap); +static gint gdk_colormap_cmp (Colormap *a, + Colormap *b); + +static GHashTable *colormap_hash = NULL; + + +GdkColormap* +gdk_colormap_new (GdkVisual *visual, + gint private_cmap) +{ + GdkColormap *colormap; + GdkColormapPrivate *private; + Visual *xvisual; + XColor default_colors[256]; + int size; + int i; + + g_return_val_if_fail (visual != NULL, NULL); + + private = g_new (GdkColormapPrivate, 1); + colormap = (GdkColormap*) private; + + private->xdisplay = gdk_display; + private->visual = visual; + private->next_color = 0; + private->ref_count = 1; + xvisual = ((GdkVisualPrivate*) visual)->xvisual; + + switch (visual->type) + { + case GDK_VISUAL_GRAYSCALE: + case GDK_VISUAL_PSEUDO_COLOR: + private->private_val = private_cmap; + private->xcolormap = XCreateColormap (private->xdisplay, gdk_root_window, + xvisual, (private_cmap) ? (AllocAll) : (AllocNone)); + + if (private_cmap) + { + for (i = 0; i < 256; i++) + default_colors[i].pixel = i; + + XQueryColors (private->xdisplay, + DefaultColormap (private->xdisplay, gdk_screen), + default_colors, visual->colormap_size); + + for (i = 0; i < visual->colormap_size; i++) + { + colormap->colors[i].pixel = default_colors[i].pixel; + colormap->colors[i].red = default_colors[i].red; + colormap->colors[i].green = default_colors[i].green; + colormap->colors[i].blue = default_colors[i].blue; + } + + gdk_colormap_change (colormap, visual->colormap_size); + } + break; + + case GDK_VISUAL_DIRECT_COLOR: + private->private_val = TRUE; + private->xcolormap = XCreateColormap (private->xdisplay, gdk_root_window, + xvisual, AllocAll); + + size = 1 << visual->red_prec; + for (i = 0; i < size; i++) + colormap->colors[i].red = i * 65535 / (size - 1); + + size = 1 << visual->green_prec; + for (i = 0; i < size; i++) + colormap->colors[i].green = i * 65535 / (size - 1); + + size = 1 << visual->blue_prec; + for (i = 0; i < size; i++) + colormap->colors[i].blue = i * 65535 / (size - 1); + + gdk_colormap_change (colormap, visual->colormap_size); + break; + + case GDK_VISUAL_STATIC_GRAY: + case GDK_VISUAL_STATIC_COLOR: + case GDK_VISUAL_TRUE_COLOR: + private->private_val = FALSE; + private->xcolormap = XCreateColormap (private->xdisplay, gdk_root_window, + xvisual, AllocNone); + break; + } + + gdk_colormap_add (colormap); + + return colormap; +} + +void +gdk_colormap_real_destroy (GdkColormap *colormap) +{ + GdkColormapPrivate *private = (GdkColormapPrivate*) colormap; + + g_return_if_fail (colormap != NULL); + + if (private->ref_count > 0) + return; + + gdk_colormap_remove (colormap); + XFreeColormap (private->xdisplay, private->xcolormap); + g_free (colormap); +} + +void +gdk_colormap_destroy (GdkColormap *colormap) +{ + gdk_colormap_unref (colormap); +} + +GdkColormap* +gdk_colormap_ref (GdkColormap *cmap) +{ + GdkColormapPrivate *private = (GdkColormapPrivate *)cmap; + g_return_val_if_fail (cmap != NULL, NULL); + + private->ref_count += 1; + return cmap; +} + +void +gdk_colormap_unref (GdkColormap *cmap) +{ + GdkColormapPrivate *private = (GdkColormapPrivate *)cmap; + g_return_if_fail (cmap != NULL); + + private->ref_count -= 1; + if (private->ref_count == 0) + gdk_colormap_real_destroy (cmap); +} + +GdkColormap* +gdk_colormap_get_system (void) +{ + static GdkColormap *colormap = NULL; + GdkColormapPrivate *private; + XColor xpalette[256]; + gint i; + + if (!colormap) + { + private = g_new (GdkColormapPrivate, 1); + colormap = (GdkColormap*) private; + + private->xdisplay = gdk_display; + private->xcolormap = DefaultColormap (gdk_display, gdk_screen); + private->visual = gdk_visual_get_system (); + private->private_val = FALSE; + private->next_color = 0; + private->ref_count = 1; + + for (i = 0; i < 256; i++) + { + xpalette[i].pixel = i; + xpalette[i].red = 0; + xpalette[i].green = 0; + xpalette[i].blue = 0; + } + + XQueryColors (gdk_display, private->xcolormap, xpalette, 256); + + for (i = 0; i < 256; i++) + { + colormap->colors[i].pixel = xpalette[i].pixel; + colormap->colors[i].red = xpalette[i].red; + colormap->colors[i].green = xpalette[i].green; + colormap->colors[i].blue = xpalette[i].blue; + } + + gdk_colormap_add (colormap); + } + + return colormap; +} + +gint +gdk_colormap_get_system_size (void) +{ + return DisplayCells (gdk_display, gdk_screen); +} + +void +gdk_colormap_change (GdkColormap *colormap, + gint ncolors) +{ + GdkColormapPrivate *private; + GdkVisual *visual; + XColor palette[256]; + gint shift; + int max_colors; + int size; + int i; + + g_return_if_fail (colormap != NULL); + + private = (GdkColormapPrivate*) colormap; + switch (private->visual->type) + { + case GDK_VISUAL_GRAYSCALE: + case GDK_VISUAL_PSEUDO_COLOR: + for (i = 0; i < ncolors; i++) + { + palette[i].pixel = colormap->colors[i].pixel; + palette[i].red = colormap->colors[i].red; + palette[i].green = colormap->colors[i].green; + palette[i].blue = colormap->colors[i].blue; + palette[i].flags = DoRed | DoGreen | DoBlue; + } + + XStoreColors (private->xdisplay, private->xcolormap, palette, ncolors); + private->next_color = MAX (private->next_color, ncolors); + break; + + case GDK_VISUAL_DIRECT_COLOR: + visual = private->visual; + + shift = visual->red_shift; + max_colors = 1 << visual->red_prec; + size = (ncolors < max_colors) ? (ncolors) : (max_colors); + + for (i = 0; i < size; i++) + { + palette[i].pixel = i << shift; + palette[i].red = colormap->colors[i].red; + palette[i].flags = DoRed; + } + + XStoreColors (private->xdisplay, private->xcolormap, palette, size); + + shift = visual->green_shift; + max_colors = 1 << visual->green_prec; + size = (ncolors < max_colors) ? (ncolors) : (max_colors); + + for (i = 0; i < size; i++) + { + palette[i].pixel = i << shift; + palette[i].green = colormap->colors[i].green; + palette[i].flags = DoGreen; + } + + XStoreColors (private->xdisplay, private->xcolormap, palette, size); + + shift = visual->blue_shift; + max_colors = 1 << visual->blue_prec; + size = (ncolors < max_colors) ? (ncolors) : (max_colors); + + for (i = 0; i < size; i++) + { + palette[i].pixel = i << shift; + palette[i].blue = colormap->colors[i].blue; + palette[i].flags = DoBlue; + } + + XStoreColors (private->xdisplay, private->xcolormap, palette, size); + break; + + default: + break; + } +} + +void +gdk_colors_store (GdkColormap *colormap, + GdkColor *colors, + gint ncolors) +{ + gint i; + + for (i = 0; i < ncolors; i++) + { + colormap->colors[i].pixel = colors[i].pixel; + colormap->colors[i].red = colors[i].red; + colormap->colors[i].green = colors[i].green; + colormap->colors[i].blue = colors[i].blue; + } + + gdk_colormap_change (colormap, ncolors); +} + +gint +gdk_colors_alloc (GdkColormap *colormap, + gint contiguous, + gulong *planes, + gint nplanes, + gulong *pixels, + gint npixels) +{ + GdkColormapPrivate *private; + gint return_val; + + g_return_val_if_fail (colormap != NULL, 0); + + private = (GdkColormapPrivate*) colormap; + + return_val = XAllocColorCells (private->xdisplay, private->xcolormap, + contiguous, planes, nplanes, pixels, npixels); + + return return_val; +} + +void +gdk_colors_free (GdkColormap *colormap, + gulong *pixels, + gint npixels, + gulong planes) +{ + GdkColormapPrivate *private; + + g_return_if_fail (colormap != NULL); + + private = (GdkColormapPrivate*) colormap; + + XFreeColors (private->xdisplay, private->xcolormap, + pixels, npixels, planes); +} + +gint +gdk_color_white (GdkColormap *colormap, + GdkColor *color) +{ + gint return_val; + + g_return_val_if_fail (colormap != NULL, FALSE); + + if (color) + { + color->pixel = WhitePixel (gdk_display, gdk_screen); + color->red = 65535; + color->green = 65535; + color->blue = 65535; + + return_val = gdk_color_alloc (colormap, color); + } + else + return_val = FALSE; + + return return_val; +} + +gint +gdk_color_black (GdkColormap *colormap, + GdkColor *color) +{ + gint return_val; + + g_return_val_if_fail (colormap != NULL, FALSE); + + if (color) + { + color->pixel = BlackPixel (gdk_display, gdk_screen); + color->red = 0; + color->green = 0; + color->blue = 0; + + return_val = gdk_color_alloc (colormap, color); + } + else + return_val = FALSE; + + return return_val; +} + +gint +gdk_color_parse (const gchar *spec, + GdkColor *color) +{ + Colormap xcolormap; + XColor xcolor; + gint return_val; + + g_return_val_if_fail (spec != NULL, FALSE); + g_return_val_if_fail (color != NULL, FALSE); + + xcolormap = DefaultColormap (gdk_display, gdk_screen); + + if (XParseColor (gdk_display, xcolormap, spec, &xcolor)) + { + return_val = TRUE; + color->red = xcolor.red; + color->green = xcolor.green; + color->blue = xcolor.blue; + } + else + return_val = FALSE; + + return return_val; +} + +gint +gdk_color_alloc (GdkColormap *colormap, + GdkColor *color) +{ + GdkColormapPrivate *private; + GdkVisual *visual; + XColor xcolor; + gchar available[256]; + gint available_init; + gint return_val; + gint i, index; + + g_return_val_if_fail (colormap != NULL, FALSE); + g_return_val_if_fail (color != NULL, FALSE); + + xcolor.red = color->red; + xcolor.green = color->green; + xcolor.blue = color->blue; + xcolor.pixel = color->pixel; + xcolor.flags = DoRed | DoGreen | DoBlue; + + return_val = FALSE; + private = (GdkColormapPrivate*) colormap; + + switch (private->visual->type) + { + case GDK_VISUAL_GRAYSCALE: + case GDK_VISUAL_PSEUDO_COLOR: + if (private->private_val) + { + if (private->next_color > 255) + { + for (i = 0; i < 256; i++) + available[i] = TRUE; + + index = gdk_colormap_match_color (colormap, color, available); + if (index != -1) + { + available[index] = FALSE; + *color = colormap->colors[index]; + return_val = TRUE; + } + else + { + return_val = FALSE; + } + } + else + { + xcolor.pixel = 255 - private->next_color; + color->pixel = xcolor.pixel; + private->next_color += 1; + + XStoreColor (private->xdisplay, private->xcolormap, &xcolor); + return_val = TRUE; + } + } + else + { + available_init = 1; + + while (1) + { + if (XAllocColor (private->xdisplay, private->xcolormap, &xcolor)) + { + color->pixel = xcolor.pixel; + color->red = xcolor.red; + color->green = xcolor.green; + color->blue = xcolor.blue; + + colormap->colors[color->pixel] = *color; + + return_val = TRUE; + break; + } + else + { + if (available_init) + { + available_init = 0; + for (i = 0; i < 256; i++) + available[i] = TRUE; + } + + index = gdk_colormap_match_color (colormap, color, available); + if (index != -1) + { + available[index] = FALSE; + xcolor.red = colormap->colors[index].red; + xcolor.green = colormap->colors[index].green; + xcolor.blue = colormap->colors[index].blue; + } + else + { + return_val = FALSE; + break; + } + } + } + } + break; + + case GDK_VISUAL_DIRECT_COLOR: + visual = private->visual; + xcolor.pixel = (((xcolor.red >> (16 - visual->red_prec)) << visual->red_shift) + + ((xcolor.green >> (16 - visual->green_prec)) << visual->green_shift) + + ((xcolor.blue >> (16 - visual->blue_prec)) << visual->blue_shift)); + color->pixel = xcolor.pixel; + return_val = TRUE; + break; + + case GDK_VISUAL_STATIC_GRAY: + case GDK_VISUAL_STATIC_COLOR: + case GDK_VISUAL_TRUE_COLOR: + if (XAllocColor (private->xdisplay, private->xcolormap, &xcolor)) + { + color->pixel = xcolor.pixel; + return_val = TRUE; + } + else + return_val = FALSE; + break; + } + + return return_val; +} + +gint +gdk_color_change (GdkColormap *colormap, + GdkColor *color) +{ + GdkColormapPrivate *private; + XColor xcolor; + + g_return_val_if_fail (colormap != NULL, FALSE); + g_return_val_if_fail (color != NULL, FALSE); + + xcolor.pixel = color->pixel; + xcolor.red = color->red; + xcolor.green = color->green; + xcolor.blue = color->blue; + xcolor.flags = DoRed | DoGreen | DoBlue; + + private = (GdkColormapPrivate*) colormap; + XStoreColor (private->xdisplay, private->xcolormap, &xcolor); + + return TRUE; +} + +gint +gdk_color_equal (GdkColor *colora, + GdkColor *colorb) +{ + g_return_val_if_fail (colora != NULL, FALSE); + g_return_val_if_fail (colorb != NULL, FALSE); + + return ((colora->red == colorb->red) && + (colora->green == colorb->green) && + (colora->blue == colorb->blue)); +} + +GdkColormap* +gdkx_colormap_get (Colormap xcolormap) +{ + GdkColormap *colormap; + GdkColormapPrivate *private; + XColor xpalette[256]; + gint i; + + colormap = gdk_colormap_lookup (xcolormap); + if (colormap) + return colormap; + + if (xcolormap == DefaultColormap (gdk_display, gdk_screen)) + return gdk_colormap_get_system (); + + private = g_new (GdkColormapPrivate, 1); + colormap = (GdkColormap*) private; + + private->xdisplay = gdk_display; + private->xcolormap = xcolormap; + private->visual = NULL; + private->private_val = TRUE; + private->next_color = 0; + + for (i = 0; i < 256; i++) + { + xpalette[i].pixel = i; + xpalette[i].red = 0; + xpalette[i].green = 0; + xpalette[i].blue = 0; + } + + XQueryColors (gdk_display, private->xcolormap, xpalette, 256); + + for (i = 0; i < 256; i++) + { + colormap->colors[i].pixel = xpalette[i].pixel; + colormap->colors[i].red = xpalette[i].red; + colormap->colors[i].green = xpalette[i].green; + colormap->colors[i].blue = xpalette[i].blue; + } + + gdk_colormap_add (colormap); + + return colormap; +} + + +static gint +gdk_colormap_match_color (GdkColormap *cmap, + GdkColor *color, + const gchar *available) +{ + GdkColor *colors; + guint sum, max; + gint rdiff, gdiff, bdiff; + gint i, index; + + g_return_val_if_fail (cmap != NULL, 0); + g_return_val_if_fail (color != NULL, 0); + + colors = cmap->colors; + max = 3 * (65536); + index = -1; + + for (i = 0; i < 256; i++) + { + if ((!available) || (available && available[i])) + { + rdiff = (color->red - colors[i].red); + gdiff = (color->green - colors[i].green); + bdiff = (color->blue - colors[i].blue); + + sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff); + + if (sum < max) + { + index = i; + max = sum; + } + } + } + + return index; +} + + +GdkColormap* +gdk_colormap_lookup (Colormap xcolormap) +{ + GdkColormap *cmap; + + if (!colormap_hash) + return NULL; + + cmap = g_hash_table_lookup (colormap_hash, &xcolormap); + return cmap; +} + +static void +gdk_colormap_add (GdkColormap *cmap) +{ + GdkColormapPrivate *private; + + if (!colormap_hash) + colormap_hash = g_hash_table_new ((GHashFunc) gdk_colormap_hash, + (GCompareFunc) gdk_colormap_cmp); + + private = (GdkColormapPrivate*) cmap; + + g_hash_table_insert (colormap_hash, &private->xcolormap, cmap); +} + +static void +gdk_colormap_remove (GdkColormap *cmap) +{ + GdkColormapPrivate *private; + + if (!colormap_hash) + colormap_hash = g_hash_table_new ((GHashFunc) gdk_colormap_hash, + (GCompareFunc) gdk_colormap_cmp); + + private = (GdkColormapPrivate*) cmap; + + g_hash_table_remove (colormap_hash, &private->xcolormap); +} + +static guint +gdk_colormap_hash (Colormap *cmap) +{ + return *cmap; +} + +static gint +gdk_colormap_cmp (Colormap *a, + Colormap *b) +{ + return (*a == *b); +} diff --git a/gdk/gdkcursor.c b/gdk/gdkcursor.c new file mode 100644 index 000000000..22bfd250b --- /dev/null +++ b/gdk/gdkcursor.c @@ -0,0 +1,52 @@ +/* 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 <X11/Xlib.h> +#include <X11/cursorfont.h> +#include "gdk.h" +#include "gdkprivate.h" + + +GdkCursor* +gdk_cursor_new (GdkCursorType cursor_type) +{ + GdkCursorPrivate *private; + GdkCursor *cursor; + Cursor xcursor; + + xcursor = XCreateFontCursor (gdk_display, cursor_type); + private = g_new (GdkCursorPrivate, 1); + private->xdisplay = gdk_display; + private->xcursor = xcursor; + cursor = (GdkCursor*) private; + cursor->type = cursor_type; + + return cursor; +} + +void +gdk_cursor_destroy (GdkCursor *cursor) +{ + GdkCursorPrivate *private; + + g_return_if_fail (cursor != NULL); + + private = (GdkCursorPrivate *) cursor; + XFreeCursor (private->xdisplay, private->xcursor); + + g_free (private); +} diff --git a/gdk/gdkdraw.c b/gdk/gdkdraw.c new file mode 100644 index 000000000..47482f72e --- /dev/null +++ b/gdk/gdkdraw.c @@ -0,0 +1,383 @@ +/* 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 <X11/Xlib.h> +#include <X11/Xos.h> +#include "gdk.h" +#include "gdkprivate.h" + + +void +gdk_draw_point (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y) +{ + GdkWindowPrivate *drawable_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (gc != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + gc_private = (GdkGCPrivate*) gc; + + XDrawPoint (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, x, y); +} + +void +gdk_draw_line (GdkDrawable *drawable, + GdkGC *gc, + gint x1, + gint y1, + gint x2, + gint y2) +{ + GdkWindowPrivate *drawable_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (gc != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + gc_private = (GdkGCPrivate*) gc; + + XDrawLine (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, x1, y1, x2, y2); +} + +void +gdk_draw_rectangle (GdkDrawable *drawable, + GdkGC *gc, + gint filled, + gint x, + gint y, + gint width, + gint height) +{ + GdkWindowPrivate *drawable_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (gc != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + gc_private = (GdkGCPrivate*) gc; + + if (width == -1) + width = drawable_private->width; + if (height == -1) + height = drawable_private->height; + + if (filled) + XFillRectangle (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, x, y, width, height); + else + XDrawRectangle (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, x, y, width, height); +} + +void +gdk_draw_arc (GdkDrawable *drawable, + GdkGC *gc, + gint filled, + gint x, + gint y, + gint width, + gint height, + gint angle1, + gint angle2) +{ + GdkWindowPrivate *drawable_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (gc != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + gc_private = (GdkGCPrivate*) gc; + + if (width == -1) + width = drawable_private->width; + if (height == -1) + height = drawable_private->height; + + if (filled) + XFillArc (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, x, y, width, height, angle1, angle2); + else + XDrawArc (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, x, y, width, height, angle1, angle2); +} + +void +gdk_draw_polygon (GdkDrawable *drawable, + GdkGC *gc, + gint filled, + GdkPoint *points, + gint npoints) +{ + GdkWindowPrivate *drawable_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (gc != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + gc_private = (GdkGCPrivate*) gc; + + if (filled) + { + XFillPolygon (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, (XPoint*) points, npoints, Complex, CoordModeOrigin); + } + else + { + XDrawLines (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, (XPoint*) points, npoints, CoordModeOrigin); + + if ((points[0].x != points[npoints-1].x) || + (points[0].y != points[npoints-1].y)) + XDrawLine (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, points[npoints-1].x, points[npoints-1].y, + points[0].x, points[0].y); + } +} + +/* gdk_draw_string + * + * Modified by Li-Da Lho to draw 16 bits and Multibyte strings + * + * Interface changed: add "GdkFont *font" to specify font or fontset explicitely + */ +void +gdk_draw_string (GdkDrawable *drawable, + GdkFont *font, + GdkGC *gc, + gint x, + gint y, + const gchar *string) +{ + GdkWindowPrivate *drawable_private; + GdkFontPrivate *font_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (font != NULL); + g_return_if_fail (gc != NULL); + g_return_if_fail (string != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + gc_private = (GdkGCPrivate*) gc; + font_private = (GdkFontPrivate*) font; + + if (font->type == GDK_FONT_FONT) + { + XFontStruct *xfont = (XFontStruct *) font_private->xfont; + XSetFont(drawable_private->xdisplay, gc_private->xgc, xfont->fid); + if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0)) + { + XDrawString (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, x, y, string, strlen (string)); + } + else + { + XDrawString16 (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, x, y, (XChar2b *) string, + strlen (string) / 2); + } + } + else if (font->type == GDK_FONT_FONTSET) + { + XFontSet fontset = (XFontSet) font_private->xfont; + XmbDrawString (drawable_private->xdisplay, drawable_private->xwindow, + fontset, gc_private->xgc, x, y, string, strlen (string)); + } + else + g_error("undefined font type\n"); +} + +/* gdk_draw_text + * + * Modified by Li-Da Lho to draw 16 bits and Multibyte strings + * + * Interface changed: add "GdkFont *font" to specify font or fontset explicitely + */ +void +gdk_draw_text (GdkDrawable *drawable, + GdkFont *font, + GdkGC *gc, + gint x, + gint y, + const gchar *text, + gint text_length) +{ + GdkWindowPrivate *drawable_private; + GdkFontPrivate *font_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (font != NULL); + g_return_if_fail (gc != NULL); + g_return_if_fail (text != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + gc_private = (GdkGCPrivate*) gc; + font_private = (GdkFontPrivate*) font; + + if (font->type == GDK_FONT_FONT) + { + XFontStruct *xfont = (XFontStruct *) font_private->xfont; + XSetFont(drawable_private->xdisplay, gc_private->xgc, xfont->fid); + if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0)) + { + XDrawString (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, x, y, text, text_length); + } + else + { + XDrawString16 (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, x, y, (XChar2b *) text, text_length / 2); + } + } + else if (font->type == GDK_FONT_FONTSET) + { + XFontSet fontset = (XFontSet) font_private->xfont; + XmbDrawString (drawable_private->xdisplay, drawable_private->xwindow, + fontset, gc_private->xgc, x, y, text, text_length); + } + else + g_error("undefined font type\n"); +} + +void +gdk_draw_pixmap (GdkDrawable *drawable, + GdkGC *gc, + GdkPixmap *src, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height) +{ + GdkWindowPrivate *drawable_private; + GdkWindowPrivate *src_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (src != NULL); + g_return_if_fail (gc != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + src_private = (GdkWindowPrivate*) src; + gc_private = (GdkGCPrivate*) gc; + + if (width == -1) + width = src_private->width; + if (height == -1) + height = src_private->height; + + XCopyArea (drawable_private->xdisplay, + src_private->xwindow, + drawable_private->xwindow, + gc_private->xgc, + xsrc, ysrc, + width, height, + xdest, ydest); +} + +void +gdk_draw_image (GdkDrawable *drawable, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height) +{ + GdkImagePrivate *image_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (image != NULL); + g_return_if_fail (gc != NULL); + + image_private = (GdkImagePrivate*) image; + + g_return_if_fail (image_private->image_put != NULL); + + if (width == -1) + width = image->width; + if (height == -1) + height = image->height; + + (* image_private->image_put) (drawable, gc, image, xsrc, ysrc, + xdest, ydest, width, height); +} + +void +gdk_draw_points (GdkDrawable *drawable, + GdkGC *gc, + GdkPoint *points, + gint npoints) +{ + GdkWindowPrivate *drawable_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail ((points != NULL) && (npoints > 0)); + g_return_if_fail (gc != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + gc_private = (GdkGCPrivate*) gc; + + XDrawPoints (drawable_private->xdisplay, + drawable_private->xwindow, + gc_private->xgc, + (XPoint *) points, + npoints, + CoordModeOrigin); +} + +void +gdk_draw_segments (GdkDrawable *drawable, + GdkGC *gc, + GdkSegment *segs, + gint nsegs) +{ + GdkWindowPrivate *drawable_private; + GdkGCPrivate *gc_private; + + if (nsegs <= 0) + return; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (segs != NULL); + g_return_if_fail (gc != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + gc_private = (GdkGCPrivate*) gc; + + XDrawSegments (drawable_private->xdisplay, + drawable_private->xwindow, + gc_private->xgc, + (XSegment *) segs, + nsegs); +} diff --git a/gdk/gdkfont.c b/gdk/gdkfont.c new file mode 100644 index 000000000..e1b1e7254 --- /dev/null +++ b/gdk/gdkfont.c @@ -0,0 +1,379 @@ +/* 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 <X11/Xlib.h> +#include <X11/Xos.h> +#include "gdk.h" +#include "gdkprivate.h" + +GdkFont* +gdk_font_load (const gchar *font_name) +{ + GdkFont *font; + GdkFontPrivate *private; + + private = g_new (GdkFontPrivate, 1); + font = (GdkFont*) private; + + private->xdisplay = gdk_display; + private->xfont = XLoadQueryFont (private->xdisplay, font_name); + private->ref_count = 1; + + if (!private->xfont) + { + g_free (font); + return NULL; + } + else + { + font->type = GDK_FONT_FONT; + font->ascent = ((XFontStruct *) private->xfont)->ascent; + font->descent = ((XFontStruct *) private->xfont)->descent; + } + + gdk_xid_table_insert (&((XFontStruct *) private->xfont)->fid, font); + + return font; +} + +GdkFont* +gdk_fontset_load(gchar *fontset_name) +{ + GdkFont *font; + GdkFontPrivate *private; + XFontSet fontset; + gint missing_charset_count; + gchar **missing_charset_list; + gchar *def_string; + + private = g_new (GdkFontPrivate, 1); + font = (GdkFont*) private; + + private->xdisplay = gdk_display; + fontset = XCreateFontSet (gdk_display, fontset_name, + &missing_charset_list, &missing_charset_count, + &def_string); + + if (missing_charset_count) + { + g_print ("Missing charsets in FontSet creation"); + XFreeStringList (missing_charset_list); + } + + private->ref_count = 1; + + if (!fontset) + { + g_free (font); + return NULL; + } + else + { + XFontSetExtents *extent = XExtentsOfFontSet(fontset); + + private->xfont = fontset; + font->type = GDK_FONT_FONTSET; + /* how to define ascent and descent for fontset ??? */ + font->ascent = extent->max_logical_extent.height; + font->descent = font->ascent / 4 ; + } + return font; +} +void +gdk_font_free (GdkFont *font) +{ + GdkFontPrivate *private; + + g_return_if_fail (font != NULL); + + private = (GdkFontPrivate*) font; + + private->ref_count -= 1; + if (private->ref_count == 0) + { + gdk_xid_table_remove (((XFontStruct *) private->xfont)->fid); + XFreeFont (private->xdisplay, (XFontStruct *) private->xfont); + g_free (font); + } +} + +void +gdk_fontset_free (GdkFont *font) +{ + GdkFontPrivate *private; + + g_return_if_fail (font != NULL); + + private = (GdkFontPrivate*) font; + + private->ref_count -= 1; + if (private->ref_count == 0) + { + XFreeFontSet (private->xdisplay, (XFontSet) private->xfont); + g_free (font); + } +} + +GdkFont* +gdk_font_ref (GdkFont *font) +{ + GdkFontPrivate *private; + + g_return_val_if_fail (font != NULL, NULL); + + private = (GdkFontPrivate*) font; + private->ref_count += 1; + return font; +} + +gint +gdk_font_id (GdkFont *font) +{ + GdkFontPrivate *font_private; + + g_return_val_if_fail (font != NULL, 0); + + font_private = (GdkFontPrivate*) font; + + if (font->type == GDK_FONT_FONT) + { + return ((XFontStruct *) font_private->xfont)->fid; + } + else + { + return 0; + } +} + +gint +gdk_font_equal (GdkFont *fonta, + GdkFont *fontb) +{ + GdkFontPrivate *privatea; + GdkFontPrivate *privateb; + + g_return_val_if_fail (fonta != NULL, FALSE); + g_return_val_if_fail (fontb != NULL, FALSE); + + privatea = (GdkFontPrivate*) fonta; + privateb = (GdkFontPrivate*) fontb; + + if (fonta->type == GDK_FONT_FONT && fontb->type == GDK_FONT_FONT) + { + return (((XFontStruct *) privatea->xfont)->fid == + ((XFontStruct *) privateb->xfont)->fid); + } + else if (fonta->type == GDK_FONT_FONTSET && fontb->type == GDK_FONT_FONTSET) + { + /* how to compare two fontsets ?? by basename or XFontSet ?? */ + return (((XFontSet) privatea->xfont) == ((XFontSet) privateb->xfont)); + } + else + /* fontset != font */ + return 0; +} + +gint +gdk_string_width (GdkFont *font, + const gchar *string) +{ + GdkFontPrivate *font_private; + gint width; + XFontStruct *xfont; + XFontSet fontset; + + g_return_val_if_fail (font != NULL, -1); + g_return_val_if_fail (string != NULL, -1); + + font_private = (GdkFontPrivate*) font; + + switch (font->type) + { + case GDK_FONT_FONT: + xfont = (XFontStruct *) font_private->xfont; + if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0)) + { + width = XTextWidth (xfont, string, strlen (string)); + } + else + { + width = XTextWidth16 (xfont, (XChar2b *) string, strlen (string) / 2); + } + break; + case GDK_FONT_FONTSET: + fontset = (XFontSet) font_private->xfont; + width = XmbTextEscapement (fontset, string, strlen(string)); + break; + default: + width = 0; + } + + return width; +} + +gint +gdk_text_width (GdkFont *font, + const gchar *text, + gint text_length) +{ + GdkFontPrivate *private; + gint width; + XFontStruct *xfont; + XFontSet fontset; + + g_return_val_if_fail (font != NULL, -1); + g_return_val_if_fail (text != NULL, -1); + + private = (GdkFontPrivate*) font; + + switch (font->type) + { + case GDK_FONT_FONT: + xfont = (XFontStruct *) private->xfont; + if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0)) + { + width = XTextWidth (xfont, text, text_length); + } + else + { + width = XTextWidth16 (xfont, (XChar2b *) text, text_length / 2); + } + break; + case GDK_FONT_FONTSET: + fontset = (XFontSet) private->xfont; + width = XmbTextEscapement (fontset, text, text_length); + break; + default: + width = 0; + } + return width; +} + +/* Problem: What if a character is a 16 bits character ?? */ +gint +gdk_char_width (GdkFont *font, + gchar character) +{ + GdkFontPrivate *private; + XCharStruct *chars; + gint width; + guint ch = character & 0xff; /* get rid of sign-extension */ + XFontStruct *xfont; + XFontSet fontset; + + g_return_val_if_fail (font != NULL, -1); + + private = (GdkFontPrivate*) font; + + switch (font->type) + { + case GDK_FONT_FONT: + /* only 8 bits characters are considered here */ + xfont = (XFontStruct *) private->xfont; + if ((xfont->min_byte1 == 0) && + (xfont->max_byte1 == 0) && + (ch >= xfont->min_char_or_byte2) && + (ch <= xfont->max_char_or_byte2)) + { + chars = xfont->per_char; + if (chars) + width = chars[ch - xfont->min_char_or_byte2].width; + else + width = xfont->min_bounds.width; + } + else + { + width = XTextWidth (xfont, &character, 1); + } + break; + case GDK_FONT_FONTSET: + fontset = (XFontSet) private->xfont; + width = XmbTextEscapement (fontset, &character, 1) ; + break; + default: + width = 0; + } + return width; +} + +gint +gdk_string_measure (GdkFont *font, + const gchar *string) +{ + g_return_val_if_fail (font != NULL, -1); + g_return_val_if_fail (string != NULL, -1); + + return gdk_text_measure (font, string, strlen (string)); +} + +gint +gdk_text_measure (GdkFont *font, + const gchar *text, + gint text_length) +{ + GdkFontPrivate *private; + XCharStruct overall; + XFontStruct *xfont; + XFontSet fontset; + XRectangle ink, log; + int direction; + int font_ascent; + int font_descent; + gint width; + + g_return_val_if_fail (font != NULL, -1); + g_return_val_if_fail (text != NULL, -1); + + private = (GdkFontPrivate*) font; + + switch (font->type) + { + case GDK_FONT_FONT: + xfont = (XFontStruct *) private->xfont; + if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0)) + { + XTextExtents (xfont, text, text_length, + &direction, &font_ascent, &font_descent, + &overall); + } + else + { + XTextExtents16 (xfont, (XChar2b *) text, text_length / 2, + &direction, &font_ascent, &font_descent, + &overall); + } + width = overall.rbearing; + break; + case GDK_FONT_FONTSET: + fontset = (XFontSet) private->xfont; + XmbTextExtents (fontset, text, text_length, &ink, &log); + width = log.width; + break; + default: + width = 0; + } + return width; +} + +gint +gdk_char_measure (GdkFont *font, + gchar character) +{ + g_return_val_if_fail (font != NULL, -1); + + return gdk_text_measure (font, &character, 1); +} diff --git a/gdk/gdkgc.c b/gdk/gdkgc.c new file mode 100644 index 000000000..3dc11ce6c --- /dev/null +++ b/gdk/gdkgc.c @@ -0,0 +1,636 @@ +/* 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 <string.h> +#include <X11/Xlib.h> +#include "gdk.h" +#include "gdkprivate.h" + + +GdkGC* +gdk_gc_new (GdkWindow *window) +{ + return gdk_gc_new_with_values (window, NULL, 0); +} + +GdkGC* +gdk_gc_new_with_values (GdkWindow *window, + GdkGCValues *values, + GdkGCValuesMask values_mask) +{ + GdkGC *gc; + GdkGCPrivate *private; + Window xwindow; + XGCValues xvalues; + unsigned long xvalues_mask; + + private = g_new (GdkGCPrivate, 1); + gc = (GdkGC*) private; + + xwindow = ((GdkWindowPrivate*) window)->xwindow; + private->xdisplay = ((GdkWindowPrivate*) window)->xdisplay; + + xvalues.function = GXcopy; + xvalues.fill_style = FillSolid; + xvalues.arc_mode = ArcPieSlice; + xvalues.subwindow_mode = ClipByChildren; + xvalues.graphics_exposures = True; + xvalues_mask = GCFunction | GCFillStyle | GCArcMode | GCSubwindowMode | GCGraphicsExposures; + + if (values_mask & GDK_GC_FOREGROUND) + { + xvalues.foreground = values->foreground.pixel; + xvalues_mask |= GCForeground; + } + if (values_mask & GDK_GC_BACKGROUND) + { + xvalues.background = values->background.pixel; + xvalues_mask |= GCBackground; + } + if ((values_mask & GDK_GC_FONT) && (values->font->type == GDK_FONT_FONT)) + { + xvalues.font = ((XFontStruct *) ((GdkFontPrivate*) values->font)->xfont)->fid; + xvalues_mask |= GCFont; + } + if (values_mask & GDK_GC_FUNCTION) + { + switch (values->function) + { + case GDK_COPY: + xvalues.function = GXcopy; + break; + case GDK_INVERT: + xvalues.function = GXinvert; + break; + case GDK_XOR: + xvalues.function = GXxor; + break; + } + xvalues_mask |= GCFunction; + } + if (values_mask & GDK_GC_FILL) + { + switch (values->fill) + { + case GDK_SOLID: + xvalues.fill_style = FillSolid; + break; + case GDK_TILED: + xvalues.fill_style = FillTiled; + break; + case GDK_STIPPLED: + xvalues.fill_style = FillStippled; + break; + case GDK_OPAQUE_STIPPLED: + xvalues.fill_style = FillOpaqueStippled; + break; + } + xvalues_mask |= GCFillStyle; + } + if (values_mask & GDK_GC_TILE) + { + xvalues.tile = ((GdkPixmapPrivate*) values->tile)->xwindow; + xvalues_mask |= GCTile; + } + if (values_mask & GDK_GC_STIPPLE) + { + xvalues.stipple = ((GdkPixmapPrivate*) values->stipple)->xwindow; + xvalues_mask |= GCStipple; + } + if (values_mask & GDK_GC_CLIP_MASK) + { + xvalues.clip_mask = ((GdkPixmapPrivate*) values->clip_mask)->xwindow; + xvalues_mask |= GCClipMask; + } + if (values_mask & GDK_GC_SUBWINDOW) + { + xvalues.subwindow_mode = values->subwindow_mode; + xvalues_mask |= GCSubwindowMode; + } + if (values_mask & GDK_GC_TS_X_ORIGIN) + { + xvalues.ts_x_origin = values->ts_x_origin; + xvalues_mask |= GCTileStipXOrigin; + } + if (values_mask & GDK_GC_TS_Y_ORIGIN) + { + xvalues.ts_y_origin = values->ts_y_origin; + xvalues_mask |= GCTileStipYOrigin; + } + if (values_mask & GDK_GC_CLIP_X_ORIGIN) + { + xvalues.clip_x_origin = values->clip_x_origin; + xvalues_mask |= GCClipXOrigin; + } + if (values_mask & GDK_GC_CLIP_Y_ORIGIN) + { + xvalues.clip_y_origin = values->clip_y_origin; + xvalues_mask |= GCClipYOrigin; + } + if (values_mask & GDK_GC_EXPOSURES) + { + xvalues.graphics_exposures = values->graphics_exposures; + xvalues_mask |= GCGraphicsExposures; + } + if (values_mask & GDK_GC_LINE_WIDTH) + { + xvalues.line_width = values->line_width; + xvalues_mask |= GCLineWidth; + } + if (values_mask & GDK_GC_LINE_STYLE) + { + switch (values->line_style) + { + case GDK_LINE_SOLID: + xvalues.line_style = LineSolid; + break; + case GDK_LINE_ON_OFF_DASH: + xvalues.line_style = LineOnOffDash; + break; + case GDK_LINE_DOUBLE_DASH: + xvalues.line_style = LineDoubleDash; + break; + } + xvalues_mask |= GCLineStyle; + } + if (values_mask & GDK_GC_CAP_STYLE) + { + switch (values->cap_style) + { + case GDK_CAP_NOT_LAST: + xvalues.cap_style = CapNotLast; + break; + case GDK_CAP_BUTT: + xvalues.cap_style = CapButt; + break; + case GDK_CAP_ROUND: + xvalues.cap_style = CapRound; + break; + case GDK_CAP_PROJECTING: + xvalues.cap_style = CapProjecting; + break; + } + xvalues_mask |= GCCapStyle; + } + if (values_mask & GDK_GC_JOIN_STYLE) + { + switch (values->join_style) + { + case GDK_JOIN_MITER: + xvalues.join_style = JoinMiter; + break; + case GDK_JOIN_ROUND: + xvalues.join_style = JoinRound; + break; + case GDK_JOIN_BEVEL: + xvalues.join_style = JoinBevel; + break; + } + xvalues_mask |= GCJoinStyle; + } + + private->xgc = XCreateGC (private->xdisplay, xwindow, xvalues_mask, &xvalues); + + return gc; +} + +void +gdk_gc_destroy (GdkGC *gc) +{ + GdkGCPrivate *private; + + g_return_if_fail (gc != NULL); + + private = (GdkGCPrivate*) gc; + XFreeGC (private->xdisplay, private->xgc); + + memset (gc, 0, sizeof (GdkGCPrivate)); + g_free (gc); +} + +void +gdk_gc_get_values (GdkGC *gc, + GdkGCValues *values) +{ + GdkGCPrivate *private; + XGCValues xvalues; + + g_return_if_fail (gc != NULL); + g_return_if_fail (values != NULL); + + private = (GdkGCPrivate*) gc; + + if (XGetGCValues (private->xdisplay, private->xgc, + GCForeground | GCBackground | GCFont | + GCFunction | GCTile | GCStipple | /* GCClipMask | */ + GCSubwindowMode | GCGraphicsExposures | + GCTileStipXOrigin | GCTileStipYOrigin | + GCClipXOrigin | GCClipYOrigin | + GCLineWidth | GCLineStyle | GCCapStyle | + GCFillStyle | GCJoinStyle, &xvalues)) + { + values->foreground.pixel = xvalues.foreground; + values->background.pixel = xvalues.background; + values->font = gdk_font_lookup (xvalues.font); + + switch (xvalues.function) + { + case GXcopy: + values->function = GDK_COPY; + break; + case GXinvert: + values->function = GDK_INVERT; + break; + case GXxor: + values->function = GDK_XOR; + break; + } + + switch (xvalues.fill_style) + { + case FillSolid: + values->fill = GDK_SOLID; + break; + case FillTiled: + values->fill = GDK_TILED; + break; + case FillStippled: + values->fill = GDK_STIPPLED; + break; + case FillOpaqueStippled: + values->fill = GDK_OPAQUE_STIPPLED; + break; + } + + values->tile = gdk_pixmap_lookup (xvalues.tile); + values->stipple = gdk_pixmap_lookup (xvalues.stipple); + values->clip_mask = NULL; + values->subwindow_mode = xvalues.subwindow_mode; + values->ts_x_origin = xvalues.ts_x_origin; + values->ts_y_origin = xvalues.ts_y_origin; + values->clip_x_origin = xvalues.clip_x_origin; + values->clip_y_origin = xvalues.clip_y_origin; + values->graphics_exposures = xvalues.graphics_exposures; + values->line_width = xvalues.line_width; + + switch (xvalues.line_style) + { + case LineSolid: + values->line_style = GDK_LINE_SOLID; + break; + case LineOnOffDash: + values->line_style = GDK_LINE_ON_OFF_DASH; + break; + case LineDoubleDash: + values->line_style = GDK_LINE_DOUBLE_DASH; + break; + } + + switch (xvalues.cap_style) + { + case CapNotLast: + values->cap_style = GDK_CAP_NOT_LAST; + break; + case CapButt: + values->cap_style = GDK_CAP_BUTT; + break; + case CapRound: + values->cap_style = GDK_CAP_ROUND; + break; + case CapProjecting: + values->cap_style = GDK_CAP_PROJECTING; + break; + } + + switch (xvalues.join_style) + { + case JoinMiter: + values->join_style = GDK_JOIN_MITER; + break; + case JoinRound: + values->join_style = GDK_JOIN_ROUND; + break; + case JoinBevel: + values->join_style = GDK_JOIN_BEVEL; + break; + } + } + else + { + memset (values, 0, sizeof (GdkGCValues)); + } +} + +void +gdk_gc_set_foreground (GdkGC *gc, + GdkColor *color) +{ + GdkGCPrivate *private; + + g_return_if_fail (gc != NULL); + g_return_if_fail (color != NULL); + + private = (GdkGCPrivate*) gc; + XSetForeground (private->xdisplay, private->xgc, color->pixel); +} + +void +gdk_gc_set_background (GdkGC *gc, + GdkColor *color) +{ + GdkGCPrivate *private; + + g_return_if_fail (gc != NULL); + g_return_if_fail (color != NULL); + + private = (GdkGCPrivate*) gc; + XSetBackground (private->xdisplay, private->xgc, color->pixel); +} + +void +gdk_gc_set_font (GdkGC *gc, + GdkFont *font) +{ + GdkGCPrivate *gc_private; + GdkFontPrivate *font_private; + + g_return_if_fail (gc != NULL); + g_return_if_fail (font != NULL); + + gc_private = (GdkGCPrivate*) gc; + font_private = (GdkFontPrivate*) font; + + XSetFont (gc_private->xdisplay, gc_private->xgc, + ((XFontStruct *) font_private->xfont)->fid); +} + +void +gdk_gc_set_function (GdkGC *gc, + GdkFunction function) +{ + GdkGCPrivate *private; + + g_return_if_fail (gc != NULL); + + private = (GdkGCPrivate*) gc; + + switch (function) + { + case GDK_COPY: + XSetFunction (private->xdisplay, private->xgc, GXcopy); + break; + case GDK_INVERT: + XSetFunction (private->xdisplay, private->xgc, GXinvert); + break; + case GDK_XOR: + XSetFunction (private->xdisplay, private->xgc, GXor); + break; + } +} + +void +gdk_gc_set_fill (GdkGC *gc, + GdkFill fill) +{ + GdkGCPrivate *private; + + g_return_if_fail (gc != NULL); + + private = (GdkGCPrivate*) gc; + + switch (fill) + { + case GDK_SOLID: + XSetFillStyle (private->xdisplay, private->xgc, FillSolid); + break; + case GDK_TILED: + XSetFillStyle (private->xdisplay, private->xgc, FillTiled); + break; + case GDK_STIPPLED: + XSetFillStyle (private->xdisplay, private->xgc, FillStippled); + break; + case GDK_OPAQUE_STIPPLED: + XSetFillStyle (private->xdisplay, private->xgc, FillOpaqueStippled); + break; + } +} + +void +gdk_gc_set_tile (GdkGC *gc, + GdkPixmap *tile) +{ + GdkGCPrivate *private; + GdkPixmapPrivate *pixmap_private; + Pixmap pixmap; + + g_return_if_fail (gc != NULL); + + private = (GdkGCPrivate*) gc; + + pixmap = None; + if (tile) + { + pixmap_private = (GdkPixmapPrivate*) tile; + pixmap = pixmap_private->xwindow; + } + + XSetTile (private->xdisplay, private->xgc, pixmap); +} + +void +gdk_gc_set_stipple (GdkGC *gc, + GdkPixmap *stipple) +{ + GdkGCPrivate *private; + GdkPixmapPrivate *pixmap_private; + Pixmap pixmap; + + g_return_if_fail (gc != NULL); + + private = (GdkGCPrivate*) gc; + + pixmap = None; + if (stipple) + { + pixmap_private = (GdkPixmapPrivate*) stipple; + pixmap = pixmap_private->xwindow; + } + + XSetStipple (private->xdisplay, private->xgc, pixmap); +} + +void +gdk_gc_set_ts_origin (GdkGC *gc, + gint x, + gint y) +{ + GdkGCPrivate *private; + + g_return_if_fail (gc != NULL); + + private = (GdkGCPrivate*) gc; + + XSetTSOrigin (private->xdisplay, private->xgc, x, y); +} + +void +gdk_gc_set_clip_origin (GdkGC *gc, + gint x, + gint y) +{ + GdkGCPrivate *private; + + g_return_if_fail (gc != NULL); + + private = (GdkGCPrivate*) gc; + + XSetClipOrigin (private->xdisplay, private->xgc, x, y); +} + +void +gdk_gc_set_clip_mask (GdkGC *gc, + GdkBitmap *mask) +{ + GdkGCPrivate *private; + Pixmap xmask; + + g_return_if_fail (gc != NULL); + + private = (GdkGCPrivate*) gc; + + if (mask) + xmask = ((GdkWindowPrivate*) mask)->xwindow; + else + xmask = None; + + XSetClipMask (private->xdisplay, private->xgc, xmask); +} + + +void +gdk_gc_set_clip_rectangle (GdkGC *gc, + GdkRectangle *rectangle) +{ + GdkGCPrivate *private; + XRectangle xrectangle; + + g_return_if_fail (gc != NULL); + + private = (GdkGCPrivate*) gc; + + xrectangle.x = rectangle->x; + xrectangle.y = rectangle->y; + xrectangle.width = rectangle->width; + xrectangle.height = rectangle->height; + + XSetClipRectangles (private->xdisplay, private->xgc, 0, 0, + &xrectangle, 1, Unsorted); +} + +void +gdk_gc_set_subwindow (GdkGC *gc, + GdkSubwindowMode mode) +{ + GdkGCPrivate *private; + + g_return_if_fail (gc != NULL); + + private = (GdkGCPrivate*) gc; + + XSetSubwindowMode (private->xdisplay, private->xgc, mode); +} + +void +gdk_gc_set_exposures (GdkGC *gc, + gint exposures) +{ + GdkGCPrivate *private; + + g_return_if_fail (gc != NULL); + + private = (GdkGCPrivate*) gc; + + XSetGraphicsExposures (private->xdisplay, private->xgc, exposures); +} + +void +gdk_gc_set_line_attributes (GdkGC *gc, + gint line_width, + GdkLineStyle line_style, + GdkCapStyle cap_style, + GdkJoinStyle join_style) +{ + GdkGCPrivate *private; + int xline_style; + int xcap_style; + int xjoin_style; + + g_return_if_fail (gc != NULL); + + private = (GdkGCPrivate*) gc; + + switch (line_style) + { + case GDK_LINE_SOLID: + xline_style = LineSolid; + break; + case GDK_LINE_ON_OFF_DASH: + xline_style = LineOnOffDash; + break; + case GDK_LINE_DOUBLE_DASH: + xline_style = LineDoubleDash; + break; + default: + xline_style = None; + } + + switch (cap_style) + { + case GDK_CAP_NOT_LAST: + xcap_style = CapNotLast; + break; + case GDK_CAP_BUTT: + xcap_style = CapButt; + break; + case GDK_CAP_ROUND: + xcap_style = CapRound; + break; + case GDK_CAP_PROJECTING: + xcap_style = CapProjecting; + break; + default: + xcap_style = None; + } + + switch (join_style) + { + case GDK_JOIN_MITER: + xjoin_style = JoinMiter; + break; + case GDK_JOIN_ROUND: + xjoin_style = JoinRound; + break; + case GDK_JOIN_BEVEL: + xjoin_style = JoinBevel; + break; + default: + xjoin_style = None; + } + + XSetLineAttributes (private->xdisplay, private->xgc, line_width, + xline_style, xcap_style, xjoin_style); +} diff --git a/gdk/gdkglobals.c b/gdk/gdkglobals.c new file mode 100644 index 000000000..58f7bf844 --- /dev/null +++ b/gdk/gdkglobals.c @@ -0,0 +1,47 @@ +/* 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 <stdio.h> +#include <X11/Xlib.h> +#include "gdktypes.h" +#include "gdkprivate.h" + +gint gdk_debug_level = 0; +gint gdk_show_events = FALSE; +gint gdk_use_xshm = TRUE; +gchar *gdk_display_name = NULL; +Display *gdk_display = NULL; +gint gdk_screen; +Window gdk_root_window; +Window gdk_leader_window; +GdkWindowPrivate gdk_root_parent; +Atom gdk_wm_delete_window; +Atom gdk_wm_take_focus; +Atom gdk_wm_protocols; +Atom gdk_wm_window_protocols[2]; +Atom gdk_selection_property; +GdkDndGlobals gdk_dnd = {None,None,None, + None,None,None, + None, + None,None, + NULL, + 0, 0, + {0,0}}; +gchar *gdk_progname = NULL; +gchar *gdk_progclass = NULL; +gint gdk_error_code; +gint gdk_error_warnings = TRUE; diff --git a/gdk/gdkimage.c b/gdk/gdkimage.c new file mode 100644 index 000000000..bcda3119f --- /dev/null +++ b/gdk/gdkimage.c @@ -0,0 +1,492 @@ +/* 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" + +#include <sys/types.h> + +#if defined (HAVE_IPC_H) && defined (HAVE_SHM_H) && defined (HAVE_XSHM_H) +#define USE_SHM +#endif + +#ifdef USE_SHM +#include <sys/ipc.h> +#include <sys/shm.h> +#endif /* USE_SHM */ + +#include <X11/Xlib.h> +#include <X11/Xutil.h> + +#ifdef USE_SHM +#include <X11/extensions/XShm.h> +#endif /* USE_SHM */ + +#include "gdk.h" +#include "gdkprivate.h" + + +static void gdk_image_put_normal (GdkDrawable *drawable, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height); +static void gdk_image_put_shared (GdkDrawable *drawable, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height); + + +static GList *image_list = NULL; + + +void +gdk_image_exit () +{ + GdkImage *image; + + while (image_list) + { + image = image_list->data; + gdk_image_destroy (image); + } +} + +GdkImage * +gdk_image_new_bitmap(GdkVisual *visual, gpointer data, gint w, gint h) +/* + * Desc: create a new bitmap image + */ +{ + Visual *xvisual; + GdkImage *image; + GdkImagePrivate *private; + private = g_new(GdkImagePrivate, 1); + image = (GdkImage *) private; + private->xdisplay = gdk_display; + private->image_put = gdk_image_put_normal; + image->type = GDK_IMAGE_NORMAL; + image->visual = visual; + image->width = w; + image->height = h; + image->depth = 1; + xvisual = ((GdkVisualPrivate*) visual)->xvisual; + private->ximage = XCreateImage(private->xdisplay, xvisual, 1, XYBitmap, + 0, 0, w ,h, 8, 0); + private->ximage->data = data; + private->ximage->bitmap_bit_order = MSBFirst; + private->ximage->byte_order = MSBFirst; + image->byte_order = MSBFirst; + image->mem = private->ximage->data; + image->bpl = private->ximage->bytes_per_line; + image->bpp = 1; + return(image); +} /* gdk_image_new_bitmap() */ + +static int +gdk_image_check_xshm(Display *display) +/* + * Desc: query the server for support for the MIT_SHM extension + * Return: 0 = not available + * 1 = shared XImage support available + * 2 = shared Pixmap support available also + */ +{ +#ifdef USE_SHM + int major, minor, ignore; + Bool pixmaps; + + if (XQueryExtension(display, "MIT-SHM", &ignore, &ignore, &ignore)) + { + if (XShmQueryVersion(display, &major, &minor, &pixmaps )==True) + { + return (pixmaps==True) ? 2 : 1; + } + } +#endif /* USE_SHM */ + return 0; +} + +void +gdk_image_init () +{ + if (gdk_use_xshm) + { + if (!gdk_image_check_xshm (gdk_display)) + { + g_warning ("MIT-SHM Extension not availible on server"); + gdk_use_xshm = False; + } + } +} + +GdkImage* +gdk_image_new (GdkImageType type, + GdkVisual *visual, + gint width, + gint height) +{ + GdkImage *image; + GdkImagePrivate *private; +#ifdef USE_SHM + XShmSegmentInfo *x_shm_info; +#endif /* USE_SHM */ + Visual *xvisual; + + switch (type) + { + case GDK_IMAGE_FASTEST: + image = gdk_image_new (GDK_IMAGE_SHARED, visual, width, height); + + if (!image) + image = gdk_image_new (GDK_IMAGE_NORMAL, visual, width, height); + break; + + default: + private = g_new (GdkImagePrivate, 1); + image = (GdkImage*) private; + + private->xdisplay = gdk_display; + private->image_put = NULL; + + image->type = type; + image->visual = visual; + image->width = width; + image->height = height; + image->depth = visual->depth; + + xvisual = ((GdkVisualPrivate*) visual)->xvisual; + + switch (type) + { + case GDK_IMAGE_SHARED: +#ifdef USE_SHM + if (gdk_use_xshm) + { + private->image_put = gdk_image_put_shared; + + private->x_shm_info = g_new (XShmSegmentInfo, 1); + x_shm_info = private->x_shm_info; + + private->ximage = XShmCreateImage (private->xdisplay, xvisual, visual->depth, + ZPixmap, NULL, x_shm_info, width, height); + if (private->ximage == NULL) + { + g_warning ("XShmCreateImage failed"); + + g_free (image); + gdk_use_xshm = False; + return NULL; + } + + x_shm_info->shmid = shmget (IPC_PRIVATE, + private->ximage->bytes_per_line * private->ximage->height, + IPC_CREAT | 0777); + + if (x_shm_info->shmid == -1) + { + g_warning ("shmget failed!"); + + XDestroyImage (private->ximage); + g_free (private->x_shm_info); + g_free (image); + + gdk_use_xshm = False; + gdk_use_xshm = False; + return NULL; + } + + x_shm_info->readOnly = False; + x_shm_info->shmaddr = shmat (x_shm_info->shmid, 0, 0); + private->ximage->data = x_shm_info->shmaddr; + + if (x_shm_info->shmaddr == (char*) -1) + { + g_warning ("shmat failed!"); + + XDestroyImage (private->ximage); + shmctl (x_shm_info->shmid, IPC_RMID, 0); + + g_free (private->x_shm_info); + g_free (image); + + return NULL; + } + +#ifdef IPC_RMID_DEFERRED_RELEASE + if (x_shm_info->shmaddr != (char*) -1) + shmctl (x_shm_info->shmid, IPC_RMID, 0); +#endif + + gdk_error_code = 0; + gdk_error_warnings = 0; + + XShmAttach (private->xdisplay, x_shm_info); + XSync (private->xdisplay, False); + + gdk_error_warnings = 1; + if (gdk_error_code == -1) + { + g_warning ("XShmAttach failed!"); + + XDestroyImage (private->ximage); + shmdt (x_shm_info->shmaddr); + shmctl (x_shm_info->shmid, IPC_RMID, 0); + + g_free (private->x_shm_info); + g_free (image); + + gdk_use_xshm = False; + return NULL; + } + + if (image) + image_list = g_list_prepend (image_list, image); + } + else + { + g_free (image); + return NULL; + } + break; +#else /* USE_SHM */ + g_free (image); + return NULL; +#endif /* USE_SHM */ + case GDK_IMAGE_NORMAL: + private->image_put = gdk_image_put_normal; + + private->ximage = XCreateImage (private->xdisplay, xvisual, visual->depth, + ZPixmap, 0, 0, width, height, 32, 0); + + private->ximage->data = g_new (char, private->ximage->bytes_per_line * + private->ximage->height); + break; + + case GDK_IMAGE_FASTEST: + g_assert_not_reached (); + } + + if (image) + { + image->byte_order = private->ximage->byte_order; + image->mem = private->ximage->data; + image->bpl = private->ximage->bytes_per_line; + + switch (private->ximage->bits_per_pixel) + { + case 8: + image->bpp = 1; + break; + case 16: + image->bpp = 2; + break; + case 24: + image->bpp = 3; + break; + case 32: + image->bpp = 4; + break; + } + } + } + + return image; +} + +GdkImage* +gdk_image_get (GdkWindow *window, + gint x, + gint y, + gint width, + gint height) +{ + GdkImage *image; + GdkImagePrivate *private; + GdkWindowPrivate *win_private; + + g_return_val_if_fail (window != NULL, NULL); + + win_private = (GdkWindowPrivate *) window; + + private = g_new (GdkImagePrivate, 1); + image = (GdkImage*) private; + + private->xdisplay = gdk_display; + private->image_put = gdk_image_put_normal; + private->ximage = XGetImage (private->xdisplay, + win_private->xwindow, + x, y, width, height, + AllPlanes, ZPixmap); + + image->type = GDK_IMAGE_NORMAL; + image->visual = gdk_window_get_visual (window); + image->width = width; + image->height = height; + image->depth = private->ximage->depth; + + image->mem = private->ximage->data; + image->bpl = private->ximage->bytes_per_line; + image->bpp = 1; + + return image; +} + +guint32 +gdk_image_get_pixel (GdkImage *image, + gint x, + gint y) +{ + guint32 pixel; + GdkImagePrivate *private; + + g_return_val_if_fail (image != NULL, 0); + + private = (GdkImagePrivate *) image; + + pixel = XGetPixel (private->ximage, x, y); + + return pixel; +} + +void +gdk_image_put_pixel (GdkImage *image, + gint x, + gint y, + guint32 pixel) +{ + GdkImagePrivate *private; + + g_return_if_fail (image != NULL); + + private = (GdkImagePrivate *) image; + + pixel = XPutPixel (private->ximage, x, y, pixel); +} + +void +gdk_image_destroy (GdkImage *image) +{ + GdkImagePrivate *private; +#ifdef USE_SHM + XShmSegmentInfo *x_shm_info; +#endif /* USE_SHM */ + + g_return_if_fail (image != NULL); + + private = (GdkImagePrivate*) image; + switch (image->type) + { + case GDK_IMAGE_NORMAL: + XDestroyImage (private->ximage); + break; + + case GDK_IMAGE_SHARED: +#ifdef USE_SHM + XShmDetach (private->xdisplay, private->x_shm_info); + XDestroyImage (private->ximage); + + x_shm_info = private->x_shm_info; + shmdt (x_shm_info->shmaddr); + shmctl (x_shm_info->shmid, IPC_RMID, 0); + + g_free (private->x_shm_info); + + image_list = g_list_remove (image_list, image); +#else /* USE_SHM */ + g_error ("trying to destroy shared memory image when gdk was compiled without shared memory support"); +#endif /* USE_SHM */ + break; + + case GDK_IMAGE_FASTEST: + g_assert_not_reached (); + } + + g_free (image); +} + +static void +gdk_image_put_normal (GdkDrawable *drawable, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height) +{ + GdkWindowPrivate *drawable_private; + GdkImagePrivate *image_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (image != NULL); + g_return_if_fail (gc != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + image_private = (GdkImagePrivate*) image; + gc_private = (GdkGCPrivate*) gc; + + g_return_if_fail (image->type == GDK_IMAGE_NORMAL); + + XPutImage (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, image_private->ximage, + xsrc, ysrc, xdest, ydest, width, height); +} + +static void +gdk_image_put_shared (GdkDrawable *drawable, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height) +{ +#ifdef USE_SHM + GdkWindowPrivate *drawable_private; + GdkImagePrivate *image_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (image != NULL); + g_return_if_fail (gc != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + image_private = (GdkImagePrivate*) image; + gc_private = (GdkGCPrivate*) gc; + + g_return_if_fail (image->type == GDK_IMAGE_SHARED); + + XShmPutImage (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, image_private->ximage, + xsrc, ysrc, xdest, ydest, width, height, False); +#else /* USE_SHM */ + g_error ("trying to draw shared memory image when gdk was compiled without shared memory support"); +#endif /* USE_SHM */ +} diff --git a/gdk/gdkinput.c b/gdk/gdkinput.c new file mode 100644 index 000000000..ad4b1fcc9 --- /dev/null +++ b/gdk/gdkinput.c @@ -0,0 +1,324 @@ +/* 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 <stdlib.h> +#include <X11/Xlib.h> +#include <X11/Xutil.h> +#include "../config.h" +#include "gdk.h" +#include "gdkx.h" +#include "gdkprivate.h" +#include "gdkinput.h" + + +/* Forward declarations */ + +static gint gdk_input_enable_window (GdkWindow *window, + GdkDevicePrivate *gdkdev); +static gint gdk_input_disable_window (GdkWindow *window, + GdkDevicePrivate *gdkdev); +static GdkInputWindow *gdk_input_window_find (GdkWindow *window); +static GdkDevicePrivate *gdk_input_find_device (guint32 id); + + +/* Incorporate the specific routines depending on compilation options */ + +static GdkAxisUse gdk_input_core_axes[] = { GDK_AXIS_X, GDK_AXIS_Y }; + +static GdkDeviceInfo gdk_input_core_info = +{ + GDK_CORE_POINTER, + "Core Pointer", + GDK_SOURCE_MOUSE, + GDK_MODE_SCREEN, + TRUE, + 2, + gdk_input_core_axes +}; + +/* Global variables */ + +GdkInputVTable gdk_input_vtable; +/* information about network port and host for gxid daemon */ +gchar *gdk_input_gxid_host; +gint gdk_input_gxid_port; +gint gdk_input_ignore_core; + +/* Local variables */ + +static GList *gdk_input_devices; +static GList *gdk_input_windows; + +#include "gdkinputnone.h" +#include "gdkinputcommon.h" +#include "gdkinputxfree.h" +#include "gdkinputgxi.h" + +GList * +gdk_input_list_devices () +{ + return gdk_input_devices; +} + +void +gdk_input_set_source (guint32 deviceid, GdkInputSource source) +{ + GdkDevicePrivate *gdkdev = gdk_input_find_device(deviceid); + g_return_if_fail (gdkdev != NULL); + + gdkdev->info.source = source; +} + +gint +gdk_input_set_mode (guint32 deviceid, GdkInputMode mode) +{ + if (deviceid == GDK_CORE_POINTER) + return FALSE; + + if (gdk_input_vtable.set_mode) + return gdk_input_vtable.set_mode(deviceid,mode); + else + return FALSE; +} + +void +gdk_input_set_axes (guint32 deviceid, GdkAxisUse *axes) +{ + if (deviceid != GDK_CORE_POINTER && gdk_input_vtable.set_axes) + gdk_input_vtable.set_axes (deviceid, axes); +} + +GdkTimeCoord * +gdk_input_motion_events (GdkWindow *window, + guint32 deviceid, + guint32 start, + guint32 stop, + gint *nevents_return) +{ + XTimeCoord *xcoords; + GdkTimeCoord *coords; + int i; + + if (deviceid == GDK_CORE_POINTER) + { + xcoords = XGetMotionEvents (gdk_display, + ((GdkWindowPrivate *)window)->xwindow, + start, stop, nevents_return); + if (xcoords) + { + coords = g_new (GdkTimeCoord, *nevents_return); + for (i=0; i<*nevents_return; i++) + { + coords[i].time = xcoords[i].time; + coords[i].x = xcoords[i].x; + coords[i].y = xcoords[i].y; + coords[i].pressure = 0.5; + coords[i].xtilt = 0.0; + coords[i].ytilt = 0.0; + } + + XFree(xcoords); + + return coords; + } + else + return NULL; + } + else + { + if (gdk_input_vtable.motion_events) + { + return gdk_input_vtable.motion_events(window, + deviceid, start, stop, + nevents_return); + } + else + { + *nevents_return = 0; + return NULL; + } + } +} + +static gint +gdk_input_enable_window (GdkWindow *window, GdkDevicePrivate *gdkdev) +{ + if (gdk_input_vtable.enable_window) + return gdk_input_vtable.enable_window (window, gdkdev); + else + return TRUE; +} + +static gint +gdk_input_disable_window (GdkWindow *window, GdkDevicePrivate *gdkdev) +{ + if (gdk_input_vtable.disable_window) + return gdk_input_vtable.disable_window(window,gdkdev); + else + return TRUE; +} + + +static GdkInputWindow * +gdk_input_window_find(GdkWindow *window) +{ + GList *tmp_list; + + for (tmp_list=gdk_input_windows; tmp_list; tmp_list=tmp_list->next) + if (((GdkInputWindow *)(tmp_list->data))->window == window) + return (GdkInputWindow *)(tmp_list->data); + + return NULL; /* Not found */ +} + +/* FIXME: this routine currently needs to be called between creation + and the corresponding configure event (because it doesn't get the + root_relative_geometry). This should work with + gtk_window_set_extension_events, but will likely fail in other + cases */ + +void +gdk_input_set_extension_events (GdkWindow *window, gint mask, + GdkExtensionMode mode) +{ + GList *tmp_list; + GdkInputWindow *iw; + + g_return_if_fail (window != NULL); + + if (mode == GDK_EXTENSION_EVENTS_NONE) + mask = 0; + + if (mask != 0) + { + iw = g_new(GdkInputWindow,1); + + iw->window = window; + iw->mode = mode; + + iw->obscuring = NULL; + iw->num_obscuring = 0; + iw->grabbed = FALSE; + + gdk_input_windows = g_list_append(gdk_input_windows,iw); + ((GdkWindowPrivate *)window)->extension_events = mask; + + /* Add enter window events to the event mask */ + /* FIXME, this is not needed for XINPUT_NONE */ + gdk_window_set_events (window, + gdk_window_get_events (window) | + GDK_ENTER_NOTIFY_MASK); + } + else + { + iw = gdk_input_window_find (window); + if (iw) + { + gdk_input_windows = g_list_remove(gdk_input_windows,iw); + g_free(iw); + } + + ((GdkWindowPrivate *)window)->extension_events = 0; + } + + for (tmp_list = gdk_input_devices; tmp_list; tmp_list = tmp_list->next) + { + GdkDevicePrivate *gdkdev = (GdkDevicePrivate *)(tmp_list->data); + + if (gdkdev->info.deviceid != GDK_CORE_POINTER) + { + if (mask != 0 && gdkdev->info.mode != GDK_MODE_DISABLED + && (gdkdev->info.has_cursor || mode == GDK_EXTENSION_EVENTS_ALL)) + gdk_input_enable_window(window,gdkdev); + else + gdk_input_disable_window(window,gdkdev); + } + } +} + +void +gdk_input_window_destroy (GdkWindow *window) +{ + GdkInputWindow *input_window; + + input_window = gdk_input_window_find (window); + g_return_if_fail (input_window != NULL); + + gdk_input_windows = g_list_remove(gdk_input_windows,input_window); + g_free(input_window); +} + +void +gdk_input_exit (void) +{ + GList *tmp_list; + GdkDevicePrivate *gdkdev; + + for (tmp_list = gdk_input_devices; tmp_list; tmp_list = tmp_list->next) + { + gdkdev = (GdkDevicePrivate *)(tmp_list->data); + if (gdkdev->info.deviceid != GDK_CORE_POINTER) + { + gdk_input_set_mode(gdkdev->info.deviceid,GDK_MODE_DISABLED); + + g_free(gdkdev->info.name); +#ifndef XINPUT_NONE + g_free(gdkdev->axes); +#endif + g_free(gdkdev->info.axes); + g_free(gdkdev); + } + } + + g_list_free(gdk_input_devices); + + for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next) + { + g_free(tmp_list->data); + } + g_list_free(gdk_input_windows); +} + +static GdkDevicePrivate * +gdk_input_find_device(guint32 id) +{ + GList *tmp_list = gdk_input_devices; + GdkDevicePrivate *gdkdev; + while (tmp_list) + { + gdkdev = (GdkDevicePrivate *)(tmp_list->data); + if (gdkdev->info.deviceid == id) + return gdkdev; + tmp_list = tmp_list->next; + } + return NULL; +} + +void +gdk_input_window_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask) +{ + if (gdk_input_vtable.get_pointer) + gdk_input_vtable.get_pointer (window, deviceid, x, y, pressure, + xtilt, ytilt, mask); +} diff --git a/gdk/gdkinput.h b/gdk/gdkinput.h new file mode 100644 index 000000000..21aee6000 --- /dev/null +++ b/gdk/gdkinput.h @@ -0,0 +1,143 @@ +/* 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. + */ + +#ifndef __GDK_INPUT_H__ +#define __GDK_INPUT_H__ + +#ifndef XINPUT_NONE +#include <X11/extensions/XInput.h> +#endif + +typedef struct _GdkAxisInfo GdkAxisInfo; +typedef struct _GdkInputVTable GdkInputVTable; +typedef struct _GdkDevicePrivate GdkDevicePrivate; +typedef struct _GdkInputWindow GdkInputWindow; + +struct _GdkInputVTable { + gint (*set_mode) (guint32 deviceid, GdkInputMode mode); + void (*set_axes) (guint32 deviceid, GdkAxisUse *axes); + GdkTimeCoord* (*motion_events) (GdkWindow *window, + guint32 deviceid, + guint32 start, + guint32 stop, + gint *nevents_return); + void (*get_pointer) (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask); + gint (*grab_pointer) (GdkWindow * window, + gint owner_events, + GdkEventMask event_mask, + GdkWindow * confine_to, + guint32 time); + void (*ungrab_pointer) (guint32 time); + + void (*configure_event) (XConfigureEvent *xevent, GdkWindow *window); + void (*enter_event) (XCrossingEvent *xevent, GdkWindow *window); + gint (*other_event) (GdkEvent *event, XEvent *xevent, GdkWindow *window); + /* Handle an unidentified event. Returns TRUE if handled, FALSE + otherwise */ + gint (*window_none_event) (GdkEvent *event, XEvent *xevent); + gint (*enable_window) (GdkWindow *window, GdkDevicePrivate *gdkdev); + gint (*disable_window) (GdkWindow *window, GdkDevicePrivate *gdkdev); +}; + +/* information about a device axis */ +struct _GdkAxisInfo +{ + /* reported x resolution */ + gint xresolution; + + /* reported x minimum/maximum values */ + gint xmin_value, xmax_value; + + /* calibrated resolution (for aspect ration) - only relative values + between axes used */ + gint resolution; + + /* calibrated minimum/maximum values */ + gint min_value, max_value; +}; + +#define GDK_INPUT_NUM_EVENTC 6 + +struct _GdkDevicePrivate { + GdkDeviceInfo info; + +#ifndef XINPUT_NONE + /* information about the axes */ + GdkAxisInfo *axes; + + /* reverse lookup on axis use type */ + gint axis_for_use[GDK_AXIS_LAST]; + + /* Information about XInput device */ + XDevice *xdevice; + + int buttonpress_type, buttonrelease_type, motionnotify_type, + proximityin_type, proximityout_type, changenotify_type; + + /* true if we need to select a different set of events, but + can't because this is the core pointer */ + gint needs_update; + + /* Mask of buttons (used for button grabs) */ + gint button_state; + + /* true if we've claimed the device as active. (used only for XINPUT_GXI) */ + gint claimed; +#endif /* !XINPUT_NONE */ +}; + +struct _GdkInputWindow +{ + /* gdk window */ + GdkWindow *window; + + /* Extension mode (GDK_EXTENSION_EVENTS_ALL/CURSOR) */ + GdkExtensionMode mode; + + /* position relative to root window */ + gint16 root_x; + gint16 root_y; + + /* rectangles relative to window of windows obscuring this one */ + GdkRectangle *obscuring; + gint num_obscuring; + + /* Is there a pointer grab for this window ? */ + gint grabbed; +}; + +/* Global data */ + +extern GdkInputVTable gdk_input_vtable; +/* information about network port and host for gxid daemon */ +extern gchar *gdk_input_gxid_host; +extern gint gdk_input_gxid_port; +extern gint gdk_input_ignore_core; + +/* Function declarations */ + +void gdk_input_window_destroy (GdkWindow *window); + +#endif __GDK_INPUT_H__ diff --git a/gdk/gdkinputcommon.h b/gdk/gdkinputcommon.h new file mode 100644 index 000000000..5e457e0aa --- /dev/null +++ b/gdk/gdkinputcommon.h @@ -0,0 +1,687 @@ +/* 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. + */ + +#if defined(XINPUT_GXI) || defined(XINPUT_XFREE) + +/* Forward declarations */ +static void gdk_input_get_root_relative_geometry (Display *dpy, Window w, + int *x_ret, int *y_ret, + int *width_ret, + int *height_ret); +static GdkDevicePrivate *gdk_input_device_new(XDeviceInfo *device, + gint include_core); +static void gdk_input_common_find_events(GdkWindow *window, + GdkDevicePrivate *gdkdev, + gint mask, + XEventClass *classes, + int *num_classes); +static void gdk_input_common_select_events(GdkWindow *window, + GdkDevicePrivate *gdkdev); +static void gdk_input_translate_coordinates(GdkDevicePrivate *gdkdev, + GdkInputWindow *input_window, + gint *axis_data, + gdouble *x, gdouble *y, + gdouble *pressure, + gdouble *xtilt, gdouble *ytilt); +static guint gdk_input_translate_state(guint state, guint device_state); +static gint gdk_input_common_init(gint include_core); +static gint gdk_input_common_other_event (GdkEvent *event, + XEvent *xevent, + GdkInputWindow *input_window, + GdkDevicePrivate *gdkdev); +static void gdk_input_common_set_axes (guint32 deviceid, GdkAxisUse *axes); +static GdkTimeCoord * gdk_input_common_motion_events (GdkWindow *window, + guint32 deviceid, + guint32 start, + guint32 stop, + gint *nevents_return); +static void gdk_input_common_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask); + +/* Global variables */ + +static gint gdk_input_root_width; +static gint gdk_input_root_height; + +static void +gdk_input_get_root_relative_geometry(Display *dpy, Window w, int *x_ret, int *y_ret, + int *width_ret, int *height_ret) +{ + Window root,parent; + Window *children; + int nchildren; + int x,y,width,height; + int xc,yc,widthc,heightc,border_widthc,depthc; + + XQueryTree(dpy,w,&root,&parent,&children,&nchildren); + if (children) XFree(children); + XGetGeometry(dpy,w,&root,&x,&y,&width,&height,&border_widthc, + &depthc); + x += border_widthc; + y += border_widthc; + + while (root != parent) + { + w = parent; + XQueryTree(dpy,w,&root,&parent,&children,&nchildren); + if (children) XFree(children); + XGetGeometry(dpy,w,&root,&xc,&yc,&widthc,&heightc, + &border_widthc,&depthc); + x += xc + border_widthc; + y += yc + border_widthc; + } + + if (x_ret) + *x_ret = x; + if (y_ret) + *y_ret = y; + if (width_ret) + *width_ret = width; + if (height_ret) + *height_ret = height; +} + +static GdkDevicePrivate * +gdk_input_device_new(XDeviceInfo *device, gint include_core) +{ + GdkDevicePrivate *gdkdev; + gchar *tmp_name, *p; + XAnyClassPtr class; + gint i,j; + + gdkdev = g_new(GdkDevicePrivate,1); + + gdkdev->info.deviceid = device->id; + if (device->name[0]) { + gdkdev->info.name = g_new(char, strlen(device->name)+1); + strcpy(gdkdev->info.name,device->name); + } else { + /* XFree86 3.2 gives an empty name to the default core devices, + (fixed in 3.2A) */ + gdkdev->info.name = g_strdup("pointer"); + strcpy(gdkdev->info.name,"pointer"); + gdkdev->info.source = GDK_SOURCE_MOUSE; + } + + gdkdev->info.mode = GDK_MODE_DISABLED; + + /* Try to figure out what kind of device this is by its name - + could invite a very, very, long list... Lowercase name + for comparison purposes */ + + tmp_name = g_strdup(gdkdev->info.name); + for (p = tmp_name; *p; p++) + { + if (*p >= 'A' && *p <= 'Z') + *p += 'a' - 'A'; + } + + if (!strcmp (tmp_name, "pointer")) + gdkdev->info.source = GDK_SOURCE_MOUSE; + else if (!strcmp (tmp_name, "wacom") || + !strcmp (tmp_name, "pen")) + gdkdev->info.source = GDK_SOURCE_PEN; + else if (!strcmp (tmp_name, "eraser")) + gdkdev->info.source = GDK_SOURCE_ERASER; + else if (!strcmp (tmp_name, "cursor")) + gdkdev->info.source = GDK_SOURCE_CURSOR; + else + gdkdev->info.source = GDK_SOURCE_PEN; + + g_free(tmp_name); + + gdkdev->xdevice = NULL; + + /* step through the classes */ + + gdkdev->info.num_axes = 0; + gdkdev->axes = 0; + gdkdev->info.has_cursor = 0; + gdkdev->needs_update = FALSE; + gdkdev->claimed = FALSE; + gdkdev->button_state = 0; + + class = device->inputclassinfo; + for (i=0;i<device->num_classes;i++) + { + switch (class->class) { + case ButtonClass: + { + break; + } + case ValuatorClass: + { + XValuatorInfo *xvi = (XValuatorInfo *)class; + gdkdev->info.num_axes = xvi->num_axes; + gdkdev->axes = g_new(GdkAxisInfo, xvi->num_axes); + gdkdev->info.axes = g_new(GdkAxisUse, xvi->num_axes); + for (j=0;j<xvi->num_axes;j++) + { + gdkdev->axes[j].resolution = + gdkdev->axes[j].xresolution = xvi->axes[j].resolution; + gdkdev->axes[j].min_value = + gdkdev->axes[j].xmin_value = xvi->axes[j].min_value; + gdkdev->axes[j].max_value = + gdkdev->axes[j].xmax_value = xvi->axes[j].max_value; + gdkdev->info.axes[j] = GDK_AXIS_IGNORE; + } + j=0; + if (j<xvi->num_axes) + gdkdev->info.axes[j++] = GDK_AXIS_X; + if (j<xvi->num_axes) + gdkdev->info.axes[j++] = GDK_AXIS_Y; + if (j<xvi->num_axes) + gdkdev->info.axes[j++] = GDK_AXIS_PRESSURE; + if (j<xvi->num_axes) + gdkdev->info.axes[j++] = GDK_AXIS_XTILT; + if (j<xvi->num_axes) + gdkdev->info.axes[j++] = GDK_AXIS_YTILT; + + /* set up reverse lookup on axis use */ + for (j=GDK_AXIS_IGNORE;j<GDK_AXIS_LAST;j++) + gdkdev->axis_for_use[j] = -1; + + for (j=0;j<xvi->num_axes;j++) + if (gdkdev->info.axes[j] != GDK_AXIS_IGNORE) + gdkdev->axis_for_use[gdkdev->info.axes[j]] = j; + + break; + } + } + class = (XAnyClassPtr)(((char *)class) + class->length); + } + /* return NULL if no axes */ + if (!gdkdev->info.num_axes || !gdkdev->axes || + (!include_core && device->use == IsXPointer)) + { + g_free(gdkdev->info.name); + if (gdkdev->axes) + g_free(gdkdev->axes); + g_free(gdkdev); + return NULL; + } + + if (device->use != IsXPointer) + gdkdev->xdevice = XOpenDevice(gdk_display, gdkdev->info.deviceid); + + return gdkdev; +} + +static void +gdk_input_common_find_events(GdkWindow *window, + GdkDevicePrivate *gdkdev, + gint mask, + XEventClass *classes, + int *num_classes) +{ + gint i; + XEventClass class; + + i = 0; + /* We have to track press and release events in pairs to keep + track of button state correctly and implement grabbing */ + if (mask & GDK_BUTTON_PRESS_MASK || mask & GDK_BUTTON_RELEASE_MASK) + { + DeviceButtonPress (gdkdev->xdevice, gdkdev->buttonpress_type, + class); + if (class != 0) + classes[i++] = class; + DeviceButtonRelease (gdkdev->xdevice, gdkdev->buttonrelease_type, + class); + if (class != 0) + classes[i++] = class; + } + if (mask & GDK_POINTER_MOTION_MASK) + { + DeviceMotionNotify (gdkdev->xdevice, gdkdev->motionnotify_type, class); + if (class != 0) + classes[i++] = class; + } + if (mask & GDK_POINTER_MOTION_HINT_MASK) + { + /* We'll get into trouble if the macros change, but at least we'll + know about it, and we avoid warnings now */ + DevicePointerMotionHint (gdkdev->xdevice, 0, class); + if (class != 0) + classes[i++] = class; + } + if (mask & GDK_PROXIMITY_IN_MASK) + { + ProximityIn (gdkdev->xdevice, gdkdev->proximityin_type, class); + if (class != 0) + classes[i++] = class; + } + if (mask & GDK_PROXIMITY_OUT_MASK) + { + ProximityOut (gdkdev->xdevice, gdkdev->proximityout_type, class); + if (class != 0) + classes[i++] = class; + } + + *num_classes = i; +} + +static void +gdk_input_common_select_events(GdkWindow *window, + GdkDevicePrivate *gdkdev) +{ + XEventClass classes[6]; + gint num_classes; + + if (gdkdev->info.mode == GDK_MODE_DISABLED) + gdk_input_common_find_events(window, gdkdev, 0, classes, &num_classes); + else + gdk_input_common_find_events(window, gdkdev, + ((GdkWindowPrivate *)window)->extension_events, + classes, &num_classes); + + XSelectExtensionEvent (gdk_display, + GDK_WINDOW_XWINDOW(window), + classes, num_classes); +} + +gint +gdk_input_common_init(gint include_core) +{ + char **extensions; + XDeviceInfo *devices; + int num_devices; + int num_extensions, loop; + Display *display = gdk_display; + + /* Init global vars */ + gdk_window_get_geometry(NULL, /* use root window */ + NULL,NULL, + &gdk_input_root_width,&gdk_input_root_height, + NULL); + + /* Init XInput extension */ + + extensions = XListExtensions(display, &num_extensions); + for (loop = 0; loop < num_extensions && + (strcmp(extensions[loop], "XInputExtension") != 0); loop++); + XFreeExtensionList(extensions); + if (loop == num_extensions) /* XInput extension not found */ + return FALSE; + + gdk_input_devices = 0; + devices = XListInputDevices(display, &num_devices); + + for(loop=0; loop<num_devices; loop++) + { + GdkDevicePrivate *gdkdev = gdk_input_device_new(&devices[loop], + include_core); + if (gdkdev) + gdk_input_devices = g_list_append(gdk_input_devices, gdkdev); + } + XFreeDeviceList(devices); + + gdk_input_devices = g_list_append (gdk_input_devices, &gdk_input_core_info); + + return TRUE; +} + +static void +gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev, + GdkInputWindow *input_window, + gint *axis_data, + gdouble *x, gdouble *y, gdouble *pressure, + gdouble *xtilt, gdouble *ytilt) +{ + GdkWindowPrivate *win_priv; + + int x_axis, y_axis, pressure_axis, xtilt_axis, ytilt_axis; + + double device_width, device_height; + double x_offset, y_offset, x_scale, y_scale; + + win_priv = (GdkWindowPrivate *) input_window->window; + + x_axis = gdkdev->axis_for_use[GDK_AXIS_X]; + y_axis = gdkdev->axis_for_use[GDK_AXIS_Y]; + pressure_axis = gdkdev->axis_for_use[GDK_AXIS_PRESSURE]; + xtilt_axis = gdkdev->axis_for_use[GDK_AXIS_XTILT]; + ytilt_axis = gdkdev->axis_for_use[GDK_AXIS_YTILT]; + + device_width = gdkdev->axes[x_axis].max_value - + gdkdev->axes[x_axis].min_value; + device_height = gdkdev->axes[y_axis].max_value - + gdkdev->axes[y_axis].min_value; + + if (gdkdev->info.mode == GDK_MODE_SCREEN) + { + x_scale = gdk_input_root_width / device_width; + y_scale = gdk_input_root_height / device_height; + + x_offset = - input_window->root_x; + y_offset = - input_window->root_y; + } + else /* GDK_MODE_WINDOW */ + { + double device_aspect = (device_height*gdkdev->axes[y_axis].resolution) / + (device_width*gdkdev->axes[x_axis].resolution); + + if (device_aspect * win_priv->width >= win_priv->height) + { + /* device taller than window */ + x_scale = win_priv->width / device_width; + y_scale = (x_scale * gdkdev->axes[x_axis].resolution) + / gdkdev->axes[y_axis].resolution; + + x_offset = 0; + y_offset = -(device_height * y_scale - + win_priv->height)/2; + } + else + { + /* window taller than device */ + y_scale = win_priv->height / device_height; + x_scale = (y_scale * gdkdev->axes[y_axis].resolution) + / gdkdev->axes[x_axis].resolution; + + y_offset = 0; + x_offset = - (device_width * x_scale - win_priv->width)/2; + } + } + + if (x) *x = x_offset + x_scale*axis_data[x_axis]; + if (y) *y = y_offset + y_scale*axis_data[y_axis]; + + if (pressure) + { + if (pressure_axis != -1) + *pressure = ((double)axis_data[pressure_axis] + - gdkdev->axes[pressure_axis].min_value) + / (gdkdev->axes[pressure_axis].max_value + - gdkdev->axes[pressure_axis].min_value); + else + *pressure = 0.5; + } + + if (xtilt) + { + if (xtilt_axis != -1) + { + *xtilt = 2. * (double)(axis_data[xtilt_axis] - + (gdkdev->axes[xtilt_axis].min_value + + gdkdev->axes[xtilt_axis].max_value)/2) / + (gdkdev->axes[xtilt_axis].max_value - + gdkdev->axes[xtilt_axis].min_value); + } + else *xtilt = 0; + } + + if (ytilt) + { + if (ytilt_axis != -1) + { + *ytilt = 2. * (double)(axis_data[ytilt_axis] - + (gdkdev->axes[ytilt_axis].min_value + + gdkdev->axes[ytilt_axis].max_value)/2) / + (gdkdev->axes[ytilt_axis].max_value - + gdkdev->axes[ytilt_axis].min_value); + } + else + *ytilt = 0; + } +} + +/* combine the state of the core device and the device state + into one - for now we do this in a simple-minded manner - + we just take the keyboard portion of the core device and + the button portion (all of?) the device state. + Any button remapping should go on here. */ +static guint +gdk_input_translate_state(guint state, guint device_state) +{ + return device_state | (state & 0xFF); +} + +static gint +gdk_input_common_other_event (GdkEvent *event, + XEvent *xevent, + GdkInputWindow *input_window, + GdkDevicePrivate *gdkdev) +{ + if ((xevent->type == gdkdev->buttonpress_type) || + (xevent->type == gdkdev->buttonrelease_type)) + { + XDeviceButtonEvent *xdbe = (XDeviceButtonEvent *)(xevent); + + if (xdbe->type == gdkdev->buttonpress_type) + { + event->button.type = GDK_BUTTON_PRESS; + gdkdev->button_state |= 1 << xdbe->button; + } + else + { + event->button.type = GDK_BUTTON_RELEASE; + gdkdev->button_state &= ~(1 << xdbe->button); + } + event->button.window = input_window->window; + event->button.time = xdbe->time; + event->button.source = gdkdev->info.source; + event->button.deviceid = xdbe->deviceid; + + gdk_input_translate_coordinates (gdkdev,input_window, xdbe->axis_data, + &event->button.x,&event->button.y, + &event->button.pressure, + &event->button.xtilt, + &event->button.ytilt); + event->button.state = gdk_input_translate_state(xdbe->state,xdbe->device_state); + event->button.button = xdbe->button; + + return TRUE; + } + + if (xevent->type == gdkdev->motionnotify_type) + { + XDeviceMotionEvent *xdme = (XDeviceMotionEvent *)(xevent); + + gdk_input_translate_coordinates(gdkdev,input_window,xdme->axis_data, + &event->motion.x,&event->motion.y, + &event->motion.pressure, + &event->motion.xtilt, + &event->motion.ytilt); + + event->motion.type = GDK_MOTION_NOTIFY; + event->motion.window = input_window->window; + event->motion.time = xdme->time; + event->motion.deviceid = xdme->deviceid; + event->motion.state = gdk_input_translate_state(xdme->state, + xdme->device_state); + event->motion.source = gdkdev->info.source; + event->motion.deviceid = xdme->deviceid; + + if (gdk_show_events) + g_print ("motion notify:\t\twindow: %ld device: %ld x,y: %f %f hint: %s\n", + xdme->window, + xdme->deviceid, + event->motion.x, event->motion.y, + (xevent->xmotion.is_hint) ? "true" : "false"); + + + return TRUE; + } + + if (xevent->type == gdkdev->proximityin_type || + xevent->type == gdkdev->proximityout_type) + { + XProximityNotifyEvent *xpne = (XProximityNotifyEvent *)(xevent); + + event->proximity.type = (xevent->type == gdkdev->proximityin_type)? + GDK_PROXIMITY_IN:GDK_PROXIMITY_OUT; + event->proximity.window = input_window->window; + event->proximity.time = xpne->time; + event->proximity.source = gdkdev->info.source; + event->proximity.deviceid = xpne->deviceid; + + return TRUE; + } + + return -1; /* wasn't one of our event types */ +} + +static void +gdk_input_common_set_axes (guint32 deviceid, GdkAxisUse *axes) +{ + int i; + GdkDevicePrivate *gdkdev = gdk_input_find_device(deviceid); + g_return_if_fail (gdkdev != NULL); + + for (i=GDK_AXIS_IGNORE;i<GDK_AXIS_LAST;i++) + { + gdkdev->axis_for_use[i] = -1; + } + + for (i=0;i<gdkdev->info.num_axes;i++) + { + gdkdev->info.axes[i] = axes[i]; + gdkdev->axis_for_use[axes[i]] = i; + } +} + +static GdkTimeCoord * +gdk_input_common_motion_events (GdkWindow *window, + guint32 deviceid, + guint32 start, + guint32 stop, + gint *nevents_return) +{ + GdkTimeCoord *coords; + XDeviceTimeCoord *device_coords; + GdkInputWindow *input_window; + GdkDevicePrivate *gdkdev; + + int mode_return; + int axis_count_return; + int i; + + gdkdev = gdk_input_find_device (deviceid); + input_window = gdk_input_window_find (window); + + g_return_val_if_fail (gdkdev != NULL, NULL); + g_return_val_if_fail (gdkdev->xdevice != NULL, NULL); + g_return_val_if_fail (input_window != NULL, NULL); + + device_coords = XGetDeviceMotionEvents (gdk_display, + gdkdev->xdevice, + start, stop, + nevents_return, &mode_return, + &axis_count_return); + + if (device_coords) + { + coords = g_new (GdkTimeCoord, *nevents_return); + + for (i=0; i<*nevents_return; i++) + { + gdk_input_translate_coordinates (gdkdev, input_window, + device_coords[i].data, + &coords[i].x, &coords[i].y, + &coords[i].pressure, + &coords[i].xtilt, &coords[i].ytilt); + } + XFreeDeviceMotionEvents (device_coords); + + return coords; + } + else + return NULL; +} + +static void +gdk_input_common_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask) +{ + GdkDevicePrivate *gdkdev; + GdkInputWindow *input_window; + XDeviceState *state; + XInputClass *input_class; + gint x_int, y_int; + gint i; + + /* we probably need to get the mask in any case */ + + if (deviceid == GDK_CORE_POINTER) + { + gdk_window_get_pointer (window, &x_int, &y_int, mask); + if (x) *x = x_int; + if (y) *y = y_int; + if (pressure) *pressure = 0.5; + if (xtilt) *xtilt = 0; + if (ytilt) *ytilt = 0; + } + else + { + if (mask) + gdk_window_get_pointer (window, NULL, NULL, mask); + + gdkdev = gdk_input_find_device (deviceid); + input_window = gdk_input_window_find (window); + + g_return_if_fail (gdkdev != NULL); + g_return_if_fail (gdkdev->xdevice != NULL); + g_return_if_fail (input_window != NULL); + + state = XQueryDeviceState (gdk_display, gdkdev->xdevice); + input_class = state->data; + for (i=0; i<state->num_classes; i++) + { + switch (input_class->class) + { + case ValuatorClass: + gdk_input_translate_coordinates(gdkdev, input_window, + ((XValuatorState *)input_class)->valuators, + x, y, pressure, + xtilt, ytilt); + + + break; + case ButtonClass: + if (mask) + { + *mask &= ~(GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | + GDK_BUTTON3_MASK | GDK_BUTTON4_MASK | + GDK_BUTTON5_MASK); + for (i=0; i < ((XButtonState *)input_class)->num_buttons; i++) + { + if (((XButtonState *)input_class)->buttons[i]) + *mask |= GDK_BUTTON1_MASK << i; + } + } + break; + } + input_class = (XInputClass *)(((char *)input_class)+input_class->length); + } + } +} + +#endif diff --git a/gdk/gdkinputgxi.h b/gdk/gdkinputgxi.h new file mode 100644 index 000000000..a30e05f95 --- /dev/null +++ b/gdk/gdkinputgxi.h @@ -0,0 +1,628 @@ +/* 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. + */ + +#ifdef XINPUT_GXI + +/* #define DEBUG_SWITCHING */ + +#include <gxid_lib.h> + +/* Forward declarations */ +static void gdk_input_gxi_select_notify (GdkDevicePrivate *gdkdev); +static gint gdk_input_gxi_set_mode (guint32 deviceid, GdkInputMode mode); +static gint gdk_input_is_extension_device (guint32 deviceid); +static void gdk_input_gxi_configure_event (XConfigureEvent *xevent, + GdkWindow *window); +static void gdk_input_gxi_enter_event (XCrossingEvent *xevent, + GdkWindow *window); +static gint gdk_input_gxi_other_event (GdkEvent *event, + XEvent *xevent, + GdkWindow *window); +static void gdk_input_gxi_update_device (GdkDevicePrivate *gdkdev); + +static gint gdk_input_gxi_window_none_event (GdkEvent *event, XEvent *xevent); +static gint gdk_input_gxi_enable_window (GdkWindow *window, + GdkDevicePrivate *gdkdev); +static gint gdk_input_gxi_disable_window (GdkWindow *window, + GdkDevicePrivate *gdkdev); +static Window gdk_input_find_root_child(Display *dpy, Window w); +static void gdk_input_compute_obscuring(GdkInputWindow *input_window); +static gint gdk_input_is_obscured(GdkInputWindow *input_window, gdouble x, + gdouble y); +static GdkTimeCoord *gdk_input_gxi_motion_events (GdkWindow *window, + guint32 deviceid, + guint32 start, + guint32 stop, + gint *nevents_return); +static void gdk_input_gxi_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask); +static gint gdk_input_gxi_grab_pointer (GdkWindow * window, + gint owner_events, + GdkEventMask event_mask, + GdkWindow * confine_to, + guint32 time); +static void gdk_input_gxi_ungrab_pointer (guint32 time); + +/* Local variables */ + +static GdkDevicePrivate *gdk_input_current_device; +static GdkDevicePrivate *gdk_input_core_pointer; + +void +gdk_input_init(void) +{ + GList *tmp_list; + + gdk_input_vtable.set_mode = gdk_input_gxi_set_mode; + gdk_input_vtable.set_axes = gdk_input_common_set_axes; + gdk_input_vtable.motion_events = gdk_input_gxi_motion_events; + gdk_input_vtable.get_pointer = gdk_input_gxi_get_pointer; + gdk_input_vtable.grab_pointer = gdk_input_gxi_grab_pointer; + gdk_input_vtable.ungrab_pointer = gdk_input_gxi_ungrab_pointer; + gdk_input_vtable.configure_event = gdk_input_gxi_configure_event; + gdk_input_vtable.enter_event = gdk_input_gxi_enter_event; + gdk_input_vtable.other_event = gdk_input_gxi_other_event; + gdk_input_vtable.window_none_event = gdk_input_gxi_window_none_event; + gdk_input_vtable.enable_window = gdk_input_gxi_enable_window; + gdk_input_vtable.disable_window = gdk_input_gxi_disable_window; + + gdk_input_ignore_core = FALSE; + gdk_input_core_pointer = NULL; + + if (!gdk_input_gxid_host) + { + gdk_input_gxid_host = getenv("GXID_HOST"); + } + if (!gdk_input_gxid_port) + { + char *t = getenv("GXID_PORT"); + if (t) + gdk_input_gxid_port = atoi(t); + } + + gdk_input_common_init(TRUE); + + /* find initial core pointer */ + + for (tmp_list = gdk_input_devices; tmp_list; tmp_list = tmp_list->next) + { + GdkDevicePrivate *gdkdev = (GdkDevicePrivate *)tmp_list->data; + if (gdk_input_is_extension_device(gdkdev->info.deviceid)) + { + gdk_input_gxi_select_notify (gdkdev); + } + else + { + if (gdkdev->info.deviceid != GDK_CORE_POINTER) + gdk_input_core_pointer = gdkdev; + } + } +} + +static void +gdk_input_gxi_select_notify (GdkDevicePrivate *gdkdev) +{ + XEventClass class; + + ChangeDeviceNotify (gdkdev->xdevice, gdkdev->changenotify_type, class); + + XSelectExtensionEvent (gdk_display, gdk_root_window, &class, 1); +} + +/* Set the core pointer. Device should already be enabled. */ +static gint +gdk_input_gxi_set_core_pointer(GdkDevicePrivate *gdkdev) +{ + int x_axis,y_axis; + + g_return_val_if_fail(gdkdev->xdevice,FALSE); + + x_axis = gdkdev->axis_for_use[GDK_AXIS_X]; + y_axis = gdkdev->axis_for_use[GDK_AXIS_Y]; + + g_return_val_if_fail(x_axis != -1 && y_axis != -1,FALSE); + + /* core_pointer might not be up to date so we check with the server + before change the pointer */ + + if ( !gdk_input_is_extension_device(gdkdev->info.deviceid) ) + { +#if 0 + if (gdkdev != gdk_input_core_pointer) + g_warning("core pointer inconsistency"); +#endif + return TRUE; + } + + if ( XChangePointerDevice(gdk_display,gdkdev->xdevice, x_axis, y_axis) + != Success ) + { + return FALSE; + } + else + { + gdk_input_gxi_update_device (gdk_input_core_pointer); + gdk_input_core_pointer = gdkdev; + return TRUE; + } +} + + +/* FIXME, merge with gdk_input_xfree_set_mode */ + +static gint +gdk_input_gxi_set_mode (guint32 deviceid, GdkInputMode mode) +{ + GList *tmp_list; + GdkDevicePrivate *gdkdev; + GdkInputMode old_mode; + GdkInputWindow *input_window; + + gdkdev = gdk_input_find_device(deviceid); + g_return_val_if_fail (gdkdev != NULL,FALSE); + old_mode = gdkdev->info.mode; + + if (gdkdev->info.mode == mode) + return TRUE; + + gdkdev->info.mode = mode; + + if (old_mode != GDK_MODE_DISABLED) + { + for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->mode != GDK_EXTENSION_EVENTS_CURSOR) + gdk_input_disable_window (input_window->window, gdkdev); + } + } + + if (mode != GDK_MODE_DISABLED) + { + for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->mode != GDK_EXTENSION_EVENTS_CURSOR) + if (!gdk_input_enable_window(input_window->window, gdkdev)) + { + gdk_input_set_mode(deviceid, old_mode); + return FALSE; + } + } + } + + return TRUE; + +} + +gint +gdk_input_is_extension_device (guint32 deviceid) +{ + XDeviceInfo *devices; + int num_devices, loop; + + if (deviceid == GDK_CORE_POINTER) + return FALSE; + + devices = XListInputDevices(gdk_display, &num_devices); + for(loop=0; loop<num_devices; loop++) + { + if ((devices[loop].id == deviceid) && (devices[loop].use == IsXExtensionDevice)) + { + XFreeDeviceList(devices); + return TRUE; + } + } + + XFreeDeviceList(devices); + return FALSE; +} + +static void +gdk_input_gxi_configure_event (XConfigureEvent *xevent, GdkWindow *window) +{ + GdkInputWindow *input_window; + gint root_x, root_y; + + input_window = gdk_input_window_find(window); + g_return_if_fail (input_window != NULL); + + gdk_input_get_root_relative_geometry(gdk_display,GDK_WINDOW_XWINDOW(window), + &root_x, &root_y, NULL, NULL); + input_window->root_x = root_x; + input_window->root_y = root_y; + gdk_input_compute_obscuring(input_window); +} + +static void +gdk_input_gxi_enter_event (XCrossingEvent *xevent, GdkWindow *window) +{ + GdkInputWindow *input_window; + + input_window = gdk_input_window_find(window); + g_return_if_fail (input_window != NULL); + + gdk_input_compute_obscuring(input_window); +} + +static gint +gdk_input_gxi_other_event (GdkEvent *event, + XEvent *xevent, + GdkWindow *window) +{ + GdkInputWindow *input_window; + + GdkDevicePrivate *gdkdev; + gint return_val; + + input_window = gdk_input_window_find(window); + g_return_val_if_fail (window != NULL, -1); + + /* This is a sort of a hack, as there isn't any XDeviceAnyEvent - + but it's potentially faster than scanning through the types of + every device. If we were deceived, then it won't match any of + the types for the device anyways */ + gdkdev = gdk_input_find_device(((XDeviceButtonEvent *)xevent)->deviceid); + + if (!gdkdev) { + return -1; /* we don't handle it - not an XInput event */ + } + + if (gdkdev->info.mode == GDK_MODE_DISABLED || + input_window->mode == GDK_EXTENSION_EVENTS_CURSOR) + return FALSE; + + if (gdkdev != gdk_input_current_device && + xevent->type != gdkdev->changenotify_type) + { + gdk_input_current_device = gdkdev; + } + + return_val = gdk_input_common_other_event (event, xevent, + input_window, gdkdev); + + if (return_val > 0 && event->type == GDK_MOTION_NOTIFY && + (!gdkdev->button_state) && (!input_window->grabbed) && + ((event->motion.x < 0) || (event->motion.y < 0) || + (event->motion.x > ((GdkWindowPrivate *)window)->width) || + (event->motion.y > ((GdkWindowPrivate *)window)->height) || + gdk_input_is_obscured(input_window,event->motion.x,event->motion.y))) + { +#ifdef DEBUG_SWITCHING + g_print("gdkinput: Setting core pointer to %d on motion at (%f,%f)\n", + gdkdev->info.deviceid,event->motion.x,event->motion.y); + g_print(" window geometry is: %dx%d\n", + ((GdkWindowPrivate *)window)->width, + ((GdkWindowPrivate *)window)->height); +#endif + gdk_input_gxi_set_core_pointer(gdkdev); + return FALSE; + } + else + return return_val; + +} + +static void +gdk_input_gxi_update_device (GdkDevicePrivate *gdkdev) +{ + GList *t; + + if (gdk_input_is_extension_device (gdkdev->info.deviceid)) + { + if (!gdkdev->xdevice) + { + gdkdev->xdevice = XOpenDevice(gdk_display, gdkdev->info.deviceid); + gdk_input_gxi_select_notify (gdkdev); + gdkdev->needs_update = 1; + } + if (gdkdev->needs_update && gdkdev->xdevice) + { + for (t = gdk_input_windows; t; t = t->next) + gdk_input_common_select_events (((GdkInputWindow *)t->data)->window, + gdkdev); + gdkdev->needs_update = 0; + } + } +} + +static gint +gdk_input_gxi_window_none_event (GdkEvent *event, XEvent *xevent) +{ + GdkDevicePrivate *gdkdev = + gdk_input_find_device(((XDeviceButtonEvent *)xevent)->deviceid); + + if (!gdkdev) { + return -1; /* we don't handle it - not an XInput event */ + } + + if (xevent->type == gdkdev->changenotify_type) + { + if (gdk_input_core_pointer != gdkdev) + { +#ifdef DEBUG_SWITCHING + g_print("ChangeNotify from %d to %d:\n", + gdk_input_core_pointer->info.deviceid, + gdkdev->info.deviceid); +#endif + gdk_input_gxi_update_device (gdk_input_core_pointer); + gdk_input_core_pointer = gdkdev; + } + } + + return FALSE; +} + +static gint +gdk_input_gxi_enable_window (GdkWindow *window, GdkDevicePrivate *gdkdev) +{ + GdkInputWindow *input_window; + + input_window = gdk_input_window_find (window); + g_return_val_if_fail (input_window != NULL, FALSE); + + if (!gdkdev->claimed) + { + if (gxid_claim_device(gdk_input_gxid_host, gdk_input_gxid_port, + gdkdev->info.deviceid, + GDK_WINDOW_XWINDOW(window), FALSE) != + GXID_RETURN_OK) + { + g_warning("Could not get device (is gxid running?)\n"); + return FALSE; + } + gdkdev->claimed = TRUE; + } + + if (gdkdev->xdevice && gdkdev != gdk_input_core_pointer) + gdk_input_common_select_events(window, gdkdev); + else + gdkdev->needs_update = TRUE; + + return TRUE; +} + +static gint +gdk_input_gxi_disable_window(GdkWindow *window, GdkDevicePrivate *gdkdev) +{ + GdkInputWindow *input_window; + + input_window = gdk_input_window_find (window); + g_return_val_if_fail (input_window != NULL, FALSE); + + if (gdkdev->claimed) + { + gxid_release_device(gdk_input_gxid_host, gdk_input_gxid_port, + gdkdev->info.deviceid, + GDK_WINDOW_XWINDOW(window)); + + gdkdev->claimed = FALSE; + } + + if (gdkdev->xdevice && gdkdev != gdk_input_core_pointer) + gdk_input_common_select_events(window, gdkdev); + else + gdkdev->needs_update = TRUE; + + return TRUE; +} + +static gint +gdk_input_is_obscured(GdkInputWindow *input_window, gdouble x, gdouble y) +{ + int i; + for (i=0;i<input_window->num_obscuring;i++) + { + GdkRectangle *rect = &input_window->obscuring[i]; + if ((x >= rect->x) && + (y >= rect->y) && + (x < rect->x + rect->width) && + (y < rect->y + rect->height)) + return TRUE; + } + return FALSE; +} + +/* If this routine needs fixing, the corresponding routine + in gxid.c will need it too. */ + +static Window +gdk_input_find_root_child(Display *dpy, Window w) +{ + Window root,parent; + Window *children; + int nchildren; + + parent = w; + do + { + w = parent; + XQueryTree(dpy,w,&root,&parent,&children,&nchildren); + if (children) XFree(children); + } + while (parent != root); + + return w; +} + +void +gdk_input_compute_obscuring(GdkInputWindow *input_window) +{ + int i; + int x,y,width,height; + int xc,yc,widthc,heightc,border_widthc,depthc; + + Window root,parent; + Window *children; + int nchildren; + + Window w = GDK_WINDOW_XWINDOW(input_window->window); + Window root_child = gdk_input_find_root_child(gdk_display,w); + gdk_input_get_root_relative_geometry(gdk_display,w,&x,&y,&width,&height); + + input_window->root_x = x; + input_window->root_y = y; + + XQueryTree(gdk_display,GDK_ROOT_WINDOW(), + &root,&parent,&children,&nchildren); + + + if (input_window->obscuring) + g_free(input_window->obscuring); + input_window->obscuring = 0; + input_window->num_obscuring = 0; + + for (i=0;i<nchildren;i++) + if (children[i] == root_child) + break; + + if (i>=nchildren-1) + { + if (nchildren) + XFree(children); + return; + } + + input_window->obscuring = g_new(GdkRectangle,(nchildren-i-1)); + + for (i=i+1;i<nchildren;i++) + { + int xmin, xmax, ymin, ymax; + XGetGeometry(gdk_display,children[i],&root,&xc,&yc,&widthc,&heightc, + &border_widthc, &depthc); + xmin = xc>x ? xc : x; + xmax = (xc+widthc)<(x+width) ? xc+widthc : x+width; + ymin = yc>y ? yc : y; + ymax = (yc+heightc)<(y+height) ? yc+heightc : y+height; + if ((xmin < xmax) && (ymin < ymax)) + { + XWindowAttributes attributes; + XGetWindowAttributes(gdk_display,children[i],&attributes); + if (attributes.map_state == IsViewable) + { + GdkRectangle *rect = &input_window->obscuring[input_window->num_obscuring]; + + /* we store the whole window, not just the obscuring part */ + rect->x = xc - x; + rect->y = yc - y; + rect->width = widthc; + rect->height = heightc; + input_window->num_obscuring++; + } + } + } + + if (nchildren) + XFree(children); +} + +static void +gdk_input_gxi_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask) +{ + GdkDevicePrivate *gdkdev; + + gdkdev = gdk_input_find_device (deviceid); + g_return_if_fail (gdkdev != NULL); + + if (gdkdev == gdk_input_core_pointer) + gdk_input_common_get_pointer (window, GDK_CORE_POINTER, x, y, + pressure, xtilt, ytilt, mask); + else + gdk_input_common_get_pointer (window, deviceid, x, y, + pressure, xtilt, ytilt, mask); +} + +static GdkTimeCoord * +gdk_input_gxi_motion_events (GdkWindow *window, + guint32 deviceid, + guint32 start, + guint32 stop, + gint *nevents_return) +{ + GdkDevicePrivate *gdkdev; + + gdkdev = gdk_input_find_device (deviceid); + g_return_val_if_fail (gdkdev != NULL, NULL); + + + if (gdkdev == gdk_input_core_pointer) + return gdk_input_motion_events (window, GDK_CORE_POINTER, start, stop, + nevents_return); + else + return gdk_input_common_motion_events (window, deviceid, start, stop, + nevents_return); + +} + +static gint +gdk_input_gxi_grab_pointer (GdkWindow * window, + gint owner_events, + GdkEventMask event_mask, + GdkWindow * confine_to, + guint32 time) +{ + GdkInputWindow *input_window, *new_window; + GList *tmp_list; + + tmp_list = gdk_input_windows; + while (tmp_list) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->grabbed) + return AlreadyGrabbed; + + if (input_window->window == window) + new_window = input_window; + + tmp_list = tmp_list->next; + } + + new_window->grabbed = TRUE; + return Success; +} + +static void +gdk_input_gxi_ungrab_pointer (guint32 time) +{ + GdkInputWindow *input_window; + GList *tmp_list; + + tmp_list = gdk_input_windows; + while (tmp_list) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->grabbed) + input_window->grabbed = FALSE; + tmp_list = tmp_list->next; + } +} + +#endif /* XINPUT_GXI */ diff --git a/gdk/gdkinputnone.h b/gdk/gdkinputnone.h new file mode 100644 index 000000000..8ae8c4189 --- /dev/null +++ b/gdk/gdkinputnone.h @@ -0,0 +1,72 @@ +/* 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. + */ + +#ifdef XINPUT_NONE + +static void gdk_input_none_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask); + +void +gdk_input_init () +{ + gdk_input_vtable.set_mode = NULL; + gdk_input_vtable.set_axes = NULL; + gdk_input_vtable.motion_events = NULL; + gdk_input_vtable.get_pointer = gdk_input_none_get_pointer; + gdk_input_vtable.grab_pointer = NULL; + gdk_input_vtable.ungrab_pointer = NULL; + gdk_input_vtable.configure_event = NULL; + gdk_input_vtable.enter_event = NULL; + gdk_input_vtable.other_event = NULL; + gdk_input_vtable.window_none_event = NULL; + gdk_input_vtable.enable_window = NULL; + gdk_input_vtable.disable_window = NULL; + + gdk_input_devices = g_list_append (NULL, &gdk_input_core_info); + + gdk_input_ignore_core = FALSE; +} + +static void +gdk_input_none_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask) +{ + gint x_int, y_int; + + gdk_window_get_pointer (window, &x_int, &y_int, mask); + + if (x) *x = x_int; + if (y) *y = y_int; + if (pressure) *pressure = 0.5; + if (xtilt) *xtilt = 0; + if (ytilt) *ytilt = 0; +} + +#endif /* XINPUT_NONE */ diff --git a/gdk/gdkinputxfree.h b/gdk/gdkinputxfree.h new file mode 100644 index 000000000..f74249008 --- /dev/null +++ b/gdk/gdkinputxfree.h @@ -0,0 +1,368 @@ +/* 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. + */ + +#ifdef XINPUT_XFREE + +/* forward declarations */ + +static gint gdk_input_xfree_set_mode (guint32 deviceid, GdkInputMode mode); +static void gdk_input_check_proximity(); +static void gdk_input_xfree_configure_event (XConfigureEvent *xevent, + GdkWindow *window); +static void gdk_input_xfree_enter_event (XCrossingEvent *xevent, + GdkWindow *window); +static gint gdk_input_xfree_other_event (GdkEvent *event, + XEvent *xevent, + GdkWindow *window); +static gint gdk_input_xfree_enable_window(GdkWindow *window, + GdkDevicePrivate *gdkdev); +static gint gdk_input_xfree_disable_window(GdkWindow *window, + GdkDevicePrivate *gdkdev); +static gint gdk_input_xfree_grab_pointer (GdkWindow * window, + gint owner_events, + GdkEventMask event_mask, + GdkWindow * confine_to, + guint32 time); +static void gdk_input_xfree_ungrab_pointer (guint32 time); + +void +gdk_input_init(void) +{ + gdk_input_vtable.set_mode = gdk_input_xfree_set_mode; + gdk_input_vtable.set_axes = gdk_input_common_set_axes; + gdk_input_vtable.motion_events = gdk_input_common_motion_events; + gdk_input_vtable.get_pointer = gdk_input_common_get_pointer; + gdk_input_vtable.grab_pointer = gdk_input_xfree_grab_pointer; + gdk_input_vtable.ungrab_pointer = gdk_input_xfree_ungrab_pointer; + gdk_input_vtable.configure_event = gdk_input_xfree_configure_event; + gdk_input_vtable.enter_event = gdk_input_xfree_enter_event; + gdk_input_vtable.other_event = gdk_input_xfree_other_event; + gdk_input_vtable.window_none_event = NULL; + gdk_input_vtable.enable_window = gdk_input_xfree_enable_window; + gdk_input_vtable.disable_window = gdk_input_xfree_disable_window; + + gdk_input_ignore_core = FALSE; + gdk_input_common_init(FALSE); +} + +static gint +gdk_input_xfree_set_mode (guint32 deviceid, GdkInputMode mode) +{ + GList *tmp_list; + GdkDevicePrivate *gdkdev; + GdkInputMode old_mode; + GdkInputWindow *input_window; + + gdkdev = gdk_input_find_device(deviceid); + g_return_val_if_fail (gdkdev != NULL,FALSE); + old_mode = gdkdev->info.mode; + + if (gdkdev->info.mode == mode) + return TRUE; + + gdkdev->info.mode = mode; + + if (mode == GDK_MODE_WINDOW) + { + gdkdev->info.has_cursor = FALSE; + for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->mode != GDK_EXTENSION_EVENTS_CURSOR) + gdk_input_enable_window (input_window->window, gdkdev); + else + if (old_mode != GDK_MODE_DISABLED) + gdk_input_disable_window (input_window->window, gdkdev); + } + } + else if (mode == GDK_MODE_SCREEN) + { + gdkdev->info.has_cursor = TRUE; + for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next) + gdk_input_enable_window (((GdkInputWindow *)tmp_list->data)->window, + gdkdev); + } + else /* mode == GDK_MODE_DISABLED */ + { + for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (old_mode != GDK_MODE_WINDOW || + input_window->mode != GDK_EXTENSION_EVENTS_CURSOR) + gdk_input_disable_window (input_window->window, gdkdev); + } + } + + return TRUE; + +} + +static void +gdk_input_check_proximity() +{ + gint new_proximity = 0; + GList *tmp_list = gdk_input_devices; + + while (tmp_list && !new_proximity) + { + GdkDevicePrivate *gdkdev = (GdkDevicePrivate *)(tmp_list->data); + + if (gdkdev->info.mode != GDK_MODE_DISABLED + && gdkdev->info.deviceid != GDK_CORE_POINTER + && gdkdev->xdevice) + { + XDeviceState *state = XQueryDeviceState(GDK_DISPLAY(), + gdkdev->xdevice); + XInputClass *xic; + int i; + + xic = state->data; + for (i=0; i<state->num_classes; i++) + { + if (xic->class == ValuatorClass) + { + XValuatorState *xvs = (XValuatorState *)xic; + if ((xvs->mode & ProximityState) == InProximity) + { + new_proximity = TRUE; + } + break; + } + xic = (XInputClass *)((char *)xic + xic->length); + } + } + tmp_list = tmp_list->next; + } + + gdk_input_ignore_core = new_proximity; +} + +static void +gdk_input_xfree_configure_event (XConfigureEvent *xevent, GdkWindow *window) +{ + GdkInputWindow *input_window; + gint root_x, root_y; + + input_window = gdk_input_window_find(window); + g_return_if_fail (window != NULL); + + gdk_input_get_root_relative_geometry(GDK_DISPLAY(),GDK_WINDOW_XWINDOW(window), + &root_x, + &root_y, NULL, NULL); + + input_window->root_x = root_x; + input_window->root_y = root_y; +} + +static void +gdk_input_xfree_enter_event (XCrossingEvent *xevent, + GdkWindow *window) +{ + GdkInputWindow *input_window; + gint root_x, root_y; + + input_window = gdk_input_window_find(window); + g_return_if_fail (window != NULL); + + gdk_input_check_proximity(); + + gdk_input_get_root_relative_geometry(GDK_DISPLAY(),GDK_WINDOW_XWINDOW(window), + &root_x, + &root_y, NULL, NULL); + + input_window->root_x = root_x; + input_window->root_y = root_y; +} + +static gint +gdk_input_xfree_other_event (GdkEvent *event, + XEvent *xevent, + GdkWindow *window) +{ + GdkInputWindow *input_window; + + GdkDevicePrivate *gdkdev; + gint return_val; + + input_window = gdk_input_window_find(window); + g_return_val_if_fail (window != NULL, -1); + + /* This is a sort of a hack, as there isn't any XDeviceAnyEvent - + but it's potentially faster than scanning through the types of + every device. If we were deceived, then it won't match any of + the types for the device anyways */ + gdkdev = gdk_input_find_device(((XDeviceButtonEvent *)xevent)->deviceid); + + if (!gdkdev) { + return -1; /* we don't handle it - not an XInput event */ + } + + /* FIXME: It would be nice if we could just get rid of the events + entirely, instead of having to ignore them */ + if (gdkdev->info.mode == GDK_MODE_DISABLED || + (gdkdev->info.mode == GDK_MODE_WINDOW + && input_window->mode == GDK_EXTENSION_EVENTS_CURSOR)) + return FALSE; + + if (!gdk_input_ignore_core) + gdk_input_check_proximity(); + + return_val = gdk_input_common_other_event (event, xevent, + input_window, gdkdev); + + if (return_val > 0 && event->type == GDK_PROXIMITY_OUT && + gdk_input_ignore_core) + gdk_input_check_proximity(); + + /* Do a passive button grab. We have to be careful not to release + an explicit grab, if any. Doubling the grab should be harmless, + but we check anyways. */ + + /* FIXME, finding the proper events here is going to be SLOW - but + we might have different sets for each window/device combination */ + + if (return_val> 0 && !input_window->grabbed) + { + if (event->type == GDK_BUTTON_PRESS) + { + XEventClass event_classes[6]; + gint num_classes; + + gdk_input_common_find_events (window, gdkdev, + ((GdkWindowPrivate *)window)->extension_events, + event_classes, &num_classes); + + XGrabDevice( GDK_DISPLAY(), gdkdev->xdevice, + GDK_WINDOW_XWINDOW (window), + TRUE, num_classes, event_classes, + GrabModeAsync, GrabModeAsync, event->button.time); + } + else if (event->type == GDK_BUTTON_RELEASE) + XUngrabDevice( GDK_DISPLAY(), gdkdev->xdevice, event->button.time); + } + + return return_val; +} + +static gint +gdk_input_xfree_enable_window(GdkWindow *window, GdkDevicePrivate *gdkdev) +{ + /* FIXME: watchout, gdkdev might be core pointer, never opened */ + gdk_input_common_select_events (window, gdkdev); + return TRUE; +} + +static gint +gdk_input_xfree_disable_window(GdkWindow *window, GdkDevicePrivate *gdkdev) +{ + gdk_input_common_select_events (window, gdkdev); + return TRUE; +} + +static gint +gdk_input_xfree_grab_pointer (GdkWindow * window, + gint owner_events, + GdkEventMask event_mask, + GdkWindow * confine_to, + guint32 time) +{ + GdkInputWindow *input_window, *new_window; + GdkDevicePrivate *gdkdev; + GList *tmp_list; + XEventClass event_classes[6]; + gint num_classes; + + tmp_list = gdk_input_windows; + new_window = NULL; + while (tmp_list) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->grabbed) + return AlreadyGrabbed; + + if (input_window->window == window) + { + new_window = input_window; + break; + } + + tmp_list = tmp_list->next; + } + + g_return_if_fail (new_window == NULL); + + new_window->grabbed = TRUE; + + tmp_list = gdk_input_devices; + while (tmp_list) + { + gdkdev = (GdkDevicePrivate *)tmp_list->data; + if (gdkdev->info.deviceid != GDK_CORE_POINTER && + gdkdev->xdevice && !gdkdev->button_state) + { + gdk_input_common_find_events (window, gdkdev, + ((GdkWindowPrivate *)window)->extension_events, + event_classes, &num_classes); + + /* FIXME: we should do something on failure */ + XGrabDevice( GDK_DISPLAY(), gdkdev->xdevice, + GDK_WINDOW_XWINDOW (window), + TRUE, num_classes, event_classes, + GrabModeAsync, GrabModeAsync, time); + } + tmp_list = tmp_list->next; + } + + return Success; +} + +static void +gdk_input_xfree_ungrab_pointer (guint32 time) +{ + GdkInputWindow *input_window; + GdkDevicePrivate *gdkdev; + GList *tmp_list; + + tmp_list = gdk_input_windows; + while (tmp_list) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->grabbed) + break; + tmp_list = tmp_list->next; + } + + if (tmp_list) /* we found a grabbed window */ + { + input_window->grabbed = FALSE; + + tmp_list = gdk_input_devices; + while (tmp_list) + { + gdkdev = (GdkDevicePrivate *)tmp_list->data; + if (gdkdev->info.deviceid != GDK_CORE_POINTER && + gdkdev->xdevice && !gdkdev->button_state) + { + XUngrabDevice( gdk_display, gdkdev->xdevice, time); + } + tmp_list = tmp_list->next; + } + } +} + +#endif /* XINPUT_XFREE */ diff --git a/gdk/gdkpixmap.c b/gdk/gdkpixmap.c new file mode 100644 index 000000000..d2d96b6da --- /dev/null +++ b/gdk/gdkpixmap.c @@ -0,0 +1,657 @@ +/* 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" +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <X11/Xlib.h> + +#include "gdk.h" +#include "gdkprivate.h" + +typedef struct +{ + gchar *color_string; + GdkColor color; + gint transparent; +} _GdkPixmapColor; + +GdkPixmap* +gdk_pixmap_new (GdkWindow *window, + gint width, + gint height, + gint depth) +{ + GdkPixmap *pixmap; + GdkWindowPrivate *private; + GdkWindowPrivate *window_private; + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + if (depth == -1) + gdk_window_get_geometry (window, NULL, NULL, NULL, NULL, &depth); + + private = g_new (GdkWindowPrivate, 1); + pixmap = (GdkPixmap*) private; + + window_private = (GdkWindowPrivate*) window; + + private->xdisplay = window_private->xdisplay; + private->window_type = GDK_WINDOW_PIXMAP; + private->xwindow = XCreatePixmap (private->xdisplay, window_private->xwindow, + width, height, depth); + private->parent = NULL; + private->x = 0; + private->y = 0; + private->width = width; + private->height = height; + private->resize_count = 0; + private->ref_count = 1; + private->destroyed = 0; + + gdk_xid_table_insert (&private->xwindow, pixmap); + + return pixmap; +} + +GdkPixmap * +gdk_bitmap_create_from_data (GdkWindow *window, + gchar *data, + gint width, + gint height) +{ + GdkPixmap *pixmap; + GdkWindowPrivate *private; + GdkWindowPrivate *window_private; + + g_return_val_if_fail (data != NULL, NULL); + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + private = g_new (GdkWindowPrivate, 1); + pixmap = (GdkPixmap*) private; + + window_private = (GdkWindowPrivate*) window; + + private->parent = NULL; + private->xdisplay = window_private->xdisplay; + private->window_type = GDK_WINDOW_PIXMAP; + private->x = 0; + private->y = 0; + private->width = width; + private->height = height; + private->resize_count = 0; + private->ref_count = 1; + private->destroyed = FALSE; + + private->xwindow = XCreateBitmapFromData (private->xdisplay, + window_private->xwindow, + data, width, height); + + gdk_xid_table_insert (&private->xwindow, pixmap); + + return pixmap; +} + +GdkPixmap* +gdk_pixmap_create_from_data (GdkWindow *window, + gchar *data, + gint width, + gint height, + gint depth, + GdkColor *fg, + GdkColor *bg) +{ + GdkPixmap *pixmap; + GdkWindowPrivate *private; + GdkWindowPrivate *window_private; + + g_return_val_if_fail (data != NULL, NULL); + g_return_val_if_fail (fg != NULL, NULL); + g_return_val_if_fail (bg != NULL, NULL); + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + if (depth == -1) + gdk_window_get_geometry (window, NULL, NULL, NULL, NULL, &depth); + + private = g_new (GdkWindowPrivate, 1); + pixmap = (GdkPixmap*) private; + + window_private = (GdkWindowPrivate*) window; + + private->parent = NULL; + private->xdisplay = window_private->xdisplay; + private->window_type = GDK_WINDOW_PIXMAP; + private->x = 0; + private->y = 0; + private->width = width; + private->height = height; + private->resize_count = 0; + private->ref_count = 1; + private->destroyed = FALSE; + + private->xwindow = XCreatePixmapFromBitmapData (private->xdisplay, + window_private->xwindow, + data, width, height, + fg->pixel, bg->pixel, depth); + + gdk_xid_table_insert (&private->xwindow, pixmap); + + return pixmap; +} + +gint +gdk_pixmap_seek_string (FILE *infile, + const gchar *str, + gint skip_comments) +{ + char instr[1024]; + + while (!feof (infile)) + { + fscanf (infile, "%s", instr); + if (skip_comments == TRUE && strcmp (instr, "/*") == 0) + { + fscanf (infile, "%s", instr); + while (!feof (infile) && strcmp (instr, "*/") != 0) + fscanf (infile, "%s", instr); + fscanf(infile, "%s", instr); + } + if (strcmp (instr, str)==0) + return TRUE; + } + + return FALSE; +} + +gint +gdk_pixmap_seek_char (FILE *infile, + gchar c) +{ + gchar b, oldb; + + while (!feof (infile)) + { + fscanf(infile, "%c", &b); + if (c != b && b == '/') + { + fscanf (infile, "%c", &b); + if (b == '*') + { + oldb = b; + while (!feof (infile) && !(oldb == '*' && b == '/')) + { + oldb = b; + fscanf (infile, "%c", &b); + } + fscanf (infile, "%c", &b); + } + } + if (c == b) + return TRUE; + } + + return FALSE; +} + +gint +gdk_pixmap_read_string (FILE *infile, + gchar **buffer, + int *buffer_size) +{ + gchar c; + gint cnt = 0; + + if ((*buffer) == NULL) + { + (*buffer_size) = 10 * sizeof (gchar); + (*buffer) = (gchar *) malloc (*buffer_size); + } + + do + fscanf (infile, "%c", &c); + while (!feof (infile) && c != '"'); + + if (c != '"') + return FALSE; + + while (!feof (infile)) + { + fscanf (infile, "%c", &c); + + if (cnt == (*buffer_size)) + { + (*buffer_size) *= 2; + (*buffer) = (gchar *) realloc ((*buffer), *buffer_size); + } + + if (c != '"') + (*buffer)[cnt++] = c; + else + { + (*buffer)[cnt++] = 0; + return TRUE; + } + } + + return FALSE; +} + +gchar* +gdk_pixmap_skip_whitespaces (gchar *buffer) +{ + gint32 index = 0; + + while (buffer[index] != 0 && (buffer[index] == 0x20 || buffer[index] == 0x09)) + index++; + + return &buffer[index]; +} + +gchar* +gdk_pixmap_skip_string (gchar *buffer) +{ + gint32 index = 0; + + while (buffer[index] != 0 && buffer[index] != 0x20 && buffer[index] != 0x09) + index++; + + return &buffer[index]; +} + +gchar* +gdk_pixmap_extract_color (gchar *buffer) +{ + gint counter, finished = FALSE, numnames; + gchar *ptr = NULL, ch, temp[128]; + gchar color[128], *retcol; + + counter = 0; + while (ptr == NULL) + { + if (buffer[counter] == 'c') + { + ch = buffer[counter + 1]; + if (ch == 0x20 || ch == 0x09) + ptr = &buffer[counter + 1]; + } + else if (buffer[counter] == 0) + return NULL; + + counter++; + } + + if (ptr == NULL) + return NULL; + + ptr = gdk_pixmap_skip_whitespaces (ptr); + + if (ptr[0] == 0) + return NULL; + else if (ptr[0] == '#') + { + retcol = g_new(gchar, strlen (ptr) + 1); + strcpy (retcol, ptr); + return retcol; + } + + color[0] = 0; + numnames = 0; + + while (finished == FALSE) + { + sscanf (ptr, "%s", temp); + + if ((gint)ptr[0] == 0 || strcmp ("s", temp) == 0 || strcmp ("m", temp) == 0 || + strcmp ("g", temp) == 0 || strcmp ("g4", temp) == 0) + finished = TRUE; + else + { + if (numnames > 0) + strcat (color, " "); + strcat (color, temp); + ptr = gdk_pixmap_skip_string (ptr); + ptr = gdk_pixmap_skip_whitespaces (ptr); + numnames++; + } + } + + retcol = g_new(gchar, strlen (color) + 1); + strcpy (retcol, color); + return retcol; +} + + +GdkPixmap* +gdk_pixmap_create_from_xpm (GdkWindow *window, + GdkBitmap **mask, + GdkColor *transparent_color, + const gchar *filename) +{ + FILE *infile = NULL; + GdkPixmap *pixmap = NULL; + GdkImage *image = NULL; + GdkColormap *colormap; + GdkVisual *visual; + GdkGC *gc; + GdkColor tmp_color; + gint width, height, num_cols, cpp, cnt, n, ns, xcnt, ycnt; + gchar *buffer = NULL, *color_name = NULL, pixel_str[32]; + guint buffer_size = 0; + _GdkPixmapColor *colors = NULL, *color = NULL; + gulong index; + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + infile = fopen (filename, "rb"); + if (infile != NULL) + { + if (gdk_pixmap_seek_string (infile, "XPM", FALSE) == TRUE) + { + if (gdk_pixmap_seek_char (infile,'{') == TRUE) + { + gdk_pixmap_seek_char (infile, '"'); + fseek (infile, -1, SEEK_CUR); + gdk_pixmap_read_string (infile, &buffer, &buffer_size); + + sscanf (buffer,"%d %d %d %d", &width, &height, &num_cols, &cpp); + + colors = g_new(_GdkPixmapColor, num_cols); + + colormap = gdk_window_get_colormap (window); + visual = gdk_window_get_visual (window); + + if (transparent_color == NULL) + { + gdk_color_white (colormap, &tmp_color); + transparent_color = &tmp_color; + } + + for (cnt = 0; cnt < num_cols; cnt++) + { + gdk_pixmap_seek_char (infile, '"'); + fseek (infile, -1, SEEK_CUR); + gdk_pixmap_read_string (infile, &buffer, &buffer_size); + + colors[cnt].color_string = g_new(gchar, cpp + 1); + for (n = 0; n < cpp; n++) + colors[cnt].color_string[n] = buffer[n]; + colors[cnt].color_string[n] = 0; + colors[cnt].transparent = FALSE; + + if (color_name != NULL) + g_free (color_name); + + color_name = gdk_pixmap_extract_color (&buffer[cpp]); + + if (color_name != NULL) + { + if (gdk_color_parse (color_name, &colors[cnt].color) == FALSE) + { + colors[cnt].color = *transparent_color; + colors[cnt].transparent = TRUE; + } + } + else + { + colors[cnt].color = *transparent_color; + colors[cnt].transparent = TRUE; + } + + gdk_color_alloc (colormap, &colors[cnt].color); + } + + index = 0; + image = gdk_image_new (GDK_IMAGE_FASTEST, visual, width, height); + + gc = NULL; + if (mask) + { + *mask = gdk_pixmap_new (window, width, height, 1); + gc = gdk_gc_new (*mask); + + gdk_color_black (colormap, &tmp_color); + gdk_gc_set_foreground (gc, &tmp_color); + gdk_draw_rectangle (*mask, gc, TRUE, 0, 0, -1, -1); + + gdk_color_white (colormap, &tmp_color); + gdk_gc_set_foreground (gc, &tmp_color); + } + + for (ycnt = 0; ycnt < height; ycnt++) + { + gdk_pixmap_read_string (infile, &buffer, &buffer_size); + + for (n = 0, cnt = 0, xcnt = 0; n < (width * cpp); n += cpp, xcnt++) + { + strncpy (pixel_str, &buffer[n], cpp); + pixel_str[cpp] = 0; + color = NULL; + ns = 0; + + while (color == NULL) + { + if (strcmp (pixel_str, colors[ns].color_string) == 0) + color = &colors[ns]; + else + ns++; + } + + gdk_image_put_pixel (image, xcnt, ycnt, color->color.pixel); + + if (mask && color->transparent) + { + if (cnt < xcnt) + gdk_draw_line (*mask, gc, cnt, ycnt, xcnt - 1, ycnt); + cnt = xcnt + 1; + } + } + + if (mask && (cnt < xcnt)) + gdk_draw_line (*mask, gc, cnt, ycnt, xcnt - 1, ycnt); + } + + if (mask) + gdk_gc_destroy (gc); + + pixmap = gdk_pixmap_new (window, width, height, visual->depth); + + gc = gdk_gc_new (pixmap); + gdk_gc_set_foreground (gc, transparent_color); + gdk_draw_image (pixmap, gc, image, 0, 0, 0, 0, image->width, image->height); + gdk_gc_destroy (gc); + gdk_image_destroy (image); + } + } + + fclose (infile); + free (buffer); + + if (colors != NULL) + { + for (cnt = 0; cnt < num_cols; cnt++) + g_free (colors[cnt].color_string); + g_free (colors); + } + } + + return pixmap; +} + +GdkPixmap* +gdk_pixmap_create_from_xpm_d (GdkWindow *window, + GdkBitmap **mask, + GdkColor *transparent_color, + gchar **data) +{ + GdkPixmap *pixmap = NULL; + GdkImage *image = NULL; + GdkColormap *colormap; + GdkVisual *visual; + GdkGC *gc; + GdkColor tmp_color; + gint width, height, num_cols, cpp, cnt, n, ns, xcnt, ycnt, i; + gchar *buffer, *color_name = NULL, pixel_str[32]; + _GdkPixmapColor *colors = NULL, *color = NULL; + gulong index; + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + i = 0; + buffer = data[i++]; + sscanf (buffer,"%d %d %d %d", &width, &height, &num_cols, &cpp); + + colors = g_new(_GdkPixmapColor, num_cols); + + colormap = gdk_window_get_colormap (window); + visual = gdk_window_get_visual (window); + + if (transparent_color == NULL) + { + gdk_color_white (colormap, &tmp_color); + transparent_color = &tmp_color; + } + + for (cnt = 0; cnt < num_cols; cnt++) + { + buffer = data[i++]; + + colors[cnt].color_string = g_new(gchar, cpp + 1); + for (n = 0; n < cpp; n++) + colors[cnt].color_string[n] = buffer[n]; + colors[cnt].color_string[n] = 0; + colors[cnt].transparent = FALSE; + + if (color_name != NULL) + g_free (color_name); + + color_name = gdk_pixmap_extract_color (&buffer[cpp]); + + if (color_name != NULL) + { + if (gdk_color_parse (color_name, &colors[cnt].color) == FALSE) + { + colors[cnt].color = *transparent_color; + colors[cnt].transparent = TRUE; + } + } + else + { + colors[cnt].color = *transparent_color; + colors[cnt].transparent = TRUE; + } + + gdk_color_alloc (colormap, &colors[cnt].color); + } + + index = 0; + image = gdk_image_new (GDK_IMAGE_FASTEST, visual, width, height); + + gc = NULL; + if (mask) + { + *mask = gdk_pixmap_new (window, width, height, 1); + gc = gdk_gc_new (*mask); + + gdk_color_black (colormap, &tmp_color); + gdk_gc_set_foreground (gc, &tmp_color); + gdk_draw_rectangle (*mask, gc, TRUE, 0, 0, -1, -1); + + gdk_color_white (colormap, &tmp_color); + gdk_gc_set_foreground (gc, &tmp_color); + } + + for (ycnt = 0; ycnt < height; ycnt++) + { + buffer = data[i++]; + + for (n = 0, cnt = 0, xcnt = 0; n < (width * cpp); n += cpp, xcnt++) + { + strncpy (pixel_str, &buffer[n], cpp); + pixel_str[cpp] = 0; + color = NULL; + ns = 0; + + while (color == NULL) + { + if (strcmp (pixel_str, colors[ns].color_string) == 0) + color = &colors[ns]; + else + ns++; + } + + gdk_image_put_pixel (image, xcnt, ycnt, color->color.pixel); + + if (mask && color->transparent) + { + if (cnt < xcnt) + gdk_draw_line (*mask, gc, cnt, ycnt, xcnt - 1, ycnt); + cnt = xcnt + 1; + } + } + + if (mask && (cnt < xcnt)) + gdk_draw_line (*mask, gc, cnt, ycnt, xcnt - 1, ycnt); + } + + if (mask) + gdk_gc_destroy (gc); + + pixmap = gdk_pixmap_new (window, width, height, visual->depth); + + gc = gdk_gc_new (pixmap); + gdk_gc_set_foreground (gc, transparent_color); + gdk_draw_image (pixmap, gc, image, 0, 0, 0, 0, image->width, image->height); + gdk_gc_destroy (gc); + gdk_image_destroy (image); + + if (colors != NULL) + { + for (cnt = 0; cnt < num_cols; cnt++) + g_free (colors[cnt].color_string); + g_free (colors); + } + + return pixmap; +} + +void +gdk_pixmap_destroy (GdkPixmap *pixmap) +{ + GdkWindowPrivate *private; + + g_return_if_fail (pixmap != NULL); + + private = (GdkPixmapPrivate*) pixmap; + if (private->ref_count <= 0) + { + XFreePixmap (private->xdisplay, private->xwindow); + gdk_xid_table_remove (private->xwindow); + g_free (pixmap); + } + else + { + private->ref_count -= 1; + } +} diff --git a/gdk/gdkprivate.h b/gdk/gdkprivate.h new file mode 100644 index 000000000..3c1677e41 --- /dev/null +++ b/gdk/gdkprivate.h @@ -0,0 +1,197 @@ +/* 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. + */ +#ifndef __GDK_PRIVATE_H__ +#define __GDK_PRIVATE_H__ + + +#include <X11/Xlib.h> +#include <X11/Xutil.h> +#include <gdk/gdktypes.h> + +#define DND_PROTOCOL_VERSION 0 + +#define gdk_window_lookup(xid) ((GdkWindow*) gdk_xid_table_lookup (xid)) +#define gdk_pixmap_lookup(xid) ((GdkPixmap*) gdk_xid_table_lookup (xid)) +#define gdk_font_lookup(xid) ((GdkFont*) gdk_xid_table_lookup (xid)) + + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + + +typedef struct _GdkWindowPrivate GdkWindowPrivate; +typedef struct _GdkWindowPrivate GdkPixmapPrivate; +typedef struct _GdkImagePrivate GdkImagePrivate; +typedef struct _GdkGCPrivate GdkGCPrivate; +typedef struct _GdkColormapPrivate GdkColormapPrivate; +typedef struct _GdkVisualPrivate GdkVisualPrivate; +typedef struct _GdkFontPrivate GdkFontPrivate; +typedef struct _GdkCursorPrivate GdkCursorPrivate; + + +struct _GdkWindowPrivate +{ + GdkWindow window; + GdkWindow *parent; + Window xwindow; + Display *xdisplay; + gint16 x; + gint16 y; + guint16 width; + guint16 height; + guint8 resize_count; + guint8 ref_count; + guint8 window_type; + guint8 destroyed : 2; + guint8 dnd_drag_enabled : 1, + dnd_drag_datashow : 1, + dnd_drag_destructive_op : 1, + dnd_drag_accepted : 1, + dnd_drop_enabled : 1, + dnd_drop_destructive_op : 1; + GdkAtom dnd_drag_data_type, *dnd_drag_data_typesavail; + guint dnd_drag_data_numtypesavail; + /* We have to turn on MotionMask/EnterWindowMask/LeaveWindowMask + during drags, then set it back to what it was after */ + glong dnd_drag_savedeventmask, dnd_drag_eventmask; + GdkAtom *dnd_drop_data_typesavail; + guint dnd_drop_data_numtypesavail; + /* need to allow custom drag/drop cursors */ + + gint extension_events; +}; + +struct _GdkImagePrivate +{ + GdkImage image; + XImage *ximage; + Display *xdisplay; + gpointer x_shm_info; + + void (*image_put) (GdkDrawable *window, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height); +}; + +struct _GdkGCPrivate +{ + GdkGC gc; + GC xgc; + Display *xdisplay; +}; + +struct _GdkColormapPrivate +{ + GdkColormap colormap; + Colormap xcolormap; + Display *xdisplay; + GdkVisual *visual; + gint private_val; + gint next_color; + gint ref_count; +}; + +struct _GdkVisualPrivate +{ + GdkVisual visual; + Visual *xvisual; +}; + +struct _GdkFontPrivate +{ + GdkFont font; + /* XFontStruct *xfont; */ + /* generic pointer point to XFontStruct or XFontSet */ + gpointer xfont; + Display *xdisplay; + gint ref_count; +}; + +struct _GdkCursorPrivate +{ + GdkCursor cursor; + Cursor xcursor; + Display *xdisplay; +}; + +struct _GdkDndGlobals { + GdkAtom gdk_XdeEnter, gdk_XdeLeave, gdk_XdeRequest; + GdkAtom gdk_XdeDataAvailable, gdk_XdeDataShow, gdk_XdeCancel; + GdkAtom gdk_XdeTypelist; + Cursor gdk_cursor_dragdefault, gdk_cursor_dragok; + GdkWindow **drag_startwindows; + guint drag_numwindows; + guint8 drag_really; + GdkPoint drag_dropcoords; +}; +typedef struct _GdkDndGlobals GdkDndGlobals; + +void gdk_window_init (void); +void gdk_visual_init (void); + +void gdk_image_init (void); +void gdk_image_exit (void); + +GdkColormap* gdk_colormap_lookup (Colormap xcolormap); +GdkVisual* gdk_visual_lookup (Visual *xvisual); + +void gdk_window_real_destroy (GdkWindow *window); +void gdk_window_add_colormap_windows (GdkWindow *window); + +void gdk_xid_table_insert (XID *xid, + gpointer data); +void gdk_xid_table_remove (XID xid); +gpointer gdk_xid_table_lookup (XID xid); + + +extern gint gdk_debug_level; +extern gint gdk_show_events; +extern gint gdk_use_xshm; +extern gint gdk_stack_trace; +extern gchar *gdk_display_name; +extern Display *gdk_display; +extern gint gdk_screen; +extern Window gdk_root_window; +extern Window gdk_leader_window; +extern GdkWindowPrivate gdk_root_parent; +extern Atom gdk_wm_delete_window; +extern Atom gdk_wm_take_focus; +extern Atom gdk_wm_protocols; +extern Atom gdk_wm_window_protocols[]; +extern Atom gdk_selection_property; +extern GdkDndGlobals gdk_dnd; +extern GdkWindow *selection_owner[]; +extern gchar *gdk_progname; +extern gchar *gdk_progclass; +extern gint gdk_error_code; +extern gint gdk_error_warnings; + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +#endif /* __GDK_PRIVATE_H__ */ diff --git a/gdk/gdkproperty.c b/gdk/gdkproperty.c new file mode 100644 index 000000000..35d8a50cf --- /dev/null +++ b/gdk/gdkproperty.c @@ -0,0 +1,194 @@ +/* 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 <X11/Xlib.h> +#include <X11/Xatom.h> +#include <string.h> +#include "gdk.h" +#include "gdkprivate.h" + + +GdkAtom +gdk_atom_intern (const gchar *atom_name, + gint only_if_exists) +{ + return XInternAtom (gdk_display, atom_name, only_if_exists); +} + +gchar * +gdk_atom_name (GdkAtom atom) +{ + gchar *t; + gchar *name; + + /* If this atom doesn't exist, we'll die with an X error unless + we take precautions */ + + gdk_error_warnings = 0; + t = XGetAtomName (gdk_display, atom); + gdk_error_warnings = 1; + + if (gdk_error_code == -1) + { + return NULL; + } + else + { + name = g_strdup (t); + XFree (t); + + return name; + } +} + +gint +gdk_property_get (GdkWindow *window, + GdkAtom property, + GdkAtom type, + gulong offset, + gulong length, + gint pdelete, + GdkAtom *actual_property_type, + gint *actual_format_type, + gint *actual_length, + guchar **data) +{ + GdkWindowPrivate *private; + Display *xdisplay; + Window xwindow; + Atom ret_prop_type; + gint ret_format; + gulong ret_nitems; + gulong ret_bytes_after; + gulong ret_length; + guchar *ret_data; + + if (window) + { + private = (GdkWindowPrivate*) window; + xdisplay = private->xdisplay; + xwindow = private->xwindow; + } + else + { + xdisplay = gdk_display; + xwindow = gdk_root_window; + } + + XGetWindowProperty (xdisplay, xwindow, property, + offset, (length + 3) / 4, pdelete, + type, &ret_prop_type, &ret_format, + &ret_nitems, &ret_bytes_after, + &ret_data); + + if ((ret_prop_type == None) && (ret_format == 0)) + return FALSE; + + if (actual_property_type) + *actual_property_type = ret_prop_type; + if (actual_format_type) + *actual_format_type = ret_format; + + if (ret_prop_type != property) + { + XFree (ret_data); + return FALSE; + } + + /* FIXME: ignoring bytes_after could have very bad effects */ + + if (data) + { + switch (ret_format) + { + case 8: + ret_length = ret_nitems; + break; + case 16: + ret_length = 2 * ret_nitems; + break; + case 32: + ret_length = 4 * ret_nitems; + break; + default: + g_warning ("unknown property return format: %d", ret_format); + XFree (ret_data); + return FALSE; + } + + *data = g_new (guchar, ret_length); + memcpy (*data, ret_data, ret_length); + if (actual_length) + *actual_length = ret_length; + } + + XFree (ret_data); + + return TRUE; +} + +void +gdk_property_change (GdkWindow *window, + GdkAtom property, + GdkAtom type, + gint format, + GdkPropMode mode, + guchar *data, + gint nelements) +{ + GdkWindowPrivate *private; + Display *xdisplay; + Window xwindow; + + if (window) + { + private = (GdkWindowPrivate*) window; + xdisplay = private->xdisplay; + xwindow = private->xwindow; + } + else + { + xdisplay = gdk_display; + xwindow = gdk_root_window; + } + + XChangeProperty (xdisplay, xwindow, property, type, + format, mode, data, nelements); +} + +void +gdk_property_delete (GdkWindow *window, + GdkAtom property) +{ + GdkWindowPrivate *private; + Display *xdisplay; + Window xwindow; + + if (window) + { + private = (GdkWindowPrivate*) window; + xdisplay = private->xdisplay; + xwindow = private->xwindow; + } + else + { + xdisplay = gdk_display; + xwindow = gdk_root_window; + } + + XDeleteProperty (xdisplay, xwindow, property); +} diff --git a/gdk/gdkrectangle.c b/gdk/gdkrectangle.c new file mode 100644 index 000000000..dbb35b664 --- /dev/null +++ b/gdk/gdkrectangle.c @@ -0,0 +1,83 @@ +/* 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 "gdk.h" + + +gint +gdk_rectangle_intersect (GdkRectangle *src1, + GdkRectangle *src2, + GdkRectangle *dest) +{ + GdkRectangle *temp; + gint src1_x2, src1_y2; + gint src2_x2, src2_y2; + gint return_val; + + g_return_val_if_fail (src1 != NULL, FALSE); + g_return_val_if_fail (src2 != NULL, FALSE); + g_return_val_if_fail (dest != NULL, FALSE); + + return_val = FALSE; + + if (src2->x < src1->x) + { + temp = src1; + src1 = src2; + src2 = temp; + } + dest->x = src2->x; + + src1_x2 = src1->x + src1->width; + src2_x2 = src2->x + src2->width; + + if (src2->x < src1_x2) + { + if (src1_x2 < src2_x2) + dest->width = src1_x2 - dest->x; + else + dest->width = src2_x2 - dest->x; + + if (src2->y < src1->y) + { + temp = src1; + src1 = src2; + src2 = temp; + } + dest->y = src2->y; + + src1_y2 = src1->y + src1->height; + src2_y2 = src2->y + src2->height; + + if (src2->y < src1_y2) + { + return_val = TRUE; + + if (src1_y2 < src2_y2) + dest->height = src1_y2 - dest->y; + else + dest->height = src2_y2 - dest->y; + + if (dest->height == 0) + return_val = FALSE; + if (dest->width == 0) + return_val = FALSE; + } + } + + return return_val; +} diff --git a/gdk/gdkselection.c b/gdk/gdkselection.c new file mode 100644 index 000000000..6bd425110 --- /dev/null +++ b/gdk/gdkselection.c @@ -0,0 +1,168 @@ +/* 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 <X11/Xlib.h> +#include <X11/Xatom.h> +#include <string.h> +#include "gdk.h" +#include "gdkprivate.h" + + +gint +gdk_selection_owner_set (GdkWindow *owner, + GdkAtom selection, + guint32 time, + gint send_event) +{ + GdkWindowPrivate *private; + Display *xdisplay; + Window xwindow; + + if (owner) + { + private = (GdkWindowPrivate*) owner; + xdisplay = private->xdisplay; + xwindow = private->xwindow; + } + else + { + xdisplay = gdk_display; + xwindow = None; + } + + XSetSelectionOwner (xdisplay, selection, xwindow, time); + + return (XGetSelectionOwner (xdisplay, selection) == xwindow); +} + +GdkWindow* +gdk_selection_owner_get (GdkAtom selection) +{ + Window xwindow; + + xwindow = XGetSelectionOwner (gdk_display, selection); + if (xwindow == None) + return NULL; + + return gdk_window_lookup (xwindow); +} + +void +gdk_selection_convert (GdkWindow *requestor, + GdkAtom selection, + GdkAtom target, + guint32 time) +{ + GdkWindowPrivate *private; + + g_return_if_fail (requestor != NULL); + + private = (GdkWindowPrivate*) requestor; + + XConvertSelection (private->xdisplay, selection, target, + gdk_selection_property, private->xwindow, time); +} + +gint +gdk_selection_property_get (GdkWindow *requestor, + guchar **data, + GdkAtom *ret_type, + gint *ret_format) +{ + GdkWindowPrivate *private; + gulong nitems; + gulong nbytes; + gulong length; + GdkAtom prop_type; + gint prop_format; + guchar *t; + + g_return_val_if_fail (requestor != NULL, 0); + + /* If retrieved chunks are typically small, (and the ICCM says the + should be) it would be a win to try first with a buffer of + moderate length, to avoid two round trips to the server */ + + private = (GdkWindowPrivate*) requestor; + + XGetWindowProperty (private->xdisplay, private->xwindow, + gdk_selection_property, 0, 0, False, + AnyPropertyType, &prop_type, &prop_format, + &nitems, &nbytes, &t); + + if (ret_type) + *ret_type = prop_type; + if (ret_format) + *ret_format = prop_format; + + if (prop_type == None) + { + *data = NULL; + return 0; + } + + XFree (t); + + /* Add on an extra byte to handle null termination. X guarantees + that t will be 1 longer than nbytes and null terminated */ + length = nbytes + 1; + + /* We can't delete the selection here, because it might be the INCR + protocol, in which case the client has to make sure they'll be + notified of PropertyChange events _before_ the property is deleted. + Otherwise there's no guarantee we'll win the race ... */ + XGetWindowProperty (private->xdisplay, private->xwindow, + gdk_selection_property, 0, (nbytes + 3) / 4, False, + AnyPropertyType, &prop_type, &prop_format, + &nitems, &nbytes, &t); + + if (prop_type != None) + { + *data = g_new (guchar, length); + memcpy (*data, t, length); + XFree (t); + return length-1; + } + else + { + *data = NULL; + return 0; + } +} + + +void +gdk_selection_send_notify (guint32 requestor, + GdkAtom selection, + GdkAtom target, + GdkAtom property, + guint32 time) +{ + XSelectionEvent xevent; + + xevent.type = SelectionNotify; + xevent.serial = 0; + xevent.send_event = True; + xevent.display = gdk_display; + xevent.requestor = requestor; + xevent.selection = selection; + xevent.target = target; + xevent.property = property; + xevent.time = time; + + XSendEvent (gdk_display, requestor, False, NoEventMask, (XEvent*) &xevent); +} diff --git a/gdk/gdktypes.h b/gdk/gdktypes.h new file mode 100644 index 000000000..7fc7434ac --- /dev/null +++ b/gdk/gdktypes.h @@ -0,0 +1,967 @@ +/* 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. + */ +#ifndef __GDK_TYPES_H__ +#define __GDK_TYPES_H__ + + +/* GDK uses "glib". (And so does GTK). + */ +#include <glib.h> + + +#define GDK_NONE 0L +#define GDK_CURRENT_TIME 0L +#define GDK_PARENT_RELATIVE 1L + +/* special deviceid for core pointer events */ +#define GDK_CORE_POINTER 0xfedc + + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + + +/* Type definitions for the basic structures. + */ + +typedef gulong GdkAtom; +typedef struct _GdkColor GdkColor; +typedef struct _GdkColormap GdkColormap; +typedef struct _GdkVisual GdkVisual; +typedef struct _GdkWindowAttr GdkWindowAttr; +typedef struct _GdkWindow GdkWindow; +typedef struct _GdkWindow GdkPixmap; +typedef struct _GdkWindow GdkBitmap; +typedef struct _GdkWindow GdkDrawable; +typedef struct _GdkImage GdkImage; +typedef struct _GdkGCValues GdkGCValues; +typedef struct _GdkGC GdkGC; +typedef struct _GdkPoint GdkPoint; +typedef struct _GdkRectangle GdkRectangle; +typedef struct _GdkSegment GdkSegment; +typedef struct _GdkFont GdkFont; +typedef struct _GdkCursor GdkCursor; + +typedef struct _GdkEventAny GdkEventAny; +typedef struct _GdkEventExpose GdkEventExpose; +typedef struct _GdkEventMotion GdkEventMotion; +typedef struct _GdkEventButton GdkEventButton; +typedef struct _GdkEventKey GdkEventKey; +typedef struct _GdkEventFocus GdkEventFocus; +typedef struct _GdkEventCrossing GdkEventCrossing; +typedef struct _GdkEventConfigure GdkEventConfigure; +typedef struct _GdkEventProperty GdkEventProperty; +typedef struct _GdkEventSelection GdkEventSelection; +typedef struct _GdkEventProximity GdkEventProximity; +typedef struct _GdkEventOther GdkEventOther; +typedef struct _GdkEventDragBegin GdkEventDragBegin; +typedef struct _GdkEventDragRequest GdkEventDragRequest; +typedef struct _GdkEventDropEnter GdkEventDropEnter; +typedef struct _GdkEventDropDataAvailable GdkEventDropDataAvailable; +typedef struct _GdkEventDropLeave GdkEventDropLeave; +typedef struct _GdkEventClient GdkEventClient; +typedef union _GdkEvent GdkEvent; +typedef struct _GdkDeviceInfo GdkDeviceInfo; +typedef struct _GdkTimeCoord GdkTimeCoord; +typedef gint (*GdkEventFunc) (GdkEvent *event, + gpointer data); + + +/* Types of windows. + * Root: There is only 1 root window and it is initialized + * at startup. Creating a window of type GDK_WINDOW_ROOT + * is an error. + * Toplevel: Windows which interact with the window manager. + * Child: Windows which are children of some other type of window. + * (Any other type of window). Most windows are child windows. + * Dialog: A special kind of toplevel window which interacts with + * the window manager slightly differently than a regular + * toplevel window. Dialog windows should be used for any + * transient window. + * Pixmap: Pixmaps are really just another kind of window which + * doesn't actually appear on the screen. It can't have + * children, either and is really just a convenience so + * that the drawing functions can work on both windows + * and pixmaps transparently. (ie. You shouldn't pass a + * pixmap to any procedure which accepts a window with the + * exception of the drawing functions). + */ +typedef enum +{ + GDK_WINDOW_ROOT, + GDK_WINDOW_TOPLEVEL, + GDK_WINDOW_CHILD, + GDK_WINDOW_DIALOG, + GDK_WINDOW_TEMP, + GDK_WINDOW_PIXMAP +} GdkWindowType; + +/* Classes of windows. + * InputOutput: Almost every window should be of this type. Such windows + * receive events and are also displayed on screen. + * InputOnly: Used only in special circumstances when events need to be + * stolen from another window or windows. Input only windows + * have no visible output, so they are handy for placing over + * top of a group of windows in order to grab the events (or + * filter the events) from those windows. + */ +typedef enum +{ + GDK_INPUT_OUTPUT, + GDK_INPUT_ONLY +} GdkWindowClass; + +/* Types of images. + * Normal: Normal X image type. These are slow as they involve passing + * the entire image through the X connection each time a draw + * request is required. + * Shared: Shared memory X image type. These are fast as the X server + * and the program actually use the same piece of memory. They + * should be used with care though as there is the possibility + * for both the X server and the program to be reading/writing + * the image simultaneously and producing undesired results. + */ +typedef enum +{ + GDK_IMAGE_NORMAL, + GDK_IMAGE_SHARED, + GDK_IMAGE_FASTEST +} GdkImageType; + +/* Types of visuals. + * StaticGray: + * Grayscale: + * StaticColor: + * PseudoColor: + * TrueColor: + * DirectColor: + */ +typedef enum +{ + GDK_VISUAL_STATIC_GRAY, + GDK_VISUAL_GRAYSCALE, + GDK_VISUAL_STATIC_COLOR, + GDK_VISUAL_PSEUDO_COLOR, + GDK_VISUAL_TRUE_COLOR, + GDK_VISUAL_DIRECT_COLOR +} GdkVisualType; + +/* Types of font. + * GDK_FONT_FONT: the font is an XFontStruct. + * GDK_FONT_FONTSET: the font is an XFontSet used for I18N. + */ +typedef enum +{ + GDK_FONT_FONT, + GDK_FONT_FONTSET +} GdkFontType; + +/* Window attribute mask values. + * GDK_WA_TITLE: The "title" field is valid. + * GDK_WA_X: The "x" field is valid. + * GDK_WA_Y: The "y" field is valid. + * GDK_WA_CURSOR: The "cursor" field is valid. + * GDK_WA_COLORMAP: The "colormap" field is valid. + * GDK_WA_VISUAL: The "visual" field is valid. + */ +typedef enum +{ + GDK_WA_TITLE = 1 << 1, + GDK_WA_X = 1 << 2, + GDK_WA_Y = 1 << 3, + GDK_WA_CURSOR = 1 << 4, + GDK_WA_COLORMAP = 1 << 5, + GDK_WA_VISUAL = 1 << 6, + GDK_WA_WMCLASS = 1 << 7 +} GdkWindowAttributesType; + +/* Size restriction enumeration. + */ +typedef enum +{ + GDK_HINT_POS = 1 << 0, + GDK_HINT_MIN_SIZE = 1 << 1, + GDK_HINT_MAX_SIZE = 1 << 2 +} GdkWindowHints; + +/* GC function types. + * Copy: Overwrites destination pixels with the source pixels. + * Invert: Inverts the destination pixels. + * Xor: Xor's the destination pixels with the source pixels. + */ +typedef enum +{ + GDK_COPY, + GDK_INVERT, + GDK_XOR +} GdkFunction; + +/* GC fill types. + * Solid: + * Tiled: + * Stippled: + * OpaqueStippled: + */ +typedef enum +{ + GDK_SOLID, + GDK_TILED, + GDK_STIPPLED, + GDK_OPAQUE_STIPPLED +} GdkFill; + +/* GC line styles + * Solid: + * OnOffDash: + * DoubleDash: + */ +typedef enum +{ + GDK_LINE_SOLID, + GDK_LINE_ON_OFF_DASH, + GDK_LINE_DOUBLE_DASH +} GdkLineStyle; + +/* GC cap styles + * CapNotLast: + * CapButt: + * CapRound: + * CapProjecting: + */ +typedef enum +{ + GDK_CAP_NOT_LAST, + GDK_CAP_BUTT, + GDK_CAP_ROUND, + GDK_CAP_PROJECTING +} GdkCapStyle; + +/* GC join styles + * JoinMiter: + * JoinRound: + * JoinBevel: + */ +typedef enum +{ + GDK_JOIN_MITER, + GDK_JOIN_ROUND, + GDK_JOIN_BEVEL +} GdkJoinStyle; + +/* Cursor types. + */ +typedef enum +{ +#include <gdk/gdkcursors.h> + GDK_LAST_CURSOR +} GdkCursorType; + +/* Event types. + * Nothing: No event occurred. + * Delete: A window delete event was sent by the window manager. + * The specified window should be deleted. + * Destroy: A window has been destroyed. + * Expose: Part of a window has been uncovered. + * MotionNotify: The mouse has moved. + * ButtonPress: A mouse button was pressed. + * ButtonRelease: A mouse button was release. + * KeyPress: A key was pressed. + * KeyRelease: A key was released. + * EnterNotify: A window was entered. + * LeaveNotify: A window was exited. + * FocusChange: The focus window has changed. (The focus window gets + * keyboard events). + * Resize: A window has been resized. + * Map: A window has been mapped. (It is now visible on the screen). + * Unmap: A window has been unmapped. (It is no longer visible on + * the screen). + */ +typedef enum +{ + GDK_NOTHING = -1, + GDK_DELETE = 0, + GDK_DESTROY = 1, + GDK_EXPOSE = 2, + GDK_MOTION_NOTIFY = 3, + GDK_BUTTON_PRESS = 4, + GDK_2BUTTON_PRESS = 5, + GDK_3BUTTON_PRESS = 6, + GDK_BUTTON_RELEASE = 7, + GDK_KEY_PRESS = 8, + GDK_KEY_RELEASE = 9, + GDK_ENTER_NOTIFY = 10, + GDK_LEAVE_NOTIFY = 11, + GDK_FOCUS_CHANGE = 12, + GDK_CONFIGURE = 13, + GDK_MAP = 14, + GDK_UNMAP = 15, + GDK_PROPERTY_NOTIFY = 16, + GDK_SELECTION_CLEAR = 17, + GDK_SELECTION_REQUEST = 18, + GDK_SELECTION_NOTIFY = 19, + GDK_PROXIMITY_IN = 20, + GDK_PROXIMITY_OUT = 21, + GDK_DRAG_BEGIN = 22, + GDK_DRAG_REQUEST = 23, + GDK_DROP_ENTER = 24, + GDK_DROP_LEAVE = 25, + GDK_DROP_DATA_AVAIL = 26, + GDK_CLIENT_EVENT = 27, + GDK_OTHER_EVENT = 9999 +} GdkEventType; + +/* Event masks. (Used to select what types of events a window + * will receive). + */ +typedef enum +{ + GDK_EXPOSURE_MASK = 1 << 1, + GDK_POINTER_MOTION_MASK = 1 << 2, + GDK_POINTER_MOTION_HINT_MASK = 1 << 3, + GDK_BUTTON_MOTION_MASK = 1 << 4, + GDK_BUTTON1_MOTION_MASK = 1 << 5, + GDK_BUTTON2_MOTION_MASK = 1 << 6, + GDK_BUTTON3_MOTION_MASK = 1 << 7, + GDK_BUTTON_PRESS_MASK = 1 << 8, + GDK_BUTTON_RELEASE_MASK = 1 << 9, + GDK_KEY_PRESS_MASK = 1 << 10, + GDK_KEY_RELEASE_MASK = 1 << 11, + GDK_ENTER_NOTIFY_MASK = 1 << 12, + GDK_LEAVE_NOTIFY_MASK = 1 << 13, + GDK_FOCUS_CHANGE_MASK = 1 << 14, + GDK_STRUCTURE_MASK = 1 << 15, + GDK_PROPERTY_CHANGE_MASK = 1 << 16, + GDK_PROXIMITY_IN_MASK = 1 << 17, + GDK_PROXIMITY_OUT_MASK = 1 << 18, + GDK_ALL_EVENTS_MASK = 0x07FFFF +} GdkEventMask; + +/* Types of enter/leave notifications. + * Ancestor: + * Virtual: + * Inferior: + * Nonlinear: + * NonlinearVirtual: + * Unknown: An unknown type of enter/leave event occurred. + */ +typedef enum +{ + GDK_NOTIFY_ANCESTOR = 0, + GDK_NOTIFY_VIRTUAL = 1, + GDK_NOTIFY_INFERIOR = 2, + GDK_NOTIFY_NONLINEAR = 3, + GDK_NOTIFY_NONLINEAR_VIRTUAL = 4, + GDK_NOTIFY_UNKNOWN = 5 +} GdkNotifyType; + +/* Types of modifiers. + */ +typedef enum +{ + GDK_SHIFT_MASK = 1 << 0, + GDK_LOCK_MASK = 1 << 1, + GDK_CONTROL_MASK = 1 << 2, + GDK_MOD1_MASK = 1 << 3, + GDK_MOD2_MASK = 1 << 4, + GDK_MOD3_MASK = 1 << 5, + GDK_MOD4_MASK = 1 << 6, + GDK_MOD5_MASK = 1 << 7, + GDK_BUTTON1_MASK = 1 << 8, + GDK_BUTTON2_MASK = 1 << 9, + GDK_BUTTON3_MASK = 1 << 10, + GDK_BUTTON4_MASK = 1 << 11, + GDK_BUTTON5_MASK = 1 << 12 +} GdkModifierType; + +typedef enum +{ + GDK_CLIP_BY_CHILDREN = 0, + GDK_INCLUDE_INFERIORS = 1 +} GdkSubwindowMode; + +typedef enum +{ + GDK_INPUT_READ = 1 << 0, + GDK_INPUT_WRITE = 1 << 1, + GDK_INPUT_EXCEPTION = 1 << 2 +} GdkInputCondition; + +typedef enum +{ + GDK_OK = 0, + GDK_ERROR = -1, + GDK_ERROR_PARAM = -2, + GDK_ERROR_FILE = -3, + GDK_ERROR_MEM = -4 +} GdkStatus; + +typedef enum +{ + GDK_LSB_FIRST, + GDK_MSB_FIRST +} GdkByteOrder; + +typedef enum +{ + GDK_GC_FOREGROUND = 1 << 0, + GDK_GC_BACKGROUND = 1 << 1, + GDK_GC_FONT = 1 << 2, + GDK_GC_FUNCTION = 1 << 3, + GDK_GC_FILL = 1 << 4, + GDK_GC_TILE = 1 << 5, + GDK_GC_STIPPLE = 1 << 6, + GDK_GC_CLIP_MASK = 1 << 7, + GDK_GC_SUBWINDOW = 1 << 8, + GDK_GC_TS_X_ORIGIN = 1 << 9, + GDK_GC_TS_Y_ORIGIN = 1 << 10, + GDK_GC_CLIP_X_ORIGIN = 1 << 11, + GDK_GC_CLIP_Y_ORIGIN = 1 << 12, + GDK_GC_EXPOSURES = 1 << 13, + GDK_GC_LINE_WIDTH = 1 << 14, + GDK_GC_LINE_STYLE = 1 << 15, + GDK_GC_CAP_STYLE = 1 << 16, + GDK_GC_JOIN_STYLE = 1 << 17 +} GdkGCValuesMask; + +typedef enum +{ + GDK_SELECTION_PRIMARY = 1, + GDK_SELECTION_SECONDARY = 2 +} GdkSelection; + +typedef enum +{ + GDK_PROPERTY_NEW_VALUE, + GDK_PROPERTY_DELETE +} GdkPropertyState; + +typedef enum +{ + GDK_PROP_MODE_REPLACE, + GDK_PROP_MODE_PREPEND, + GDK_PROP_MODE_APPEND +} GdkPropMode; + +/* These definitions are for version 1 of the OffiX D&D protocol, + taken from <OffiX/DragAndDropTypes.h> */ +typedef enum +{ + GDK_DNDTYPE_NOTDND = -1, + GDK_DNDTYPE_UNKNOWN = 0, + GDK_DNDTYPE_RAWDATA = 1, + GDK_DNDTYPE_FILE = 2, + GDK_DNDTYPE_FILES = 3, + GDK_DNDTYPE_TEXT = 4, + GDK_DNDTYPE_DIR = 5, + GDK_DNDTYPE_LINK = 6, + GDK_DNDTYPE_EXE = 7, + GDK_DNDTYPE_URL = 8, + GDK_DNDTYPE_MIME = 9, + GDK_DNDTYPE_END = 10 +} GdkDndType; + +/* Enums for XInput support */ + +typedef enum +{ + GDK_SOURCE_MOUSE, + GDK_SOURCE_PEN, + GDK_SOURCE_ERASER, + GDK_SOURCE_CURSOR +} GdkInputSource; + +typedef enum +{ + GDK_MODE_DISABLED, + GDK_MODE_SCREEN, + GDK_MODE_WINDOW +} GdkInputMode; + +typedef enum +{ + GDK_AXIS_IGNORE, + GDK_AXIS_X, + GDK_AXIS_Y, + GDK_AXIS_PRESSURE, + GDK_AXIS_XTILT, + GDK_AXIS_YTILT, + GDK_AXIS_LAST +} GdkAxisUse; + +/* The next two types define enums for predefined atoms relating + to selections. In general, one will need to use gdk_intern_atom */ + +typedef enum +{ + GDK_TARGET_BITMAP = 5, + GDK_TARGET_COLORMAP = 7, + GDK_TARGET_DRAWABLE = 17, + GDK_TARGET_PIXMAP = 20, + GDK_TARGET_STRING = 31 +} GdkTarget; + +typedef enum +{ + GDK_SELECTION_TYPE_ATOM = 4, + GDK_SELECTION_TYPE_BITMAP = 5, + GDK_SELECTION_TYPE_COLORMAP = 7, + GDK_SELECTION_TYPE_DRAWABLE = 17, + GDK_SELECTION_TYPE_INTEGER = 19, + GDK_SELECTION_TYPE_PIXMAP = 20, + GDK_SELECTION_TYPE_WINDOW = 33, + GDK_SELECTION_TYPE_STRING = 31 +} GdkSelectionType; + +typedef enum +{ + GDK_EXTENSION_EVENTS_NONE, + GDK_EXTENSION_EVENTS_ALL, + GDK_EXTENSION_EVENTS_CURSOR +} GdkExtensionMode; + +typedef void (*GdkInputFunction) (gpointer data, + gint source, + GdkInputCondition condition); + +/* The color type. + * A color consists of red, green and blue values in the + * range 0-65535 and a pixel value. The pixel value is highly + * dependent on the depth and colormap which this color will + * be used to draw into. Therefore, sharing colors between + * colormaps is a bad idea. + */ +struct _GdkColor +{ + gulong pixel; + gushort red; + gushort green; + gushort blue; +}; + +/* The colormap type. + * Colormaps consist of 256 colors. + */ +struct _GdkColormap +{ + GdkColor colors[256]; +}; + +/* The visual type. + * "type" is the type of visual this is (PseudoColor, TrueColor, etc). + * "depth" is the bit depth of this visual. + * "colormap_size" is the size of a colormap for this visual. + * "bits_per_rgb" is the number of significant bits per red, green and blue. + * The red, green and blue masks, shifts and precisions refer + * to value needed to calculate pixel values in TrueColor and DirectColor + * visuals. The "mask" is the significant bits within the pixel. The + * "shift" is the number of bits left we must shift a primary for it + * to be in position (according to the "mask"). "prec" refers to how + * much precision the pixel value contains for a particular primary. + */ +struct _GdkVisual +{ + GdkVisualType type; + gint depth; + GdkByteOrder byte_order; + gint colormap_size; + gint bits_per_rgb; + + guint32 red_mask; + gint red_shift; + gint red_prec; + + guint32 green_mask; + gint green_shift; + gint green_prec; + + guint32 blue_mask; + gint blue_shift; + gint blue_prec; +}; + +struct _GdkWindowAttr +{ + gchar *title; + gint event_mask; + gint16 x, y; + gint16 width; + gint16 height; + GdkWindowClass wclass; + GdkVisual *visual; + GdkColormap *colormap; + GdkWindowType window_type; + GdkCursor *cursor; + gchar *wmclass_name; + gchar *wmclass_class; +}; + +struct _GdkWindow +{ + gpointer user_data; +}; + +struct _GdkImage +{ + GdkImageType type; + GdkVisual *visual; /* visual used to create the image */ + GdkByteOrder byte_order; + guint16 width; + guint16 height; + guint16 depth; + guint16 bpp; /* bytes per pixel */ + guint16 bpl; /* bytes per line */ + gpointer mem; +}; + +struct _GdkGCValues +{ + GdkColor foreground; + GdkColor background; + GdkFont *font; + GdkFunction function; + GdkFill fill; + GdkPixmap *tile; + GdkPixmap *stipple; + GdkPixmap *clip_mask; + GdkSubwindowMode subwindow_mode; + gint ts_x_origin; + gint ts_y_origin; + gint clip_x_origin; + gint clip_y_origin; + gint graphics_exposures; + gint line_width; + GdkLineStyle line_style; + GdkCapStyle cap_style; + GdkJoinStyle join_style; +}; + +struct _GdkGC +{ + gint dummy_var; +}; + +struct _GdkPoint +{ + gint16 x; + gint16 y; +}; + +struct _GdkRectangle +{ + gint16 x; + gint16 y; + guint16 width; + guint16 height; +}; + +struct _GdkSegment +{ + gint16 x1; + gint16 y1; + gint16 x2; + gint16 y2; +}; + +struct _GdkFont +{ + GdkFontType type; + gint ascent; + gint descent; +}; + +struct _GdkCursor +{ + GdkCursorType type; +}; + +/* Types for XInput support */ + +struct _GdkDeviceInfo +{ + guint32 deviceid; + gchar *name; + GdkInputSource source; + GdkInputMode mode; + gint has_cursor; /* TRUE if the X pointer follows device motion */ + gint num_axes; + GdkAxisUse *axes; /* Specifies use for each axis */ +}; + +struct _GdkTimeCoord +{ + guint32 time; + gdouble x; + gdouble y; + gdouble pressure; + gdouble xtilt; + gdouble ytilt; +}; + +struct _GdkEventAny +{ + GdkEventType type; + GdkWindow *window; + gint8 send_event; +}; + +struct _GdkEventExpose +{ + GdkEventType type; + GdkWindow *window; + GdkRectangle area; + gint count; /* If non-zero, how many more events follow. */ +}; + +struct _GdkEventMotion +{ + GdkEventType type; + GdkWindow *window; + guint32 time; + gdouble x; + gdouble y; + gdouble pressure; + gdouble xtilt; + gdouble ytilt; + guint state; + gint16 is_hint; + GdkInputSource source; + guint32 deviceid; +}; + +struct _GdkEventButton +{ + GdkEventType type; + GdkWindow *window; + guint32 time; + gdouble x; + gdouble y; + gdouble pressure; + gdouble xtilt; + gdouble ytilt; + guint state; + guint button; + GdkInputSource source; + guint32 deviceid; +}; + +struct _GdkEventKey +{ + GdkEventType type; + GdkWindow *window; + guint32 time; + guint state; + guint keyval; +}; + +struct _GdkEventCrossing +{ + GdkEventType type; + GdkWindow *window; + GdkWindow *subwindow; + GdkNotifyType detail; +}; + +struct _GdkEventFocus +{ + GdkEventType type; + GdkWindow *window; + gint16 in; +}; + +struct _GdkEventConfigure +{ + GdkEventType type; + GdkWindow *window; + gint16 x, y; + gint16 width; + gint16 height; +}; + +struct _GdkEventProperty +{ + GdkEventType type; + GdkWindow *window; + GdkAtom atom; + guint32 time; + guint state; +}; + +struct _GdkEventSelection +{ + GdkEventType type; + GdkWindow *window; + GdkAtom selection; + GdkAtom target; + GdkAtom property; + guint32 requestor; + guint32 time; +}; + +/* This event type will be used pretty rarely. It only is important + for XInput aware programs that are drawing their own cursor */ + +struct _GdkEventProximity +{ + GdkEventType type; + GdkWindow *window; + guint32 time; + GdkInputSource source; + guint32 deviceid; +}; + +struct _GdkEventDragRequest +{ + GdkEventType type; + GdkWindow *window; + guint32 requestor; + union { + struct { + guint protocol_version:4; + guint sendreply:1; + guint willaccept:1; + guint delete_data:1; /* Do *not* delete if link is sent, only + if data is sent */ + guint senddata:1; + guint reserved:22; + } flags; + glong allflags; + } u; + guint8 isdrop; /* This gdk event can be generated by a couple of + X events - this lets the app know whether the + drop really occurred or we just set the data */ + + GdkPoint drop_coords; + gchar *data_type; +}; + +struct _GdkEventDragBegin +{ + GdkEventType type; + GdkWindow *window; + union { + struct { + guint protocol_version:4; + guint reserved:28; + } flags; + glong allflags; + } u; +}; + +struct _GdkEventDropEnter +{ + GdkEventType type; + GdkWindow *window; + guint32 requestor; + union { + struct { + guint protocol_version:4; + guint sendreply:1; + guint extended_typelist:1; + guint reserved:26; + } flags; + glong allflags; + } u; +}; + +struct _GdkEventDropLeave +{ + GdkEventType type; + GdkWindow *window; + guint32 requestor; + union { + struct { + guint protocol_version:4; + guint reserved:28; + } flags; + glong allflags; + } u; +}; + +struct _GdkEventDropDataAvailable +{ + GdkEventType type; + GdkWindow *window; + guint32 requestor; + union { + struct { + guint protocol_version:4; + guint isdrop:1; + guint reserved:25; + } flags; + glong allflags; + } u; + gchar *data_type; /* MIME type */ + gulong data_numbytes; + gpointer data; +}; + +struct _GdkEventClient +{ + GdkEventType type; + GdkWindow *window; + GdkAtom message_type; + gushort data_format; + union { + char b[20]; + short s[10]; + long l[5]; + } data; +}; + +#ifndef _XLIB_H_ +#define XEvent void +#endif + +struct _GdkEventOther +{ + GdkEventType type; + GdkWindow *window; + XEvent *xevent; +}; + +union _GdkEvent +{ + GdkEventType type; + GdkEventAny any; + GdkEventExpose expose; + GdkEventMotion motion; + GdkEventButton button; + GdkEventKey key; + GdkEventCrossing crossing; + GdkEventFocus focus_change; + GdkEventConfigure configure; + GdkEventProperty property; + GdkEventSelection selection; + GdkEventProximity proximity; + GdkEventDragBegin dragbegin; + GdkEventDragRequest dragrequest; + GdkEventDropEnter dropenter; + GdkEventDropLeave dropleave; + GdkEventDropDataAvailable dropdataavailable; + GdkEventClient client; + GdkEventOther other; +}; + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +#endif /* __GDK_TYPES_H__ */ diff --git a/gdk/gdkvisual.c b/gdk/gdkvisual.c new file mode 100644 index 000000000..22acee6f1 --- /dev/null +++ b/gdk/gdkvisual.c @@ -0,0 +1,431 @@ +/* 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 <X11/Xlib.h> +#include <X11/Xutil.h> +#include "gdk.h" +#include "gdkprivate.h" + + +static void gdk_visual_add (GdkVisual *visual); +static void gdk_visual_decompose_mask (gulong mask, + gint *shift, + gint *prec); +static guint gdk_visual_hash (Visual *key); +static gint gdk_visual_compare (Visual *a, + Visual *b); + + +static GdkVisualPrivate *system_visual; +static GdkVisualPrivate *visuals; +static gint nvisuals; + +static gint available_depths[4]; +static gint navailable_depths; + +static GdkVisualType available_types[6]; +static gint navailable_types; + +static char* visual_names[] = +{ + "static gray", + "grayscale", + "static color", + "pseudo color", + "true color", + "direct color", +}; + +static GHashTable *visual_hash = NULL; + +void +gdk_visual_init () +{ + static gint possible_depths[5] = { 32, 24, 16, 15, 8 }; + static GdkVisualType possible_types[6] = + { + GDK_VISUAL_DIRECT_COLOR, + GDK_VISUAL_TRUE_COLOR, + GDK_VISUAL_PSEUDO_COLOR, + GDK_VISUAL_STATIC_COLOR, + GDK_VISUAL_GRAYSCALE, + GDK_VISUAL_STATIC_GRAY + }; + + static gint npossible_depths = 5; + static gint npossible_types = 6; + + XVisualInfo *visual_list; + XVisualInfo visual_template; + GdkVisualPrivate temp_visual; + Visual *default_xvisual; + int nxvisuals; + int i, j; + + visual_template.screen = gdk_screen; + visual_list = XGetVisualInfo (gdk_display, VisualScreenMask, &visual_template, &nxvisuals); + visuals = g_new (GdkVisualPrivate, nxvisuals); + + default_xvisual = DefaultVisual (gdk_display, gdk_screen); + + nvisuals = 0; + for (i = 0; i < nxvisuals; i++) + { + if (visual_list[i].depth >= 8) + { +#ifdef __cplusplus + switch (visual_list[i].c_class) +#else /* __cplusplus */ + switch (visual_list[i].class) +#endif /* __cplusplus */ + { + case StaticGray: + visuals[nvisuals].visual.type = GDK_VISUAL_STATIC_GRAY; + break; + case GrayScale: + visuals[nvisuals].visual.type = GDK_VISUAL_GRAYSCALE; + break; + case StaticColor: + visuals[nvisuals].visual.type = GDK_VISUAL_STATIC_COLOR; + break; + case PseudoColor: + visuals[nvisuals].visual.type = GDK_VISUAL_PSEUDO_COLOR; + break; + case TrueColor: + visuals[nvisuals].visual.type = GDK_VISUAL_TRUE_COLOR; + break; + case DirectColor: + visuals[nvisuals].visual.type = GDK_VISUAL_DIRECT_COLOR; + break; + } + + visuals[nvisuals].visual.depth = visual_list[i].depth; + visuals[nvisuals].visual.byte_order = + (ImageByteOrder(gdk_display) == LSBFirst) ? + GDK_LSB_FIRST : GDK_MSB_FIRST; + visuals[nvisuals].visual.red_mask = visual_list[i].red_mask; + visuals[nvisuals].visual.green_mask = visual_list[i].green_mask; + visuals[nvisuals].visual.blue_mask = visual_list[i].blue_mask; + visuals[nvisuals].visual.colormap_size = visual_list[i].colormap_size; + visuals[nvisuals].visual.bits_per_rgb = visual_list[i].bits_per_rgb; + visuals[nvisuals].xvisual = visual_list[i].visual; + + if ((visuals[nvisuals].visual.type == GDK_VISUAL_TRUE_COLOR) || + (visuals[nvisuals].visual.type == GDK_VISUAL_DIRECT_COLOR)) + { + gdk_visual_decompose_mask (visuals[nvisuals].visual.red_mask, + &visuals[nvisuals].visual.red_shift, + &visuals[nvisuals].visual.red_prec); + + gdk_visual_decompose_mask (visuals[nvisuals].visual.green_mask, + &visuals[nvisuals].visual.green_shift, + &visuals[nvisuals].visual.green_prec); + + gdk_visual_decompose_mask (visuals[nvisuals].visual.blue_mask, + &visuals[nvisuals].visual.blue_shift, + &visuals[nvisuals].visual.blue_prec); + } + else + { + visuals[nvisuals].visual.red_mask = 0; + visuals[nvisuals].visual.red_shift = 0; + visuals[nvisuals].visual.red_prec = 0; + + visuals[nvisuals].visual.green_mask = 0; + visuals[nvisuals].visual.green_shift = 0; + visuals[nvisuals].visual.green_prec = 0; + + visuals[nvisuals].visual.blue_mask = 0; + visuals[nvisuals].visual.blue_shift = 0; + visuals[nvisuals].visual.blue_prec = 0; + } + + nvisuals += 1; + } + } + + XFree (visual_list); + + for (i = 0; i < nvisuals; i++) + { + for (j = i+1; j < nvisuals; j++) + { + if (visuals[j].visual.depth >= visuals[i].visual.depth) + { + if ((visuals[j].visual.depth == 8) && (visuals[i].visual.depth == 8)) + { + if (visuals[j].visual.type == GDK_VISUAL_PSEUDO_COLOR) + { + temp_visual = visuals[j]; + visuals[j] = visuals[i]; + visuals[i] = temp_visual; + } + else if ((visuals[i].visual.type != GDK_VISUAL_PSEUDO_COLOR) && + visuals[j].visual.type > visuals[i].visual.type) + { + temp_visual = visuals[j]; + visuals[j] = visuals[i]; + visuals[i] = temp_visual; + } + } + else if ((visuals[j].visual.depth > visuals[i].visual.depth) || + ((visuals[j].visual.depth == visuals[i].visual.depth) && + (visuals[j].visual.type > visuals[i].visual.type))) + { + temp_visual = visuals[j]; + visuals[j] = visuals[i]; + visuals[i] = temp_visual; + } + } + } + } + + for (i = 0; i < nvisuals; i++) + if (default_xvisual->visualid == visuals[i].xvisual->visualid) + { + system_visual = &visuals[i]; + break; + } + + if (gdk_debug_level >= 1) + for (i = 0; i < nvisuals; i++) + g_print ("visual: %s: %d\n", + visual_names[visuals[i].visual.type], + visuals[i].visual.depth); + + navailable_depths = 0; + for (i = 0; i < npossible_depths; i++) + { + for (j = 0; j < nvisuals; j++) + { + if (visuals[j].visual.depth == possible_depths[i]) + { + available_depths[navailable_depths++] = visuals[j].visual.depth; + break; + } + } + } + + if (navailable_depths == 0) + g_error ("unable to find a usable depth"); + + navailable_types = 0; + for (i = 0; i < npossible_types; i++) + { + for (j = 0; j < nvisuals; j++) + { + if (visuals[j].visual.type == possible_types[i]) + { + available_types[navailable_types++] = visuals[j].visual.type; + break; + } + } + } + + for (i = 0; i < nvisuals; i++) + gdk_visual_add ((GdkVisual*) &visuals[i]); + + if (npossible_types == 0) + g_error ("unable to find a usable visual type"); +} + +GdkVisual* +gdk_visual_ref (GdkVisual *visual) +{ + return visual; +} + +void +gdk_visual_unref (GdkVisual *visual) +{ + return; +} + +gint +gdk_visual_get_best_depth () +{ + return available_depths[0]; +} + +GdkVisualType +gdk_visual_get_best_type () +{ + return available_types[0]; +} + +GdkVisual* +gdk_visual_get_system () +{ + return ((GdkVisual*) system_visual); +} + +GdkVisual* +gdk_visual_get_best () +{ + return ((GdkVisual*) &(visuals[0])); +} + +GdkVisual* +gdk_visual_get_best_with_depth (gint depth) +{ + GdkVisual *return_val; + int i; + + return_val = NULL; + for (i = 0; i < nvisuals; i++) + if (depth == visuals[i].visual.depth) + { + return_val = (GdkVisual*) &(visuals[i]); + break; + } + + return return_val; +} + +GdkVisual* +gdk_visual_get_best_with_type (GdkVisualType visual_type) +{ + GdkVisual *return_val; + int i; + + return_val = NULL; + for (i = 0; i < nvisuals; i++) + if (visual_type == visuals[i].visual.type) + { + return_val = (GdkVisual*) &(visuals[i]); + break; + } + + return return_val; +} + +GdkVisual* +gdk_visual_get_best_with_both (gint depth, + GdkVisualType visual_type) +{ + GdkVisual *return_val; + int i; + + return_val = NULL; + for (i = 0; i < nvisuals; i++) + if ((depth == visuals[i].visual.depth) && + (visual_type == visuals[i].visual.type)) + { + return_val = (GdkVisual*) &(visuals[i]); + break; + } + + return return_val; +} + +void +gdk_query_depths (gint **depths, + gint *count) +{ + *count = navailable_depths; + *depths = available_depths; +} + +void +gdk_query_visual_types (GdkVisualType **visual_types, + gint *count) +{ + *count = navailable_types; + *visual_types = available_types; +} + +void +gdk_query_visuals (GdkVisual **visual_return, + gint *count) +{ + *count = nvisuals; + *visual_return = (GdkVisual*) visuals; +} + + +GdkVisual* +gdk_visual_lookup (Visual *xvisual) +{ + GdkVisual *visual; + + if (!visual_hash) + return NULL; + + visual = g_hash_table_lookup (visual_hash, xvisual); + return visual; +} + +GdkVisual* +gdkx_visual_get (VisualID xvisualid) +{ + int i; + + for (i = 0; i < nvisuals; i++) + if (xvisualid == visuals[i].xvisual->visualid) + return (GdkVisual*) &visuals[i]; + + return NULL; +} + + +static void +gdk_visual_add (GdkVisual *visual) +{ + GdkVisualPrivate *private; + + if (!visual_hash) + visual_hash = g_hash_table_new ((GHashFunc) gdk_visual_hash, + (GCompareFunc) gdk_visual_compare); + + private = (GdkVisualPrivate*) visual; + + g_hash_table_insert (visual_hash, private->xvisual, visual); +} + +static void +gdk_visual_decompose_mask (gulong mask, + gint *shift, + gint *prec) +{ + *shift = 0; + *prec = 0; + + while (!(mask & 0x1)) + { + (*shift)++; + mask >>= 1; + } + + while (mask & 0x1) + { + (*prec)++; + mask >>= 1; + } +} + +static guint +gdk_visual_hash (Visual *key) +{ + return key->visualid; +} + +static gint +gdk_visual_compare (Visual *a, + Visual *b) +{ + return (a->visualid == b->visualid); +} diff --git a/gdk/gdkwindow.c b/gdk/gdkwindow.c new file mode 100644 index 000000000..aef1367d9 --- /dev/null +++ b/gdk/gdkwindow.c @@ -0,0 +1,1358 @@ +/* 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 <X11/Xlib.h> +#include <X11/Xutil.h> +#include <X11/Xatom.h> +#include <X11/extensions/shape.h> +#include <netinet/in.h> +#include "gdk.h" +#include "gdkinput.h" +#include "gdkprivate.h" +#include <stdlib.h> + +int nevent_masks = 16; +int event_mask_table[18] = +{ + ExposureMask, + PointerMotionMask, + PointerMotionHintMask, + ButtonMotionMask, + Button1MotionMask, + Button2MotionMask, + Button3MotionMask, + ButtonPressMask | OwnerGrabButtonMask, + ButtonReleaseMask | OwnerGrabButtonMask, + KeyPressMask, + KeyReleaseMask, + EnterWindowMask, + LeaveWindowMask, + FocusChangeMask, + StructureNotifyMask, + PropertyChangeMask, + 0, /* PROXIMITY_IN */ + 0 /* PROXIMTY_OUT */ +}; + + +void +gdk_window_init () +{ + XWindowAttributes xattributes; + unsigned int width; + unsigned int height; + unsigned int border_width; + unsigned int depth; + int x, y; + + XGetGeometry (gdk_display, gdk_root_window, &gdk_root_window, + &x, &y, &width, &height, &border_width, &depth); + XGetWindowAttributes (gdk_display, gdk_root_window, &xattributes); + + gdk_root_parent.xdisplay = gdk_display; + gdk_root_parent.xwindow = gdk_root_window; + gdk_root_parent.window_type = GDK_WINDOW_ROOT; + gdk_root_parent.window.user_data = NULL; +} + +GdkWindow* +gdk_window_new (GdkWindow *parent, + GdkWindowAttr *attributes, + gint attributes_mask) +{ + GdkWindow *window; + GdkWindowPrivate *private; + GdkWindowPrivate *parent_private; + GdkVisual *visual; + GdkColormap *colormap; + Display *parent_display; + Window xparent; + Visual *xvisual; + XSetWindowAttributes xattributes; + long xattributes_mask; + XSizeHints size_hints; + XWMHints wm_hints; + XTextProperty text_property; + XClassHint *class_hint; + int x, y, depth; + unsigned int class; + char *title; + int i; + + g_return_val_if_fail (attributes != NULL, NULL); + + if (!parent) + parent = (GdkWindow*) &gdk_root_parent; + + parent_private = (GdkWindowPrivate*) parent; + xparent = parent_private->xwindow; + parent_display = parent_private->xdisplay; + + private = g_new (GdkWindowPrivate, 1); + window = (GdkWindow*) private; + + private->parent = parent; + private->xdisplay = parent_display; + private->destroyed = FALSE; + private->resize_count = 0; + private->ref_count = 1; + xattributes_mask = 0; + + if (attributes_mask & GDK_WA_X) + x = attributes->x; + else + x = 0; + + if (attributes_mask & GDK_WA_Y) + y = attributes->y; + else + y = 0; + + private->x = x; + private->y = y; + private->width = (attributes->width > 1) ? (attributes->width) : (1); + private->height = (attributes->height > 1) ? (attributes->height) : (1); + private->window_type = attributes->window_type; + private->extension_events = FALSE; + private->dnd_drag_data_type = None; + private->dnd_drag_data_typesavail = + private->dnd_drop_data_typesavail = NULL; + private->dnd_drop_enabled = private->dnd_drag_enabled = + private->dnd_drag_accepted = private->dnd_drag_datashow = + private->dnd_drop_data_numtypesavail = + private->dnd_drag_data_numtypesavail = 0; + private->dnd_drag_eventmask = private->dnd_drag_savedeventmask = 0; + + window->user_data = NULL; + + if (attributes_mask & GDK_WA_VISUAL) + visual = attributes->visual; + else + visual = gdk_visual_get_system (); + xvisual = ((GdkVisualPrivate*) visual)->xvisual; + + xattributes.event_mask = StructureNotifyMask; + for (i = 0; i < nevent_masks; i++) + { + if (attributes->event_mask & (1 << (i + 1))) + xattributes.event_mask |= event_mask_table[i]; + } + + if (xattributes.event_mask) + xattributes_mask |= CWEventMask; + + if (attributes->wclass == GDK_INPUT_OUTPUT) + { + class = InputOutput; + depth = visual->depth; + + if (attributes_mask & GDK_WA_COLORMAP) + colormap = attributes->colormap; + else + colormap = gdk_colormap_get_system (); + + xattributes.background_pixel = BlackPixel (gdk_display, gdk_screen); + xattributes.border_pixel = BlackPixel (gdk_display, gdk_screen); + xattributes_mask |= CWBorderPixel | CWBackPixel; + + switch (private->window_type) + { + case GDK_WINDOW_TOPLEVEL: + xattributes.colormap = ((GdkColormapPrivate*) colormap)->xcolormap; + xattributes_mask |= CWColormap; + + xparent = gdk_root_window; + break; + + case GDK_WINDOW_CHILD: + xattributes.colormap = ((GdkColormapPrivate*) colormap)->xcolormap; + xattributes_mask |= CWColormap; + break; + + case GDK_WINDOW_DIALOG: + xattributes.colormap = ((GdkColormapPrivate*) colormap)->xcolormap; + xattributes_mask |= CWColormap; + + xparent = gdk_root_window; + break; + + case GDK_WINDOW_TEMP: + xattributes.colormap = ((GdkColormapPrivate*) colormap)->xcolormap; + xattributes_mask |= CWColormap; + + xparent = gdk_root_window; + + xattributes.save_under = True; + xattributes.override_redirect = True; + xattributes.cursor = None; + xattributes_mask |= CWSaveUnder | CWOverrideRedirect; + break; + case GDK_WINDOW_ROOT: + g_error ("cannot make windows of type GDK_WINDOW_ROOT"); + break; + case GDK_WINDOW_PIXMAP: + g_error ("cannot make windows of type GDK_WINDOW_PIXMAP (use gdk_pixmap_new)"); + break; + } + } + else + { + depth = 1; + class = InputOnly; + colormap = NULL; + } + + private->xwindow = XCreateWindow (private->xdisplay, xparent, + x, y, private->width, private->height, + 0, depth, class, xvisual, + xattributes_mask, &xattributes); + gdk_xid_table_insert (&private->xwindow, window); + + switch (private->window_type) + { + case GDK_WINDOW_DIALOG: + XSetTransientForHint (private->xdisplay, private->xwindow, xparent); + case GDK_WINDOW_TOPLEVEL: + case GDK_WINDOW_TEMP: + XSetWMProtocols (private->xdisplay, private->xwindow, gdk_wm_window_protocols, 2); + break; + case GDK_WINDOW_CHILD: + if ((attributes->wclass == GDK_INPUT_OUTPUT) && + (colormap != gdk_colormap_get_system ()) && + (colormap != gdk_window_get_colormap (gdk_window_get_toplevel (window)))) + { + g_print ("adding colormap window\n"); + gdk_window_add_colormap_windows (window); + } + break; + default: + break; + } + + size_hints.flags = PSize | PBaseSize; + size_hints.width = private->width; + size_hints.height = private->height; + size_hints.base_width = private->width; + size_hints.base_height = private->height; + + wm_hints.flags = InputHint | StateHint | WindowGroupHint; + wm_hints.window_group = gdk_leader_window; + wm_hints.input = True; + wm_hints.initial_state = NormalState; + + XSetWMNormalHints (private->xdisplay, private->xwindow, &size_hints); + XSetWMHints (private->xdisplay, private->xwindow, &wm_hints); + + if (attributes_mask & GDK_WA_TITLE) + title = attributes->title; + else + title = gdk_progname; + + if (XStringListToTextProperty (&title, 1, &text_property)) + { + XSetWMName (private->xdisplay, private->xwindow, &text_property); + XSetWMIconName (private->xdisplay, private->xwindow, &text_property); + XFree (text_property.value); + } + + if (attributes_mask & GDK_WA_WMCLASS) + { + class_hint = XAllocClassHint (); + class_hint->res_name = attributes->wmclass_name; + class_hint->res_class = attributes->wmclass_class; + XSetClassHint (private->xdisplay, private->xwindow, class_hint); + XFree (class_hint); + } + + gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ? + (attributes->cursor) : + NULL)); + + return window; +} + +GdkWindow * +gdk_window_foreign_new (guint32 anid) +{ + GdkWindow *window; + GdkWindowPrivate *private; + XWindowAttributes attrs; + + private = g_new (GdkWindowPrivate, 1); + window = (GdkWindow*) private; + + XGetWindowAttributes (gdk_display, anid, &attrs); + + private->parent = NULL; + private->xwindow = anid; + private->xdisplay = gdk_display; + private->x = attrs.x; + private->y = attrs.y; + private->width = attrs.width; + private->height = attrs.height; + private->resize_count = 0; + private->ref_count = 1; + if (anid == attrs.root) + private->window_type = GDK_WINDOW_ROOT; + else + private->window_type = GDK_WINDOW_TOPLEVEL; + /* the above is probably wrong, but it may not be worth the extra + X call to get it right */ + + private->destroyed = FALSE; + private->extension_events = 0; + + window->user_data = NULL; + + gdk_xid_table_insert (&private->xwindow, window); + + return window; +} + +void +gdk_window_destroy (GdkWindow *window) +{ + GdkWindowPrivate *private; + GdkWindowPrivate *temp_private; + GdkWindow *temp_window; + GList *children; + GList *tmp; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + if(private->dnd_drag_data_numtypesavail > 0) + { + free(private->dnd_drag_data_typesavail); + private->dnd_drag_data_typesavail = NULL; + } + if(private->dnd_drop_data_numtypesavail > 0) + { + free(private->dnd_drop_data_typesavail); + private->dnd_drop_data_typesavail = NULL; + } + + switch (private->window_type) + { + case GDK_WINDOW_TOPLEVEL: + case GDK_WINDOW_CHILD: + case GDK_WINDOW_DIALOG: + case GDK_WINDOW_TEMP: + if (private->ref_count >= 1) + private->ref_count -= 1; + + if (!private->destroyed || (private->destroyed == 2)) + { + children = gdk_window_get_children (window); + tmp = children; + + while (tmp) + { + temp_window = tmp->data; + tmp = tmp->next; + + temp_private = (GdkWindowPrivate*) temp_window; + if (temp_private && !temp_private->destroyed) + /* Removes some nice coredumps... /David */ + { + temp_private->destroyed = 2; + temp_private->ref_count += 1; + gdk_window_destroy (temp_window); + } + } + + g_list_free (children); + + if (!private->destroyed) + XDestroyWindow (private->xdisplay, private->xwindow); + private->destroyed = TRUE; + } + break; + + case GDK_WINDOW_ROOT: + g_error ("attempted to destroy root window"); + break; + + case GDK_WINDOW_PIXMAP: + g_warning ("called gdk_window_destroy on a pixmap (use gdk_pixmap_destroy)"); + gdk_pixmap_destroy (window); + break; + } +} + +void +gdk_window_real_destroy (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + + if (private->extension_events != 0) + gdk_input_window_destroy (window); + + if (private->ref_count == 0) + { + gdk_xid_table_remove (private->xwindow); + g_free (window); + } +} + +GdkWindow* +gdk_window_ref (GdkWindow *window) +{ + GdkWindowPrivate *private = (GdkWindowPrivate *)window; + g_return_if_fail (window != NULL); + + private->ref_count += 1; + return window; +} + +void +gdk_window_unref (GdkWindow *window) +{ + GdkWindowPrivate *private = (GdkWindowPrivate *)window; + g_return_if_fail (window != NULL); + + private->ref_count -= 1; + if (private->ref_count == 0) + gdk_window_real_destroy (window); +} + +void +gdk_window_show (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + if (!private->destroyed) + { + XRaiseWindow (private->xdisplay, private->xwindow); + XMapWindow (private->xdisplay, private->xwindow); + } +} + +void +gdk_window_hide (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + if (!private->destroyed) + XUnmapWindow (private->xdisplay, private->xwindow); +} + +void +gdk_window_move (GdkWindow *window, + gint x, + gint y) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + XMoveWindow (private->xdisplay, private->xwindow, x, y); + + if (private->window_type == GDK_WINDOW_CHILD) + { + private->x = x; + private->y = y; + } +} + +void +gdk_window_resize (GdkWindow *window, + gint width, + gint height) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + if (width < 1) + width = 1; + if (height < 1) + height = 1; + + private = (GdkWindowPrivate*) window; + + if (!private->destroyed && + ((private->resize_count > 0) || + (private->width != (guint16) width) || + (private->height != (guint16) height))) + { + XResizeWindow (private->xdisplay, private->xwindow, width, height); + private->resize_count += 1; + + if (private->window_type == GDK_WINDOW_CHILD) + { + private->width = width; + private->height = height; + } + } +} + +void +gdk_window_move_resize (GdkWindow *window, + gint x, + gint y, + gint width, + gint height) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + if (width < 1) + width = 1; + if (height < 1) + height = 1; + + private = (GdkWindowPrivate*) window; + XMoveResizeWindow (private->xdisplay, private->xwindow, x, y, width, height); + + if (!private->destroyed && + (private->window_type == GDK_WINDOW_CHILD)) + { + private->x = x; + private->y = y; + private->width = width; + private->height = height; + } +} + +void +gdk_window_reparent (GdkWindow *window, + GdkWindow *new_parent, + gint x, + gint y) +{ + GdkWindowPrivate *window_private; + GdkWindowPrivate *parent_private; + + g_return_if_fail (window != NULL); + + if (!new_parent) + new_parent = (GdkWindow*) &gdk_root_parent; + + window_private = (GdkWindowPrivate*) window; + parent_private = (GdkWindowPrivate*) new_parent; + + XReparentWindow (window_private->xdisplay, + window_private->xwindow, + parent_private->xwindow, + x, y); +} + +void +gdk_window_clear (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + + XClearWindow (private->xdisplay, private->xwindow); +} + +void +gdk_window_clear_area (GdkWindow *window, + gint x, + gint y, + gint width, + gint height) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + + if (!private->destroyed) + XClearArea (private->xdisplay, private->xwindow, + x, y, width, height, False); +} + +void +gdk_window_clear_area_e (GdkWindow *window, + gint x, + gint y, + gint width, + gint height) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + + if (!private->destroyed) + XClearArea (private->xdisplay, private->xwindow, + x, y, width, height, True); +} + +void +gdk_window_copy_area (GdkWindow *window, + GdkGC *gc, + gint x, + gint y, + GdkWindow *source_window, + gint source_x, + gint source_y, + gint width, + gint height) +{ + GdkWindowPrivate *src_private; + GdkWindowPrivate *dest_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (window != NULL); + g_return_if_fail (gc != NULL); + + if (source_window == NULL) + source_window = window; + + src_private = (GdkWindowPrivate*) source_window; + dest_private = (GdkWindowPrivate*) window; + gc_private = (GdkGCPrivate*) gc; + + if (!src_private->destroyed && !dest_private->destroyed) + { + XCopyArea (dest_private->xdisplay, src_private->xwindow, dest_private->xwindow, + gc_private->xgc, + source_x, source_y, + width, height, + x, y); + } +} + +void +gdk_window_raise (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + + if (!private->destroyed) + XRaiseWindow (private->xdisplay, private->xwindow); +} + +void +gdk_window_lower (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + + if (!private->destroyed) + XLowerWindow (private->xdisplay, private->xwindow); +} + +void +gdk_window_set_user_data (GdkWindow *window, + gpointer user_data) +{ + g_return_if_fail (window != NULL); + + window->user_data = user_data; +} + +void +gdk_window_set_hints (GdkWindow *window, + gint x, + gint y, + gint min_width, + gint min_height, + gint max_width, + gint max_height, + gint flags) +{ + GdkWindowPrivate *private; + XSizeHints size_hints; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + size_hints.flags = 0; + + if (flags & GDK_HINT_POS) + { + size_hints.flags |= PPosition; + size_hints.x = x; + size_hints.y = y; + } + + if (flags & GDK_HINT_MIN_SIZE) + { + size_hints.flags |= PMinSize; + size_hints.min_width = min_width; + size_hints.min_height = min_height; + } + + if (flags & GDK_HINT_MAX_SIZE) + { + size_hints.flags |= PMaxSize; + size_hints.max_width = max_width; + size_hints.max_height = max_height; + } + + if (flags) + XSetWMNormalHints (private->xdisplay, private->xwindow, &size_hints); +} + +void +gdk_window_set_title (GdkWindow *window, + const gchar *title) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + XStoreName (private->xdisplay, private->xwindow, title); + XSetIconName (private->xdisplay, private->xwindow, title); +} + +void +gdk_window_set_background (GdkWindow *window, + GdkColor *color) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + XSetWindowBackground (private->xdisplay, private->xwindow, color->pixel); +} + +void +gdk_window_set_back_pixmap (GdkWindow *window, + GdkPixmap *pixmap, + gint parent_relative) +{ + GdkWindowPrivate *window_private; + GdkPixmapPrivate *pixmap_private; + Pixmap xpixmap; + + g_return_if_fail (window != NULL); + + window_private = (GdkWindowPrivate*) window; + pixmap_private = (GdkPixmapPrivate*) pixmap; + + if (pixmap) + xpixmap = pixmap_private->xwindow; + else + xpixmap = None; + + if (parent_relative) + xpixmap = ParentRelative; + + XSetWindowBackgroundPixmap (window_private->xdisplay, window_private->xwindow, xpixmap); +} + +void +gdk_window_set_cursor (GdkWindow *window, + GdkCursor *cursor) +{ + GdkWindowPrivate *window_private; + GdkCursorPrivate *cursor_private; + Cursor xcursor; + + g_return_if_fail (window != NULL); + + window_private = (GdkWindowPrivate*) window; + cursor_private = (GdkCursorPrivate*) cursor; + + if (!cursor) + xcursor = None; + else + xcursor = cursor_private->xcursor; + + XDefineCursor (window_private->xdisplay, window_private->xwindow, xcursor); +} + +void +gdk_window_set_colormap (GdkWindow *window, + GdkColormap *colormap) +{ + GdkWindowPrivate *window_private; + GdkColormapPrivate *colormap_private; + + g_return_if_fail (window != NULL); + g_return_if_fail (colormap != NULL); + + window_private = (GdkWindowPrivate*) window; + colormap_private = (GdkColormapPrivate*) colormap; + + XSetWindowColormap (window_private->xdisplay, + window_private->xwindow, + colormap_private->xcolormap); + + if (window_private->window_type != GDK_WINDOW_TOPLEVEL) + gdk_window_add_colormap_windows (window); +} + +void +gdk_window_get_user_data (GdkWindow *window, + gpointer *data) +{ + g_return_if_fail (window != NULL); + + *data = window->user_data; +} + +void +gdk_window_get_geometry (GdkWindow *window, + gint *x, + gint *y, + gint *width, + gint *height, + gint *depth) +{ + GdkWindowPrivate *window_private; + Window root; + gint tx; + gint ty; + guint twidth; + guint theight; + guint tborder_width; + guint tdepth; + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + window_private = (GdkWindowPrivate*) window; + + XGetGeometry (window_private->xdisplay, window_private->xwindow, + &root, &tx, &ty, &twidth, &theight, &tborder_width, &tdepth); + + if (x) + *x = tx; + if (y) + *y = ty; + if (width) + *width = twidth; + if (height) + *height = theight; + if (depth) + *depth = tdepth; +} + +void +gdk_window_get_position (GdkWindow *window, + gint *x, + gint *y) +{ + GdkWindowPrivate *window_private; + + g_return_if_fail (window != NULL); + + window_private = (GdkWindowPrivate*) window; + + if (x) + *x = window_private->x; + if (y) + *y = window_private->y; +} + +void +gdk_window_get_size (GdkWindow *window, + gint *width, + gint *height) +{ + GdkWindowPrivate *window_private; + + g_return_if_fail (window != NULL); + + window_private = (GdkWindowPrivate*) window; + + if (width) + *width = window_private->width; + if (height) + *height = window_private->height; +} + + +GdkVisual* +gdk_window_get_visual (GdkWindow *window) +{ + GdkWindowPrivate *window_private; + XWindowAttributes window_attributes; + + g_return_val_if_fail (window != NULL, NULL); + + window_private = (GdkWindowPrivate*) window; + while (window_private && (window_private->window_type == GDK_WINDOW_PIXMAP)) + window_private = (GdkWindowPrivate*) window_private->parent; + + if (window_private) + { + XGetWindowAttributes (window_private->xdisplay, + window_private->xwindow, + &window_attributes); + + return gdk_visual_lookup (window_attributes.visual); + } + + return NULL; +} + +GdkColormap* +gdk_window_get_colormap (GdkWindow *window) +{ + GdkWindowPrivate *window_private; + XWindowAttributes window_attributes; + + g_return_val_if_fail (window != NULL, NULL); + + window_private = (GdkWindowPrivate*) window; + + XGetWindowAttributes (window_private->xdisplay, + window_private->xwindow, + &window_attributes); + + return gdk_colormap_lookup (window_attributes.colormap); +} + +GdkWindowType +gdk_window_get_type (GdkWindow *window) +{ + GdkWindowPrivate *window_private; + + g_return_val_if_fail (window != NULL, (GdkWindowType) -1); + + window_private = (GdkWindowPrivate*) window; + return window_private->window_type; +} + +gint +gdk_window_get_origin (GdkWindow *window, + gint *x, + gint *y) +{ + GdkWindowPrivate *private; + gint return_val; + Window child; + gint tx, ty; + + g_return_val_if_fail (window != NULL, 0); + + private = (GdkWindowPrivate*) window; + + return_val = XTranslateCoordinates (private->xdisplay, + private->xwindow, + gdk_root_window, + 0, 0, &tx, &ty, + &child); + + if (x) + *x = tx; + if (y) + *y = ty; + + return return_val; +} + +GdkWindow* +gdk_window_get_pointer (GdkWindow *window, + gint *x, + gint *y, + GdkModifierType *mask) +{ + GdkWindowPrivate *private; + GdkWindow *return_val; + Window root; + Window child; + int rootx, rooty; + int winx, winy; + unsigned int xmask; + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + private = (GdkWindowPrivate*) window; + + return_val = NULL; + if (XQueryPointer (private->xdisplay, private->xwindow, &root, &child, + &rootx, &rooty, &winx, &winy, &xmask)) + { + if (x) *x = winx; + if (y) *y = winy; + if (mask) *mask = xmask; + + if (child) + return_val = gdk_window_lookup (child); + } + + return return_val; +} + +GdkWindow* +gdk_window_get_parent (GdkWindow *window) +{ + g_return_val_if_fail (window != NULL, NULL); + + return ((GdkWindowPrivate*) window)->parent; +} + +GdkWindow* +gdk_window_get_toplevel (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_val_if_fail (window != NULL, NULL); + + private = (GdkWindowPrivate*) window; + + while (private->window_type == GDK_WINDOW_CHILD) + { + window = ((GdkWindowPrivate*) window)->parent; + private = (GdkWindowPrivate*) window; + } + + return window; +} + +GList* +gdk_window_get_children (GdkWindow *window) +{ + GdkWindowPrivate *private; + GdkWindow *child; + GList *children; + Window root; + Window parent; + Window *xchildren; + unsigned int nchildren; + unsigned int i; + + g_return_val_if_fail (window != NULL, NULL); + + private = (GdkWindowPrivate*) window; + + XQueryTree (private->xdisplay, private->xwindow, + &root, &parent, &xchildren, &nchildren); + + children = NULL; + + if (nchildren > 0) + { + for (i = 0; i < nchildren; i++) + { + child = gdk_window_lookup (xchildren[i]); + if (child) + children = g_list_prepend (children, child); + } + + XFree (xchildren); + } + + return children; +} + +GdkEventMask +gdk_window_get_events (GdkWindow *window) +{ + XWindowAttributes attrs; + GdkEventMask event_mask; + int i; + + XGetWindowAttributes (gdk_display, ((GdkWindowPrivate *)window)->xwindow, + &attrs); + + event_mask = 0; + for (i = 0; i < nevent_masks; i++) + { + if (attrs.your_event_mask & event_mask_table[i]) + event_mask |= 1 << (i + 1); + } + + return event_mask; +} + +void +gdk_window_set_events (GdkWindow *window, + GdkEventMask event_mask) +{ + long xevent_mask; + int i; + + xevent_mask = StructureNotifyMask; + for (i = 0; i < nevent_masks; i++) + { + if (event_mask & (1 << (i + 1))) + xevent_mask |= event_mask_table[i]; + } + + XSelectInput (gdk_display, ((GdkWindowPrivate *)window)->xwindow, + xevent_mask); +} + +void +gdk_window_add_colormap_windows (GdkWindow *window) +{ + GdkWindow *toplevel; + GdkWindowPrivate *toplevel_private; + GdkWindowPrivate *window_private; + Window *old_windows; + Window *new_windows; + int i, count; + + g_return_if_fail (window != NULL); + + toplevel = gdk_window_get_toplevel (window); + toplevel_private = (GdkWindowPrivate*) toplevel; + window_private = (GdkWindowPrivate*) window; + + if (!XGetWMColormapWindows (toplevel_private->xdisplay, + toplevel_private->xwindow, + &old_windows, &count)) + { + old_windows = NULL; + count = 0; + } + + for (i = 0; i < count; i++) + if (old_windows[i] == window_private->xwindow) + return; + + new_windows = g_new (Window, count + 1); + + for (i = 0; i < count; i++) + new_windows[i] = old_windows[i]; + new_windows[count] = window_private->xwindow; + + XSetWMColormapWindows (toplevel_private->xdisplay, + toplevel_private->xwindow, + new_windows, count + 1); + + g_free (new_windows); + if (old_windows) + XFree (old_windows); +} + +/* + * This needs the X11 shape extension. + * If not available, simply remove the call to + * XShapeCombineMask. Shaped windows will look + * ugly, but programs still work. Stefan Wille + */ +void +gdk_window_shape_combine_mask (GdkWindow *window, + GdkBitmap *mask, + gint x, gint y) +{ + GdkWindowPrivate *window_private; + GdkWindowPrivate *pixmap_private; + + g_return_if_fail (window != NULL); + g_return_if_fail (mask != NULL); + + window_private = (GdkWindowPrivate*) window; + pixmap_private = (GdkWindowPrivate*) mask; + + XShapeCombineMask (window_private->xdisplay, + window_private->xwindow, + ShapeBounding, + x, y, /* offset */ + (Pixmap)pixmap_private->xwindow, + ShapeSet); +} + +void +gdk_dnd_drag_addwindow (GdkWindow *window) +{ + GdkWindowPrivate *window_private; + + g_return_if_fail (window != NULL); + + window_private = (GdkWindowPrivate *) window; + + if (window_private->dnd_drag_enabled == 1 && gdk_dnd.drag_really == 0) + { + gdk_dnd.drag_numwindows++; + gdk_dnd.drag_startwindows = g_realloc (gdk_dnd.drag_startwindows, + gdk_dnd.drag_numwindows + * sizeof(GdkWindow *)); + gdk_dnd.drag_startwindows[gdk_dnd.drag_numwindows - 1] = window; + window_private->dnd_drag_accepted = 0; + } + else + g_warning ("dnd_really is 1 or drag is not enabled! can't addwindow\n"); +} + +void +gdk_window_dnd_drag_set (GdkWindow *window, + guint8 drag_enable, + gchar **typelist, + guint numtypes) +{ + GdkWindowPrivate *window_private; + int i, wasset = 0; + + g_return_if_fail (window != NULL); + window_private = (GdkWindowPrivate *) window; + + window_private->dnd_drag_enabled = drag_enable ? 1 : 0; + + if (drag_enable) + { + g_return_if_fail(typelist != NULL); + + if (window_private->dnd_drag_data_numtypesavail > 3) + wasset = 1; + window_private->dnd_drag_data_numtypesavail = numtypes; + + window_private->dnd_drag_data_typesavail = + g_realloc (window_private->dnd_drag_data_typesavail, + (numtypes + 1) * sizeof (GdkAtom)); + + for (i = 0; i < numtypes; i++) + { + /* Allow blanket use of ALL to get anything... */ + if (strcmp (typelist[i], "ALL")) + window_private->dnd_drag_data_typesavail[i] = + gdk_atom_intern (typelist[i], FALSE); + else + window_private->dnd_drag_data_typesavail[i] = None; + } + + /* + * set our extended type list if we need to + */ + if (numtypes > 3) + gdk_property_change(window, gdk_dnd.gdk_XdeTypelist, + XA_PRIMARY, 32, GDK_PROP_MODE_REPLACE, + (guchar *)(window_private->dnd_drag_data_typesavail + + (sizeof(GdkAtom) * 3)), + (numtypes - 3) * sizeof(GdkAtom)); + else if (wasset) + gdk_property_delete (window, gdk_dnd.gdk_XdeTypelist); + } + else + { + free (window_private->dnd_drag_data_typesavail); + window_private->dnd_drag_data_typesavail = NULL; + window_private->dnd_drag_data_numtypesavail = 0; + } +} + +void +gdk_window_dnd_drop_set (GdkWindow *window, + guint8 drop_enable, + gchar **typelist, + guint numtypes, + guint8 destructive_op) +{ + GdkWindowPrivate *window_private; + int i; + + g_return_if_fail (window != NULL); + + window_private = (GdkWindowPrivate *) window; + + window_private->dnd_drop_enabled = drop_enable ? 1 : 0; + if (drop_enable) + { + g_return_if_fail(typelist != NULL); + + window_private->dnd_drop_data_numtypesavail = numtypes; + + window_private->dnd_drop_data_typesavail = + g_realloc (window_private->dnd_drop_data_typesavail, + (numtypes + 1) * sizeof (GdkAtom)); + + for (i = 0; i < numtypes; i++) + window_private->dnd_drop_data_typesavail[i] = + gdk_atom_intern (typelist[i], FALSE); + + window_private->dnd_drop_destructive_op = destructive_op; + } +} + +/* + * This is used to reply to a GDK_DRAG_REQUEST event + * (which may be generated by XdeRequest or a confirmed drop... + */ +void +gdk_window_dnd_data_set (GdkWindow *window, + GdkEvent *event, + gpointer data, + gulong data_numbytes) +{ + GdkWindowPrivate *window_private; + XEvent sev; + GdkEventDropDataAvailable tmp_ev; + gchar *tmp; + + g_return_if_fail (window != NULL); + g_return_if_fail (event != NULL); + g_return_if_fail (data != NULL); + g_return_if_fail (data_numbytes > 0); + g_return_if_fail (event->type == GDK_DRAG_REQUEST); + + g_free (event->dragrequest.data_type); + event->dragrequest.data_type = NULL; + + window_private = (GdkWindowPrivate *) window; + g_return_if_fail (window_private->dnd_drag_accepted != 0); + + /* We set the property on our window... */ + gdk_property_change (window, window_private->dnd_drag_data_type, + XA_PRIMARY, 8, GDK_PROP_MODE_REPLACE, data, + data_numbytes); + tmp = gdk_atom_name(window_private->dnd_drag_data_type); + g_print("DnD type %s on window %ld\n", tmp, window_private->xwindow); + g_free(tmp); + + /* + * Then we send the event to tell the receiving window that the + * drop has happened + */ + tmp_ev.u.allflags = 0; + tmp_ev.u.flags.protocol_version = DND_PROTOCOL_VERSION; + tmp_ev.u.flags.isdrop = event->dragrequest.isdrop; + + sev.xclient.type = ClientMessage; + sev.xclient.format = 32; + sev.xclient.window = event->dragrequest.requestor; + sev.xclient.message_type = gdk_dnd.gdk_XdeDataAvailable; + sev.xclient.data.l[0] = window_private->xwindow; + sev.xclient.data.l[1] = tmp_ev.u.allflags; + sev.xclient.data.l[2] = window_private->dnd_drag_data_type; + + if (event->dragrequest.isdrop) + sev.xclient.data.l[3] = event->dragrequest.drop_coords.x + + (event->dragrequest.drop_coords.y << 16); + else + sev.xclient.data.l[3] = 0; + + sev.xclient.data.l[4] = 0; + + XSendEvent (gdk_display, event->dragrequest.requestor, False, + NoEventMask, &sev); +} diff --git a/gdk/gdkx.h b/gdk/gdkx.h new file mode 100644 index 000000000..cb8e33b44 --- /dev/null +++ b/gdk/gdkx.h @@ -0,0 +1,48 @@ +/* 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. + */ +#ifndef __GDK_X_H__ +#define __GDK_X_H__ + +#include <gdk/gdkprivate.h> + + +#define GDK_ROOT_WINDOW() gdk_root_window +#define GDK_ROOT_PARENT() &gdk_root_parent +#define GDK_DISPLAY() gdk_display +#define GDK_WINDOW_XDISPLAY(win) (((GdkWindowPrivate*) win)->xdisplay) +#define GDK_WINDOW_XWINDOW(win) (((GdkWindowPrivate*) win)->xwindow) +#define GDK_IMAGE_XDISPLAY(image) (((GdkImagePrivate*) image)->xdisplay) +#define GDK_IMAGE_XIMAGE(image) (((GdkImagePrivate*) image)->ximage) +#define GDK_GC_XDISPLAY(gc) (((GdkGCPrivate*) gc)->xdisplay) +#define GDK_GC_XGC(gc) (((GdkGCPrivate*) gc)->xgc) +#define GDK_COLORMAP_XDISPLAY(cmap) (((GdkColormapPrivate*) cmap)->xdisplay) +#define GDK_COLORMAP_XCOLORMAP(cmap) (((GdkColormapPrivate*) cmap)->xcolormap) +#define GDK_VISUAL_XVISUAL(vis) (((GdkVisualPrivate*) vis)->xvisual) +#define GDK_FONT_XDISPLAY(font) (((GdkFontPrivate*) font)->xdisplay) +#define GDK_FONT_XFONT(font) (((GdkFontPrivate*) font)->xfont) + + +GdkVisual* gdkx_visual_get (VisualID xvisualid); +GdkColormap* gdkx_colormap_get (Colormap xcolormap); +/* Utility function in gdk.c - not sure where it belongs, but it's + needed in more than one place, so make it public */ +Window gdk_get_client_window (Display *dpy, + Window win); + + +#endif /* __GDK_X_H__ */ diff --git a/gdk/gdkxid.c b/gdk/gdkxid.c new file mode 100644 index 000000000..7ee6075c5 --- /dev/null +++ b/gdk/gdkxid.c @@ -0,0 +1,74 @@ +/* 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 "gdkprivate.h" + + +static guint gdk_xid_hash (XID *xid); +static gint gdk_xid_compare (XID *a, + XID *b); + + +GHashTable *xid_ht = NULL; + + +void +gdk_xid_table_insert (XID *xid, + gpointer data) +{ + g_return_if_fail (xid != NULL); + + if (!xid_ht) + xid_ht = g_hash_table_new ((GHashFunc) gdk_xid_hash, + (GCompareFunc) gdk_xid_compare); + + g_hash_table_insert (xid_ht, xid, data); +} + +void +gdk_xid_table_remove (XID xid) +{ + if (!xid_ht) + xid_ht = g_hash_table_new ((GHashFunc) gdk_xid_hash, + (GCompareFunc) gdk_xid_compare); + + g_hash_table_remove (xid_ht, &xid); +} + +gpointer +gdk_xid_table_lookup (XID xid) +{ + gpointer data; + + data = g_hash_table_lookup (xid_ht, &xid); + + return data; +} + + +static guint +gdk_xid_hash (XID *xid) +{ + return *xid; +} + +static gint +gdk_xid_compare (XID *a, + XID *b) +{ + return (*a == *b); +} diff --git a/gdk/gxid.c b/gdk/gxid.c new file mode 100644 index 000000000..219c08bfe --- /dev/null +++ b/gdk/gxid.c @@ -0,0 +1,844 @@ +/* + * gxid version 0.3 + * + * Copyright 1997 Owen Taylor <owt1@cornell.edu> +*/ + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <signal.h> +#include <sys/time.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <X11/Xlib.h> +#include <X11/extensions/XInput.h> + +#include "gxid_proto.h" + +/* #define DEBUG_CLIENTS */ +/* #define DEBUG_EVENTS */ + +char *program_name; +Display *dpy; +Window root_window; /* default root window of dpy */ +int port = 0; /* port to listen on */ +int socket_fd = 0; /* file descriptor of socket */ +typedef struct GxidWindow_ GxidWindow; + +typedef struct GxidDevice_ GxidDevice; +struct GxidDevice_ { + XID id; + int exclusive; + int ispointer; + + XDevice *xdevice; + int motionnotify_type; + int changenotify_type; +}; + +struct GxidWindow_ { + Window xwindow; + /* Immediate child of root that is ancestor of window */ + Window root_child; + int num_devices; + GxidDevice **devices; +}; + +GxidDevice **devices = NULL; +int num_devices = 0; +GxidWindow **windows = NULL; +int num_windows = 0; + +void +handler(int signal) +{ + fprintf(stderr,"%s: dying on signal %d\n",program_name,signal); + if (socket_fd) + close(socket_fd); + exit(1); +} + +void +init_socket() +{ + struct sockaddr_in sin; + + socket_fd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); + if (socket_fd < 0) + { + fprintf (stderr, "%s: error getting socket\n", + program_name); + exit(1); + } + + sin.sin_family = AF_INET; + sin.sin_port = htons(port); + sin.sin_addr.s_addr = INADDR_ANY; + + if (bind(socket_fd,(struct sockaddr *)(&sin), + sizeof(struct sockaddr_in)) < 0) + { + fprintf (stderr,"%s: cannot bind to port %d\n", + program_name,port); + exit(1); + } + + if (listen(socket_fd,5) < 0) + { + fprintf (stderr,"%s: error listening on socket\n", + program_name); + exit(1); + }; +} + +#define NUM_EVENTC 2 +static void +enable_device(GxidDevice *dev) +{ + XEventClass xevc[NUM_EVENTC]; + int num_eventc = NUM_EVENTC; + int i,j; + + if (!dev->xdevice) + { + if (dev->ispointer) return; + + dev->xdevice = XOpenDevice(dpy, dev->id); + if (!dev->xdevice) return; + + DeviceMotionNotify (dev->xdevice, dev->motionnotify_type, + xevc[0]); + ChangeDeviceNotify (dev->xdevice, dev->changenotify_type, + xevc[1]); + + /* compress out zero event classes */ + for (i=0,j=0;i<NUM_EVENTC;i++) + { + if (xevc[i]) { + xevc[j] = xevc[i]; + j++; + } + } + num_eventc = j; + + XSelectExtensionEvent (dpy, root_window, xevc, num_eventc); + } +} + +/* switch the core pointer from whatever it is now to something else, + return true on success, false otherwise */ +static int +switch_core_pointer() +{ + GxidDevice *old_pointer = 0; + GxidDevice *new_pointer = 0; + int result; + int i; + + for (i=0;i<num_devices;i++) + { + if (devices[i]->ispointer) + old_pointer = devices[i]; + else + if (!new_pointer && !devices[i]->exclusive) + new_pointer = devices[i]; + } + + if (!old_pointer || !new_pointer) + return 0; + +#ifdef DEBUG_EVENTS + fprintf(stderr,"gxid: Switching core from %ld to %ld\n", + old_pointer->id,new_pointer->id); +#endif + result = XChangePointerDevice(dpy,new_pointer->xdevice, 0, 1); + if (result != Success) + { + fprintf(stderr,"gxid: Error %d switching core from %ld to %ld\n", + result, old_pointer->id, new_pointer->id); + } + else + { + new_pointer->ispointer = 1; + old_pointer->ispointer = 0; + if (!old_pointer->xdevice) + enable_device(old_pointer); + } + + return 1; +} + +void +disable_device(GxidDevice *dev) +{ + if (dev->xdevice) + { + if (dev->ispointer) + return; + XCloseDevice(dpy,dev->xdevice); + dev->xdevice = 0; + } +} + +GxidDevice * +init_device(XDeviceInfo *xdevice) +{ + GxidDevice *dev = (GxidDevice *)malloc(sizeof(GxidDevice)); + XAnyClassPtr class; + int num_axes, i; + + dev->id = xdevice->id; + dev->exclusive = 0; + dev->xdevice = NULL; + + dev->ispointer = (xdevice->use == IsXPointer); + + /* step through the classes */ + + num_axes = 0; + class = xdevice->inputclassinfo; + for (i=0;i<xdevice->num_classes;i++) + { + if (class->class == ValuatorClass) + { + XValuatorInfo *xvi = (XValuatorInfo *)class; + num_axes = xvi->num_axes; + } + class = (XAnyClassPtr)(((char *)class) + class->length); + } + + /* return NULL if insufficient axes */ + if (num_axes < 2) + { + free((void *)dev); + return NULL; + } + + if (!dev->ispointer) + enable_device(dev); + return dev; +} + +void +init_xinput() +{ + char **extensions; + XDeviceInfo *xdevices; + int num_xdevices; + int num_extensions; + int i; + + extensions = XListExtensions(dpy, &num_extensions); + for (i = 0; i < num_extensions && + (strcmp(extensions[i], "XInputExtension") != 0); i++); + XFreeExtensionList(extensions); + if (i == num_extensions) /* XInput extension not found */ + { + fprintf(stderr,"XInput extension not found\n"); + exit(1); + } + + xdevices = XListInputDevices(dpy, &num_xdevices); + devices = (GxidDevice **)malloc(num_xdevices * sizeof(GxidDevice *)); + + num_devices = 0; + for(i=0; i<num_xdevices; i++) + { + GxidDevice *dev = init_device(&xdevices[i]); + if (dev) + devices[num_devices++] = dev; + } + XFreeDeviceList(xdevices); +} + +/* If this routine needs fixing, the corresponding routine + in gdkinputgxi.h will need it too. */ + +Window +gxi_find_root_child(Display *dpy, Window w) +{ + Window root,parent; + Window *children; + int nchildren; + + parent = w; + do + { + w = parent; + XQueryTree(dpy,w,&root,&parent,&children,&nchildren); + if (children) XFree(children); + } + while (parent != root); + + return w; +} + +int +handle_claim_device(GxidClaimDevice *msg) +{ + int i,j; + XID devid = ntohl(msg->device); + XID winid = ntohl(msg->window); + int exclusive = ntohl(msg->exclusive); + GxidDevice *device = NULL; + GxidWindow *window = NULL; + +#ifdef DEBUG_CLIENTS + fprintf(stderr,"device %ld claimed (window 0x%lx)\n",devid,winid); +#endif + + for (i=0;i<num_devices;i++) + { + if (devices[i]->id == devid) + { + device = devices[i]; + break; + } + } + if (!device) + { + fprintf(stderr,"%s: Unknown device id %ld\n",program_name,devid); + return GXID_RETURN_ERROR; + } + + if (device->exclusive) + { + /* already in use */ + fprintf(stderr, + "%s: Device %ld already claimed in exclusive mode\n", + program_name,devid); + return GXID_RETURN_ERROR; + } + + if (exclusive) + { + for (i=0;i<num_windows;i++) + { + for (j=0;j<windows[i]->num_devices;j++) + if (windows[i]->devices[j]->id == devid) + { + /* already in use */ + fprintf(stderr, + "%s: Can't establish exclusive use of device %ld\n", + program_name,devid); + return GXID_RETURN_ERROR; + } + } + if (device->ispointer) + if (!switch_core_pointer()) + { + fprintf(stderr, + "%s: Can't free up core pointer %ld\n", + program_name,devid); + return GXID_RETURN_ERROR; + } + + device->exclusive = 1; + disable_device(device); + XSelectInput(dpy,winid,StructureNotifyMask); + } + else /* !exclusive */ + { + /* FIXME: this is a bit improper. We probably should do this only + when a window is first claimed. But we might be fooled if + an old client died without releasing it's windows. So until + we look for client-window closings, do it here + + (We do look for closings now...) + */ + + XSelectInput(dpy,winid,EnterWindowMask|StructureNotifyMask); + } + + for (i=0;i<num_windows;i++) + { + if (windows[i]->xwindow == winid) + { + window = windows[i]; + break; + } + } + + /* Create window structure if no devices have been previously + claimed on it */ + if (!window) + { + num_windows++; + windows = (GxidWindow **)realloc(windows, + sizeof(GxidWindow*)*num_windows); + window = (GxidWindow *)malloc(sizeof(GxidWindow)); + windows[num_windows-1] = window; + + window->xwindow = winid; + window->root_child = gxi_find_root_child(dpy,winid); + window->num_devices = 0; + window->devices = 0; + } + + + for (i=0;i<window->num_devices;i++) + { + if (window->devices[i] == device) + return GXID_RETURN_OK; + } + + window->num_devices++; + window->devices = (GxidDevice **)realloc(window->devices, + sizeof(GxidDevice*)*num_devices); + /* we need add the device to the window */ + window->devices[i] = device; + + return GXID_RETURN_OK; +} + +int +handle_release_device(GxidReleaseDevice *msg) +{ + int i,j; + XID devid = ntohl(msg->device); + XID winid = ntohl(msg->window); + + GxidDevice *device = NULL; + +#ifdef DEBUG_CLIENTS + fprintf(stderr,"device %ld released (window 0x%lx)\n",devid,winid); +#endif + + for (i=0;i<num_devices;i++) + { + if (devices[i]->id == devid) + { + device = devices[i]; + break; + } + } + if (!device) + { + fprintf(stderr,"%s: Unknown device id %ld\n",program_name,devid); + return GXID_RETURN_ERROR; + } + + for (i=0;i<num_windows;i++) + { + GxidWindow *w = windows[i]; + + if (w->xwindow == winid) + for (j=0;j<w->num_devices;j++) + if (w->devices[j]->id == devid) + { + if (j<w->num_devices-1) + w->devices[j] = w->devices[w->num_devices-1]; + w->num_devices--; + + if (w->num_devices == 0) + { + if (i<num_windows-1) + windows[i] = windows[num_windows-1]; + num_windows--; + + free((void *)w); + /* FIXME: should we deselect input? But what + what if window is already destroyed */ + } + + if (device->exclusive) + { + device->exclusive = 0; + enable_device(device); + } + return GXID_RETURN_OK; + } + } + + /* device/window combination not found */ + fprintf(stderr, + "%s: Device %ld not claimed for window 0x%lx\n", + program_name,devid,winid); + return GXID_RETURN_ERROR; +} + +void +handle_connection() +{ + GxidMessage msg; + GxidU32 type; + int length; + GxidI32 retval; + + int conn_fd; + struct sockaddr_in sin; + int sin_length; + int count; + + sin_length = sizeof(struct sockaddr_in); + conn_fd = accept(socket_fd,(struct sockaddr *)&sin,&sin_length); + if (conn_fd < 0) + { + fprintf(stderr,"%s: Error accepting connection\n", + program_name); + exit(1); + } + + /* read type and length of message */ + + count = read(conn_fd,(char *)&msg,2*sizeof(GxidU32)); + if (count != 2*sizeof(GxidU32)) + { + fprintf(stderr,"%s: Error reading message header\n", + program_name); + close(conn_fd); + return; + } + type = ntohl(msg.any.type); + length = ntohl(msg.any.length); + + /* read rest of message */ + + if (length > sizeof(GxidMessage)) + { + fprintf(stderr,"%s: Bad message length\n", + program_name); + close(conn_fd); + return; + } + + count = read(conn_fd,2*sizeof(GxidU32) + (char *)&msg, + length - 2*sizeof(GxidU32)); + if (count != length - 2*sizeof(GxidU32)) + { + fprintf(stderr,"%s: Error reading message body\n", + program_name); + close(conn_fd); + return; + } + + switch (type) + { + case GXID_CLAIM_DEVICE: + retval = handle_claim_device((GxidClaimDevice *)&msg); + break; + case GXID_RELEASE_DEVICE: + retval = handle_release_device((GxidReleaseDevice *)&msg); + break; + default: + fprintf(stderr,"%s: Unknown message type: %ld (ignoring)\n", + program_name,type); + close(conn_fd); + return; + } + + count = write(conn_fd,&retval,sizeof(GxidI32)); + if (count != sizeof(GxidI32)) + { + fprintf(stderr,"%s: Error writing return code\n", + program_name); + } + + close(conn_fd); +} + +void +handle_motion_notify(XDeviceMotionEvent *event) +{ + int i,j; + GxidDevice *old_device = NULL; + GxidDevice *new_device = NULL; + Window w, root, child; + int root_x, root_y, x, y, mask; + + for (j=0;j<num_devices;j++) + { + if (devices[j]->ispointer) + old_device = devices[j]; + if (devices[j]->id == event->deviceid) + new_device = devices[j]; + } + + if (new_device && !new_device->exclusive && !new_device->ispointer) + { + /* make sure we aren't stealing the pointer back from a slow + client */ + child = root_window; + do + { + w = child; + /* FIXME: this fails disasterously if child vanishes between + calls. (Which is prone to happening since we get events + on root just as the client exits) */ + + XQueryPointer(dpy,w,&root,&child,&root_x,&root_y, + &x,&y,&mask); + } + while (child != None); + + for (i=0;i<num_windows;i++) + if (windows[i]->xwindow == w) + for (j=0;j<windows[i]->num_devices;j++) + if (windows[i]->devices[j] == new_device) + return; + + /* FIXME: do something smarter with axes */ + XChangePointerDevice(dpy,new_device->xdevice, 0, 1); + new_device->ispointer = 1; + + old_device->ispointer = 0; + if (!old_device->xdevice) + enable_device(old_device); + } +} + +void +handle_change_notify(XChangeDeviceNotifyEvent *event) +{ + int j; + GxidDevice *old_device = NULL; + GxidDevice *new_device = NULL; + + + for (j=0;j<num_devices;j++) + { + if (devices[j]->ispointer) + old_device = devices[j]; + if (devices[j]->id == event->deviceid) + new_device = devices[j]; + } + +#ifdef DEBUG_EVENTS + fprintf(stderr,"gxid: ChangeNotify event; old = %ld; new = %ld\n", + old_device->id, new_device->id); +#endif + + if (old_device != new_device) + { + new_device->ispointer = 1; + + old_device->ispointer = 0; + if (!old_device->xdevice) + enable_device(old_device); + } +} + +void +handle_enter_notify(XEnterWindowEvent *event, GxidWindow *window) +{ + int i; + GxidDevice *old_pointer = NULL; + for (i=0;i<num_devices;i++) + { + if (devices[i]->ispointer) + { + old_pointer = devices[i]; + break; + } + } + +#ifdef DEBUG_EVENTS + fprintf(stderr,"gxid: Enter event; oldpointer = %ld\n", + old_pointer->id); +#endif + + if (old_pointer) + for (i=0;i<window->num_devices;i++) + { + if (window->devices[i] == old_pointer) + { + switch_core_pointer(); + break; + } + } +} + +void +handle_destroy_notify(XDestroyWindowEvent *event) +{ + int i,j; + + for (i=0;i<num_windows;i++) + if (windows[i]->xwindow == event->window) + { + GxidWindow *w = windows[i]; + + for (j=0;j<w->num_devices;j++) + { +#ifdef DEBUG_CLIENTS + fprintf(stderr,"device %ld released on destruction of window 0x%lx.\n", + w->devices[j]->id,w->xwindow); +#endif + + if (w->devices[j]->exclusive) + { + w->devices[j]->exclusive = 0; + enable_device(devices[j]); + } + } + + if (i<num_windows-1) + windows[i] = windows[num_windows-1]; + num_windows--; + + if (w->devices) + free((void *)w->devices); + free((void *)w); + /* FIXME: should we deselect input? But what + what if window is already destroyed */ + + return; + } +} + +void +handle_xevent() +{ + int i; + XEvent event; + + XNextEvent (dpy, &event); + +#ifdef DEBUG_EVENTS + fprintf(stderr,"Event - type = %d; window = 0x%lx\n", + event.type,event.xany.window); +#endif + + if (event.type == ConfigureNotify) + { +#ifdef DEBUG_EVENTS + XConfigureEvent *xce = (XConfigureEvent *)&event; + fprintf(stderr," configureNotify: window = 0x%lx\n",xce->window); +#endif + } + else if (event.type == EnterNotify) + { + /* pointer entered a claimed window */ + for (i=0;i<num_windows;i++) + { + if (event.xany.window == windows[i]->xwindow) + handle_enter_notify((XEnterWindowEvent *)&event,windows[i]); + } + } + else if (event.type == DestroyNotify) + { + /* A claimed window was destroyed */ + for (i=0;i<num_windows;i++) + { + if (event.xany.window == windows[i]->xwindow) + handle_destroy_notify((XDestroyWindowEvent *)&event); + } + } + else + for (i=0;i<num_devices;i++) + { + if (event.type == devices[i]->motionnotify_type) + { + handle_motion_notify((XDeviceMotionEvent *)&event); + break; + } + else if (event.type == devices[i]->changenotify_type) + { + handle_change_notify((XChangeDeviceNotifyEvent *)&event); + break; + } + } +} + +void +usage() +{ + fprintf(stderr,"Usage: %s [-d display] [-p --gxid-port port]\n", + program_name); + exit(1); +} + +int +main(int argc, char **argv) +{ + int i; + char *display_name = NULL; + fd_set readfds; + + program_name = argv[0]; + + for (i=1;i<argc;i++) + { + if (!strcmp(argv[i],"-d")) + { + if (++i >= argc) usage(); + display_name = argv[i]; + } + else if (!strcmp(argv[i],"--gxid-port") || + !strcmp(argv[i],"-p")) + { + if (++i >= argc) usage(); + port = atoi(argv[i]); + break; + } + else + usage(); + } + + if (!port) + { + char *t = getenv("GXID_PORT"); + if (t) + port = atoi(t); + else + port = 6951; + } + /* set up a signal handler so we can clean up if killed */ + + signal(SIGTERM,handler); + signal(SIGINT,handler); + + /* initialize the X connection */ + + dpy = XOpenDisplay (display_name); + if (!dpy) + { + fprintf (stderr, "%s: unable to open display '%s'\n", + program_name, XDisplayName (display_name)); + exit (1); + } + + root_window = DefaultRootWindow(dpy); + + /* We'll want to do this in the future if we are to support + gxid monitoring visibility information for clients */ +#if 0 + XSelectInput(dpy,root_window,SubstructureNotifyMask); +#endif + init_xinput(); + + /* set up our server connection */ + + init_socket(); + + /* main loop */ + + if (XPending(dpy)) /* this seems necessary to get things + in sync */ + handle_xevent(); + while (1) + { + + FD_ZERO(&readfds); + FD_SET(ConnectionNumber(dpy),&readfds); + FD_SET(socket_fd,&readfds); + + if (select(8*sizeof(readfds),&readfds, + (fd_set *)0,(fd_set *)0, (struct timeval *)0) < 0) + { + fprintf(stderr,"Error in select\n"); + exit(1); + } + + if (FD_ISSET(socket_fd,&readfds)) + handle_connection(socket_fd); + + while (XPending(dpy)) + handle_xevent(); + } + + XCloseDisplay (dpy); + exit (0); +} diff --git a/gdk/gxid_lib.c b/gdk/gxid_lib.c new file mode 100644 index 000000000..357b76451 --- /dev/null +++ b/gdk/gxid_lib.c @@ -0,0 +1,116 @@ +/* + * gxid version 0.3 + * + * Copyright 1997 Owen Taylor <owt1@cornell.edu> +*/ + +#include "../config.h" + +#ifdef XINPUT_GXI + +#include <stdio.h> +#include <unistd.h> +#include <sys/time.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netdb.h> + +#include "gxid_lib.h" + +/* handles mechanics of communicating with a client */ +static int +gxid_send_message(char *host, int port, GxidMessage *msg) +{ + int socket_fd; + struct sockaddr_in sin; + int count; + GxidI32 retval; + struct hostent *he; + + if (!port) port = 6951; + + if (!host || strcmp(host,"localhost") ) + { + /* looking it up as localhost can be _SLOW_ on ppp systems */ + /* FIXME: Could localhost be anything other than loopback? */ + host = "127.0.0.1"; + } + + he = gethostbyname(host); + if (!he) + { + fprintf(stderr,"gxid_lib: error looking up %s\n",host); + return GXID_RETURN_ERROR; + } + + sin.sin_family = he->h_addrtype; + sin.sin_port = htons(port); + memcpy(&sin.sin_addr,he->h_addr_list[0],he->h_length); + + socket_fd = socket(AF_INET,SOCK_STREAM,0); + if (socket_fd < 0) + { + fprintf(stderr,"gxid_lib: can't get socket"); + return GXID_RETURN_ERROR; + } + + if (connect(socket_fd, (struct sockaddr *)&sin, + sizeof sin) < 0) + { + fprintf(stderr,"gxid_lib: can't connect to %s:%d\n",host,port); + close(socket_fd); + return GXID_RETURN_ERROR; + } + + count = write(socket_fd,(char *)msg,ntohl(msg->any.length)); + if (count != ntohl(msg->any.length)) + { + fprintf(stderr,"gxid_lib: error writing"); + close(socket_fd); + return GXID_RETURN_ERROR; + } + + /* now read the return code */ + count = read(socket_fd,(char *)&retval,sizeof(GxidI32)); + if (count != sizeof(GxidI32)) + { + fprintf(stderr,"gxid_lib: error reading return code"); + close(socket_fd); + return GXID_RETURN_ERROR; + } + + close (socket_fd); + return ntohl(retval); +} + +/* claim a device. If exclusive, device is claimed exclusively */ +int +gxid_claim_device(char *host, int port, GxidU32 device, GxidU32 window, + int exclusive) +{ + GxidClaimDevice msg; + msg.type = htonl(GXID_CLAIM_DEVICE); + msg.length = htonl(sizeof(GxidClaimDevice)); + msg.device = htonl(device); + msg.window = htonl(window); + msg.exclusive = htonl(exclusive); + + return gxid_send_message(host,port,(GxidMessage *)&msg); +} + +/* release a device/window pair */ +int +gxid_release_device(char *host, int port, GxidU32 device, GxidU32 window) +{ + GxidReleaseDevice msg; + msg.type = htonl(GXID_RELEASE_DEVICE); + msg.length = htonl(sizeof(GxidReleaseDevice)); + msg.device = htonl(device); + msg.window = htonl(window); + + return gxid_send_message(host,port,(GxidMessage *)&msg); +} + +#endif /* XINPUT_GXI */ + diff --git a/gdk/gxid_lib.h b/gdk/gxid_lib.h new file mode 100644 index 000000000..6a7103bbe --- /dev/null +++ b/gdk/gxid_lib.h @@ -0,0 +1,6 @@ +#include "gxid_proto.h" + +int gxid_claim_device(char *host, int port, + GxidU32 device, GxidU32 window, int exclusive); +int gxid_release_device(char *host, int port, GxidU32 device, + GxidU32 window); diff --git a/gdk/gxid_proto.h b/gdk/gxid_proto.h new file mode 100644 index 000000000..24959b806 --- /dev/null +++ b/gdk/gxid_proto.h @@ -0,0 +1,39 @@ +#define GXID_CLAIM_DEVICE 1 +#define GXID_RELEASE_DEVICE 2 + +#define GXID_RETURN_OK 0 +#define GXID_RETURN_ERROR -1 + +typedef struct GxidClaimDevice_ GxidClaimDevice; +typedef struct GxidReleaseDevice_ GxidReleaseDevice; +typedef struct GxidMessageAny_ GxidMessageAny; +typedef union GxidMessage_ GxidMessage; + +typedef unsigned long GxidU32; +typedef long GxidI32; + +struct GxidClaimDevice_ { + GxidU32 type; + GxidU32 length; + GxidU32 device; + GxidU32 window; + GxidU32 exclusive; +}; + +struct GxidReleaseDevice_ { + GxidU32 type; + GxidU32 length; + GxidU32 device; + GxidU32 window; +}; + +struct GxidMessageAny_ { + GxidU32 type; + GxidU32 length; +}; + +union GxidMessage_ { + GxidMessageAny any; + GxidClaimDevice claim; + GxidReleaseDevice release; +}; diff --git a/gdk/makecursors b/gdk/makecursors new file mode 100755 index 000000000..664776a2b --- /dev/null +++ b/gdk/makecursors @@ -0,0 +1,5 @@ +#!/bin/sh + +sed -f makecursors.sed $1 > .makecursors.tmp +awk '{printf "%s = %s,\n", $1, $2}' .makecursors.tmp +rm .makecursors.tmp diff --git a/gdk/makecursors.sed b/gdk/makecursors.sed new file mode 100644 index 000000000..107d13f8d --- /dev/null +++ b/gdk/makecursors.sed @@ -0,0 +1,3 @@ +/define/ ! d +/define/ y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/ +s/^.*XC_/GDK_/g diff --git a/gdk/makekeysyms b/gdk/makekeysyms new file mode 100755 index 000000000..40b49d4e8 --- /dev/null +++ b/gdk/makekeysyms @@ -0,0 +1,5 @@ +#!/bin/sh + +sed -f makekeysyms.sed $1 > .makekeysms.tmp +awk '{printf "#define %s %s\n", $1, $2}' .makekeysms.tmp +rm .makekeysms.tmp diff --git a/gdk/makekeysyms.sed b/gdk/makekeysyms.sed new file mode 100644 index 000000000..bafbf76c0 --- /dev/null +++ b/gdk/makekeysyms.sed @@ -0,0 +1,3 @@ +/define/ ! d +s/^.*XK_/GDK_/g +s/0X/0x/g diff --git a/gdk/x11/gdkcolor-x11.c b/gdk/x11/gdkcolor-x11.c new file mode 100644 index 000000000..5e66f089b --- /dev/null +++ b/gdk/x11/gdkcolor-x11.c @@ -0,0 +1,718 @@ +/* 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 <X11/Xlib.h> +#include "gdk.h" +#include "gdkprivate.h" + + +static gint gdk_colormap_match_color (GdkColormap *cmap, + GdkColor *color, + const gchar *available); +static void gdk_colormap_add (GdkColormap *cmap); +static void gdk_colormap_remove (GdkColormap *cmap); +static guint gdk_colormap_hash (Colormap *cmap); +static gint gdk_colormap_cmp (Colormap *a, + Colormap *b); + +static GHashTable *colormap_hash = NULL; + + +GdkColormap* +gdk_colormap_new (GdkVisual *visual, + gint private_cmap) +{ + GdkColormap *colormap; + GdkColormapPrivate *private; + Visual *xvisual; + XColor default_colors[256]; + int size; + int i; + + g_return_val_if_fail (visual != NULL, NULL); + + private = g_new (GdkColormapPrivate, 1); + colormap = (GdkColormap*) private; + + private->xdisplay = gdk_display; + private->visual = visual; + private->next_color = 0; + private->ref_count = 1; + xvisual = ((GdkVisualPrivate*) visual)->xvisual; + + switch (visual->type) + { + case GDK_VISUAL_GRAYSCALE: + case GDK_VISUAL_PSEUDO_COLOR: + private->private_val = private_cmap; + private->xcolormap = XCreateColormap (private->xdisplay, gdk_root_window, + xvisual, (private_cmap) ? (AllocAll) : (AllocNone)); + + if (private_cmap) + { + for (i = 0; i < 256; i++) + default_colors[i].pixel = i; + + XQueryColors (private->xdisplay, + DefaultColormap (private->xdisplay, gdk_screen), + default_colors, visual->colormap_size); + + for (i = 0; i < visual->colormap_size; i++) + { + colormap->colors[i].pixel = default_colors[i].pixel; + colormap->colors[i].red = default_colors[i].red; + colormap->colors[i].green = default_colors[i].green; + colormap->colors[i].blue = default_colors[i].blue; + } + + gdk_colormap_change (colormap, visual->colormap_size); + } + break; + + case GDK_VISUAL_DIRECT_COLOR: + private->private_val = TRUE; + private->xcolormap = XCreateColormap (private->xdisplay, gdk_root_window, + xvisual, AllocAll); + + size = 1 << visual->red_prec; + for (i = 0; i < size; i++) + colormap->colors[i].red = i * 65535 / (size - 1); + + size = 1 << visual->green_prec; + for (i = 0; i < size; i++) + colormap->colors[i].green = i * 65535 / (size - 1); + + size = 1 << visual->blue_prec; + for (i = 0; i < size; i++) + colormap->colors[i].blue = i * 65535 / (size - 1); + + gdk_colormap_change (colormap, visual->colormap_size); + break; + + case GDK_VISUAL_STATIC_GRAY: + case GDK_VISUAL_STATIC_COLOR: + case GDK_VISUAL_TRUE_COLOR: + private->private_val = FALSE; + private->xcolormap = XCreateColormap (private->xdisplay, gdk_root_window, + xvisual, AllocNone); + break; + } + + gdk_colormap_add (colormap); + + return colormap; +} + +void +gdk_colormap_real_destroy (GdkColormap *colormap) +{ + GdkColormapPrivate *private = (GdkColormapPrivate*) colormap; + + g_return_if_fail (colormap != NULL); + + if (private->ref_count > 0) + return; + + gdk_colormap_remove (colormap); + XFreeColormap (private->xdisplay, private->xcolormap); + g_free (colormap); +} + +void +gdk_colormap_destroy (GdkColormap *colormap) +{ + gdk_colormap_unref (colormap); +} + +GdkColormap* +gdk_colormap_ref (GdkColormap *cmap) +{ + GdkColormapPrivate *private = (GdkColormapPrivate *)cmap; + g_return_val_if_fail (cmap != NULL, NULL); + + private->ref_count += 1; + return cmap; +} + +void +gdk_colormap_unref (GdkColormap *cmap) +{ + GdkColormapPrivate *private = (GdkColormapPrivate *)cmap; + g_return_if_fail (cmap != NULL); + + private->ref_count -= 1; + if (private->ref_count == 0) + gdk_colormap_real_destroy (cmap); +} + +GdkColormap* +gdk_colormap_get_system (void) +{ + static GdkColormap *colormap = NULL; + GdkColormapPrivate *private; + XColor xpalette[256]; + gint i; + + if (!colormap) + { + private = g_new (GdkColormapPrivate, 1); + colormap = (GdkColormap*) private; + + private->xdisplay = gdk_display; + private->xcolormap = DefaultColormap (gdk_display, gdk_screen); + private->visual = gdk_visual_get_system (); + private->private_val = FALSE; + private->next_color = 0; + private->ref_count = 1; + + for (i = 0; i < 256; i++) + { + xpalette[i].pixel = i; + xpalette[i].red = 0; + xpalette[i].green = 0; + xpalette[i].blue = 0; + } + + XQueryColors (gdk_display, private->xcolormap, xpalette, 256); + + for (i = 0; i < 256; i++) + { + colormap->colors[i].pixel = xpalette[i].pixel; + colormap->colors[i].red = xpalette[i].red; + colormap->colors[i].green = xpalette[i].green; + colormap->colors[i].blue = xpalette[i].blue; + } + + gdk_colormap_add (colormap); + } + + return colormap; +} + +gint +gdk_colormap_get_system_size (void) +{ + return DisplayCells (gdk_display, gdk_screen); +} + +void +gdk_colormap_change (GdkColormap *colormap, + gint ncolors) +{ + GdkColormapPrivate *private; + GdkVisual *visual; + XColor palette[256]; + gint shift; + int max_colors; + int size; + int i; + + g_return_if_fail (colormap != NULL); + + private = (GdkColormapPrivate*) colormap; + switch (private->visual->type) + { + case GDK_VISUAL_GRAYSCALE: + case GDK_VISUAL_PSEUDO_COLOR: + for (i = 0; i < ncolors; i++) + { + palette[i].pixel = colormap->colors[i].pixel; + palette[i].red = colormap->colors[i].red; + palette[i].green = colormap->colors[i].green; + palette[i].blue = colormap->colors[i].blue; + palette[i].flags = DoRed | DoGreen | DoBlue; + } + + XStoreColors (private->xdisplay, private->xcolormap, palette, ncolors); + private->next_color = MAX (private->next_color, ncolors); + break; + + case GDK_VISUAL_DIRECT_COLOR: + visual = private->visual; + + shift = visual->red_shift; + max_colors = 1 << visual->red_prec; + size = (ncolors < max_colors) ? (ncolors) : (max_colors); + + for (i = 0; i < size; i++) + { + palette[i].pixel = i << shift; + palette[i].red = colormap->colors[i].red; + palette[i].flags = DoRed; + } + + XStoreColors (private->xdisplay, private->xcolormap, palette, size); + + shift = visual->green_shift; + max_colors = 1 << visual->green_prec; + size = (ncolors < max_colors) ? (ncolors) : (max_colors); + + for (i = 0; i < size; i++) + { + palette[i].pixel = i << shift; + palette[i].green = colormap->colors[i].green; + palette[i].flags = DoGreen; + } + + XStoreColors (private->xdisplay, private->xcolormap, palette, size); + + shift = visual->blue_shift; + max_colors = 1 << visual->blue_prec; + size = (ncolors < max_colors) ? (ncolors) : (max_colors); + + for (i = 0; i < size; i++) + { + palette[i].pixel = i << shift; + palette[i].blue = colormap->colors[i].blue; + palette[i].flags = DoBlue; + } + + XStoreColors (private->xdisplay, private->xcolormap, palette, size); + break; + + default: + break; + } +} + +void +gdk_colors_store (GdkColormap *colormap, + GdkColor *colors, + gint ncolors) +{ + gint i; + + for (i = 0; i < ncolors; i++) + { + colormap->colors[i].pixel = colors[i].pixel; + colormap->colors[i].red = colors[i].red; + colormap->colors[i].green = colors[i].green; + colormap->colors[i].blue = colors[i].blue; + } + + gdk_colormap_change (colormap, ncolors); +} + +gint +gdk_colors_alloc (GdkColormap *colormap, + gint contiguous, + gulong *planes, + gint nplanes, + gulong *pixels, + gint npixels) +{ + GdkColormapPrivate *private; + gint return_val; + + g_return_val_if_fail (colormap != NULL, 0); + + private = (GdkColormapPrivate*) colormap; + + return_val = XAllocColorCells (private->xdisplay, private->xcolormap, + contiguous, planes, nplanes, pixels, npixels); + + return return_val; +} + +void +gdk_colors_free (GdkColormap *colormap, + gulong *pixels, + gint npixels, + gulong planes) +{ + GdkColormapPrivate *private; + + g_return_if_fail (colormap != NULL); + + private = (GdkColormapPrivate*) colormap; + + XFreeColors (private->xdisplay, private->xcolormap, + pixels, npixels, planes); +} + +gint +gdk_color_white (GdkColormap *colormap, + GdkColor *color) +{ + gint return_val; + + g_return_val_if_fail (colormap != NULL, FALSE); + + if (color) + { + color->pixel = WhitePixel (gdk_display, gdk_screen); + color->red = 65535; + color->green = 65535; + color->blue = 65535; + + return_val = gdk_color_alloc (colormap, color); + } + else + return_val = FALSE; + + return return_val; +} + +gint +gdk_color_black (GdkColormap *colormap, + GdkColor *color) +{ + gint return_val; + + g_return_val_if_fail (colormap != NULL, FALSE); + + if (color) + { + color->pixel = BlackPixel (gdk_display, gdk_screen); + color->red = 0; + color->green = 0; + color->blue = 0; + + return_val = gdk_color_alloc (colormap, color); + } + else + return_val = FALSE; + + return return_val; +} + +gint +gdk_color_parse (const gchar *spec, + GdkColor *color) +{ + Colormap xcolormap; + XColor xcolor; + gint return_val; + + g_return_val_if_fail (spec != NULL, FALSE); + g_return_val_if_fail (color != NULL, FALSE); + + xcolormap = DefaultColormap (gdk_display, gdk_screen); + + if (XParseColor (gdk_display, xcolormap, spec, &xcolor)) + { + return_val = TRUE; + color->red = xcolor.red; + color->green = xcolor.green; + color->blue = xcolor.blue; + } + else + return_val = FALSE; + + return return_val; +} + +gint +gdk_color_alloc (GdkColormap *colormap, + GdkColor *color) +{ + GdkColormapPrivate *private; + GdkVisual *visual; + XColor xcolor; + gchar available[256]; + gint available_init; + gint return_val; + gint i, index; + + g_return_val_if_fail (colormap != NULL, FALSE); + g_return_val_if_fail (color != NULL, FALSE); + + xcolor.red = color->red; + xcolor.green = color->green; + xcolor.blue = color->blue; + xcolor.pixel = color->pixel; + xcolor.flags = DoRed | DoGreen | DoBlue; + + return_val = FALSE; + private = (GdkColormapPrivate*) colormap; + + switch (private->visual->type) + { + case GDK_VISUAL_GRAYSCALE: + case GDK_VISUAL_PSEUDO_COLOR: + if (private->private_val) + { + if (private->next_color > 255) + { + for (i = 0; i < 256; i++) + available[i] = TRUE; + + index = gdk_colormap_match_color (colormap, color, available); + if (index != -1) + { + available[index] = FALSE; + *color = colormap->colors[index]; + return_val = TRUE; + } + else + { + return_val = FALSE; + } + } + else + { + xcolor.pixel = 255 - private->next_color; + color->pixel = xcolor.pixel; + private->next_color += 1; + + XStoreColor (private->xdisplay, private->xcolormap, &xcolor); + return_val = TRUE; + } + } + else + { + available_init = 1; + + while (1) + { + if (XAllocColor (private->xdisplay, private->xcolormap, &xcolor)) + { + color->pixel = xcolor.pixel; + color->red = xcolor.red; + color->green = xcolor.green; + color->blue = xcolor.blue; + + colormap->colors[color->pixel] = *color; + + return_val = TRUE; + break; + } + else + { + if (available_init) + { + available_init = 0; + for (i = 0; i < 256; i++) + available[i] = TRUE; + } + + index = gdk_colormap_match_color (colormap, color, available); + if (index != -1) + { + available[index] = FALSE; + xcolor.red = colormap->colors[index].red; + xcolor.green = colormap->colors[index].green; + xcolor.blue = colormap->colors[index].blue; + } + else + { + return_val = FALSE; + break; + } + } + } + } + break; + + case GDK_VISUAL_DIRECT_COLOR: + visual = private->visual; + xcolor.pixel = (((xcolor.red >> (16 - visual->red_prec)) << visual->red_shift) + + ((xcolor.green >> (16 - visual->green_prec)) << visual->green_shift) + + ((xcolor.blue >> (16 - visual->blue_prec)) << visual->blue_shift)); + color->pixel = xcolor.pixel; + return_val = TRUE; + break; + + case GDK_VISUAL_STATIC_GRAY: + case GDK_VISUAL_STATIC_COLOR: + case GDK_VISUAL_TRUE_COLOR: + if (XAllocColor (private->xdisplay, private->xcolormap, &xcolor)) + { + color->pixel = xcolor.pixel; + return_val = TRUE; + } + else + return_val = FALSE; + break; + } + + return return_val; +} + +gint +gdk_color_change (GdkColormap *colormap, + GdkColor *color) +{ + GdkColormapPrivate *private; + XColor xcolor; + + g_return_val_if_fail (colormap != NULL, FALSE); + g_return_val_if_fail (color != NULL, FALSE); + + xcolor.pixel = color->pixel; + xcolor.red = color->red; + xcolor.green = color->green; + xcolor.blue = color->blue; + xcolor.flags = DoRed | DoGreen | DoBlue; + + private = (GdkColormapPrivate*) colormap; + XStoreColor (private->xdisplay, private->xcolormap, &xcolor); + + return TRUE; +} + +gint +gdk_color_equal (GdkColor *colora, + GdkColor *colorb) +{ + g_return_val_if_fail (colora != NULL, FALSE); + g_return_val_if_fail (colorb != NULL, FALSE); + + return ((colora->red == colorb->red) && + (colora->green == colorb->green) && + (colora->blue == colorb->blue)); +} + +GdkColormap* +gdkx_colormap_get (Colormap xcolormap) +{ + GdkColormap *colormap; + GdkColormapPrivate *private; + XColor xpalette[256]; + gint i; + + colormap = gdk_colormap_lookup (xcolormap); + if (colormap) + return colormap; + + if (xcolormap == DefaultColormap (gdk_display, gdk_screen)) + return gdk_colormap_get_system (); + + private = g_new (GdkColormapPrivate, 1); + colormap = (GdkColormap*) private; + + private->xdisplay = gdk_display; + private->xcolormap = xcolormap; + private->visual = NULL; + private->private_val = TRUE; + private->next_color = 0; + + for (i = 0; i < 256; i++) + { + xpalette[i].pixel = i; + xpalette[i].red = 0; + xpalette[i].green = 0; + xpalette[i].blue = 0; + } + + XQueryColors (gdk_display, private->xcolormap, xpalette, 256); + + for (i = 0; i < 256; i++) + { + colormap->colors[i].pixel = xpalette[i].pixel; + colormap->colors[i].red = xpalette[i].red; + colormap->colors[i].green = xpalette[i].green; + colormap->colors[i].blue = xpalette[i].blue; + } + + gdk_colormap_add (colormap); + + return colormap; +} + + +static gint +gdk_colormap_match_color (GdkColormap *cmap, + GdkColor *color, + const gchar *available) +{ + GdkColor *colors; + guint sum, max; + gint rdiff, gdiff, bdiff; + gint i, index; + + g_return_val_if_fail (cmap != NULL, 0); + g_return_val_if_fail (color != NULL, 0); + + colors = cmap->colors; + max = 3 * (65536); + index = -1; + + for (i = 0; i < 256; i++) + { + if ((!available) || (available && available[i])) + { + rdiff = (color->red - colors[i].red); + gdiff = (color->green - colors[i].green); + bdiff = (color->blue - colors[i].blue); + + sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff); + + if (sum < max) + { + index = i; + max = sum; + } + } + } + + return index; +} + + +GdkColormap* +gdk_colormap_lookup (Colormap xcolormap) +{ + GdkColormap *cmap; + + if (!colormap_hash) + return NULL; + + cmap = g_hash_table_lookup (colormap_hash, &xcolormap); + return cmap; +} + +static void +gdk_colormap_add (GdkColormap *cmap) +{ + GdkColormapPrivate *private; + + if (!colormap_hash) + colormap_hash = g_hash_table_new ((GHashFunc) gdk_colormap_hash, + (GCompareFunc) gdk_colormap_cmp); + + private = (GdkColormapPrivate*) cmap; + + g_hash_table_insert (colormap_hash, &private->xcolormap, cmap); +} + +static void +gdk_colormap_remove (GdkColormap *cmap) +{ + GdkColormapPrivate *private; + + if (!colormap_hash) + colormap_hash = g_hash_table_new ((GHashFunc) gdk_colormap_hash, + (GCompareFunc) gdk_colormap_cmp); + + private = (GdkColormapPrivate*) cmap; + + g_hash_table_remove (colormap_hash, &private->xcolormap); +} + +static guint +gdk_colormap_hash (Colormap *cmap) +{ + return *cmap; +} + +static gint +gdk_colormap_cmp (Colormap *a, + Colormap *b) +{ + return (*a == *b); +} diff --git a/gdk/x11/gdkcursor-x11.c b/gdk/x11/gdkcursor-x11.c new file mode 100644 index 000000000..22bfd250b --- /dev/null +++ b/gdk/x11/gdkcursor-x11.c @@ -0,0 +1,52 @@ +/* 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 <X11/Xlib.h> +#include <X11/cursorfont.h> +#include "gdk.h" +#include "gdkprivate.h" + + +GdkCursor* +gdk_cursor_new (GdkCursorType cursor_type) +{ + GdkCursorPrivate *private; + GdkCursor *cursor; + Cursor xcursor; + + xcursor = XCreateFontCursor (gdk_display, cursor_type); + private = g_new (GdkCursorPrivate, 1); + private->xdisplay = gdk_display; + private->xcursor = xcursor; + cursor = (GdkCursor*) private; + cursor->type = cursor_type; + + return cursor; +} + +void +gdk_cursor_destroy (GdkCursor *cursor) +{ + GdkCursorPrivate *private; + + g_return_if_fail (cursor != NULL); + + private = (GdkCursorPrivate *) cursor; + XFreeCursor (private->xdisplay, private->xcursor); + + g_free (private); +} diff --git a/gdk/x11/gdkfont-x11.c b/gdk/x11/gdkfont-x11.c new file mode 100644 index 000000000..e1b1e7254 --- /dev/null +++ b/gdk/x11/gdkfont-x11.c @@ -0,0 +1,379 @@ +/* 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 <X11/Xlib.h> +#include <X11/Xos.h> +#include "gdk.h" +#include "gdkprivate.h" + +GdkFont* +gdk_font_load (const gchar *font_name) +{ + GdkFont *font; + GdkFontPrivate *private; + + private = g_new (GdkFontPrivate, 1); + font = (GdkFont*) private; + + private->xdisplay = gdk_display; + private->xfont = XLoadQueryFont (private->xdisplay, font_name); + private->ref_count = 1; + + if (!private->xfont) + { + g_free (font); + return NULL; + } + else + { + font->type = GDK_FONT_FONT; + font->ascent = ((XFontStruct *) private->xfont)->ascent; + font->descent = ((XFontStruct *) private->xfont)->descent; + } + + gdk_xid_table_insert (&((XFontStruct *) private->xfont)->fid, font); + + return font; +} + +GdkFont* +gdk_fontset_load(gchar *fontset_name) +{ + GdkFont *font; + GdkFontPrivate *private; + XFontSet fontset; + gint missing_charset_count; + gchar **missing_charset_list; + gchar *def_string; + + private = g_new (GdkFontPrivate, 1); + font = (GdkFont*) private; + + private->xdisplay = gdk_display; + fontset = XCreateFontSet (gdk_display, fontset_name, + &missing_charset_list, &missing_charset_count, + &def_string); + + if (missing_charset_count) + { + g_print ("Missing charsets in FontSet creation"); + XFreeStringList (missing_charset_list); + } + + private->ref_count = 1; + + if (!fontset) + { + g_free (font); + return NULL; + } + else + { + XFontSetExtents *extent = XExtentsOfFontSet(fontset); + + private->xfont = fontset; + font->type = GDK_FONT_FONTSET; + /* how to define ascent and descent for fontset ??? */ + font->ascent = extent->max_logical_extent.height; + font->descent = font->ascent / 4 ; + } + return font; +} +void +gdk_font_free (GdkFont *font) +{ + GdkFontPrivate *private; + + g_return_if_fail (font != NULL); + + private = (GdkFontPrivate*) font; + + private->ref_count -= 1; + if (private->ref_count == 0) + { + gdk_xid_table_remove (((XFontStruct *) private->xfont)->fid); + XFreeFont (private->xdisplay, (XFontStruct *) private->xfont); + g_free (font); + } +} + +void +gdk_fontset_free (GdkFont *font) +{ + GdkFontPrivate *private; + + g_return_if_fail (font != NULL); + + private = (GdkFontPrivate*) font; + + private->ref_count -= 1; + if (private->ref_count == 0) + { + XFreeFontSet (private->xdisplay, (XFontSet) private->xfont); + g_free (font); + } +} + +GdkFont* +gdk_font_ref (GdkFont *font) +{ + GdkFontPrivate *private; + + g_return_val_if_fail (font != NULL, NULL); + + private = (GdkFontPrivate*) font; + private->ref_count += 1; + return font; +} + +gint +gdk_font_id (GdkFont *font) +{ + GdkFontPrivate *font_private; + + g_return_val_if_fail (font != NULL, 0); + + font_private = (GdkFontPrivate*) font; + + if (font->type == GDK_FONT_FONT) + { + return ((XFontStruct *) font_private->xfont)->fid; + } + else + { + return 0; + } +} + +gint +gdk_font_equal (GdkFont *fonta, + GdkFont *fontb) +{ + GdkFontPrivate *privatea; + GdkFontPrivate *privateb; + + g_return_val_if_fail (fonta != NULL, FALSE); + g_return_val_if_fail (fontb != NULL, FALSE); + + privatea = (GdkFontPrivate*) fonta; + privateb = (GdkFontPrivate*) fontb; + + if (fonta->type == GDK_FONT_FONT && fontb->type == GDK_FONT_FONT) + { + return (((XFontStruct *) privatea->xfont)->fid == + ((XFontStruct *) privateb->xfont)->fid); + } + else if (fonta->type == GDK_FONT_FONTSET && fontb->type == GDK_FONT_FONTSET) + { + /* how to compare two fontsets ?? by basename or XFontSet ?? */ + return (((XFontSet) privatea->xfont) == ((XFontSet) privateb->xfont)); + } + else + /* fontset != font */ + return 0; +} + +gint +gdk_string_width (GdkFont *font, + const gchar *string) +{ + GdkFontPrivate *font_private; + gint width; + XFontStruct *xfont; + XFontSet fontset; + + g_return_val_if_fail (font != NULL, -1); + g_return_val_if_fail (string != NULL, -1); + + font_private = (GdkFontPrivate*) font; + + switch (font->type) + { + case GDK_FONT_FONT: + xfont = (XFontStruct *) font_private->xfont; + if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0)) + { + width = XTextWidth (xfont, string, strlen (string)); + } + else + { + width = XTextWidth16 (xfont, (XChar2b *) string, strlen (string) / 2); + } + break; + case GDK_FONT_FONTSET: + fontset = (XFontSet) font_private->xfont; + width = XmbTextEscapement (fontset, string, strlen(string)); + break; + default: + width = 0; + } + + return width; +} + +gint +gdk_text_width (GdkFont *font, + const gchar *text, + gint text_length) +{ + GdkFontPrivate *private; + gint width; + XFontStruct *xfont; + XFontSet fontset; + + g_return_val_if_fail (font != NULL, -1); + g_return_val_if_fail (text != NULL, -1); + + private = (GdkFontPrivate*) font; + + switch (font->type) + { + case GDK_FONT_FONT: + xfont = (XFontStruct *) private->xfont; + if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0)) + { + width = XTextWidth (xfont, text, text_length); + } + else + { + width = XTextWidth16 (xfont, (XChar2b *) text, text_length / 2); + } + break; + case GDK_FONT_FONTSET: + fontset = (XFontSet) private->xfont; + width = XmbTextEscapement (fontset, text, text_length); + break; + default: + width = 0; + } + return width; +} + +/* Problem: What if a character is a 16 bits character ?? */ +gint +gdk_char_width (GdkFont *font, + gchar character) +{ + GdkFontPrivate *private; + XCharStruct *chars; + gint width; + guint ch = character & 0xff; /* get rid of sign-extension */ + XFontStruct *xfont; + XFontSet fontset; + + g_return_val_if_fail (font != NULL, -1); + + private = (GdkFontPrivate*) font; + + switch (font->type) + { + case GDK_FONT_FONT: + /* only 8 bits characters are considered here */ + xfont = (XFontStruct *) private->xfont; + if ((xfont->min_byte1 == 0) && + (xfont->max_byte1 == 0) && + (ch >= xfont->min_char_or_byte2) && + (ch <= xfont->max_char_or_byte2)) + { + chars = xfont->per_char; + if (chars) + width = chars[ch - xfont->min_char_or_byte2].width; + else + width = xfont->min_bounds.width; + } + else + { + width = XTextWidth (xfont, &character, 1); + } + break; + case GDK_FONT_FONTSET: + fontset = (XFontSet) private->xfont; + width = XmbTextEscapement (fontset, &character, 1) ; + break; + default: + width = 0; + } + return width; +} + +gint +gdk_string_measure (GdkFont *font, + const gchar *string) +{ + g_return_val_if_fail (font != NULL, -1); + g_return_val_if_fail (string != NULL, -1); + + return gdk_text_measure (font, string, strlen (string)); +} + +gint +gdk_text_measure (GdkFont *font, + const gchar *text, + gint text_length) +{ + GdkFontPrivate *private; + XCharStruct overall; + XFontStruct *xfont; + XFontSet fontset; + XRectangle ink, log; + int direction; + int font_ascent; + int font_descent; + gint width; + + g_return_val_if_fail (font != NULL, -1); + g_return_val_if_fail (text != NULL, -1); + + private = (GdkFontPrivate*) font; + + switch (font->type) + { + case GDK_FONT_FONT: + xfont = (XFontStruct *) private->xfont; + if ((xfont->min_byte1 == 0) && (xfont->max_byte1 == 0)) + { + XTextExtents (xfont, text, text_length, + &direction, &font_ascent, &font_descent, + &overall); + } + else + { + XTextExtents16 (xfont, (XChar2b *) text, text_length / 2, + &direction, &font_ascent, &font_descent, + &overall); + } + width = overall.rbearing; + break; + case GDK_FONT_FONTSET: + fontset = (XFontSet) private->xfont; + XmbTextExtents (fontset, text, text_length, &ink, &log); + width = log.width; + break; + default: + width = 0; + } + return width; +} + +gint +gdk_char_measure (GdkFont *font, + gchar character) +{ + g_return_val_if_fail (font != NULL, -1); + + return gdk_text_measure (font, &character, 1); +} diff --git a/gdk/x11/gdkglobals-x11.c b/gdk/x11/gdkglobals-x11.c new file mode 100644 index 000000000..58f7bf844 --- /dev/null +++ b/gdk/x11/gdkglobals-x11.c @@ -0,0 +1,47 @@ +/* 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 <stdio.h> +#include <X11/Xlib.h> +#include "gdktypes.h" +#include "gdkprivate.h" + +gint gdk_debug_level = 0; +gint gdk_show_events = FALSE; +gint gdk_use_xshm = TRUE; +gchar *gdk_display_name = NULL; +Display *gdk_display = NULL; +gint gdk_screen; +Window gdk_root_window; +Window gdk_leader_window; +GdkWindowPrivate gdk_root_parent; +Atom gdk_wm_delete_window; +Atom gdk_wm_take_focus; +Atom gdk_wm_protocols; +Atom gdk_wm_window_protocols[2]; +Atom gdk_selection_property; +GdkDndGlobals gdk_dnd = {None,None,None, + None,None,None, + None, + None,None, + NULL, + 0, 0, + {0,0}}; +gchar *gdk_progname = NULL; +gchar *gdk_progclass = NULL; +gint gdk_error_code; +gint gdk_error_warnings = TRUE; diff --git a/gdk/x11/gdkimage-x11.c b/gdk/x11/gdkimage-x11.c new file mode 100644 index 000000000..bcda3119f --- /dev/null +++ b/gdk/x11/gdkimage-x11.c @@ -0,0 +1,492 @@ +/* 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" + +#include <sys/types.h> + +#if defined (HAVE_IPC_H) && defined (HAVE_SHM_H) && defined (HAVE_XSHM_H) +#define USE_SHM +#endif + +#ifdef USE_SHM +#include <sys/ipc.h> +#include <sys/shm.h> +#endif /* USE_SHM */ + +#include <X11/Xlib.h> +#include <X11/Xutil.h> + +#ifdef USE_SHM +#include <X11/extensions/XShm.h> +#endif /* USE_SHM */ + +#include "gdk.h" +#include "gdkprivate.h" + + +static void gdk_image_put_normal (GdkDrawable *drawable, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height); +static void gdk_image_put_shared (GdkDrawable *drawable, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height); + + +static GList *image_list = NULL; + + +void +gdk_image_exit () +{ + GdkImage *image; + + while (image_list) + { + image = image_list->data; + gdk_image_destroy (image); + } +} + +GdkImage * +gdk_image_new_bitmap(GdkVisual *visual, gpointer data, gint w, gint h) +/* + * Desc: create a new bitmap image + */ +{ + Visual *xvisual; + GdkImage *image; + GdkImagePrivate *private; + private = g_new(GdkImagePrivate, 1); + image = (GdkImage *) private; + private->xdisplay = gdk_display; + private->image_put = gdk_image_put_normal; + image->type = GDK_IMAGE_NORMAL; + image->visual = visual; + image->width = w; + image->height = h; + image->depth = 1; + xvisual = ((GdkVisualPrivate*) visual)->xvisual; + private->ximage = XCreateImage(private->xdisplay, xvisual, 1, XYBitmap, + 0, 0, w ,h, 8, 0); + private->ximage->data = data; + private->ximage->bitmap_bit_order = MSBFirst; + private->ximage->byte_order = MSBFirst; + image->byte_order = MSBFirst; + image->mem = private->ximage->data; + image->bpl = private->ximage->bytes_per_line; + image->bpp = 1; + return(image); +} /* gdk_image_new_bitmap() */ + +static int +gdk_image_check_xshm(Display *display) +/* + * Desc: query the server for support for the MIT_SHM extension + * Return: 0 = not available + * 1 = shared XImage support available + * 2 = shared Pixmap support available also + */ +{ +#ifdef USE_SHM + int major, minor, ignore; + Bool pixmaps; + + if (XQueryExtension(display, "MIT-SHM", &ignore, &ignore, &ignore)) + { + if (XShmQueryVersion(display, &major, &minor, &pixmaps )==True) + { + return (pixmaps==True) ? 2 : 1; + } + } +#endif /* USE_SHM */ + return 0; +} + +void +gdk_image_init () +{ + if (gdk_use_xshm) + { + if (!gdk_image_check_xshm (gdk_display)) + { + g_warning ("MIT-SHM Extension not availible on server"); + gdk_use_xshm = False; + } + } +} + +GdkImage* +gdk_image_new (GdkImageType type, + GdkVisual *visual, + gint width, + gint height) +{ + GdkImage *image; + GdkImagePrivate *private; +#ifdef USE_SHM + XShmSegmentInfo *x_shm_info; +#endif /* USE_SHM */ + Visual *xvisual; + + switch (type) + { + case GDK_IMAGE_FASTEST: + image = gdk_image_new (GDK_IMAGE_SHARED, visual, width, height); + + if (!image) + image = gdk_image_new (GDK_IMAGE_NORMAL, visual, width, height); + break; + + default: + private = g_new (GdkImagePrivate, 1); + image = (GdkImage*) private; + + private->xdisplay = gdk_display; + private->image_put = NULL; + + image->type = type; + image->visual = visual; + image->width = width; + image->height = height; + image->depth = visual->depth; + + xvisual = ((GdkVisualPrivate*) visual)->xvisual; + + switch (type) + { + case GDK_IMAGE_SHARED: +#ifdef USE_SHM + if (gdk_use_xshm) + { + private->image_put = gdk_image_put_shared; + + private->x_shm_info = g_new (XShmSegmentInfo, 1); + x_shm_info = private->x_shm_info; + + private->ximage = XShmCreateImage (private->xdisplay, xvisual, visual->depth, + ZPixmap, NULL, x_shm_info, width, height); + if (private->ximage == NULL) + { + g_warning ("XShmCreateImage failed"); + + g_free (image); + gdk_use_xshm = False; + return NULL; + } + + x_shm_info->shmid = shmget (IPC_PRIVATE, + private->ximage->bytes_per_line * private->ximage->height, + IPC_CREAT | 0777); + + if (x_shm_info->shmid == -1) + { + g_warning ("shmget failed!"); + + XDestroyImage (private->ximage); + g_free (private->x_shm_info); + g_free (image); + + gdk_use_xshm = False; + gdk_use_xshm = False; + return NULL; + } + + x_shm_info->readOnly = False; + x_shm_info->shmaddr = shmat (x_shm_info->shmid, 0, 0); + private->ximage->data = x_shm_info->shmaddr; + + if (x_shm_info->shmaddr == (char*) -1) + { + g_warning ("shmat failed!"); + + XDestroyImage (private->ximage); + shmctl (x_shm_info->shmid, IPC_RMID, 0); + + g_free (private->x_shm_info); + g_free (image); + + return NULL; + } + +#ifdef IPC_RMID_DEFERRED_RELEASE + if (x_shm_info->shmaddr != (char*) -1) + shmctl (x_shm_info->shmid, IPC_RMID, 0); +#endif + + gdk_error_code = 0; + gdk_error_warnings = 0; + + XShmAttach (private->xdisplay, x_shm_info); + XSync (private->xdisplay, False); + + gdk_error_warnings = 1; + if (gdk_error_code == -1) + { + g_warning ("XShmAttach failed!"); + + XDestroyImage (private->ximage); + shmdt (x_shm_info->shmaddr); + shmctl (x_shm_info->shmid, IPC_RMID, 0); + + g_free (private->x_shm_info); + g_free (image); + + gdk_use_xshm = False; + return NULL; + } + + if (image) + image_list = g_list_prepend (image_list, image); + } + else + { + g_free (image); + return NULL; + } + break; +#else /* USE_SHM */ + g_free (image); + return NULL; +#endif /* USE_SHM */ + case GDK_IMAGE_NORMAL: + private->image_put = gdk_image_put_normal; + + private->ximage = XCreateImage (private->xdisplay, xvisual, visual->depth, + ZPixmap, 0, 0, width, height, 32, 0); + + private->ximage->data = g_new (char, private->ximage->bytes_per_line * + private->ximage->height); + break; + + case GDK_IMAGE_FASTEST: + g_assert_not_reached (); + } + + if (image) + { + image->byte_order = private->ximage->byte_order; + image->mem = private->ximage->data; + image->bpl = private->ximage->bytes_per_line; + + switch (private->ximage->bits_per_pixel) + { + case 8: + image->bpp = 1; + break; + case 16: + image->bpp = 2; + break; + case 24: + image->bpp = 3; + break; + case 32: + image->bpp = 4; + break; + } + } + } + + return image; +} + +GdkImage* +gdk_image_get (GdkWindow *window, + gint x, + gint y, + gint width, + gint height) +{ + GdkImage *image; + GdkImagePrivate *private; + GdkWindowPrivate *win_private; + + g_return_val_if_fail (window != NULL, NULL); + + win_private = (GdkWindowPrivate *) window; + + private = g_new (GdkImagePrivate, 1); + image = (GdkImage*) private; + + private->xdisplay = gdk_display; + private->image_put = gdk_image_put_normal; + private->ximage = XGetImage (private->xdisplay, + win_private->xwindow, + x, y, width, height, + AllPlanes, ZPixmap); + + image->type = GDK_IMAGE_NORMAL; + image->visual = gdk_window_get_visual (window); + image->width = width; + image->height = height; + image->depth = private->ximage->depth; + + image->mem = private->ximage->data; + image->bpl = private->ximage->bytes_per_line; + image->bpp = 1; + + return image; +} + +guint32 +gdk_image_get_pixel (GdkImage *image, + gint x, + gint y) +{ + guint32 pixel; + GdkImagePrivate *private; + + g_return_val_if_fail (image != NULL, 0); + + private = (GdkImagePrivate *) image; + + pixel = XGetPixel (private->ximage, x, y); + + return pixel; +} + +void +gdk_image_put_pixel (GdkImage *image, + gint x, + gint y, + guint32 pixel) +{ + GdkImagePrivate *private; + + g_return_if_fail (image != NULL); + + private = (GdkImagePrivate *) image; + + pixel = XPutPixel (private->ximage, x, y, pixel); +} + +void +gdk_image_destroy (GdkImage *image) +{ + GdkImagePrivate *private; +#ifdef USE_SHM + XShmSegmentInfo *x_shm_info; +#endif /* USE_SHM */ + + g_return_if_fail (image != NULL); + + private = (GdkImagePrivate*) image; + switch (image->type) + { + case GDK_IMAGE_NORMAL: + XDestroyImage (private->ximage); + break; + + case GDK_IMAGE_SHARED: +#ifdef USE_SHM + XShmDetach (private->xdisplay, private->x_shm_info); + XDestroyImage (private->ximage); + + x_shm_info = private->x_shm_info; + shmdt (x_shm_info->shmaddr); + shmctl (x_shm_info->shmid, IPC_RMID, 0); + + g_free (private->x_shm_info); + + image_list = g_list_remove (image_list, image); +#else /* USE_SHM */ + g_error ("trying to destroy shared memory image when gdk was compiled without shared memory support"); +#endif /* USE_SHM */ + break; + + case GDK_IMAGE_FASTEST: + g_assert_not_reached (); + } + + g_free (image); +} + +static void +gdk_image_put_normal (GdkDrawable *drawable, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height) +{ + GdkWindowPrivate *drawable_private; + GdkImagePrivate *image_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (image != NULL); + g_return_if_fail (gc != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + image_private = (GdkImagePrivate*) image; + gc_private = (GdkGCPrivate*) gc; + + g_return_if_fail (image->type == GDK_IMAGE_NORMAL); + + XPutImage (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, image_private->ximage, + xsrc, ysrc, xdest, ydest, width, height); +} + +static void +gdk_image_put_shared (GdkDrawable *drawable, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height) +{ +#ifdef USE_SHM + GdkWindowPrivate *drawable_private; + GdkImagePrivate *image_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (drawable != NULL); + g_return_if_fail (image != NULL); + g_return_if_fail (gc != NULL); + + drawable_private = (GdkWindowPrivate*) drawable; + image_private = (GdkImagePrivate*) image; + gc_private = (GdkGCPrivate*) gc; + + g_return_if_fail (image->type == GDK_IMAGE_SHARED); + + XShmPutImage (drawable_private->xdisplay, drawable_private->xwindow, + gc_private->xgc, image_private->ximage, + xsrc, ysrc, xdest, ydest, width, height, False); +#else /* USE_SHM */ + g_error ("trying to draw shared memory image when gdk was compiled without shared memory support"); +#endif /* USE_SHM */ +} diff --git a/gdk/x11/gdkinput-gxi.c b/gdk/x11/gdkinput-gxi.c new file mode 100644 index 000000000..a30e05f95 --- /dev/null +++ b/gdk/x11/gdkinput-gxi.c @@ -0,0 +1,628 @@ +/* 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. + */ + +#ifdef XINPUT_GXI + +/* #define DEBUG_SWITCHING */ + +#include <gxid_lib.h> + +/* Forward declarations */ +static void gdk_input_gxi_select_notify (GdkDevicePrivate *gdkdev); +static gint gdk_input_gxi_set_mode (guint32 deviceid, GdkInputMode mode); +static gint gdk_input_is_extension_device (guint32 deviceid); +static void gdk_input_gxi_configure_event (XConfigureEvent *xevent, + GdkWindow *window); +static void gdk_input_gxi_enter_event (XCrossingEvent *xevent, + GdkWindow *window); +static gint gdk_input_gxi_other_event (GdkEvent *event, + XEvent *xevent, + GdkWindow *window); +static void gdk_input_gxi_update_device (GdkDevicePrivate *gdkdev); + +static gint gdk_input_gxi_window_none_event (GdkEvent *event, XEvent *xevent); +static gint gdk_input_gxi_enable_window (GdkWindow *window, + GdkDevicePrivate *gdkdev); +static gint gdk_input_gxi_disable_window (GdkWindow *window, + GdkDevicePrivate *gdkdev); +static Window gdk_input_find_root_child(Display *dpy, Window w); +static void gdk_input_compute_obscuring(GdkInputWindow *input_window); +static gint gdk_input_is_obscured(GdkInputWindow *input_window, gdouble x, + gdouble y); +static GdkTimeCoord *gdk_input_gxi_motion_events (GdkWindow *window, + guint32 deviceid, + guint32 start, + guint32 stop, + gint *nevents_return); +static void gdk_input_gxi_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask); +static gint gdk_input_gxi_grab_pointer (GdkWindow * window, + gint owner_events, + GdkEventMask event_mask, + GdkWindow * confine_to, + guint32 time); +static void gdk_input_gxi_ungrab_pointer (guint32 time); + +/* Local variables */ + +static GdkDevicePrivate *gdk_input_current_device; +static GdkDevicePrivate *gdk_input_core_pointer; + +void +gdk_input_init(void) +{ + GList *tmp_list; + + gdk_input_vtable.set_mode = gdk_input_gxi_set_mode; + gdk_input_vtable.set_axes = gdk_input_common_set_axes; + gdk_input_vtable.motion_events = gdk_input_gxi_motion_events; + gdk_input_vtable.get_pointer = gdk_input_gxi_get_pointer; + gdk_input_vtable.grab_pointer = gdk_input_gxi_grab_pointer; + gdk_input_vtable.ungrab_pointer = gdk_input_gxi_ungrab_pointer; + gdk_input_vtable.configure_event = gdk_input_gxi_configure_event; + gdk_input_vtable.enter_event = gdk_input_gxi_enter_event; + gdk_input_vtable.other_event = gdk_input_gxi_other_event; + gdk_input_vtable.window_none_event = gdk_input_gxi_window_none_event; + gdk_input_vtable.enable_window = gdk_input_gxi_enable_window; + gdk_input_vtable.disable_window = gdk_input_gxi_disable_window; + + gdk_input_ignore_core = FALSE; + gdk_input_core_pointer = NULL; + + if (!gdk_input_gxid_host) + { + gdk_input_gxid_host = getenv("GXID_HOST"); + } + if (!gdk_input_gxid_port) + { + char *t = getenv("GXID_PORT"); + if (t) + gdk_input_gxid_port = atoi(t); + } + + gdk_input_common_init(TRUE); + + /* find initial core pointer */ + + for (tmp_list = gdk_input_devices; tmp_list; tmp_list = tmp_list->next) + { + GdkDevicePrivate *gdkdev = (GdkDevicePrivate *)tmp_list->data; + if (gdk_input_is_extension_device(gdkdev->info.deviceid)) + { + gdk_input_gxi_select_notify (gdkdev); + } + else + { + if (gdkdev->info.deviceid != GDK_CORE_POINTER) + gdk_input_core_pointer = gdkdev; + } + } +} + +static void +gdk_input_gxi_select_notify (GdkDevicePrivate *gdkdev) +{ + XEventClass class; + + ChangeDeviceNotify (gdkdev->xdevice, gdkdev->changenotify_type, class); + + XSelectExtensionEvent (gdk_display, gdk_root_window, &class, 1); +} + +/* Set the core pointer. Device should already be enabled. */ +static gint +gdk_input_gxi_set_core_pointer(GdkDevicePrivate *gdkdev) +{ + int x_axis,y_axis; + + g_return_val_if_fail(gdkdev->xdevice,FALSE); + + x_axis = gdkdev->axis_for_use[GDK_AXIS_X]; + y_axis = gdkdev->axis_for_use[GDK_AXIS_Y]; + + g_return_val_if_fail(x_axis != -1 && y_axis != -1,FALSE); + + /* core_pointer might not be up to date so we check with the server + before change the pointer */ + + if ( !gdk_input_is_extension_device(gdkdev->info.deviceid) ) + { +#if 0 + if (gdkdev != gdk_input_core_pointer) + g_warning("core pointer inconsistency"); +#endif + return TRUE; + } + + if ( XChangePointerDevice(gdk_display,gdkdev->xdevice, x_axis, y_axis) + != Success ) + { + return FALSE; + } + else + { + gdk_input_gxi_update_device (gdk_input_core_pointer); + gdk_input_core_pointer = gdkdev; + return TRUE; + } +} + + +/* FIXME, merge with gdk_input_xfree_set_mode */ + +static gint +gdk_input_gxi_set_mode (guint32 deviceid, GdkInputMode mode) +{ + GList *tmp_list; + GdkDevicePrivate *gdkdev; + GdkInputMode old_mode; + GdkInputWindow *input_window; + + gdkdev = gdk_input_find_device(deviceid); + g_return_val_if_fail (gdkdev != NULL,FALSE); + old_mode = gdkdev->info.mode; + + if (gdkdev->info.mode == mode) + return TRUE; + + gdkdev->info.mode = mode; + + if (old_mode != GDK_MODE_DISABLED) + { + for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->mode != GDK_EXTENSION_EVENTS_CURSOR) + gdk_input_disable_window (input_window->window, gdkdev); + } + } + + if (mode != GDK_MODE_DISABLED) + { + for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->mode != GDK_EXTENSION_EVENTS_CURSOR) + if (!gdk_input_enable_window(input_window->window, gdkdev)) + { + gdk_input_set_mode(deviceid, old_mode); + return FALSE; + } + } + } + + return TRUE; + +} + +gint +gdk_input_is_extension_device (guint32 deviceid) +{ + XDeviceInfo *devices; + int num_devices, loop; + + if (deviceid == GDK_CORE_POINTER) + return FALSE; + + devices = XListInputDevices(gdk_display, &num_devices); + for(loop=0; loop<num_devices; loop++) + { + if ((devices[loop].id == deviceid) && (devices[loop].use == IsXExtensionDevice)) + { + XFreeDeviceList(devices); + return TRUE; + } + } + + XFreeDeviceList(devices); + return FALSE; +} + +static void +gdk_input_gxi_configure_event (XConfigureEvent *xevent, GdkWindow *window) +{ + GdkInputWindow *input_window; + gint root_x, root_y; + + input_window = gdk_input_window_find(window); + g_return_if_fail (input_window != NULL); + + gdk_input_get_root_relative_geometry(gdk_display,GDK_WINDOW_XWINDOW(window), + &root_x, &root_y, NULL, NULL); + input_window->root_x = root_x; + input_window->root_y = root_y; + gdk_input_compute_obscuring(input_window); +} + +static void +gdk_input_gxi_enter_event (XCrossingEvent *xevent, GdkWindow *window) +{ + GdkInputWindow *input_window; + + input_window = gdk_input_window_find(window); + g_return_if_fail (input_window != NULL); + + gdk_input_compute_obscuring(input_window); +} + +static gint +gdk_input_gxi_other_event (GdkEvent *event, + XEvent *xevent, + GdkWindow *window) +{ + GdkInputWindow *input_window; + + GdkDevicePrivate *gdkdev; + gint return_val; + + input_window = gdk_input_window_find(window); + g_return_val_if_fail (window != NULL, -1); + + /* This is a sort of a hack, as there isn't any XDeviceAnyEvent - + but it's potentially faster than scanning through the types of + every device. If we were deceived, then it won't match any of + the types for the device anyways */ + gdkdev = gdk_input_find_device(((XDeviceButtonEvent *)xevent)->deviceid); + + if (!gdkdev) { + return -1; /* we don't handle it - not an XInput event */ + } + + if (gdkdev->info.mode == GDK_MODE_DISABLED || + input_window->mode == GDK_EXTENSION_EVENTS_CURSOR) + return FALSE; + + if (gdkdev != gdk_input_current_device && + xevent->type != gdkdev->changenotify_type) + { + gdk_input_current_device = gdkdev; + } + + return_val = gdk_input_common_other_event (event, xevent, + input_window, gdkdev); + + if (return_val > 0 && event->type == GDK_MOTION_NOTIFY && + (!gdkdev->button_state) && (!input_window->grabbed) && + ((event->motion.x < 0) || (event->motion.y < 0) || + (event->motion.x > ((GdkWindowPrivate *)window)->width) || + (event->motion.y > ((GdkWindowPrivate *)window)->height) || + gdk_input_is_obscured(input_window,event->motion.x,event->motion.y))) + { +#ifdef DEBUG_SWITCHING + g_print("gdkinput: Setting core pointer to %d on motion at (%f,%f)\n", + gdkdev->info.deviceid,event->motion.x,event->motion.y); + g_print(" window geometry is: %dx%d\n", + ((GdkWindowPrivate *)window)->width, + ((GdkWindowPrivate *)window)->height); +#endif + gdk_input_gxi_set_core_pointer(gdkdev); + return FALSE; + } + else + return return_val; + +} + +static void +gdk_input_gxi_update_device (GdkDevicePrivate *gdkdev) +{ + GList *t; + + if (gdk_input_is_extension_device (gdkdev->info.deviceid)) + { + if (!gdkdev->xdevice) + { + gdkdev->xdevice = XOpenDevice(gdk_display, gdkdev->info.deviceid); + gdk_input_gxi_select_notify (gdkdev); + gdkdev->needs_update = 1; + } + if (gdkdev->needs_update && gdkdev->xdevice) + { + for (t = gdk_input_windows; t; t = t->next) + gdk_input_common_select_events (((GdkInputWindow *)t->data)->window, + gdkdev); + gdkdev->needs_update = 0; + } + } +} + +static gint +gdk_input_gxi_window_none_event (GdkEvent *event, XEvent *xevent) +{ + GdkDevicePrivate *gdkdev = + gdk_input_find_device(((XDeviceButtonEvent *)xevent)->deviceid); + + if (!gdkdev) { + return -1; /* we don't handle it - not an XInput event */ + } + + if (xevent->type == gdkdev->changenotify_type) + { + if (gdk_input_core_pointer != gdkdev) + { +#ifdef DEBUG_SWITCHING + g_print("ChangeNotify from %d to %d:\n", + gdk_input_core_pointer->info.deviceid, + gdkdev->info.deviceid); +#endif + gdk_input_gxi_update_device (gdk_input_core_pointer); + gdk_input_core_pointer = gdkdev; + } + } + + return FALSE; +} + +static gint +gdk_input_gxi_enable_window (GdkWindow *window, GdkDevicePrivate *gdkdev) +{ + GdkInputWindow *input_window; + + input_window = gdk_input_window_find (window); + g_return_val_if_fail (input_window != NULL, FALSE); + + if (!gdkdev->claimed) + { + if (gxid_claim_device(gdk_input_gxid_host, gdk_input_gxid_port, + gdkdev->info.deviceid, + GDK_WINDOW_XWINDOW(window), FALSE) != + GXID_RETURN_OK) + { + g_warning("Could not get device (is gxid running?)\n"); + return FALSE; + } + gdkdev->claimed = TRUE; + } + + if (gdkdev->xdevice && gdkdev != gdk_input_core_pointer) + gdk_input_common_select_events(window, gdkdev); + else + gdkdev->needs_update = TRUE; + + return TRUE; +} + +static gint +gdk_input_gxi_disable_window(GdkWindow *window, GdkDevicePrivate *gdkdev) +{ + GdkInputWindow *input_window; + + input_window = gdk_input_window_find (window); + g_return_val_if_fail (input_window != NULL, FALSE); + + if (gdkdev->claimed) + { + gxid_release_device(gdk_input_gxid_host, gdk_input_gxid_port, + gdkdev->info.deviceid, + GDK_WINDOW_XWINDOW(window)); + + gdkdev->claimed = FALSE; + } + + if (gdkdev->xdevice && gdkdev != gdk_input_core_pointer) + gdk_input_common_select_events(window, gdkdev); + else + gdkdev->needs_update = TRUE; + + return TRUE; +} + +static gint +gdk_input_is_obscured(GdkInputWindow *input_window, gdouble x, gdouble y) +{ + int i; + for (i=0;i<input_window->num_obscuring;i++) + { + GdkRectangle *rect = &input_window->obscuring[i]; + if ((x >= rect->x) && + (y >= rect->y) && + (x < rect->x + rect->width) && + (y < rect->y + rect->height)) + return TRUE; + } + return FALSE; +} + +/* If this routine needs fixing, the corresponding routine + in gxid.c will need it too. */ + +static Window +gdk_input_find_root_child(Display *dpy, Window w) +{ + Window root,parent; + Window *children; + int nchildren; + + parent = w; + do + { + w = parent; + XQueryTree(dpy,w,&root,&parent,&children,&nchildren); + if (children) XFree(children); + } + while (parent != root); + + return w; +} + +void +gdk_input_compute_obscuring(GdkInputWindow *input_window) +{ + int i; + int x,y,width,height; + int xc,yc,widthc,heightc,border_widthc,depthc; + + Window root,parent; + Window *children; + int nchildren; + + Window w = GDK_WINDOW_XWINDOW(input_window->window); + Window root_child = gdk_input_find_root_child(gdk_display,w); + gdk_input_get_root_relative_geometry(gdk_display,w,&x,&y,&width,&height); + + input_window->root_x = x; + input_window->root_y = y; + + XQueryTree(gdk_display,GDK_ROOT_WINDOW(), + &root,&parent,&children,&nchildren); + + + if (input_window->obscuring) + g_free(input_window->obscuring); + input_window->obscuring = 0; + input_window->num_obscuring = 0; + + for (i=0;i<nchildren;i++) + if (children[i] == root_child) + break; + + if (i>=nchildren-1) + { + if (nchildren) + XFree(children); + return; + } + + input_window->obscuring = g_new(GdkRectangle,(nchildren-i-1)); + + for (i=i+1;i<nchildren;i++) + { + int xmin, xmax, ymin, ymax; + XGetGeometry(gdk_display,children[i],&root,&xc,&yc,&widthc,&heightc, + &border_widthc, &depthc); + xmin = xc>x ? xc : x; + xmax = (xc+widthc)<(x+width) ? xc+widthc : x+width; + ymin = yc>y ? yc : y; + ymax = (yc+heightc)<(y+height) ? yc+heightc : y+height; + if ((xmin < xmax) && (ymin < ymax)) + { + XWindowAttributes attributes; + XGetWindowAttributes(gdk_display,children[i],&attributes); + if (attributes.map_state == IsViewable) + { + GdkRectangle *rect = &input_window->obscuring[input_window->num_obscuring]; + + /* we store the whole window, not just the obscuring part */ + rect->x = xc - x; + rect->y = yc - y; + rect->width = widthc; + rect->height = heightc; + input_window->num_obscuring++; + } + } + } + + if (nchildren) + XFree(children); +} + +static void +gdk_input_gxi_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask) +{ + GdkDevicePrivate *gdkdev; + + gdkdev = gdk_input_find_device (deviceid); + g_return_if_fail (gdkdev != NULL); + + if (gdkdev == gdk_input_core_pointer) + gdk_input_common_get_pointer (window, GDK_CORE_POINTER, x, y, + pressure, xtilt, ytilt, mask); + else + gdk_input_common_get_pointer (window, deviceid, x, y, + pressure, xtilt, ytilt, mask); +} + +static GdkTimeCoord * +gdk_input_gxi_motion_events (GdkWindow *window, + guint32 deviceid, + guint32 start, + guint32 stop, + gint *nevents_return) +{ + GdkDevicePrivate *gdkdev; + + gdkdev = gdk_input_find_device (deviceid); + g_return_val_if_fail (gdkdev != NULL, NULL); + + + if (gdkdev == gdk_input_core_pointer) + return gdk_input_motion_events (window, GDK_CORE_POINTER, start, stop, + nevents_return); + else + return gdk_input_common_motion_events (window, deviceid, start, stop, + nevents_return); + +} + +static gint +gdk_input_gxi_grab_pointer (GdkWindow * window, + gint owner_events, + GdkEventMask event_mask, + GdkWindow * confine_to, + guint32 time) +{ + GdkInputWindow *input_window, *new_window; + GList *tmp_list; + + tmp_list = gdk_input_windows; + while (tmp_list) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->grabbed) + return AlreadyGrabbed; + + if (input_window->window == window) + new_window = input_window; + + tmp_list = tmp_list->next; + } + + new_window->grabbed = TRUE; + return Success; +} + +static void +gdk_input_gxi_ungrab_pointer (guint32 time) +{ + GdkInputWindow *input_window; + GList *tmp_list; + + tmp_list = gdk_input_windows; + while (tmp_list) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->grabbed) + input_window->grabbed = FALSE; + tmp_list = tmp_list->next; + } +} + +#endif /* XINPUT_GXI */ diff --git a/gdk/x11/gdkinput-none.c b/gdk/x11/gdkinput-none.c new file mode 100644 index 000000000..8ae8c4189 --- /dev/null +++ b/gdk/x11/gdkinput-none.c @@ -0,0 +1,72 @@ +/* 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. + */ + +#ifdef XINPUT_NONE + +static void gdk_input_none_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask); + +void +gdk_input_init () +{ + gdk_input_vtable.set_mode = NULL; + gdk_input_vtable.set_axes = NULL; + gdk_input_vtable.motion_events = NULL; + gdk_input_vtable.get_pointer = gdk_input_none_get_pointer; + gdk_input_vtable.grab_pointer = NULL; + gdk_input_vtable.ungrab_pointer = NULL; + gdk_input_vtable.configure_event = NULL; + gdk_input_vtable.enter_event = NULL; + gdk_input_vtable.other_event = NULL; + gdk_input_vtable.window_none_event = NULL; + gdk_input_vtable.enable_window = NULL; + gdk_input_vtable.disable_window = NULL; + + gdk_input_devices = g_list_append (NULL, &gdk_input_core_info); + + gdk_input_ignore_core = FALSE; +} + +static void +gdk_input_none_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask) +{ + gint x_int, y_int; + + gdk_window_get_pointer (window, &x_int, &y_int, mask); + + if (x) *x = x_int; + if (y) *y = y_int; + if (pressure) *pressure = 0.5; + if (xtilt) *xtilt = 0; + if (ytilt) *ytilt = 0; +} + +#endif /* XINPUT_NONE */ diff --git a/gdk/x11/gdkinput-x11.c b/gdk/x11/gdkinput-x11.c new file mode 100644 index 000000000..5e457e0aa --- /dev/null +++ b/gdk/x11/gdkinput-x11.c @@ -0,0 +1,687 @@ +/* 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. + */ + +#if defined(XINPUT_GXI) || defined(XINPUT_XFREE) + +/* Forward declarations */ +static void gdk_input_get_root_relative_geometry (Display *dpy, Window w, + int *x_ret, int *y_ret, + int *width_ret, + int *height_ret); +static GdkDevicePrivate *gdk_input_device_new(XDeviceInfo *device, + gint include_core); +static void gdk_input_common_find_events(GdkWindow *window, + GdkDevicePrivate *gdkdev, + gint mask, + XEventClass *classes, + int *num_classes); +static void gdk_input_common_select_events(GdkWindow *window, + GdkDevicePrivate *gdkdev); +static void gdk_input_translate_coordinates(GdkDevicePrivate *gdkdev, + GdkInputWindow *input_window, + gint *axis_data, + gdouble *x, gdouble *y, + gdouble *pressure, + gdouble *xtilt, gdouble *ytilt); +static guint gdk_input_translate_state(guint state, guint device_state); +static gint gdk_input_common_init(gint include_core); +static gint gdk_input_common_other_event (GdkEvent *event, + XEvent *xevent, + GdkInputWindow *input_window, + GdkDevicePrivate *gdkdev); +static void gdk_input_common_set_axes (guint32 deviceid, GdkAxisUse *axes); +static GdkTimeCoord * gdk_input_common_motion_events (GdkWindow *window, + guint32 deviceid, + guint32 start, + guint32 stop, + gint *nevents_return); +static void gdk_input_common_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask); + +/* Global variables */ + +static gint gdk_input_root_width; +static gint gdk_input_root_height; + +static void +gdk_input_get_root_relative_geometry(Display *dpy, Window w, int *x_ret, int *y_ret, + int *width_ret, int *height_ret) +{ + Window root,parent; + Window *children; + int nchildren; + int x,y,width,height; + int xc,yc,widthc,heightc,border_widthc,depthc; + + XQueryTree(dpy,w,&root,&parent,&children,&nchildren); + if (children) XFree(children); + XGetGeometry(dpy,w,&root,&x,&y,&width,&height,&border_widthc, + &depthc); + x += border_widthc; + y += border_widthc; + + while (root != parent) + { + w = parent; + XQueryTree(dpy,w,&root,&parent,&children,&nchildren); + if (children) XFree(children); + XGetGeometry(dpy,w,&root,&xc,&yc,&widthc,&heightc, + &border_widthc,&depthc); + x += xc + border_widthc; + y += yc + border_widthc; + } + + if (x_ret) + *x_ret = x; + if (y_ret) + *y_ret = y; + if (width_ret) + *width_ret = width; + if (height_ret) + *height_ret = height; +} + +static GdkDevicePrivate * +gdk_input_device_new(XDeviceInfo *device, gint include_core) +{ + GdkDevicePrivate *gdkdev; + gchar *tmp_name, *p; + XAnyClassPtr class; + gint i,j; + + gdkdev = g_new(GdkDevicePrivate,1); + + gdkdev->info.deviceid = device->id; + if (device->name[0]) { + gdkdev->info.name = g_new(char, strlen(device->name)+1); + strcpy(gdkdev->info.name,device->name); + } else { + /* XFree86 3.2 gives an empty name to the default core devices, + (fixed in 3.2A) */ + gdkdev->info.name = g_strdup("pointer"); + strcpy(gdkdev->info.name,"pointer"); + gdkdev->info.source = GDK_SOURCE_MOUSE; + } + + gdkdev->info.mode = GDK_MODE_DISABLED; + + /* Try to figure out what kind of device this is by its name - + could invite a very, very, long list... Lowercase name + for comparison purposes */ + + tmp_name = g_strdup(gdkdev->info.name); + for (p = tmp_name; *p; p++) + { + if (*p >= 'A' && *p <= 'Z') + *p += 'a' - 'A'; + } + + if (!strcmp (tmp_name, "pointer")) + gdkdev->info.source = GDK_SOURCE_MOUSE; + else if (!strcmp (tmp_name, "wacom") || + !strcmp (tmp_name, "pen")) + gdkdev->info.source = GDK_SOURCE_PEN; + else if (!strcmp (tmp_name, "eraser")) + gdkdev->info.source = GDK_SOURCE_ERASER; + else if (!strcmp (tmp_name, "cursor")) + gdkdev->info.source = GDK_SOURCE_CURSOR; + else + gdkdev->info.source = GDK_SOURCE_PEN; + + g_free(tmp_name); + + gdkdev->xdevice = NULL; + + /* step through the classes */ + + gdkdev->info.num_axes = 0; + gdkdev->axes = 0; + gdkdev->info.has_cursor = 0; + gdkdev->needs_update = FALSE; + gdkdev->claimed = FALSE; + gdkdev->button_state = 0; + + class = device->inputclassinfo; + for (i=0;i<device->num_classes;i++) + { + switch (class->class) { + case ButtonClass: + { + break; + } + case ValuatorClass: + { + XValuatorInfo *xvi = (XValuatorInfo *)class; + gdkdev->info.num_axes = xvi->num_axes; + gdkdev->axes = g_new(GdkAxisInfo, xvi->num_axes); + gdkdev->info.axes = g_new(GdkAxisUse, xvi->num_axes); + for (j=0;j<xvi->num_axes;j++) + { + gdkdev->axes[j].resolution = + gdkdev->axes[j].xresolution = xvi->axes[j].resolution; + gdkdev->axes[j].min_value = + gdkdev->axes[j].xmin_value = xvi->axes[j].min_value; + gdkdev->axes[j].max_value = + gdkdev->axes[j].xmax_value = xvi->axes[j].max_value; + gdkdev->info.axes[j] = GDK_AXIS_IGNORE; + } + j=0; + if (j<xvi->num_axes) + gdkdev->info.axes[j++] = GDK_AXIS_X; + if (j<xvi->num_axes) + gdkdev->info.axes[j++] = GDK_AXIS_Y; + if (j<xvi->num_axes) + gdkdev->info.axes[j++] = GDK_AXIS_PRESSURE; + if (j<xvi->num_axes) + gdkdev->info.axes[j++] = GDK_AXIS_XTILT; + if (j<xvi->num_axes) + gdkdev->info.axes[j++] = GDK_AXIS_YTILT; + + /* set up reverse lookup on axis use */ + for (j=GDK_AXIS_IGNORE;j<GDK_AXIS_LAST;j++) + gdkdev->axis_for_use[j] = -1; + + for (j=0;j<xvi->num_axes;j++) + if (gdkdev->info.axes[j] != GDK_AXIS_IGNORE) + gdkdev->axis_for_use[gdkdev->info.axes[j]] = j; + + break; + } + } + class = (XAnyClassPtr)(((char *)class) + class->length); + } + /* return NULL if no axes */ + if (!gdkdev->info.num_axes || !gdkdev->axes || + (!include_core && device->use == IsXPointer)) + { + g_free(gdkdev->info.name); + if (gdkdev->axes) + g_free(gdkdev->axes); + g_free(gdkdev); + return NULL; + } + + if (device->use != IsXPointer) + gdkdev->xdevice = XOpenDevice(gdk_display, gdkdev->info.deviceid); + + return gdkdev; +} + +static void +gdk_input_common_find_events(GdkWindow *window, + GdkDevicePrivate *gdkdev, + gint mask, + XEventClass *classes, + int *num_classes) +{ + gint i; + XEventClass class; + + i = 0; + /* We have to track press and release events in pairs to keep + track of button state correctly and implement grabbing */ + if (mask & GDK_BUTTON_PRESS_MASK || mask & GDK_BUTTON_RELEASE_MASK) + { + DeviceButtonPress (gdkdev->xdevice, gdkdev->buttonpress_type, + class); + if (class != 0) + classes[i++] = class; + DeviceButtonRelease (gdkdev->xdevice, gdkdev->buttonrelease_type, + class); + if (class != 0) + classes[i++] = class; + } + if (mask & GDK_POINTER_MOTION_MASK) + { + DeviceMotionNotify (gdkdev->xdevice, gdkdev->motionnotify_type, class); + if (class != 0) + classes[i++] = class; + } + if (mask & GDK_POINTER_MOTION_HINT_MASK) + { + /* We'll get into trouble if the macros change, but at least we'll + know about it, and we avoid warnings now */ + DevicePointerMotionHint (gdkdev->xdevice, 0, class); + if (class != 0) + classes[i++] = class; + } + if (mask & GDK_PROXIMITY_IN_MASK) + { + ProximityIn (gdkdev->xdevice, gdkdev->proximityin_type, class); + if (class != 0) + classes[i++] = class; + } + if (mask & GDK_PROXIMITY_OUT_MASK) + { + ProximityOut (gdkdev->xdevice, gdkdev->proximityout_type, class); + if (class != 0) + classes[i++] = class; + } + + *num_classes = i; +} + +static void +gdk_input_common_select_events(GdkWindow *window, + GdkDevicePrivate *gdkdev) +{ + XEventClass classes[6]; + gint num_classes; + + if (gdkdev->info.mode == GDK_MODE_DISABLED) + gdk_input_common_find_events(window, gdkdev, 0, classes, &num_classes); + else + gdk_input_common_find_events(window, gdkdev, + ((GdkWindowPrivate *)window)->extension_events, + classes, &num_classes); + + XSelectExtensionEvent (gdk_display, + GDK_WINDOW_XWINDOW(window), + classes, num_classes); +} + +gint +gdk_input_common_init(gint include_core) +{ + char **extensions; + XDeviceInfo *devices; + int num_devices; + int num_extensions, loop; + Display *display = gdk_display; + + /* Init global vars */ + gdk_window_get_geometry(NULL, /* use root window */ + NULL,NULL, + &gdk_input_root_width,&gdk_input_root_height, + NULL); + + /* Init XInput extension */ + + extensions = XListExtensions(display, &num_extensions); + for (loop = 0; loop < num_extensions && + (strcmp(extensions[loop], "XInputExtension") != 0); loop++); + XFreeExtensionList(extensions); + if (loop == num_extensions) /* XInput extension not found */ + return FALSE; + + gdk_input_devices = 0; + devices = XListInputDevices(display, &num_devices); + + for(loop=0; loop<num_devices; loop++) + { + GdkDevicePrivate *gdkdev = gdk_input_device_new(&devices[loop], + include_core); + if (gdkdev) + gdk_input_devices = g_list_append(gdk_input_devices, gdkdev); + } + XFreeDeviceList(devices); + + gdk_input_devices = g_list_append (gdk_input_devices, &gdk_input_core_info); + + return TRUE; +} + +static void +gdk_input_translate_coordinates (GdkDevicePrivate *gdkdev, + GdkInputWindow *input_window, + gint *axis_data, + gdouble *x, gdouble *y, gdouble *pressure, + gdouble *xtilt, gdouble *ytilt) +{ + GdkWindowPrivate *win_priv; + + int x_axis, y_axis, pressure_axis, xtilt_axis, ytilt_axis; + + double device_width, device_height; + double x_offset, y_offset, x_scale, y_scale; + + win_priv = (GdkWindowPrivate *) input_window->window; + + x_axis = gdkdev->axis_for_use[GDK_AXIS_X]; + y_axis = gdkdev->axis_for_use[GDK_AXIS_Y]; + pressure_axis = gdkdev->axis_for_use[GDK_AXIS_PRESSURE]; + xtilt_axis = gdkdev->axis_for_use[GDK_AXIS_XTILT]; + ytilt_axis = gdkdev->axis_for_use[GDK_AXIS_YTILT]; + + device_width = gdkdev->axes[x_axis].max_value - + gdkdev->axes[x_axis].min_value; + device_height = gdkdev->axes[y_axis].max_value - + gdkdev->axes[y_axis].min_value; + + if (gdkdev->info.mode == GDK_MODE_SCREEN) + { + x_scale = gdk_input_root_width / device_width; + y_scale = gdk_input_root_height / device_height; + + x_offset = - input_window->root_x; + y_offset = - input_window->root_y; + } + else /* GDK_MODE_WINDOW */ + { + double device_aspect = (device_height*gdkdev->axes[y_axis].resolution) / + (device_width*gdkdev->axes[x_axis].resolution); + + if (device_aspect * win_priv->width >= win_priv->height) + { + /* device taller than window */ + x_scale = win_priv->width / device_width; + y_scale = (x_scale * gdkdev->axes[x_axis].resolution) + / gdkdev->axes[y_axis].resolution; + + x_offset = 0; + y_offset = -(device_height * y_scale - + win_priv->height)/2; + } + else + { + /* window taller than device */ + y_scale = win_priv->height / device_height; + x_scale = (y_scale * gdkdev->axes[y_axis].resolution) + / gdkdev->axes[x_axis].resolution; + + y_offset = 0; + x_offset = - (device_width * x_scale - win_priv->width)/2; + } + } + + if (x) *x = x_offset + x_scale*axis_data[x_axis]; + if (y) *y = y_offset + y_scale*axis_data[y_axis]; + + if (pressure) + { + if (pressure_axis != -1) + *pressure = ((double)axis_data[pressure_axis] + - gdkdev->axes[pressure_axis].min_value) + / (gdkdev->axes[pressure_axis].max_value + - gdkdev->axes[pressure_axis].min_value); + else + *pressure = 0.5; + } + + if (xtilt) + { + if (xtilt_axis != -1) + { + *xtilt = 2. * (double)(axis_data[xtilt_axis] - + (gdkdev->axes[xtilt_axis].min_value + + gdkdev->axes[xtilt_axis].max_value)/2) / + (gdkdev->axes[xtilt_axis].max_value - + gdkdev->axes[xtilt_axis].min_value); + } + else *xtilt = 0; + } + + if (ytilt) + { + if (ytilt_axis != -1) + { + *ytilt = 2. * (double)(axis_data[ytilt_axis] - + (gdkdev->axes[ytilt_axis].min_value + + gdkdev->axes[ytilt_axis].max_value)/2) / + (gdkdev->axes[ytilt_axis].max_value - + gdkdev->axes[ytilt_axis].min_value); + } + else + *ytilt = 0; + } +} + +/* combine the state of the core device and the device state + into one - for now we do this in a simple-minded manner - + we just take the keyboard portion of the core device and + the button portion (all of?) the device state. + Any button remapping should go on here. */ +static guint +gdk_input_translate_state(guint state, guint device_state) +{ + return device_state | (state & 0xFF); +} + +static gint +gdk_input_common_other_event (GdkEvent *event, + XEvent *xevent, + GdkInputWindow *input_window, + GdkDevicePrivate *gdkdev) +{ + if ((xevent->type == gdkdev->buttonpress_type) || + (xevent->type == gdkdev->buttonrelease_type)) + { + XDeviceButtonEvent *xdbe = (XDeviceButtonEvent *)(xevent); + + if (xdbe->type == gdkdev->buttonpress_type) + { + event->button.type = GDK_BUTTON_PRESS; + gdkdev->button_state |= 1 << xdbe->button; + } + else + { + event->button.type = GDK_BUTTON_RELEASE; + gdkdev->button_state &= ~(1 << xdbe->button); + } + event->button.window = input_window->window; + event->button.time = xdbe->time; + event->button.source = gdkdev->info.source; + event->button.deviceid = xdbe->deviceid; + + gdk_input_translate_coordinates (gdkdev,input_window, xdbe->axis_data, + &event->button.x,&event->button.y, + &event->button.pressure, + &event->button.xtilt, + &event->button.ytilt); + event->button.state = gdk_input_translate_state(xdbe->state,xdbe->device_state); + event->button.button = xdbe->button; + + return TRUE; + } + + if (xevent->type == gdkdev->motionnotify_type) + { + XDeviceMotionEvent *xdme = (XDeviceMotionEvent *)(xevent); + + gdk_input_translate_coordinates(gdkdev,input_window,xdme->axis_data, + &event->motion.x,&event->motion.y, + &event->motion.pressure, + &event->motion.xtilt, + &event->motion.ytilt); + + event->motion.type = GDK_MOTION_NOTIFY; + event->motion.window = input_window->window; + event->motion.time = xdme->time; + event->motion.deviceid = xdme->deviceid; + event->motion.state = gdk_input_translate_state(xdme->state, + xdme->device_state); + event->motion.source = gdkdev->info.source; + event->motion.deviceid = xdme->deviceid; + + if (gdk_show_events) + g_print ("motion notify:\t\twindow: %ld device: %ld x,y: %f %f hint: %s\n", + xdme->window, + xdme->deviceid, + event->motion.x, event->motion.y, + (xevent->xmotion.is_hint) ? "true" : "false"); + + + return TRUE; + } + + if (xevent->type == gdkdev->proximityin_type || + xevent->type == gdkdev->proximityout_type) + { + XProximityNotifyEvent *xpne = (XProximityNotifyEvent *)(xevent); + + event->proximity.type = (xevent->type == gdkdev->proximityin_type)? + GDK_PROXIMITY_IN:GDK_PROXIMITY_OUT; + event->proximity.window = input_window->window; + event->proximity.time = xpne->time; + event->proximity.source = gdkdev->info.source; + event->proximity.deviceid = xpne->deviceid; + + return TRUE; + } + + return -1; /* wasn't one of our event types */ +} + +static void +gdk_input_common_set_axes (guint32 deviceid, GdkAxisUse *axes) +{ + int i; + GdkDevicePrivate *gdkdev = gdk_input_find_device(deviceid); + g_return_if_fail (gdkdev != NULL); + + for (i=GDK_AXIS_IGNORE;i<GDK_AXIS_LAST;i++) + { + gdkdev->axis_for_use[i] = -1; + } + + for (i=0;i<gdkdev->info.num_axes;i++) + { + gdkdev->info.axes[i] = axes[i]; + gdkdev->axis_for_use[axes[i]] = i; + } +} + +static GdkTimeCoord * +gdk_input_common_motion_events (GdkWindow *window, + guint32 deviceid, + guint32 start, + guint32 stop, + gint *nevents_return) +{ + GdkTimeCoord *coords; + XDeviceTimeCoord *device_coords; + GdkInputWindow *input_window; + GdkDevicePrivate *gdkdev; + + int mode_return; + int axis_count_return; + int i; + + gdkdev = gdk_input_find_device (deviceid); + input_window = gdk_input_window_find (window); + + g_return_val_if_fail (gdkdev != NULL, NULL); + g_return_val_if_fail (gdkdev->xdevice != NULL, NULL); + g_return_val_if_fail (input_window != NULL, NULL); + + device_coords = XGetDeviceMotionEvents (gdk_display, + gdkdev->xdevice, + start, stop, + nevents_return, &mode_return, + &axis_count_return); + + if (device_coords) + { + coords = g_new (GdkTimeCoord, *nevents_return); + + for (i=0; i<*nevents_return; i++) + { + gdk_input_translate_coordinates (gdkdev, input_window, + device_coords[i].data, + &coords[i].x, &coords[i].y, + &coords[i].pressure, + &coords[i].xtilt, &coords[i].ytilt); + } + XFreeDeviceMotionEvents (device_coords); + + return coords; + } + else + return NULL; +} + +static void +gdk_input_common_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask) +{ + GdkDevicePrivate *gdkdev; + GdkInputWindow *input_window; + XDeviceState *state; + XInputClass *input_class; + gint x_int, y_int; + gint i; + + /* we probably need to get the mask in any case */ + + if (deviceid == GDK_CORE_POINTER) + { + gdk_window_get_pointer (window, &x_int, &y_int, mask); + if (x) *x = x_int; + if (y) *y = y_int; + if (pressure) *pressure = 0.5; + if (xtilt) *xtilt = 0; + if (ytilt) *ytilt = 0; + } + else + { + if (mask) + gdk_window_get_pointer (window, NULL, NULL, mask); + + gdkdev = gdk_input_find_device (deviceid); + input_window = gdk_input_window_find (window); + + g_return_if_fail (gdkdev != NULL); + g_return_if_fail (gdkdev->xdevice != NULL); + g_return_if_fail (input_window != NULL); + + state = XQueryDeviceState (gdk_display, gdkdev->xdevice); + input_class = state->data; + for (i=0; i<state->num_classes; i++) + { + switch (input_class->class) + { + case ValuatorClass: + gdk_input_translate_coordinates(gdkdev, input_window, + ((XValuatorState *)input_class)->valuators, + x, y, pressure, + xtilt, ytilt); + + + break; + case ButtonClass: + if (mask) + { + *mask &= ~(GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | + GDK_BUTTON3_MASK | GDK_BUTTON4_MASK | + GDK_BUTTON5_MASK); + for (i=0; i < ((XButtonState *)input_class)->num_buttons; i++) + { + if (((XButtonState *)input_class)->buttons[i]) + *mask |= GDK_BUTTON1_MASK << i; + } + } + break; + } + input_class = (XInputClass *)(((char *)input_class)+input_class->length); + } + } +} + +#endif diff --git a/gdk/x11/gdkinput-xfree.c b/gdk/x11/gdkinput-xfree.c new file mode 100644 index 000000000..f74249008 --- /dev/null +++ b/gdk/x11/gdkinput-xfree.c @@ -0,0 +1,368 @@ +/* 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. + */ + +#ifdef XINPUT_XFREE + +/* forward declarations */ + +static gint gdk_input_xfree_set_mode (guint32 deviceid, GdkInputMode mode); +static void gdk_input_check_proximity(); +static void gdk_input_xfree_configure_event (XConfigureEvent *xevent, + GdkWindow *window); +static void gdk_input_xfree_enter_event (XCrossingEvent *xevent, + GdkWindow *window); +static gint gdk_input_xfree_other_event (GdkEvent *event, + XEvent *xevent, + GdkWindow *window); +static gint gdk_input_xfree_enable_window(GdkWindow *window, + GdkDevicePrivate *gdkdev); +static gint gdk_input_xfree_disable_window(GdkWindow *window, + GdkDevicePrivate *gdkdev); +static gint gdk_input_xfree_grab_pointer (GdkWindow * window, + gint owner_events, + GdkEventMask event_mask, + GdkWindow * confine_to, + guint32 time); +static void gdk_input_xfree_ungrab_pointer (guint32 time); + +void +gdk_input_init(void) +{ + gdk_input_vtable.set_mode = gdk_input_xfree_set_mode; + gdk_input_vtable.set_axes = gdk_input_common_set_axes; + gdk_input_vtable.motion_events = gdk_input_common_motion_events; + gdk_input_vtable.get_pointer = gdk_input_common_get_pointer; + gdk_input_vtable.grab_pointer = gdk_input_xfree_grab_pointer; + gdk_input_vtable.ungrab_pointer = gdk_input_xfree_ungrab_pointer; + gdk_input_vtable.configure_event = gdk_input_xfree_configure_event; + gdk_input_vtable.enter_event = gdk_input_xfree_enter_event; + gdk_input_vtable.other_event = gdk_input_xfree_other_event; + gdk_input_vtable.window_none_event = NULL; + gdk_input_vtable.enable_window = gdk_input_xfree_enable_window; + gdk_input_vtable.disable_window = gdk_input_xfree_disable_window; + + gdk_input_ignore_core = FALSE; + gdk_input_common_init(FALSE); +} + +static gint +gdk_input_xfree_set_mode (guint32 deviceid, GdkInputMode mode) +{ + GList *tmp_list; + GdkDevicePrivate *gdkdev; + GdkInputMode old_mode; + GdkInputWindow *input_window; + + gdkdev = gdk_input_find_device(deviceid); + g_return_val_if_fail (gdkdev != NULL,FALSE); + old_mode = gdkdev->info.mode; + + if (gdkdev->info.mode == mode) + return TRUE; + + gdkdev->info.mode = mode; + + if (mode == GDK_MODE_WINDOW) + { + gdkdev->info.has_cursor = FALSE; + for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->mode != GDK_EXTENSION_EVENTS_CURSOR) + gdk_input_enable_window (input_window->window, gdkdev); + else + if (old_mode != GDK_MODE_DISABLED) + gdk_input_disable_window (input_window->window, gdkdev); + } + } + else if (mode == GDK_MODE_SCREEN) + { + gdkdev->info.has_cursor = TRUE; + for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next) + gdk_input_enable_window (((GdkInputWindow *)tmp_list->data)->window, + gdkdev); + } + else /* mode == GDK_MODE_DISABLED */ + { + for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (old_mode != GDK_MODE_WINDOW || + input_window->mode != GDK_EXTENSION_EVENTS_CURSOR) + gdk_input_disable_window (input_window->window, gdkdev); + } + } + + return TRUE; + +} + +static void +gdk_input_check_proximity() +{ + gint new_proximity = 0; + GList *tmp_list = gdk_input_devices; + + while (tmp_list && !new_proximity) + { + GdkDevicePrivate *gdkdev = (GdkDevicePrivate *)(tmp_list->data); + + if (gdkdev->info.mode != GDK_MODE_DISABLED + && gdkdev->info.deviceid != GDK_CORE_POINTER + && gdkdev->xdevice) + { + XDeviceState *state = XQueryDeviceState(GDK_DISPLAY(), + gdkdev->xdevice); + XInputClass *xic; + int i; + + xic = state->data; + for (i=0; i<state->num_classes; i++) + { + if (xic->class == ValuatorClass) + { + XValuatorState *xvs = (XValuatorState *)xic; + if ((xvs->mode & ProximityState) == InProximity) + { + new_proximity = TRUE; + } + break; + } + xic = (XInputClass *)((char *)xic + xic->length); + } + } + tmp_list = tmp_list->next; + } + + gdk_input_ignore_core = new_proximity; +} + +static void +gdk_input_xfree_configure_event (XConfigureEvent *xevent, GdkWindow *window) +{ + GdkInputWindow *input_window; + gint root_x, root_y; + + input_window = gdk_input_window_find(window); + g_return_if_fail (window != NULL); + + gdk_input_get_root_relative_geometry(GDK_DISPLAY(),GDK_WINDOW_XWINDOW(window), + &root_x, + &root_y, NULL, NULL); + + input_window->root_x = root_x; + input_window->root_y = root_y; +} + +static void +gdk_input_xfree_enter_event (XCrossingEvent *xevent, + GdkWindow *window) +{ + GdkInputWindow *input_window; + gint root_x, root_y; + + input_window = gdk_input_window_find(window); + g_return_if_fail (window != NULL); + + gdk_input_check_proximity(); + + gdk_input_get_root_relative_geometry(GDK_DISPLAY(),GDK_WINDOW_XWINDOW(window), + &root_x, + &root_y, NULL, NULL); + + input_window->root_x = root_x; + input_window->root_y = root_y; +} + +static gint +gdk_input_xfree_other_event (GdkEvent *event, + XEvent *xevent, + GdkWindow *window) +{ + GdkInputWindow *input_window; + + GdkDevicePrivate *gdkdev; + gint return_val; + + input_window = gdk_input_window_find(window); + g_return_val_if_fail (window != NULL, -1); + + /* This is a sort of a hack, as there isn't any XDeviceAnyEvent - + but it's potentially faster than scanning through the types of + every device. If we were deceived, then it won't match any of + the types for the device anyways */ + gdkdev = gdk_input_find_device(((XDeviceButtonEvent *)xevent)->deviceid); + + if (!gdkdev) { + return -1; /* we don't handle it - not an XInput event */ + } + + /* FIXME: It would be nice if we could just get rid of the events + entirely, instead of having to ignore them */ + if (gdkdev->info.mode == GDK_MODE_DISABLED || + (gdkdev->info.mode == GDK_MODE_WINDOW + && input_window->mode == GDK_EXTENSION_EVENTS_CURSOR)) + return FALSE; + + if (!gdk_input_ignore_core) + gdk_input_check_proximity(); + + return_val = gdk_input_common_other_event (event, xevent, + input_window, gdkdev); + + if (return_val > 0 && event->type == GDK_PROXIMITY_OUT && + gdk_input_ignore_core) + gdk_input_check_proximity(); + + /* Do a passive button grab. We have to be careful not to release + an explicit grab, if any. Doubling the grab should be harmless, + but we check anyways. */ + + /* FIXME, finding the proper events here is going to be SLOW - but + we might have different sets for each window/device combination */ + + if (return_val> 0 && !input_window->grabbed) + { + if (event->type == GDK_BUTTON_PRESS) + { + XEventClass event_classes[6]; + gint num_classes; + + gdk_input_common_find_events (window, gdkdev, + ((GdkWindowPrivate *)window)->extension_events, + event_classes, &num_classes); + + XGrabDevice( GDK_DISPLAY(), gdkdev->xdevice, + GDK_WINDOW_XWINDOW (window), + TRUE, num_classes, event_classes, + GrabModeAsync, GrabModeAsync, event->button.time); + } + else if (event->type == GDK_BUTTON_RELEASE) + XUngrabDevice( GDK_DISPLAY(), gdkdev->xdevice, event->button.time); + } + + return return_val; +} + +static gint +gdk_input_xfree_enable_window(GdkWindow *window, GdkDevicePrivate *gdkdev) +{ + /* FIXME: watchout, gdkdev might be core pointer, never opened */ + gdk_input_common_select_events (window, gdkdev); + return TRUE; +} + +static gint +gdk_input_xfree_disable_window(GdkWindow *window, GdkDevicePrivate *gdkdev) +{ + gdk_input_common_select_events (window, gdkdev); + return TRUE; +} + +static gint +gdk_input_xfree_grab_pointer (GdkWindow * window, + gint owner_events, + GdkEventMask event_mask, + GdkWindow * confine_to, + guint32 time) +{ + GdkInputWindow *input_window, *new_window; + GdkDevicePrivate *gdkdev; + GList *tmp_list; + XEventClass event_classes[6]; + gint num_classes; + + tmp_list = gdk_input_windows; + new_window = NULL; + while (tmp_list) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->grabbed) + return AlreadyGrabbed; + + if (input_window->window == window) + { + new_window = input_window; + break; + } + + tmp_list = tmp_list->next; + } + + g_return_if_fail (new_window == NULL); + + new_window->grabbed = TRUE; + + tmp_list = gdk_input_devices; + while (tmp_list) + { + gdkdev = (GdkDevicePrivate *)tmp_list->data; + if (gdkdev->info.deviceid != GDK_CORE_POINTER && + gdkdev->xdevice && !gdkdev->button_state) + { + gdk_input_common_find_events (window, gdkdev, + ((GdkWindowPrivate *)window)->extension_events, + event_classes, &num_classes); + + /* FIXME: we should do something on failure */ + XGrabDevice( GDK_DISPLAY(), gdkdev->xdevice, + GDK_WINDOW_XWINDOW (window), + TRUE, num_classes, event_classes, + GrabModeAsync, GrabModeAsync, time); + } + tmp_list = tmp_list->next; + } + + return Success; +} + +static void +gdk_input_xfree_ungrab_pointer (guint32 time) +{ + GdkInputWindow *input_window; + GdkDevicePrivate *gdkdev; + GList *tmp_list; + + tmp_list = gdk_input_windows; + while (tmp_list) + { + input_window = (GdkInputWindow *)tmp_list->data; + if (input_window->grabbed) + break; + tmp_list = tmp_list->next; + } + + if (tmp_list) /* we found a grabbed window */ + { + input_window->grabbed = FALSE; + + tmp_list = gdk_input_devices; + while (tmp_list) + { + gdkdev = (GdkDevicePrivate *)tmp_list->data; + if (gdkdev->info.deviceid != GDK_CORE_POINTER && + gdkdev->xdevice && !gdkdev->button_state) + { + XUngrabDevice( gdk_display, gdkdev->xdevice, time); + } + tmp_list = tmp_list->next; + } + } +} + +#endif /* XINPUT_XFREE */ diff --git a/gdk/x11/gdkinput.c b/gdk/x11/gdkinput.c new file mode 100644 index 000000000..ad4b1fcc9 --- /dev/null +++ b/gdk/x11/gdkinput.c @@ -0,0 +1,324 @@ +/* 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 <stdlib.h> +#include <X11/Xlib.h> +#include <X11/Xutil.h> +#include "../config.h" +#include "gdk.h" +#include "gdkx.h" +#include "gdkprivate.h" +#include "gdkinput.h" + + +/* Forward declarations */ + +static gint gdk_input_enable_window (GdkWindow *window, + GdkDevicePrivate *gdkdev); +static gint gdk_input_disable_window (GdkWindow *window, + GdkDevicePrivate *gdkdev); +static GdkInputWindow *gdk_input_window_find (GdkWindow *window); +static GdkDevicePrivate *gdk_input_find_device (guint32 id); + + +/* Incorporate the specific routines depending on compilation options */ + +static GdkAxisUse gdk_input_core_axes[] = { GDK_AXIS_X, GDK_AXIS_Y }; + +static GdkDeviceInfo gdk_input_core_info = +{ + GDK_CORE_POINTER, + "Core Pointer", + GDK_SOURCE_MOUSE, + GDK_MODE_SCREEN, + TRUE, + 2, + gdk_input_core_axes +}; + +/* Global variables */ + +GdkInputVTable gdk_input_vtable; +/* information about network port and host for gxid daemon */ +gchar *gdk_input_gxid_host; +gint gdk_input_gxid_port; +gint gdk_input_ignore_core; + +/* Local variables */ + +static GList *gdk_input_devices; +static GList *gdk_input_windows; + +#include "gdkinputnone.h" +#include "gdkinputcommon.h" +#include "gdkinputxfree.h" +#include "gdkinputgxi.h" + +GList * +gdk_input_list_devices () +{ + return gdk_input_devices; +} + +void +gdk_input_set_source (guint32 deviceid, GdkInputSource source) +{ + GdkDevicePrivate *gdkdev = gdk_input_find_device(deviceid); + g_return_if_fail (gdkdev != NULL); + + gdkdev->info.source = source; +} + +gint +gdk_input_set_mode (guint32 deviceid, GdkInputMode mode) +{ + if (deviceid == GDK_CORE_POINTER) + return FALSE; + + if (gdk_input_vtable.set_mode) + return gdk_input_vtable.set_mode(deviceid,mode); + else + return FALSE; +} + +void +gdk_input_set_axes (guint32 deviceid, GdkAxisUse *axes) +{ + if (deviceid != GDK_CORE_POINTER && gdk_input_vtable.set_axes) + gdk_input_vtable.set_axes (deviceid, axes); +} + +GdkTimeCoord * +gdk_input_motion_events (GdkWindow *window, + guint32 deviceid, + guint32 start, + guint32 stop, + gint *nevents_return) +{ + XTimeCoord *xcoords; + GdkTimeCoord *coords; + int i; + + if (deviceid == GDK_CORE_POINTER) + { + xcoords = XGetMotionEvents (gdk_display, + ((GdkWindowPrivate *)window)->xwindow, + start, stop, nevents_return); + if (xcoords) + { + coords = g_new (GdkTimeCoord, *nevents_return); + for (i=0; i<*nevents_return; i++) + { + coords[i].time = xcoords[i].time; + coords[i].x = xcoords[i].x; + coords[i].y = xcoords[i].y; + coords[i].pressure = 0.5; + coords[i].xtilt = 0.0; + coords[i].ytilt = 0.0; + } + + XFree(xcoords); + + return coords; + } + else + return NULL; + } + else + { + if (gdk_input_vtable.motion_events) + { + return gdk_input_vtable.motion_events(window, + deviceid, start, stop, + nevents_return); + } + else + { + *nevents_return = 0; + return NULL; + } + } +} + +static gint +gdk_input_enable_window (GdkWindow *window, GdkDevicePrivate *gdkdev) +{ + if (gdk_input_vtable.enable_window) + return gdk_input_vtable.enable_window (window, gdkdev); + else + return TRUE; +} + +static gint +gdk_input_disable_window (GdkWindow *window, GdkDevicePrivate *gdkdev) +{ + if (gdk_input_vtable.disable_window) + return gdk_input_vtable.disable_window(window,gdkdev); + else + return TRUE; +} + + +static GdkInputWindow * +gdk_input_window_find(GdkWindow *window) +{ + GList *tmp_list; + + for (tmp_list=gdk_input_windows; tmp_list; tmp_list=tmp_list->next) + if (((GdkInputWindow *)(tmp_list->data))->window == window) + return (GdkInputWindow *)(tmp_list->data); + + return NULL; /* Not found */ +} + +/* FIXME: this routine currently needs to be called between creation + and the corresponding configure event (because it doesn't get the + root_relative_geometry). This should work with + gtk_window_set_extension_events, but will likely fail in other + cases */ + +void +gdk_input_set_extension_events (GdkWindow *window, gint mask, + GdkExtensionMode mode) +{ + GList *tmp_list; + GdkInputWindow *iw; + + g_return_if_fail (window != NULL); + + if (mode == GDK_EXTENSION_EVENTS_NONE) + mask = 0; + + if (mask != 0) + { + iw = g_new(GdkInputWindow,1); + + iw->window = window; + iw->mode = mode; + + iw->obscuring = NULL; + iw->num_obscuring = 0; + iw->grabbed = FALSE; + + gdk_input_windows = g_list_append(gdk_input_windows,iw); + ((GdkWindowPrivate *)window)->extension_events = mask; + + /* Add enter window events to the event mask */ + /* FIXME, this is not needed for XINPUT_NONE */ + gdk_window_set_events (window, + gdk_window_get_events (window) | + GDK_ENTER_NOTIFY_MASK); + } + else + { + iw = gdk_input_window_find (window); + if (iw) + { + gdk_input_windows = g_list_remove(gdk_input_windows,iw); + g_free(iw); + } + + ((GdkWindowPrivate *)window)->extension_events = 0; + } + + for (tmp_list = gdk_input_devices; tmp_list; tmp_list = tmp_list->next) + { + GdkDevicePrivate *gdkdev = (GdkDevicePrivate *)(tmp_list->data); + + if (gdkdev->info.deviceid != GDK_CORE_POINTER) + { + if (mask != 0 && gdkdev->info.mode != GDK_MODE_DISABLED + && (gdkdev->info.has_cursor || mode == GDK_EXTENSION_EVENTS_ALL)) + gdk_input_enable_window(window,gdkdev); + else + gdk_input_disable_window(window,gdkdev); + } + } +} + +void +gdk_input_window_destroy (GdkWindow *window) +{ + GdkInputWindow *input_window; + + input_window = gdk_input_window_find (window); + g_return_if_fail (input_window != NULL); + + gdk_input_windows = g_list_remove(gdk_input_windows,input_window); + g_free(input_window); +} + +void +gdk_input_exit (void) +{ + GList *tmp_list; + GdkDevicePrivate *gdkdev; + + for (tmp_list = gdk_input_devices; tmp_list; tmp_list = tmp_list->next) + { + gdkdev = (GdkDevicePrivate *)(tmp_list->data); + if (gdkdev->info.deviceid != GDK_CORE_POINTER) + { + gdk_input_set_mode(gdkdev->info.deviceid,GDK_MODE_DISABLED); + + g_free(gdkdev->info.name); +#ifndef XINPUT_NONE + g_free(gdkdev->axes); +#endif + g_free(gdkdev->info.axes); + g_free(gdkdev); + } + } + + g_list_free(gdk_input_devices); + + for (tmp_list = gdk_input_windows; tmp_list; tmp_list = tmp_list->next) + { + g_free(tmp_list->data); + } + g_list_free(gdk_input_windows); +} + +static GdkDevicePrivate * +gdk_input_find_device(guint32 id) +{ + GList *tmp_list = gdk_input_devices; + GdkDevicePrivate *gdkdev; + while (tmp_list) + { + gdkdev = (GdkDevicePrivate *)(tmp_list->data); + if (gdkdev->info.deviceid == id) + return gdkdev; + tmp_list = tmp_list->next; + } + return NULL; +} + +void +gdk_input_window_get_pointer (GdkWindow *window, + guint32 deviceid, + gdouble *x, + gdouble *y, + gdouble *pressure, + gdouble *xtilt, + gdouble *ytilt, + GdkModifierType *mask) +{ + if (gdk_input_vtable.get_pointer) + gdk_input_vtable.get_pointer (window, deviceid, x, y, pressure, + xtilt, ytilt, mask); +} diff --git a/gdk/x11/gdkmain-x11.c b/gdk/x11/gdkmain-x11.c new file mode 100644 index 000000000..d5f85dd1e --- /dev/null +++ b/gdk/x11/gdkmain-x11.c @@ -0,0 +1,2897 @@ +/* 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" + +#include <ctype.h> +#include <locale.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <limits.h> + +#ifdef HAVE_SYS_SELECT_H +#include <sys/select.h> +#endif /* HAVE_SYS_SELECT_H_ */ + +#define XLIB_ILLEGAL_ACCESS +#include <X11/Xatom.h> +#include <X11/Xlib.h> +#include <X11/Xos.h> +#include <X11/Xutil.h> +#include <X11/Xmu/WinUtil.h> +#include <X11/cursorfont.h> +#include "gdk.h" +#include "gdkprivate.h" +#include "gdkinput.h" + + +#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; +}; + +struct _GdkPredicate +{ + GdkEventFunc func; + gpointer data; +}; + +/* + * Private function declarations + */ +static gint gdk_event_wait (void); +static gint gdk_event_translate (GdkEvent *event, + XEvent *xevent); +static Bool gdk_event_get_type (Display *display, + XEvent *xevent, + XPointer arg); +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); +static void gdk_dnd_drag_end (Window dest, + GdkPoint coords); +static GdkAtom gdk_dnd_check_types (GdkWindow *window, + XEvent *xevent); +static void gdk_print_atom (GdkAtom anatom); + +/* + * old junk from offix, we might use it though so leave it + */ +static Window gdk_drop_get_client_window (Display *dpy, + Window win); +static GdkWindow * gdk_drop_get_real_window (GdkWindow *w, + guint16 *x, + guint16 *y); +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); + + +/* 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 gint received_destroy_notify = FALSE; /* Did we just receive a destroy notify + * event? If so, we need to actually + * destroy the window which received + * it now. + */ +static GdkWindow *window_to_destroy = NULL; /* If we previously received a destroy + * notify event then this is the window + * which received that event. + */ + +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. + */ + +#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; + + +/* + *-------------------------------------------------------------- + * 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; + int synchronize; + int i, j, k; + XClassHint *class_hint; + int argc_orig = *argc; + char **argv_orig; + + argv_orig = malloc ((argc_orig + 1) * sizeof (char*)); + for (i = 0; i < argc_orig; i++) + argv_orig[i] = g_strdup ((*argv)[i]); + argv_orig[argc_orig] = NULL; + + X_GETTIMEOFDAY (&start); + + 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); + + gdk_display_name = NULL; + + XSetErrorHandler (gdk_x_error); + XSetIOErrorHandler (gdk_x_io_error); + + synchronize = FALSE; + + if (argc && argv) + { + if (*argc > 0) + gdk_progname = (*argv)[0]; + + for (i = 1; i < *argc;) + { + if (strcmp ("--display", (*argv)[i]) == 0) + { + (*argv)[i] = NULL; + + if ((i + 1) < *argc) + { + gdk_display_name = g_strdup ((*argv)[i + 1]); + (*argv)[i + 1] = NULL; + i += 1; + } + } + else if (strcmp ("--sync", (*argv)[i]) == 0) + { + (*argv)[i] = NULL; + synchronize = TRUE; + } + else if (strcmp ("--show-events", (*argv)[i]) == 0) + { + (*argv)[i] = NULL; + gdk_show_events = TRUE; + } + else if (strcmp ("--no-show-events", (*argv)[i]) == 0) + { + (*argv)[i] = NULL; + gdk_show_events = FALSE; + } + else if (strcmp ("--no-xshm", (*argv)[i]) == 0) + { + (*argv)[i] = NULL; + gdk_use_xshm = FALSE; + } + else if (strcmp ("--debug-level", (*argv)[i]) == 0) + { + if ((i + 1) < *argc) + { + (*argv)[i++] = NULL; + gdk_debug_level = atoi ((*argv)[i]); + (*argv)[i] = NULL; + } + } + else if (strcmp ("-name", (*argv)[i]) == 0) + { + if ((i + 1) < *argc) + { + (*argv)[i++] = NULL; + gdk_progname = (*argv)[i]; + (*argv)[i] = NULL; + } + } + else if (strcmp ("-class", (*argv)[i]) == 0) + { + if ((i + 1) < *argc) + { + (*argv)[i++] = NULL; + gdk_progclass = (*argv)[i]; + (*argv)[i] = NULL; + } + } +#ifdef XINPUT_GXI + else if (strcmp ("--gxid_host", (*argv)[i]) == 0) + { + if ((i + 1) < *argc) + { + (*argv)[i++] = NULL; + gdk_input_gxid_host = ((*argv)[i]); + (*argv)[i] = NULL; + } + } + else if (strcmp ("--gxid_port", (*argv)[i]) == 0) + { + if ((i + 1) < *argc) + { + (*argv)[i++] = NULL; + gdk_input_gxid_port = atoi ((*argv)[i]); + (*argv)[i] = NULL; + } + } +#endif + 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) + g_error ("cannot open display: %s", XDisplayName (gdk_display_name)); + + /* 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; + if (gdk_show_events) + g_print ("base id: %lu\n", base_id); + + connection_number = ConnectionNumber (gdk_display); + if (gdk_debug_level >= 1) + g_print ("connection number: %d\n", connection_number); + + 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; + 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); + + 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); + gdk_dnd.gdk_cursor_dragdefault = XCreateFontCursor(gdk_display, XC_bogosity); + gdk_dnd.gdk_cursor_dragok = XCreateFontCursor(gdk_display, XC_heart); + + 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 (); + + 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 () +{ + return XPending (gdk_display); +} + +/* + *-------------------------------------------------------------- + * gdk_event_get + * + * Gets the next event. + * + * Arguments: + * "event" is used to hold the received event. + * If "event" is NULL an event is received as normal + * however it is not placed in "event" (and thus no + * error occurs). + * + * Results: + * Returns TRUE if an event was received that we care about + * and FALSE otherwise. This function will also return + * before an event is received if the timeout interval + * runs out. + * + * Side effects: + * + *-------------------------------------------------------------- + */ + +gint +gdk_event_get (GdkEvent *event, + GdkEventFunc pred, + gpointer data) +{ + GdkEvent *temp_event; + GdkPredicate event_pred; + GList *temp_list; + XEvent xevent; + + /* If the last event we received was a destroy notify + * event then we will actually destroy the "gdk" data + * structures now. We don't want to destroy them at the + * time of receiving the event since the main program + * may try to access them and may need to destroy user + * data that has been attached to the window + */ + if (received_destroy_notify) + { + if (gdk_show_events) + g_print ("destroying window:\twindow: %ld\n", + ((GdkWindowPrivate*) window_to_destroy)->xwindow - base_id); + + gdk_window_real_destroy (window_to_destroy); + received_destroy_notify = FALSE; + window_to_destroy = NULL; + } + + /* Initially we haven't received an event and want to + * return FALSE. If "event" is non-NULL, then initialize + * it to the nothing event. + */ + if (event) + { + event->any.type = GDK_NOTHING; + event->any.window = NULL; + event->any.send_event = FALSE; + } + + 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; + + if (XCheckIfEvent (gdk_display, &xevent, gdk_event_get_type, (XPointer) &event_pred)) + if (event) + return gdk_event_translate (event, &xevent); + } + else + { + if (putback_events) + { + temp_event = putback_events->data; + *event = *temp_event; + + temp_list = putback_events; + putback_events = putback_events->next; + if (putback_events) + putback_events->prev = NULL; + + temp_list->next = NULL; + temp_list->prev = NULL; + g_list_free (temp_list); + g_free (temp_event); + + return TRUE; + } + + /* 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. + */ + XNextEvent (gdk_display, &xevent); + + event->any.send_event = xevent.xany.send_event; + + /* If "event" non-NULL. + */ + if (event) + return gdk_event_translate (event, &xevent); + } + } + + return FALSE; +} + +void +gdk_event_put (GdkEvent *event) +{ + GdkEvent *new_event; + + g_return_if_fail (event != NULL); + + new_event = g_new (GdkEvent, 1); + *new_event = *event; + + 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; + +GdkEvent* +gdk_event_copy (GdkEvent *event) +{ + GdkEvent *new_event; + + g_return_val_if_fail (event != NULL, NULL); + + 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); + *new_event = *event; + gdk_window_ref (new_event->any.window); + 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); + + gdk_window_unref (event->any.window); + g_mem_chunk_free (event_chunk, event); +} + +/* + *-------------------------------------------------------------- + * gdk_set_debug_level + * + * Sets the debugging level. + * + * Arguments: + * "level" is the new debugging level. + * + * Results: + * + * Side effects: + * Other function calls to "gdk" use the debugging + * level to determine what kind of debugging information + * to print out. + * + *-------------------------------------------------------------- + */ + +void +gdk_set_debug_level (int level) +{ + gdk_debug_level = level; +} + +/* + *-------------------------------------------------------------- + * 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) +{ + gdk_show_events = show_events; +} + +void +gdk_set_use_xshm (gint use_xshm) +{ + gdk_use_xshm = use_xshm; +} + +gint +gdk_get_debug_level () +{ + return gdk_debug_level; +} + +gint +gdk_get_show_events () +{ + return gdk_show_events; +} + +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 +gdk_input_add (gint source, + GdkInputCondition condition, + GdkInputFunction function, + gpointer data) +{ + 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)) + { + input->function = function; + input->data = data; + 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; + tag = input->tag; + + inputs = g_list_prepend (inputs, input); + } + + return tag; +} + +void +gdk_input_remove (gint tag) +{ + GList *list; + GList *temp_list; + GdkInput *input; + + list = inputs; + while (list) + { + input = list->data; + + if (input->tag == tag) + { + 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; + + if (!confine_to) + 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 + return_val = Success;; + + if (return_val == Success) + return_val = XGrabPointer (window_private->xdisplay, + xwindow, + owner_events, + xevent_mask, + GrabModeAsync, GrabModeAsync, + xconfine_to, + xcursor, + time); + + 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); +} + +/* + *-------------------------------------------------------------- + * 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; + + return XGrabKeyboard (window_private->xdisplay, + xwindow, + owner_events, + GrabModeAsync, GrabModeAsync, + time); +} + +/* + *-------------------------------------------------------------- + * 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; +} + +static gint +gdk_event_translate (GdkEvent *event, + XEvent *xevent) +{ + + GdkWindow *window; + GdkWindowPrivate *window_private; + XComposeStatus compose; + int charcount; + char buf[16]; + gint return_val; + + /* Are static variables used for this purpose thread-safe? */ + static GdkPoint dnd_drag_start = {0,0}, + dnd_drag_oldpos = {0,0}; + static GdkRectangle dnd_drag_dropzone = {0,0,0,0}; + static gint dnd_drag_perhaps = 0; + static GdkWindowPrivate *real_sw = NULL; + static Window dnd_drag_curwin = None, dnd_drag_target = None; + + 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; + + /* 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. + */ + charcount = XLookupString (&xevent->xkey, buf, 16, + (KeySym*) &event->key.keyval, + &compose); + + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("key press:\t\twindow: %ld key: %12s %d\n", + xevent->xkey.window - base_id, + XKeysymToString (event->key.keyval), + event->key.keyval); + + event->key.type = GDK_KEY_PRESS; + event->key.window = window; + event->key.time = xevent->xkey.time; + event->key.state = (GdkModifierType) xevent->xkey.state; + + return_val = !window_private->destroyed; + 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. + */ + if (gdk_show_events) + g_print ("key release:\t\twindow: %ld key: %12s %d\n", + xevent->xkey.window - base_id, + XKeysymToString (event->key.keyval), + event->key.keyval); + + event->key.type = GDK_KEY_RELEASE; + event->key.window = window; + event->key.time = xevent->xkey.time; + event->key.state = (GdkModifierType) xevent->xkey.state; + + return_val = !window_private->destroyed; + break; + + case ButtonPress: + /* Print debugging info. + */ + if (gdk_show_events) + 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, + xevent->xbutton.button); + + 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; + 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 + && !dnd_drag_perhaps + && !gdk_dnd.drag_really) + { + dnd_drag_perhaps = 1; + dnd_drag_start.x = xevent->xbutton.x_root; + dnd_drag_start.y = xevent->xbutton.y_root; + real_sw = window_private; + + 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; + + { + /* Set motion mask for first DnD'd window, since it + will be the one that is actually dragged */ + XWindowAttributes dnd_winattr; + XSetWindowAttributes dnd_setwinattr; + Status rv; + + /* 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 = + window_private->dnd_drag_eventmask = ButtonMotionMask; + XChangeWindowAttributes(gdk_display, window_private->xwindow, + CWEventMask, &dnd_setwinattr); + } + } + return_val = window_private?(!window_private->destroyed):FALSE; + break; + + case ButtonRelease: + /* Print debugging info. + */ + if (gdk_show_events) + 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, + xevent->xbutton.button); + + 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; + 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(dnd_drag_perhaps) + { + if(gdk_dnd.drag_really) + { + GdkPoint foo = {xevent->xbutton.x_root, + xevent->xbutton.y_root}; + XUngrabPointer(gdk_display, CurrentTime); + + if(dnd_drag_target != None) + gdk_dnd_drag_end(dnd_drag_target, foo); + gdk_dnd.drag_really = 0; + + if(gdk_dnd.drag_numwindows) + { + XSetWindowAttributes attrs; + /* Reset event mask to pre-drag value, assuming event_mask + doesn't change during drag */ + attrs.event_mask = real_sw->dnd_drag_savedeventmask; + XChangeWindowAttributes(gdk_display, real_sw->xwindow, + CWEventMask, &attrs); + } + + gdk_dnd.drag_numwindows = 0; + if(gdk_dnd.drag_startwindows) + { + g_free(gdk_dnd.drag_startwindows); + gdk_dnd.drag_startwindows = NULL; + } + + real_sw = NULL; + } + + dnd_drag_perhaps = 0; + dnd_drag_start.x = dnd_drag_start.y = 0; + dnd_drag_dropzone.x = dnd_drag_dropzone.y = 0; + dnd_drag_dropzone.width = dnd_drag_dropzone.height = 0; + dnd_drag_curwin = None; + } + return_val = window ? (!window_private->destroyed) : FALSE; + break; + + case MotionNotify: + /* Print debugging info. + */ + if (gdk_show_events) + 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", + dnd_drag_perhaps, gdk_dnd.drag_really); + + 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; + 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; + +#define IS_IN_ZONE(cx, cy) (cx >= dnd_drag_dropzone.x \ + && cy >= dnd_drag_dropzone.y \ + && cx < (dnd_drag_dropzone.x + dnd_drag_dropzone.width) \ + && cy < (dnd_drag_dropzone.y + dnd_drag_dropzone.height)) + + if(dnd_drag_perhaps && gdk_dnd.drag_really) + { + /* 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 */ + Window curwin, childwin = gdk_root_window, rootwinret; + int x, y; + unsigned int mask; + while(childwin != None) + { + curwin = childwin; + XQueryPointer(gdk_display, curwin, &rootwinret, &childwin, + &x, &y, &x, &y, &mask); + } + if(curwin != dnd_drag_curwin) + { + /* We have left one window and entered another + (do leave & enter bits) */ + if(dnd_drag_curwin != real_sw->xwindow && dnd_drag_curwin != None) + gdk_dnd_drag_leave(dnd_drag_curwin); + dnd_drag_curwin = curwin; + gdk_dnd_drag_enter(dnd_drag_curwin); + dnd_drag_dropzone.x = dnd_drag_dropzone.y = 0; + dnd_drag_dropzone.width = dnd_drag_dropzone.height = 0; + dnd_drag_target = None; + XChangeActivePointerGrab(gdk_display, + ButtonMotionMask | + ButtonPressMask | ButtonReleaseMask | + EnterWindowMask | LeaveWindowMask, + gdk_dnd.gdk_cursor_dragdefault, + CurrentTime); + } + else if(dnd_drag_dropzone.width > 0 + && dnd_drag_dropzone.height > 0) + { + /* Handle all that dropzone stuff - thanks John ;-) */ + if(dnd_drag_target != None + && IS_IN_ZONE(dnd_drag_oldpos.x, dnd_drag_oldpos.y) + && !IS_IN_ZONE(xevent->xmotion.x_root, + xevent->xmotion.y_root)) + { + /* We were in the drop zone and moved out */ + dnd_drag_target = None; + gdk_dnd_drag_leave(curwin); + } + else + { + /* We were outside drop zone but in the window + - have to send enter events */ + gdk_dnd_drag_enter(curwin); + dnd_drag_curwin = curwin; + dnd_drag_dropzone.x = dnd_drag_dropzone.y = 0; + dnd_drag_target = None; + } + } else + dnd_drag_curwin = None; + return_val = FALSE; + } + else + return_val = window?(!window_private->destroyed):FALSE; + break; + + case EnterNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("enter notify:\t\twindow: %ld detail: %d subwin: %ld\n", + xevent->xcrossing.window - base_id, + xevent->xcrossing.detail, + xevent->xcrossing.subwindow - base_id); + + /* 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; + } + + if(dnd_drag_perhaps + && gdk_dnd.drag_really + && xevent->xcrossing.window == real_sw->xwindow) + { + gdk_dnd.drag_really = 0; + XUngrabPointer(gdk_display, CurrentTime); + } + + return_val = (window ? !window_private->destroyed : FALSE); + break; + + case LeaveNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("leave notify:\t\twindow: %ld detail: %d subwin: %ld\n", + xevent->xcrossing.window - base_id, + xevent->xcrossing.detail, xevent->xcrossing.subwindow - base_id); + + event->crossing.type = GDK_LEAVE_NOTIFY; + event->crossing.window = window; + + /* 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; + } + if(dnd_drag_perhaps + && !gdk_dnd.drag_really) + { + gdk_dnd_drag_addwindow((GdkWindow *) real_sw); + gdk_dnd_drag_begin((GdkWindow *) real_sw); + XGrabPointer(gdk_display, real_sw->xwindow, False, + ButtonMotionMask | + ButtonPressMask | ButtonReleaseMask | + EnterWindowMask | LeaveWindowMask, + GrabModeAsync, GrabModeAsync, gdk_root_window, + gdk_dnd.gdk_cursor_dragdefault, CurrentTime); + gdk_dnd.drag_really = 1; + } + return_val = window ? (!window_private->destroyed) : FALSE; + break; + + case FocusIn: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("focus in:\t\twindow: %ld\n", + xevent->xfocus.window - base_id); + + event->focus_change.type = GDK_FOCUS_CHANGE; + event->focus_change.window = window; + event->focus_change.in = TRUE; + + return_val = !window_private->destroyed; + break; + + case FocusOut: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("focus out:\t\twindow: %ld\n", + xevent->xfocus.window - base_id); + + event->focus_change.type = GDK_FOCUS_CHANGE; + event->focus_change.window = window; + event->focus_change.in = FALSE; + + return_val = !window_private->destroyed; + break; + + case KeymapNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("keymap notify\n"); + + /* Not currently handled */ + break; + + case Expose: + /* Print debugging info. + */ + if (gdk_show_events) + 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, + xevent->xexpose.width, xevent->xexpose.height); + + 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; + + return_val = !window_private->destroyed; + break; + + case GraphicsExpose: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("graphics expose:\tdrawable: %ld\n", + xevent->xgraphicsexpose.drawable - base_id); + + 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; + + return_val = !window_private->destroyed; + break; + + case NoExpose: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("no expose:\t\tdrawable: %ld\n", + xevent->xnoexpose.drawable - base_id); + + /* Not currently handled */ + break; + + case VisibilityNotify: + /* Print debugging info. + */ + if (gdk_show_events) + 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; + } + + /* Not currently handled */ + break; + + case CreateNotify: + /* Not currently handled */ + break; + + case DestroyNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("destroy notify:\twindow: %ld\n", + xevent->xdestroywindow.window - base_id); + + event->any.type = GDK_DESTROY; + event->any.window = window; + + /* Remeber which window received the destroy notify + * event so that we can destroy our associated + * data structures the next time the user asks + * us for an event. + */ + received_destroy_notify = TRUE; + window_to_destroy = window; + + return_val = !window_private->destroyed; + break; + + case UnmapNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("unmap notify:\t\twindow: %ld\n", + xevent->xmap.window - base_id); + + event->any.type = GDK_UNMAP; + event->any.window = window; + + return_val = !window_private->destroyed; + break; + + case MapNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("map notify:\t\twindow: %ld\n", + xevent->xmap.window - base_id); + + event->any.type = GDK_MAP; + event->any.window = window; + + return_val = !window_private->destroyed; + break; + + case ReparentNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("reparent notify:\twindow: %ld\n", + xevent->xreparent.window - base_id); + + /* Not currently handled */ + break; + + case ConfigureNotify: + /* Print debugging info. + */ + while ((XPending(gdk_display) > 0) && + XCheckTypedWindowEvent(gdk_display, xevent->xany.window, + ConfigureNotify, xevent)) + /*XSync(gdk_display, 0)*/; + + if (gdk_show_events) + g_print ("configure notify:\twindow: %ld x,y: %d %d w,h: %d %d\n", + xevent->xconfigure.window - base_id, + xevent->xconfigure.x, xevent->xconfigure.y, + xevent->xconfigure.width, xevent->xconfigure.height); + + if (window_private && + (window_private->extension_events != 0) && + gdk_input_vtable.configure_event) + gdk_input_vtable.configure_event (&xevent->xconfigure, window); + + if ((window_private->window_type != GDK_WINDOW_CHILD) && + ((window_private->width != xevent->xconfigure.width) || + (window_private->height != xevent->xconfigure.height))) + { + event->configure.type = GDK_CONFIGURE; + event->configure.window = window; + event->configure.x = xevent->xconfigure.x; + event->configure.y = xevent->xconfigure.y; + event->configure.width = xevent->xconfigure.width; + event->configure.height = xevent->xconfigure.height; + + window_private->x = xevent->xconfigure.x; + window_private->y = xevent->xconfigure.y; + window_private->width = xevent->xconfigure.width; + window_private->height = xevent->xconfigure.height; + if (window_private->resize_count > 1) + window_private->resize_count -= 1; + + return_val = !window_private->destroyed; + } + break; + + case PropertyNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("property notify:\twindow: %ld\n", + xevent->xproperty.window - base_id); + + 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; + + return_val = !window_private->destroyed; + break; + + case SelectionClear: + if (gdk_show_events) + g_print ("selection clear:\twindow: %ld\n", + xevent->xproperty.window - base_id); + + event->selection.type = GDK_SELECTION_CLEAR; + event->selection.window = window; + event->selection.selection = xevent->xselectionclear.selection; + event->selection.time = xevent->xselectionclear.time; + + return_val = !((GdkWindowPrivate*) window)->destroyed; + break; + + case SelectionRequest: + if (gdk_show_events) + g_print ("selection request:\twindow: %ld\n", + xevent->xproperty.window - base_id); + + 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; + + return_val = !((GdkWindowPrivate*) window)->destroyed; + break; + + case SelectionNotify: + if (gdk_show_events) + g_print ("selection notify:\twindow: %ld\n", + xevent->xproperty.window - base_id); + + + 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; + + return_val = !((GdkWindowPrivate*) window)->destroyed; + break; + + case ColormapNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("colormap notify:\twindow: %ld\n", + xevent->xcolormap.window - base_id); + + /* Not currently handled */ + break; + + case ClientMessage: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("client message:\twindow: %ld\n", + xevent->xclient.window - base_id); + + /* 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. + */ + if (gdk_show_events) + g_print ("delete window:\t\twindow: %ld\n", + xevent->xclient.window - base_id); + + event->any.type = GDK_DELETE; + event->any.window = window; + + return_val = !window_private->destroyed; + } + 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]; + if (gdk_show_events) + g_print ("GDK_DROP_ENTER\n"); + 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; + + XSendEvent (gdk_display, replyev.xclient.window, + False, NoEventMask, &replyev); + + event->any.type = GDK_DROP_ENTER; + event->dropenter.requestor = replyev.xclient.window; + event->dropenter.u.allflags = xevent->xclient.data.l[1]; + } + } + else if (xevent->xclient.message_type == gdk_dnd.gdk_XdeLeave) + { + if (gdk_show_events) + g_print ("GDK_DROP_LEAVE\n"); + 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 + */ + if (gdk_show_events) + g_print ("GDK_DRAG_REQUEST\n"); + event->dragrequest.u.allflags = xevent->xclient.data.l[1]; + return_val = FALSE; + + if (window && gdk_dnd.drag_really && + xevent->xclient.data.l[0] == dnd_drag_curwin && + 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]; + + dnd_drag_target = dnd_drag_curwin; + XChangeActivePointerGrab (gdk_display, + ButtonMotionMask | + ButtonPressMask | + ButtonReleaseMask | + EnterWindowMask | LeaveWindowMask, + gdk_dnd.gdk_cursor_dragok, + CurrentTime); + } + dnd_drag_dropzone.x = xevent->xclient.data.l[2] & 65535; + dnd_drag_dropzone.y = + (xevent->xclient.data.l[2] >> 16) & 65535; + dnd_drag_dropzone.width = xevent->xclient.data.l[3] & 65535; + dnd_drag_dropzone.height = + (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; + gpointer tmp_ptr; + + if(gdk_show_events) + g_print("GDK_DROP_DATA_AVAIL\n"); + event->dropdataavailable.u.allflags = xevent->xclient.data.l[1]; + 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 + { + g_print("XGetWindowProperty got us %d bytes\n", + event->dropdataavailable.data_numbytes); + event->dropdataavailable.data = + g_malloc(event->dropdataavailable.data_numbytes); + memcpy(event->dropdataavailable.data, + tmp_charptr, event->dropdataavailable.data_numbytes); + XFree(tmp_charptr); + return_val = TRUE; + } + return_val = TRUE; + } + } else { + /* 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)); + return_val = TRUE; + } + return_val = return_val && !window_private->destroyed; + break; + + case MappingNotify: + /* Print debugging info. + */ + if (gdk_show_events) + g_print ("mapping notify\n"); + + /* 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); + + if (return_val < 0) /* not an XInput event, convert */ + { + event->other.type = GDK_OTHER_EVENT; + event->other.window = window; + event->other.xevent = &other_xevent[other_xevent_i]; + memcpy (&other_xevent[other_xevent_i], xevent, sizeof (XEvent)); + other_xevent_i = (other_xevent_i+1) % OTHER_XEVENT_BUFSIZE; + return_val = TRUE; + } + + return_val = return_val && !window_private->destroyed; + break; + } + + return return_val; +} + +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; +} + +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 () +{ + if (initialized) + { + 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); + gdk_exit (1); +} + +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; + XSendEvent (gdk_display, dest, False, NoEventMask, &sev); + } + + } +} + +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; + XSendEvent(gdk_display, dest, False, NoEventMask, &sev); + 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; + gchar *tmp_cptr; + 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; + 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 + */ +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); +} + +/* + * 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]; + } + + for (i = 0; !inf && (i < nchildren); i++) + inf = getchildren (dpy, children[i], WM_STATE); + + if (children != 0) + 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; +} + +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; +} + +/* 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; + XSendEvent(gdk_display, curwin, False, NoEventMask, &sev); + } + + XFree(ret_children); +} diff --git a/gdk/x11/gdkpixmap-x11.c b/gdk/x11/gdkpixmap-x11.c new file mode 100644 index 000000000..d2d96b6da --- /dev/null +++ b/gdk/x11/gdkpixmap-x11.c @@ -0,0 +1,657 @@ +/* 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" +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <X11/Xlib.h> + +#include "gdk.h" +#include "gdkprivate.h" + +typedef struct +{ + gchar *color_string; + GdkColor color; + gint transparent; +} _GdkPixmapColor; + +GdkPixmap* +gdk_pixmap_new (GdkWindow *window, + gint width, + gint height, + gint depth) +{ + GdkPixmap *pixmap; + GdkWindowPrivate *private; + GdkWindowPrivate *window_private; + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + if (depth == -1) + gdk_window_get_geometry (window, NULL, NULL, NULL, NULL, &depth); + + private = g_new (GdkWindowPrivate, 1); + pixmap = (GdkPixmap*) private; + + window_private = (GdkWindowPrivate*) window; + + private->xdisplay = window_private->xdisplay; + private->window_type = GDK_WINDOW_PIXMAP; + private->xwindow = XCreatePixmap (private->xdisplay, window_private->xwindow, + width, height, depth); + private->parent = NULL; + private->x = 0; + private->y = 0; + private->width = width; + private->height = height; + private->resize_count = 0; + private->ref_count = 1; + private->destroyed = 0; + + gdk_xid_table_insert (&private->xwindow, pixmap); + + return pixmap; +} + +GdkPixmap * +gdk_bitmap_create_from_data (GdkWindow *window, + gchar *data, + gint width, + gint height) +{ + GdkPixmap *pixmap; + GdkWindowPrivate *private; + GdkWindowPrivate *window_private; + + g_return_val_if_fail (data != NULL, NULL); + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + private = g_new (GdkWindowPrivate, 1); + pixmap = (GdkPixmap*) private; + + window_private = (GdkWindowPrivate*) window; + + private->parent = NULL; + private->xdisplay = window_private->xdisplay; + private->window_type = GDK_WINDOW_PIXMAP; + private->x = 0; + private->y = 0; + private->width = width; + private->height = height; + private->resize_count = 0; + private->ref_count = 1; + private->destroyed = FALSE; + + private->xwindow = XCreateBitmapFromData (private->xdisplay, + window_private->xwindow, + data, width, height); + + gdk_xid_table_insert (&private->xwindow, pixmap); + + return pixmap; +} + +GdkPixmap* +gdk_pixmap_create_from_data (GdkWindow *window, + gchar *data, + gint width, + gint height, + gint depth, + GdkColor *fg, + GdkColor *bg) +{ + GdkPixmap *pixmap; + GdkWindowPrivate *private; + GdkWindowPrivate *window_private; + + g_return_val_if_fail (data != NULL, NULL); + g_return_val_if_fail (fg != NULL, NULL); + g_return_val_if_fail (bg != NULL, NULL); + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + if (depth == -1) + gdk_window_get_geometry (window, NULL, NULL, NULL, NULL, &depth); + + private = g_new (GdkWindowPrivate, 1); + pixmap = (GdkPixmap*) private; + + window_private = (GdkWindowPrivate*) window; + + private->parent = NULL; + private->xdisplay = window_private->xdisplay; + private->window_type = GDK_WINDOW_PIXMAP; + private->x = 0; + private->y = 0; + private->width = width; + private->height = height; + private->resize_count = 0; + private->ref_count = 1; + private->destroyed = FALSE; + + private->xwindow = XCreatePixmapFromBitmapData (private->xdisplay, + window_private->xwindow, + data, width, height, + fg->pixel, bg->pixel, depth); + + gdk_xid_table_insert (&private->xwindow, pixmap); + + return pixmap; +} + +gint +gdk_pixmap_seek_string (FILE *infile, + const gchar *str, + gint skip_comments) +{ + char instr[1024]; + + while (!feof (infile)) + { + fscanf (infile, "%s", instr); + if (skip_comments == TRUE && strcmp (instr, "/*") == 0) + { + fscanf (infile, "%s", instr); + while (!feof (infile) && strcmp (instr, "*/") != 0) + fscanf (infile, "%s", instr); + fscanf(infile, "%s", instr); + } + if (strcmp (instr, str)==0) + return TRUE; + } + + return FALSE; +} + +gint +gdk_pixmap_seek_char (FILE *infile, + gchar c) +{ + gchar b, oldb; + + while (!feof (infile)) + { + fscanf(infile, "%c", &b); + if (c != b && b == '/') + { + fscanf (infile, "%c", &b); + if (b == '*') + { + oldb = b; + while (!feof (infile) && !(oldb == '*' && b == '/')) + { + oldb = b; + fscanf (infile, "%c", &b); + } + fscanf (infile, "%c", &b); + } + } + if (c == b) + return TRUE; + } + + return FALSE; +} + +gint +gdk_pixmap_read_string (FILE *infile, + gchar **buffer, + int *buffer_size) +{ + gchar c; + gint cnt = 0; + + if ((*buffer) == NULL) + { + (*buffer_size) = 10 * sizeof (gchar); + (*buffer) = (gchar *) malloc (*buffer_size); + } + + do + fscanf (infile, "%c", &c); + while (!feof (infile) && c != '"'); + + if (c != '"') + return FALSE; + + while (!feof (infile)) + { + fscanf (infile, "%c", &c); + + if (cnt == (*buffer_size)) + { + (*buffer_size) *= 2; + (*buffer) = (gchar *) realloc ((*buffer), *buffer_size); + } + + if (c != '"') + (*buffer)[cnt++] = c; + else + { + (*buffer)[cnt++] = 0; + return TRUE; + } + } + + return FALSE; +} + +gchar* +gdk_pixmap_skip_whitespaces (gchar *buffer) +{ + gint32 index = 0; + + while (buffer[index] != 0 && (buffer[index] == 0x20 || buffer[index] == 0x09)) + index++; + + return &buffer[index]; +} + +gchar* +gdk_pixmap_skip_string (gchar *buffer) +{ + gint32 index = 0; + + while (buffer[index] != 0 && buffer[index] != 0x20 && buffer[index] != 0x09) + index++; + + return &buffer[index]; +} + +gchar* +gdk_pixmap_extract_color (gchar *buffer) +{ + gint counter, finished = FALSE, numnames; + gchar *ptr = NULL, ch, temp[128]; + gchar color[128], *retcol; + + counter = 0; + while (ptr == NULL) + { + if (buffer[counter] == 'c') + { + ch = buffer[counter + 1]; + if (ch == 0x20 || ch == 0x09) + ptr = &buffer[counter + 1]; + } + else if (buffer[counter] == 0) + return NULL; + + counter++; + } + + if (ptr == NULL) + return NULL; + + ptr = gdk_pixmap_skip_whitespaces (ptr); + + if (ptr[0] == 0) + return NULL; + else if (ptr[0] == '#') + { + retcol = g_new(gchar, strlen (ptr) + 1); + strcpy (retcol, ptr); + return retcol; + } + + color[0] = 0; + numnames = 0; + + while (finished == FALSE) + { + sscanf (ptr, "%s", temp); + + if ((gint)ptr[0] == 0 || strcmp ("s", temp) == 0 || strcmp ("m", temp) == 0 || + strcmp ("g", temp) == 0 || strcmp ("g4", temp) == 0) + finished = TRUE; + else + { + if (numnames > 0) + strcat (color, " "); + strcat (color, temp); + ptr = gdk_pixmap_skip_string (ptr); + ptr = gdk_pixmap_skip_whitespaces (ptr); + numnames++; + } + } + + retcol = g_new(gchar, strlen (color) + 1); + strcpy (retcol, color); + return retcol; +} + + +GdkPixmap* +gdk_pixmap_create_from_xpm (GdkWindow *window, + GdkBitmap **mask, + GdkColor *transparent_color, + const gchar *filename) +{ + FILE *infile = NULL; + GdkPixmap *pixmap = NULL; + GdkImage *image = NULL; + GdkColormap *colormap; + GdkVisual *visual; + GdkGC *gc; + GdkColor tmp_color; + gint width, height, num_cols, cpp, cnt, n, ns, xcnt, ycnt; + gchar *buffer = NULL, *color_name = NULL, pixel_str[32]; + guint buffer_size = 0; + _GdkPixmapColor *colors = NULL, *color = NULL; + gulong index; + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + infile = fopen (filename, "rb"); + if (infile != NULL) + { + if (gdk_pixmap_seek_string (infile, "XPM", FALSE) == TRUE) + { + if (gdk_pixmap_seek_char (infile,'{') == TRUE) + { + gdk_pixmap_seek_char (infile, '"'); + fseek (infile, -1, SEEK_CUR); + gdk_pixmap_read_string (infile, &buffer, &buffer_size); + + sscanf (buffer,"%d %d %d %d", &width, &height, &num_cols, &cpp); + + colors = g_new(_GdkPixmapColor, num_cols); + + colormap = gdk_window_get_colormap (window); + visual = gdk_window_get_visual (window); + + if (transparent_color == NULL) + { + gdk_color_white (colormap, &tmp_color); + transparent_color = &tmp_color; + } + + for (cnt = 0; cnt < num_cols; cnt++) + { + gdk_pixmap_seek_char (infile, '"'); + fseek (infile, -1, SEEK_CUR); + gdk_pixmap_read_string (infile, &buffer, &buffer_size); + + colors[cnt].color_string = g_new(gchar, cpp + 1); + for (n = 0; n < cpp; n++) + colors[cnt].color_string[n] = buffer[n]; + colors[cnt].color_string[n] = 0; + colors[cnt].transparent = FALSE; + + if (color_name != NULL) + g_free (color_name); + + color_name = gdk_pixmap_extract_color (&buffer[cpp]); + + if (color_name != NULL) + { + if (gdk_color_parse (color_name, &colors[cnt].color) == FALSE) + { + colors[cnt].color = *transparent_color; + colors[cnt].transparent = TRUE; + } + } + else + { + colors[cnt].color = *transparent_color; + colors[cnt].transparent = TRUE; + } + + gdk_color_alloc (colormap, &colors[cnt].color); + } + + index = 0; + image = gdk_image_new (GDK_IMAGE_FASTEST, visual, width, height); + + gc = NULL; + if (mask) + { + *mask = gdk_pixmap_new (window, width, height, 1); + gc = gdk_gc_new (*mask); + + gdk_color_black (colormap, &tmp_color); + gdk_gc_set_foreground (gc, &tmp_color); + gdk_draw_rectangle (*mask, gc, TRUE, 0, 0, -1, -1); + + gdk_color_white (colormap, &tmp_color); + gdk_gc_set_foreground (gc, &tmp_color); + } + + for (ycnt = 0; ycnt < height; ycnt++) + { + gdk_pixmap_read_string (infile, &buffer, &buffer_size); + + for (n = 0, cnt = 0, xcnt = 0; n < (width * cpp); n += cpp, xcnt++) + { + strncpy (pixel_str, &buffer[n], cpp); + pixel_str[cpp] = 0; + color = NULL; + ns = 0; + + while (color == NULL) + { + if (strcmp (pixel_str, colors[ns].color_string) == 0) + color = &colors[ns]; + else + ns++; + } + + gdk_image_put_pixel (image, xcnt, ycnt, color->color.pixel); + + if (mask && color->transparent) + { + if (cnt < xcnt) + gdk_draw_line (*mask, gc, cnt, ycnt, xcnt - 1, ycnt); + cnt = xcnt + 1; + } + } + + if (mask && (cnt < xcnt)) + gdk_draw_line (*mask, gc, cnt, ycnt, xcnt - 1, ycnt); + } + + if (mask) + gdk_gc_destroy (gc); + + pixmap = gdk_pixmap_new (window, width, height, visual->depth); + + gc = gdk_gc_new (pixmap); + gdk_gc_set_foreground (gc, transparent_color); + gdk_draw_image (pixmap, gc, image, 0, 0, 0, 0, image->width, image->height); + gdk_gc_destroy (gc); + gdk_image_destroy (image); + } + } + + fclose (infile); + free (buffer); + + if (colors != NULL) + { + for (cnt = 0; cnt < num_cols; cnt++) + g_free (colors[cnt].color_string); + g_free (colors); + } + } + + return pixmap; +} + +GdkPixmap* +gdk_pixmap_create_from_xpm_d (GdkWindow *window, + GdkBitmap **mask, + GdkColor *transparent_color, + gchar **data) +{ + GdkPixmap *pixmap = NULL; + GdkImage *image = NULL; + GdkColormap *colormap; + GdkVisual *visual; + GdkGC *gc; + GdkColor tmp_color; + gint width, height, num_cols, cpp, cnt, n, ns, xcnt, ycnt, i; + gchar *buffer, *color_name = NULL, pixel_str[32]; + _GdkPixmapColor *colors = NULL, *color = NULL; + gulong index; + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + i = 0; + buffer = data[i++]; + sscanf (buffer,"%d %d %d %d", &width, &height, &num_cols, &cpp); + + colors = g_new(_GdkPixmapColor, num_cols); + + colormap = gdk_window_get_colormap (window); + visual = gdk_window_get_visual (window); + + if (transparent_color == NULL) + { + gdk_color_white (colormap, &tmp_color); + transparent_color = &tmp_color; + } + + for (cnt = 0; cnt < num_cols; cnt++) + { + buffer = data[i++]; + + colors[cnt].color_string = g_new(gchar, cpp + 1); + for (n = 0; n < cpp; n++) + colors[cnt].color_string[n] = buffer[n]; + colors[cnt].color_string[n] = 0; + colors[cnt].transparent = FALSE; + + if (color_name != NULL) + g_free (color_name); + + color_name = gdk_pixmap_extract_color (&buffer[cpp]); + + if (color_name != NULL) + { + if (gdk_color_parse (color_name, &colors[cnt].color) == FALSE) + { + colors[cnt].color = *transparent_color; + colors[cnt].transparent = TRUE; + } + } + else + { + colors[cnt].color = *transparent_color; + colors[cnt].transparent = TRUE; + } + + gdk_color_alloc (colormap, &colors[cnt].color); + } + + index = 0; + image = gdk_image_new (GDK_IMAGE_FASTEST, visual, width, height); + + gc = NULL; + if (mask) + { + *mask = gdk_pixmap_new (window, width, height, 1); + gc = gdk_gc_new (*mask); + + gdk_color_black (colormap, &tmp_color); + gdk_gc_set_foreground (gc, &tmp_color); + gdk_draw_rectangle (*mask, gc, TRUE, 0, 0, -1, -1); + + gdk_color_white (colormap, &tmp_color); + gdk_gc_set_foreground (gc, &tmp_color); + } + + for (ycnt = 0; ycnt < height; ycnt++) + { + buffer = data[i++]; + + for (n = 0, cnt = 0, xcnt = 0; n < (width * cpp); n += cpp, xcnt++) + { + strncpy (pixel_str, &buffer[n], cpp); + pixel_str[cpp] = 0; + color = NULL; + ns = 0; + + while (color == NULL) + { + if (strcmp (pixel_str, colors[ns].color_string) == 0) + color = &colors[ns]; + else + ns++; + } + + gdk_image_put_pixel (image, xcnt, ycnt, color->color.pixel); + + if (mask && color->transparent) + { + if (cnt < xcnt) + gdk_draw_line (*mask, gc, cnt, ycnt, xcnt - 1, ycnt); + cnt = xcnt + 1; + } + } + + if (mask && (cnt < xcnt)) + gdk_draw_line (*mask, gc, cnt, ycnt, xcnt - 1, ycnt); + } + + if (mask) + gdk_gc_destroy (gc); + + pixmap = gdk_pixmap_new (window, width, height, visual->depth); + + gc = gdk_gc_new (pixmap); + gdk_gc_set_foreground (gc, transparent_color); + gdk_draw_image (pixmap, gc, image, 0, 0, 0, 0, image->width, image->height); + gdk_gc_destroy (gc); + gdk_image_destroy (image); + + if (colors != NULL) + { + for (cnt = 0; cnt < num_cols; cnt++) + g_free (colors[cnt].color_string); + g_free (colors); + } + + return pixmap; +} + +void +gdk_pixmap_destroy (GdkPixmap *pixmap) +{ + GdkWindowPrivate *private; + + g_return_if_fail (pixmap != NULL); + + private = (GdkPixmapPrivate*) pixmap; + if (private->ref_count <= 0) + { + XFreePixmap (private->xdisplay, private->xwindow); + gdk_xid_table_remove (private->xwindow); + g_free (pixmap); + } + else + { + private->ref_count -= 1; + } +} diff --git a/gdk/x11/gdkproperty-x11.c b/gdk/x11/gdkproperty-x11.c new file mode 100644 index 000000000..35d8a50cf --- /dev/null +++ b/gdk/x11/gdkproperty-x11.c @@ -0,0 +1,194 @@ +/* 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 <X11/Xlib.h> +#include <X11/Xatom.h> +#include <string.h> +#include "gdk.h" +#include "gdkprivate.h" + + +GdkAtom +gdk_atom_intern (const gchar *atom_name, + gint only_if_exists) +{ + return XInternAtom (gdk_display, atom_name, only_if_exists); +} + +gchar * +gdk_atom_name (GdkAtom atom) +{ + gchar *t; + gchar *name; + + /* If this atom doesn't exist, we'll die with an X error unless + we take precautions */ + + gdk_error_warnings = 0; + t = XGetAtomName (gdk_display, atom); + gdk_error_warnings = 1; + + if (gdk_error_code == -1) + { + return NULL; + } + else + { + name = g_strdup (t); + XFree (t); + + return name; + } +} + +gint +gdk_property_get (GdkWindow *window, + GdkAtom property, + GdkAtom type, + gulong offset, + gulong length, + gint pdelete, + GdkAtom *actual_property_type, + gint *actual_format_type, + gint *actual_length, + guchar **data) +{ + GdkWindowPrivate *private; + Display *xdisplay; + Window xwindow; + Atom ret_prop_type; + gint ret_format; + gulong ret_nitems; + gulong ret_bytes_after; + gulong ret_length; + guchar *ret_data; + + if (window) + { + private = (GdkWindowPrivate*) window; + xdisplay = private->xdisplay; + xwindow = private->xwindow; + } + else + { + xdisplay = gdk_display; + xwindow = gdk_root_window; + } + + XGetWindowProperty (xdisplay, xwindow, property, + offset, (length + 3) / 4, pdelete, + type, &ret_prop_type, &ret_format, + &ret_nitems, &ret_bytes_after, + &ret_data); + + if ((ret_prop_type == None) && (ret_format == 0)) + return FALSE; + + if (actual_property_type) + *actual_property_type = ret_prop_type; + if (actual_format_type) + *actual_format_type = ret_format; + + if (ret_prop_type != property) + { + XFree (ret_data); + return FALSE; + } + + /* FIXME: ignoring bytes_after could have very bad effects */ + + if (data) + { + switch (ret_format) + { + case 8: + ret_length = ret_nitems; + break; + case 16: + ret_length = 2 * ret_nitems; + break; + case 32: + ret_length = 4 * ret_nitems; + break; + default: + g_warning ("unknown property return format: %d", ret_format); + XFree (ret_data); + return FALSE; + } + + *data = g_new (guchar, ret_length); + memcpy (*data, ret_data, ret_length); + if (actual_length) + *actual_length = ret_length; + } + + XFree (ret_data); + + return TRUE; +} + +void +gdk_property_change (GdkWindow *window, + GdkAtom property, + GdkAtom type, + gint format, + GdkPropMode mode, + guchar *data, + gint nelements) +{ + GdkWindowPrivate *private; + Display *xdisplay; + Window xwindow; + + if (window) + { + private = (GdkWindowPrivate*) window; + xdisplay = private->xdisplay; + xwindow = private->xwindow; + } + else + { + xdisplay = gdk_display; + xwindow = gdk_root_window; + } + + XChangeProperty (xdisplay, xwindow, property, type, + format, mode, data, nelements); +} + +void +gdk_property_delete (GdkWindow *window, + GdkAtom property) +{ + GdkWindowPrivate *private; + Display *xdisplay; + Window xwindow; + + if (window) + { + private = (GdkWindowPrivate*) window; + xdisplay = private->xdisplay; + xwindow = private->xwindow; + } + else + { + xdisplay = gdk_display; + xwindow = gdk_root_window; + } + + XDeleteProperty (xdisplay, xwindow, property); +} diff --git a/gdk/x11/gdkselection-x11.c b/gdk/x11/gdkselection-x11.c new file mode 100644 index 000000000..6bd425110 --- /dev/null +++ b/gdk/x11/gdkselection-x11.c @@ -0,0 +1,168 @@ +/* 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 <X11/Xlib.h> +#include <X11/Xatom.h> +#include <string.h> +#include "gdk.h" +#include "gdkprivate.h" + + +gint +gdk_selection_owner_set (GdkWindow *owner, + GdkAtom selection, + guint32 time, + gint send_event) +{ + GdkWindowPrivate *private; + Display *xdisplay; + Window xwindow; + + if (owner) + { + private = (GdkWindowPrivate*) owner; + xdisplay = private->xdisplay; + xwindow = private->xwindow; + } + else + { + xdisplay = gdk_display; + xwindow = None; + } + + XSetSelectionOwner (xdisplay, selection, xwindow, time); + + return (XGetSelectionOwner (xdisplay, selection) == xwindow); +} + +GdkWindow* +gdk_selection_owner_get (GdkAtom selection) +{ + Window xwindow; + + xwindow = XGetSelectionOwner (gdk_display, selection); + if (xwindow == None) + return NULL; + + return gdk_window_lookup (xwindow); +} + +void +gdk_selection_convert (GdkWindow *requestor, + GdkAtom selection, + GdkAtom target, + guint32 time) +{ + GdkWindowPrivate *private; + + g_return_if_fail (requestor != NULL); + + private = (GdkWindowPrivate*) requestor; + + XConvertSelection (private->xdisplay, selection, target, + gdk_selection_property, private->xwindow, time); +} + +gint +gdk_selection_property_get (GdkWindow *requestor, + guchar **data, + GdkAtom *ret_type, + gint *ret_format) +{ + GdkWindowPrivate *private; + gulong nitems; + gulong nbytes; + gulong length; + GdkAtom prop_type; + gint prop_format; + guchar *t; + + g_return_val_if_fail (requestor != NULL, 0); + + /* If retrieved chunks are typically small, (and the ICCM says the + should be) it would be a win to try first with a buffer of + moderate length, to avoid two round trips to the server */ + + private = (GdkWindowPrivate*) requestor; + + XGetWindowProperty (private->xdisplay, private->xwindow, + gdk_selection_property, 0, 0, False, + AnyPropertyType, &prop_type, &prop_format, + &nitems, &nbytes, &t); + + if (ret_type) + *ret_type = prop_type; + if (ret_format) + *ret_format = prop_format; + + if (prop_type == None) + { + *data = NULL; + return 0; + } + + XFree (t); + + /* Add on an extra byte to handle null termination. X guarantees + that t will be 1 longer than nbytes and null terminated */ + length = nbytes + 1; + + /* We can't delete the selection here, because it might be the INCR + protocol, in which case the client has to make sure they'll be + notified of PropertyChange events _before_ the property is deleted. + Otherwise there's no guarantee we'll win the race ... */ + XGetWindowProperty (private->xdisplay, private->xwindow, + gdk_selection_property, 0, (nbytes + 3) / 4, False, + AnyPropertyType, &prop_type, &prop_format, + &nitems, &nbytes, &t); + + if (prop_type != None) + { + *data = g_new (guchar, length); + memcpy (*data, t, length); + XFree (t); + return length-1; + } + else + { + *data = NULL; + return 0; + } +} + + +void +gdk_selection_send_notify (guint32 requestor, + GdkAtom selection, + GdkAtom target, + GdkAtom property, + guint32 time) +{ + XSelectionEvent xevent; + + xevent.type = SelectionNotify; + xevent.serial = 0; + xevent.send_event = True; + xevent.display = gdk_display; + xevent.requestor = requestor; + xevent.selection = selection; + xevent.target = target; + xevent.property = property; + xevent.time = time; + + XSendEvent (gdk_display, requestor, False, NoEventMask, (XEvent*) &xevent); +} diff --git a/gdk/x11/gdkvisual-x11.c b/gdk/x11/gdkvisual-x11.c new file mode 100644 index 000000000..22acee6f1 --- /dev/null +++ b/gdk/x11/gdkvisual-x11.c @@ -0,0 +1,431 @@ +/* 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 <X11/Xlib.h> +#include <X11/Xutil.h> +#include "gdk.h" +#include "gdkprivate.h" + + +static void gdk_visual_add (GdkVisual *visual); +static void gdk_visual_decompose_mask (gulong mask, + gint *shift, + gint *prec); +static guint gdk_visual_hash (Visual *key); +static gint gdk_visual_compare (Visual *a, + Visual *b); + + +static GdkVisualPrivate *system_visual; +static GdkVisualPrivate *visuals; +static gint nvisuals; + +static gint available_depths[4]; +static gint navailable_depths; + +static GdkVisualType available_types[6]; +static gint navailable_types; + +static char* visual_names[] = +{ + "static gray", + "grayscale", + "static color", + "pseudo color", + "true color", + "direct color", +}; + +static GHashTable *visual_hash = NULL; + +void +gdk_visual_init () +{ + static gint possible_depths[5] = { 32, 24, 16, 15, 8 }; + static GdkVisualType possible_types[6] = + { + GDK_VISUAL_DIRECT_COLOR, + GDK_VISUAL_TRUE_COLOR, + GDK_VISUAL_PSEUDO_COLOR, + GDK_VISUAL_STATIC_COLOR, + GDK_VISUAL_GRAYSCALE, + GDK_VISUAL_STATIC_GRAY + }; + + static gint npossible_depths = 5; + static gint npossible_types = 6; + + XVisualInfo *visual_list; + XVisualInfo visual_template; + GdkVisualPrivate temp_visual; + Visual *default_xvisual; + int nxvisuals; + int i, j; + + visual_template.screen = gdk_screen; + visual_list = XGetVisualInfo (gdk_display, VisualScreenMask, &visual_template, &nxvisuals); + visuals = g_new (GdkVisualPrivate, nxvisuals); + + default_xvisual = DefaultVisual (gdk_display, gdk_screen); + + nvisuals = 0; + for (i = 0; i < nxvisuals; i++) + { + if (visual_list[i].depth >= 8) + { +#ifdef __cplusplus + switch (visual_list[i].c_class) +#else /* __cplusplus */ + switch (visual_list[i].class) +#endif /* __cplusplus */ + { + case StaticGray: + visuals[nvisuals].visual.type = GDK_VISUAL_STATIC_GRAY; + break; + case GrayScale: + visuals[nvisuals].visual.type = GDK_VISUAL_GRAYSCALE; + break; + case StaticColor: + visuals[nvisuals].visual.type = GDK_VISUAL_STATIC_COLOR; + break; + case PseudoColor: + visuals[nvisuals].visual.type = GDK_VISUAL_PSEUDO_COLOR; + break; + case TrueColor: + visuals[nvisuals].visual.type = GDK_VISUAL_TRUE_COLOR; + break; + case DirectColor: + visuals[nvisuals].visual.type = GDK_VISUAL_DIRECT_COLOR; + break; + } + + visuals[nvisuals].visual.depth = visual_list[i].depth; + visuals[nvisuals].visual.byte_order = + (ImageByteOrder(gdk_display) == LSBFirst) ? + GDK_LSB_FIRST : GDK_MSB_FIRST; + visuals[nvisuals].visual.red_mask = visual_list[i].red_mask; + visuals[nvisuals].visual.green_mask = visual_list[i].green_mask; + visuals[nvisuals].visual.blue_mask = visual_list[i].blue_mask; + visuals[nvisuals].visual.colormap_size = visual_list[i].colormap_size; + visuals[nvisuals].visual.bits_per_rgb = visual_list[i].bits_per_rgb; + visuals[nvisuals].xvisual = visual_list[i].visual; + + if ((visuals[nvisuals].visual.type == GDK_VISUAL_TRUE_COLOR) || + (visuals[nvisuals].visual.type == GDK_VISUAL_DIRECT_COLOR)) + { + gdk_visual_decompose_mask (visuals[nvisuals].visual.red_mask, + &visuals[nvisuals].visual.red_shift, + &visuals[nvisuals].visual.red_prec); + + gdk_visual_decompose_mask (visuals[nvisuals].visual.green_mask, + &visuals[nvisuals].visual.green_shift, + &visuals[nvisuals].visual.green_prec); + + gdk_visual_decompose_mask (visuals[nvisuals].visual.blue_mask, + &visuals[nvisuals].visual.blue_shift, + &visuals[nvisuals].visual.blue_prec); + } + else + { + visuals[nvisuals].visual.red_mask = 0; + visuals[nvisuals].visual.red_shift = 0; + visuals[nvisuals].visual.red_prec = 0; + + visuals[nvisuals].visual.green_mask = 0; + visuals[nvisuals].visual.green_shift = 0; + visuals[nvisuals].visual.green_prec = 0; + + visuals[nvisuals].visual.blue_mask = 0; + visuals[nvisuals].visual.blue_shift = 0; + visuals[nvisuals].visual.blue_prec = 0; + } + + nvisuals += 1; + } + } + + XFree (visual_list); + + for (i = 0; i < nvisuals; i++) + { + for (j = i+1; j < nvisuals; j++) + { + if (visuals[j].visual.depth >= visuals[i].visual.depth) + { + if ((visuals[j].visual.depth == 8) && (visuals[i].visual.depth == 8)) + { + if (visuals[j].visual.type == GDK_VISUAL_PSEUDO_COLOR) + { + temp_visual = visuals[j]; + visuals[j] = visuals[i]; + visuals[i] = temp_visual; + } + else if ((visuals[i].visual.type != GDK_VISUAL_PSEUDO_COLOR) && + visuals[j].visual.type > visuals[i].visual.type) + { + temp_visual = visuals[j]; + visuals[j] = visuals[i]; + visuals[i] = temp_visual; + } + } + else if ((visuals[j].visual.depth > visuals[i].visual.depth) || + ((visuals[j].visual.depth == visuals[i].visual.depth) && + (visuals[j].visual.type > visuals[i].visual.type))) + { + temp_visual = visuals[j]; + visuals[j] = visuals[i]; + visuals[i] = temp_visual; + } + } + } + } + + for (i = 0; i < nvisuals; i++) + if (default_xvisual->visualid == visuals[i].xvisual->visualid) + { + system_visual = &visuals[i]; + break; + } + + if (gdk_debug_level >= 1) + for (i = 0; i < nvisuals; i++) + g_print ("visual: %s: %d\n", + visual_names[visuals[i].visual.type], + visuals[i].visual.depth); + + navailable_depths = 0; + for (i = 0; i < npossible_depths; i++) + { + for (j = 0; j < nvisuals; j++) + { + if (visuals[j].visual.depth == possible_depths[i]) + { + available_depths[navailable_depths++] = visuals[j].visual.depth; + break; + } + } + } + + if (navailable_depths == 0) + g_error ("unable to find a usable depth"); + + navailable_types = 0; + for (i = 0; i < npossible_types; i++) + { + for (j = 0; j < nvisuals; j++) + { + if (visuals[j].visual.type == possible_types[i]) + { + available_types[navailable_types++] = visuals[j].visual.type; + break; + } + } + } + + for (i = 0; i < nvisuals; i++) + gdk_visual_add ((GdkVisual*) &visuals[i]); + + if (npossible_types == 0) + g_error ("unable to find a usable visual type"); +} + +GdkVisual* +gdk_visual_ref (GdkVisual *visual) +{ + return visual; +} + +void +gdk_visual_unref (GdkVisual *visual) +{ + return; +} + +gint +gdk_visual_get_best_depth () +{ + return available_depths[0]; +} + +GdkVisualType +gdk_visual_get_best_type () +{ + return available_types[0]; +} + +GdkVisual* +gdk_visual_get_system () +{ + return ((GdkVisual*) system_visual); +} + +GdkVisual* +gdk_visual_get_best () +{ + return ((GdkVisual*) &(visuals[0])); +} + +GdkVisual* +gdk_visual_get_best_with_depth (gint depth) +{ + GdkVisual *return_val; + int i; + + return_val = NULL; + for (i = 0; i < nvisuals; i++) + if (depth == visuals[i].visual.depth) + { + return_val = (GdkVisual*) &(visuals[i]); + break; + } + + return return_val; +} + +GdkVisual* +gdk_visual_get_best_with_type (GdkVisualType visual_type) +{ + GdkVisual *return_val; + int i; + + return_val = NULL; + for (i = 0; i < nvisuals; i++) + if (visual_type == visuals[i].visual.type) + { + return_val = (GdkVisual*) &(visuals[i]); + break; + } + + return return_val; +} + +GdkVisual* +gdk_visual_get_best_with_both (gint depth, + GdkVisualType visual_type) +{ + GdkVisual *return_val; + int i; + + return_val = NULL; + for (i = 0; i < nvisuals; i++) + if ((depth == visuals[i].visual.depth) && + (visual_type == visuals[i].visual.type)) + { + return_val = (GdkVisual*) &(visuals[i]); + break; + } + + return return_val; +} + +void +gdk_query_depths (gint **depths, + gint *count) +{ + *count = navailable_depths; + *depths = available_depths; +} + +void +gdk_query_visual_types (GdkVisualType **visual_types, + gint *count) +{ + *count = navailable_types; + *visual_types = available_types; +} + +void +gdk_query_visuals (GdkVisual **visual_return, + gint *count) +{ + *count = nvisuals; + *visual_return = (GdkVisual*) visuals; +} + + +GdkVisual* +gdk_visual_lookup (Visual *xvisual) +{ + GdkVisual *visual; + + if (!visual_hash) + return NULL; + + visual = g_hash_table_lookup (visual_hash, xvisual); + return visual; +} + +GdkVisual* +gdkx_visual_get (VisualID xvisualid) +{ + int i; + + for (i = 0; i < nvisuals; i++) + if (xvisualid == visuals[i].xvisual->visualid) + return (GdkVisual*) &visuals[i]; + + return NULL; +} + + +static void +gdk_visual_add (GdkVisual *visual) +{ + GdkVisualPrivate *private; + + if (!visual_hash) + visual_hash = g_hash_table_new ((GHashFunc) gdk_visual_hash, + (GCompareFunc) gdk_visual_compare); + + private = (GdkVisualPrivate*) visual; + + g_hash_table_insert (visual_hash, private->xvisual, visual); +} + +static void +gdk_visual_decompose_mask (gulong mask, + gint *shift, + gint *prec) +{ + *shift = 0; + *prec = 0; + + while (!(mask & 0x1)) + { + (*shift)++; + mask >>= 1; + } + + while (mask & 0x1) + { + (*prec)++; + mask >>= 1; + } +} + +static guint +gdk_visual_hash (Visual *key) +{ + return key->visualid; +} + +static gint +gdk_visual_compare (Visual *a, + Visual *b) +{ + return (a->visualid == b->visualid); +} diff --git a/gdk/x11/gdkwindow-x11.c b/gdk/x11/gdkwindow-x11.c new file mode 100644 index 000000000..aef1367d9 --- /dev/null +++ b/gdk/x11/gdkwindow-x11.c @@ -0,0 +1,1358 @@ +/* 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 <X11/Xlib.h> +#include <X11/Xutil.h> +#include <X11/Xatom.h> +#include <X11/extensions/shape.h> +#include <netinet/in.h> +#include "gdk.h" +#include "gdkinput.h" +#include "gdkprivate.h" +#include <stdlib.h> + +int nevent_masks = 16; +int event_mask_table[18] = +{ + ExposureMask, + PointerMotionMask, + PointerMotionHintMask, + ButtonMotionMask, + Button1MotionMask, + Button2MotionMask, + Button3MotionMask, + ButtonPressMask | OwnerGrabButtonMask, + ButtonReleaseMask | OwnerGrabButtonMask, + KeyPressMask, + KeyReleaseMask, + EnterWindowMask, + LeaveWindowMask, + FocusChangeMask, + StructureNotifyMask, + PropertyChangeMask, + 0, /* PROXIMITY_IN */ + 0 /* PROXIMTY_OUT */ +}; + + +void +gdk_window_init () +{ + XWindowAttributes xattributes; + unsigned int width; + unsigned int height; + unsigned int border_width; + unsigned int depth; + int x, y; + + XGetGeometry (gdk_display, gdk_root_window, &gdk_root_window, + &x, &y, &width, &height, &border_width, &depth); + XGetWindowAttributes (gdk_display, gdk_root_window, &xattributes); + + gdk_root_parent.xdisplay = gdk_display; + gdk_root_parent.xwindow = gdk_root_window; + gdk_root_parent.window_type = GDK_WINDOW_ROOT; + gdk_root_parent.window.user_data = NULL; +} + +GdkWindow* +gdk_window_new (GdkWindow *parent, + GdkWindowAttr *attributes, + gint attributes_mask) +{ + GdkWindow *window; + GdkWindowPrivate *private; + GdkWindowPrivate *parent_private; + GdkVisual *visual; + GdkColormap *colormap; + Display *parent_display; + Window xparent; + Visual *xvisual; + XSetWindowAttributes xattributes; + long xattributes_mask; + XSizeHints size_hints; + XWMHints wm_hints; + XTextProperty text_property; + XClassHint *class_hint; + int x, y, depth; + unsigned int class; + char *title; + int i; + + g_return_val_if_fail (attributes != NULL, NULL); + + if (!parent) + parent = (GdkWindow*) &gdk_root_parent; + + parent_private = (GdkWindowPrivate*) parent; + xparent = parent_private->xwindow; + parent_display = parent_private->xdisplay; + + private = g_new (GdkWindowPrivate, 1); + window = (GdkWindow*) private; + + private->parent = parent; + private->xdisplay = parent_display; + private->destroyed = FALSE; + private->resize_count = 0; + private->ref_count = 1; + xattributes_mask = 0; + + if (attributes_mask & GDK_WA_X) + x = attributes->x; + else + x = 0; + + if (attributes_mask & GDK_WA_Y) + y = attributes->y; + else + y = 0; + + private->x = x; + private->y = y; + private->width = (attributes->width > 1) ? (attributes->width) : (1); + private->height = (attributes->height > 1) ? (attributes->height) : (1); + private->window_type = attributes->window_type; + private->extension_events = FALSE; + private->dnd_drag_data_type = None; + private->dnd_drag_data_typesavail = + private->dnd_drop_data_typesavail = NULL; + private->dnd_drop_enabled = private->dnd_drag_enabled = + private->dnd_drag_accepted = private->dnd_drag_datashow = + private->dnd_drop_data_numtypesavail = + private->dnd_drag_data_numtypesavail = 0; + private->dnd_drag_eventmask = private->dnd_drag_savedeventmask = 0; + + window->user_data = NULL; + + if (attributes_mask & GDK_WA_VISUAL) + visual = attributes->visual; + else + visual = gdk_visual_get_system (); + xvisual = ((GdkVisualPrivate*) visual)->xvisual; + + xattributes.event_mask = StructureNotifyMask; + for (i = 0; i < nevent_masks; i++) + { + if (attributes->event_mask & (1 << (i + 1))) + xattributes.event_mask |= event_mask_table[i]; + } + + if (xattributes.event_mask) + xattributes_mask |= CWEventMask; + + if (attributes->wclass == GDK_INPUT_OUTPUT) + { + class = InputOutput; + depth = visual->depth; + + if (attributes_mask & GDK_WA_COLORMAP) + colormap = attributes->colormap; + else + colormap = gdk_colormap_get_system (); + + xattributes.background_pixel = BlackPixel (gdk_display, gdk_screen); + xattributes.border_pixel = BlackPixel (gdk_display, gdk_screen); + xattributes_mask |= CWBorderPixel | CWBackPixel; + + switch (private->window_type) + { + case GDK_WINDOW_TOPLEVEL: + xattributes.colormap = ((GdkColormapPrivate*) colormap)->xcolormap; + xattributes_mask |= CWColormap; + + xparent = gdk_root_window; + break; + + case GDK_WINDOW_CHILD: + xattributes.colormap = ((GdkColormapPrivate*) colormap)->xcolormap; + xattributes_mask |= CWColormap; + break; + + case GDK_WINDOW_DIALOG: + xattributes.colormap = ((GdkColormapPrivate*) colormap)->xcolormap; + xattributes_mask |= CWColormap; + + xparent = gdk_root_window; + break; + + case GDK_WINDOW_TEMP: + xattributes.colormap = ((GdkColormapPrivate*) colormap)->xcolormap; + xattributes_mask |= CWColormap; + + xparent = gdk_root_window; + + xattributes.save_under = True; + xattributes.override_redirect = True; + xattributes.cursor = None; + xattributes_mask |= CWSaveUnder | CWOverrideRedirect; + break; + case GDK_WINDOW_ROOT: + g_error ("cannot make windows of type GDK_WINDOW_ROOT"); + break; + case GDK_WINDOW_PIXMAP: + g_error ("cannot make windows of type GDK_WINDOW_PIXMAP (use gdk_pixmap_new)"); + break; + } + } + else + { + depth = 1; + class = InputOnly; + colormap = NULL; + } + + private->xwindow = XCreateWindow (private->xdisplay, xparent, + x, y, private->width, private->height, + 0, depth, class, xvisual, + xattributes_mask, &xattributes); + gdk_xid_table_insert (&private->xwindow, window); + + switch (private->window_type) + { + case GDK_WINDOW_DIALOG: + XSetTransientForHint (private->xdisplay, private->xwindow, xparent); + case GDK_WINDOW_TOPLEVEL: + case GDK_WINDOW_TEMP: + XSetWMProtocols (private->xdisplay, private->xwindow, gdk_wm_window_protocols, 2); + break; + case GDK_WINDOW_CHILD: + if ((attributes->wclass == GDK_INPUT_OUTPUT) && + (colormap != gdk_colormap_get_system ()) && + (colormap != gdk_window_get_colormap (gdk_window_get_toplevel (window)))) + { + g_print ("adding colormap window\n"); + gdk_window_add_colormap_windows (window); + } + break; + default: + break; + } + + size_hints.flags = PSize | PBaseSize; + size_hints.width = private->width; + size_hints.height = private->height; + size_hints.base_width = private->width; + size_hints.base_height = private->height; + + wm_hints.flags = InputHint | StateHint | WindowGroupHint; + wm_hints.window_group = gdk_leader_window; + wm_hints.input = True; + wm_hints.initial_state = NormalState; + + XSetWMNormalHints (private->xdisplay, private->xwindow, &size_hints); + XSetWMHints (private->xdisplay, private->xwindow, &wm_hints); + + if (attributes_mask & GDK_WA_TITLE) + title = attributes->title; + else + title = gdk_progname; + + if (XStringListToTextProperty (&title, 1, &text_property)) + { + XSetWMName (private->xdisplay, private->xwindow, &text_property); + XSetWMIconName (private->xdisplay, private->xwindow, &text_property); + XFree (text_property.value); + } + + if (attributes_mask & GDK_WA_WMCLASS) + { + class_hint = XAllocClassHint (); + class_hint->res_name = attributes->wmclass_name; + class_hint->res_class = attributes->wmclass_class; + XSetClassHint (private->xdisplay, private->xwindow, class_hint); + XFree (class_hint); + } + + gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ? + (attributes->cursor) : + NULL)); + + return window; +} + +GdkWindow * +gdk_window_foreign_new (guint32 anid) +{ + GdkWindow *window; + GdkWindowPrivate *private; + XWindowAttributes attrs; + + private = g_new (GdkWindowPrivate, 1); + window = (GdkWindow*) private; + + XGetWindowAttributes (gdk_display, anid, &attrs); + + private->parent = NULL; + private->xwindow = anid; + private->xdisplay = gdk_display; + private->x = attrs.x; + private->y = attrs.y; + private->width = attrs.width; + private->height = attrs.height; + private->resize_count = 0; + private->ref_count = 1; + if (anid == attrs.root) + private->window_type = GDK_WINDOW_ROOT; + else + private->window_type = GDK_WINDOW_TOPLEVEL; + /* the above is probably wrong, but it may not be worth the extra + X call to get it right */ + + private->destroyed = FALSE; + private->extension_events = 0; + + window->user_data = NULL; + + gdk_xid_table_insert (&private->xwindow, window); + + return window; +} + +void +gdk_window_destroy (GdkWindow *window) +{ + GdkWindowPrivate *private; + GdkWindowPrivate *temp_private; + GdkWindow *temp_window; + GList *children; + GList *tmp; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + if(private->dnd_drag_data_numtypesavail > 0) + { + free(private->dnd_drag_data_typesavail); + private->dnd_drag_data_typesavail = NULL; + } + if(private->dnd_drop_data_numtypesavail > 0) + { + free(private->dnd_drop_data_typesavail); + private->dnd_drop_data_typesavail = NULL; + } + + switch (private->window_type) + { + case GDK_WINDOW_TOPLEVEL: + case GDK_WINDOW_CHILD: + case GDK_WINDOW_DIALOG: + case GDK_WINDOW_TEMP: + if (private->ref_count >= 1) + private->ref_count -= 1; + + if (!private->destroyed || (private->destroyed == 2)) + { + children = gdk_window_get_children (window); + tmp = children; + + while (tmp) + { + temp_window = tmp->data; + tmp = tmp->next; + + temp_private = (GdkWindowPrivate*) temp_window; + if (temp_private && !temp_private->destroyed) + /* Removes some nice coredumps... /David */ + { + temp_private->destroyed = 2; + temp_private->ref_count += 1; + gdk_window_destroy (temp_window); + } + } + + g_list_free (children); + + if (!private->destroyed) + XDestroyWindow (private->xdisplay, private->xwindow); + private->destroyed = TRUE; + } + break; + + case GDK_WINDOW_ROOT: + g_error ("attempted to destroy root window"); + break; + + case GDK_WINDOW_PIXMAP: + g_warning ("called gdk_window_destroy on a pixmap (use gdk_pixmap_destroy)"); + gdk_pixmap_destroy (window); + break; + } +} + +void +gdk_window_real_destroy (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + + if (private->extension_events != 0) + gdk_input_window_destroy (window); + + if (private->ref_count == 0) + { + gdk_xid_table_remove (private->xwindow); + g_free (window); + } +} + +GdkWindow* +gdk_window_ref (GdkWindow *window) +{ + GdkWindowPrivate *private = (GdkWindowPrivate *)window; + g_return_if_fail (window != NULL); + + private->ref_count += 1; + return window; +} + +void +gdk_window_unref (GdkWindow *window) +{ + GdkWindowPrivate *private = (GdkWindowPrivate *)window; + g_return_if_fail (window != NULL); + + private->ref_count -= 1; + if (private->ref_count == 0) + gdk_window_real_destroy (window); +} + +void +gdk_window_show (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + if (!private->destroyed) + { + XRaiseWindow (private->xdisplay, private->xwindow); + XMapWindow (private->xdisplay, private->xwindow); + } +} + +void +gdk_window_hide (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + if (!private->destroyed) + XUnmapWindow (private->xdisplay, private->xwindow); +} + +void +gdk_window_move (GdkWindow *window, + gint x, + gint y) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + XMoveWindow (private->xdisplay, private->xwindow, x, y); + + if (private->window_type == GDK_WINDOW_CHILD) + { + private->x = x; + private->y = y; + } +} + +void +gdk_window_resize (GdkWindow *window, + gint width, + gint height) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + if (width < 1) + width = 1; + if (height < 1) + height = 1; + + private = (GdkWindowPrivate*) window; + + if (!private->destroyed && + ((private->resize_count > 0) || + (private->width != (guint16) width) || + (private->height != (guint16) height))) + { + XResizeWindow (private->xdisplay, private->xwindow, width, height); + private->resize_count += 1; + + if (private->window_type == GDK_WINDOW_CHILD) + { + private->width = width; + private->height = height; + } + } +} + +void +gdk_window_move_resize (GdkWindow *window, + gint x, + gint y, + gint width, + gint height) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + if (width < 1) + width = 1; + if (height < 1) + height = 1; + + private = (GdkWindowPrivate*) window; + XMoveResizeWindow (private->xdisplay, private->xwindow, x, y, width, height); + + if (!private->destroyed && + (private->window_type == GDK_WINDOW_CHILD)) + { + private->x = x; + private->y = y; + private->width = width; + private->height = height; + } +} + +void +gdk_window_reparent (GdkWindow *window, + GdkWindow *new_parent, + gint x, + gint y) +{ + GdkWindowPrivate *window_private; + GdkWindowPrivate *parent_private; + + g_return_if_fail (window != NULL); + + if (!new_parent) + new_parent = (GdkWindow*) &gdk_root_parent; + + window_private = (GdkWindowPrivate*) window; + parent_private = (GdkWindowPrivate*) new_parent; + + XReparentWindow (window_private->xdisplay, + window_private->xwindow, + parent_private->xwindow, + x, y); +} + +void +gdk_window_clear (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + + XClearWindow (private->xdisplay, private->xwindow); +} + +void +gdk_window_clear_area (GdkWindow *window, + gint x, + gint y, + gint width, + gint height) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + + if (!private->destroyed) + XClearArea (private->xdisplay, private->xwindow, + x, y, width, height, False); +} + +void +gdk_window_clear_area_e (GdkWindow *window, + gint x, + gint y, + gint width, + gint height) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + + if (!private->destroyed) + XClearArea (private->xdisplay, private->xwindow, + x, y, width, height, True); +} + +void +gdk_window_copy_area (GdkWindow *window, + GdkGC *gc, + gint x, + gint y, + GdkWindow *source_window, + gint source_x, + gint source_y, + gint width, + gint height) +{ + GdkWindowPrivate *src_private; + GdkWindowPrivate *dest_private; + GdkGCPrivate *gc_private; + + g_return_if_fail (window != NULL); + g_return_if_fail (gc != NULL); + + if (source_window == NULL) + source_window = window; + + src_private = (GdkWindowPrivate*) source_window; + dest_private = (GdkWindowPrivate*) window; + gc_private = (GdkGCPrivate*) gc; + + if (!src_private->destroyed && !dest_private->destroyed) + { + XCopyArea (dest_private->xdisplay, src_private->xwindow, dest_private->xwindow, + gc_private->xgc, + source_x, source_y, + width, height, + x, y); + } +} + +void +gdk_window_raise (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + + if (!private->destroyed) + XRaiseWindow (private->xdisplay, private->xwindow); +} + +void +gdk_window_lower (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + + if (!private->destroyed) + XLowerWindow (private->xdisplay, private->xwindow); +} + +void +gdk_window_set_user_data (GdkWindow *window, + gpointer user_data) +{ + g_return_if_fail (window != NULL); + + window->user_data = user_data; +} + +void +gdk_window_set_hints (GdkWindow *window, + gint x, + gint y, + gint min_width, + gint min_height, + gint max_width, + gint max_height, + gint flags) +{ + GdkWindowPrivate *private; + XSizeHints size_hints; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + size_hints.flags = 0; + + if (flags & GDK_HINT_POS) + { + size_hints.flags |= PPosition; + size_hints.x = x; + size_hints.y = y; + } + + if (flags & GDK_HINT_MIN_SIZE) + { + size_hints.flags |= PMinSize; + size_hints.min_width = min_width; + size_hints.min_height = min_height; + } + + if (flags & GDK_HINT_MAX_SIZE) + { + size_hints.flags |= PMaxSize; + size_hints.max_width = max_width; + size_hints.max_height = max_height; + } + + if (flags) + XSetWMNormalHints (private->xdisplay, private->xwindow, &size_hints); +} + +void +gdk_window_set_title (GdkWindow *window, + const gchar *title) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + XStoreName (private->xdisplay, private->xwindow, title); + XSetIconName (private->xdisplay, private->xwindow, title); +} + +void +gdk_window_set_background (GdkWindow *window, + GdkColor *color) +{ + GdkWindowPrivate *private; + + g_return_if_fail (window != NULL); + + private = (GdkWindowPrivate*) window; + XSetWindowBackground (private->xdisplay, private->xwindow, color->pixel); +} + +void +gdk_window_set_back_pixmap (GdkWindow *window, + GdkPixmap *pixmap, + gint parent_relative) +{ + GdkWindowPrivate *window_private; + GdkPixmapPrivate *pixmap_private; + Pixmap xpixmap; + + g_return_if_fail (window != NULL); + + window_private = (GdkWindowPrivate*) window; + pixmap_private = (GdkPixmapPrivate*) pixmap; + + if (pixmap) + xpixmap = pixmap_private->xwindow; + else + xpixmap = None; + + if (parent_relative) + xpixmap = ParentRelative; + + XSetWindowBackgroundPixmap (window_private->xdisplay, window_private->xwindow, xpixmap); +} + +void +gdk_window_set_cursor (GdkWindow *window, + GdkCursor *cursor) +{ + GdkWindowPrivate *window_private; + GdkCursorPrivate *cursor_private; + Cursor xcursor; + + g_return_if_fail (window != NULL); + + window_private = (GdkWindowPrivate*) window; + cursor_private = (GdkCursorPrivate*) cursor; + + if (!cursor) + xcursor = None; + else + xcursor = cursor_private->xcursor; + + XDefineCursor (window_private->xdisplay, window_private->xwindow, xcursor); +} + +void +gdk_window_set_colormap (GdkWindow *window, + GdkColormap *colormap) +{ + GdkWindowPrivate *window_private; + GdkColormapPrivate *colormap_private; + + g_return_if_fail (window != NULL); + g_return_if_fail (colormap != NULL); + + window_private = (GdkWindowPrivate*) window; + colormap_private = (GdkColormapPrivate*) colormap; + + XSetWindowColormap (window_private->xdisplay, + window_private->xwindow, + colormap_private->xcolormap); + + if (window_private->window_type != GDK_WINDOW_TOPLEVEL) + gdk_window_add_colormap_windows (window); +} + +void +gdk_window_get_user_data (GdkWindow *window, + gpointer *data) +{ + g_return_if_fail (window != NULL); + + *data = window->user_data; +} + +void +gdk_window_get_geometry (GdkWindow *window, + gint *x, + gint *y, + gint *width, + gint *height, + gint *depth) +{ + GdkWindowPrivate *window_private; + Window root; + gint tx; + gint ty; + guint twidth; + guint theight; + guint tborder_width; + guint tdepth; + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + window_private = (GdkWindowPrivate*) window; + + XGetGeometry (window_private->xdisplay, window_private->xwindow, + &root, &tx, &ty, &twidth, &theight, &tborder_width, &tdepth); + + if (x) + *x = tx; + if (y) + *y = ty; + if (width) + *width = twidth; + if (height) + *height = theight; + if (depth) + *depth = tdepth; +} + +void +gdk_window_get_position (GdkWindow *window, + gint *x, + gint *y) +{ + GdkWindowPrivate *window_private; + + g_return_if_fail (window != NULL); + + window_private = (GdkWindowPrivate*) window; + + if (x) + *x = window_private->x; + if (y) + *y = window_private->y; +} + +void +gdk_window_get_size (GdkWindow *window, + gint *width, + gint *height) +{ + GdkWindowPrivate *window_private; + + g_return_if_fail (window != NULL); + + window_private = (GdkWindowPrivate*) window; + + if (width) + *width = window_private->width; + if (height) + *height = window_private->height; +} + + +GdkVisual* +gdk_window_get_visual (GdkWindow *window) +{ + GdkWindowPrivate *window_private; + XWindowAttributes window_attributes; + + g_return_val_if_fail (window != NULL, NULL); + + window_private = (GdkWindowPrivate*) window; + while (window_private && (window_private->window_type == GDK_WINDOW_PIXMAP)) + window_private = (GdkWindowPrivate*) window_private->parent; + + if (window_private) + { + XGetWindowAttributes (window_private->xdisplay, + window_private->xwindow, + &window_attributes); + + return gdk_visual_lookup (window_attributes.visual); + } + + return NULL; +} + +GdkColormap* +gdk_window_get_colormap (GdkWindow *window) +{ + GdkWindowPrivate *window_private; + XWindowAttributes window_attributes; + + g_return_val_if_fail (window != NULL, NULL); + + window_private = (GdkWindowPrivate*) window; + + XGetWindowAttributes (window_private->xdisplay, + window_private->xwindow, + &window_attributes); + + return gdk_colormap_lookup (window_attributes.colormap); +} + +GdkWindowType +gdk_window_get_type (GdkWindow *window) +{ + GdkWindowPrivate *window_private; + + g_return_val_if_fail (window != NULL, (GdkWindowType) -1); + + window_private = (GdkWindowPrivate*) window; + return window_private->window_type; +} + +gint +gdk_window_get_origin (GdkWindow *window, + gint *x, + gint *y) +{ + GdkWindowPrivate *private; + gint return_val; + Window child; + gint tx, ty; + + g_return_val_if_fail (window != NULL, 0); + + private = (GdkWindowPrivate*) window; + + return_val = XTranslateCoordinates (private->xdisplay, + private->xwindow, + gdk_root_window, + 0, 0, &tx, &ty, + &child); + + if (x) + *x = tx; + if (y) + *y = ty; + + return return_val; +} + +GdkWindow* +gdk_window_get_pointer (GdkWindow *window, + gint *x, + gint *y, + GdkModifierType *mask) +{ + GdkWindowPrivate *private; + GdkWindow *return_val; + Window root; + Window child; + int rootx, rooty; + int winx, winy; + unsigned int xmask; + + if (!window) + window = (GdkWindow*) &gdk_root_parent; + + private = (GdkWindowPrivate*) window; + + return_val = NULL; + if (XQueryPointer (private->xdisplay, private->xwindow, &root, &child, + &rootx, &rooty, &winx, &winy, &xmask)) + { + if (x) *x = winx; + if (y) *y = winy; + if (mask) *mask = xmask; + + if (child) + return_val = gdk_window_lookup (child); + } + + return return_val; +} + +GdkWindow* +gdk_window_get_parent (GdkWindow *window) +{ + g_return_val_if_fail (window != NULL, NULL); + + return ((GdkWindowPrivate*) window)->parent; +} + +GdkWindow* +gdk_window_get_toplevel (GdkWindow *window) +{ + GdkWindowPrivate *private; + + g_return_val_if_fail (window != NULL, NULL); + + private = (GdkWindowPrivate*) window; + + while (private->window_type == GDK_WINDOW_CHILD) + { + window = ((GdkWindowPrivate*) window)->parent; + private = (GdkWindowPrivate*) window; + } + + return window; +} + +GList* +gdk_window_get_children (GdkWindow *window) +{ + GdkWindowPrivate *private; + GdkWindow *child; + GList *children; + Window root; + Window parent; + Window *xchildren; + unsigned int nchildren; + unsigned int i; + + g_return_val_if_fail (window != NULL, NULL); + + private = (GdkWindowPrivate*) window; + + XQueryTree (private->xdisplay, private->xwindow, + &root, &parent, &xchildren, &nchildren); + + children = NULL; + + if (nchildren > 0) + { + for (i = 0; i < nchildren; i++) + { + child = gdk_window_lookup (xchildren[i]); + if (child) + children = g_list_prepend (children, child); + } + + XFree (xchildren); + } + + return children; +} + +GdkEventMask +gdk_window_get_events (GdkWindow *window) +{ + XWindowAttributes attrs; + GdkEventMask event_mask; + int i; + + XGetWindowAttributes (gdk_display, ((GdkWindowPrivate *)window)->xwindow, + &attrs); + + event_mask = 0; + for (i = 0; i < nevent_masks; i++) + { + if (attrs.your_event_mask & event_mask_table[i]) + event_mask |= 1 << (i + 1); + } + + return event_mask; +} + +void +gdk_window_set_events (GdkWindow *window, + GdkEventMask event_mask) +{ + long xevent_mask; + int i; + + xevent_mask = StructureNotifyMask; + for (i = 0; i < nevent_masks; i++) + { + if (event_mask & (1 << (i + 1))) + xevent_mask |= event_mask_table[i]; + } + + XSelectInput (gdk_display, ((GdkWindowPrivate *)window)->xwindow, + xevent_mask); +} + +void +gdk_window_add_colormap_windows (GdkWindow *window) +{ + GdkWindow *toplevel; + GdkWindowPrivate *toplevel_private; + GdkWindowPrivate *window_private; + Window *old_windows; + Window *new_windows; + int i, count; + + g_return_if_fail (window != NULL); + + toplevel = gdk_window_get_toplevel (window); + toplevel_private = (GdkWindowPrivate*) toplevel; + window_private = (GdkWindowPrivate*) window; + + if (!XGetWMColormapWindows (toplevel_private->xdisplay, + toplevel_private->xwindow, + &old_windows, &count)) + { + old_windows = NULL; + count = 0; + } + + for (i = 0; i < count; i++) + if (old_windows[i] == window_private->xwindow) + return; + + new_windows = g_new (Window, count + 1); + + for (i = 0; i < count; i++) + new_windows[i] = old_windows[i]; + new_windows[count] = window_private->xwindow; + + XSetWMColormapWindows (toplevel_private->xdisplay, + toplevel_private->xwindow, + new_windows, count + 1); + + g_free (new_windows); + if (old_windows) + XFree (old_windows); +} + +/* + * This needs the X11 shape extension. + * If not available, simply remove the call to + * XShapeCombineMask. Shaped windows will look + * ugly, but programs still work. Stefan Wille + */ +void +gdk_window_shape_combine_mask (GdkWindow *window, + GdkBitmap *mask, + gint x, gint y) +{ + GdkWindowPrivate *window_private; + GdkWindowPrivate *pixmap_private; + + g_return_if_fail (window != NULL); + g_return_if_fail (mask != NULL); + + window_private = (GdkWindowPrivate*) window; + pixmap_private = (GdkWindowPrivate*) mask; + + XShapeCombineMask (window_private->xdisplay, + window_private->xwindow, + ShapeBounding, + x, y, /* offset */ + (Pixmap)pixmap_private->xwindow, + ShapeSet); +} + +void +gdk_dnd_drag_addwindow (GdkWindow *window) +{ + GdkWindowPrivate *window_private; + + g_return_if_fail (window != NULL); + + window_private = (GdkWindowPrivate *) window; + + if (window_private->dnd_drag_enabled == 1 && gdk_dnd.drag_really == 0) + { + gdk_dnd.drag_numwindows++; + gdk_dnd.drag_startwindows = g_realloc (gdk_dnd.drag_startwindows, + gdk_dnd.drag_numwindows + * sizeof(GdkWindow *)); + gdk_dnd.drag_startwindows[gdk_dnd.drag_numwindows - 1] = window; + window_private->dnd_drag_accepted = 0; + } + else + g_warning ("dnd_really is 1 or drag is not enabled! can't addwindow\n"); +} + +void +gdk_window_dnd_drag_set (GdkWindow *window, + guint8 drag_enable, + gchar **typelist, + guint numtypes) +{ + GdkWindowPrivate *window_private; + int i, wasset = 0; + + g_return_if_fail (window != NULL); + window_private = (GdkWindowPrivate *) window; + + window_private->dnd_drag_enabled = drag_enable ? 1 : 0; + + if (drag_enable) + { + g_return_if_fail(typelist != NULL); + + if (window_private->dnd_drag_data_numtypesavail > 3) + wasset = 1; + window_private->dnd_drag_data_numtypesavail = numtypes; + + window_private->dnd_drag_data_typesavail = + g_realloc (window_private->dnd_drag_data_typesavail, + (numtypes + 1) * sizeof (GdkAtom)); + + for (i = 0; i < numtypes; i++) + { + /* Allow blanket use of ALL to get anything... */ + if (strcmp (typelist[i], "ALL")) + window_private->dnd_drag_data_typesavail[i] = + gdk_atom_intern (typelist[i], FALSE); + else + window_private->dnd_drag_data_typesavail[i] = None; + } + + /* + * set our extended type list if we need to + */ + if (numtypes > 3) + gdk_property_change(window, gdk_dnd.gdk_XdeTypelist, + XA_PRIMARY, 32, GDK_PROP_MODE_REPLACE, + (guchar *)(window_private->dnd_drag_data_typesavail + + (sizeof(GdkAtom) * 3)), + (numtypes - 3) * sizeof(GdkAtom)); + else if (wasset) + gdk_property_delete (window, gdk_dnd.gdk_XdeTypelist); + } + else + { + free (window_private->dnd_drag_data_typesavail); + window_private->dnd_drag_data_typesavail = NULL; + window_private->dnd_drag_data_numtypesavail = 0; + } +} + +void +gdk_window_dnd_drop_set (GdkWindow *window, + guint8 drop_enable, + gchar **typelist, + guint numtypes, + guint8 destructive_op) +{ + GdkWindowPrivate *window_private; + int i; + + g_return_if_fail (window != NULL); + + window_private = (GdkWindowPrivate *) window; + + window_private->dnd_drop_enabled = drop_enable ? 1 : 0; + if (drop_enable) + { + g_return_if_fail(typelist != NULL); + + window_private->dnd_drop_data_numtypesavail = numtypes; + + window_private->dnd_drop_data_typesavail = + g_realloc (window_private->dnd_drop_data_typesavail, + (numtypes + 1) * sizeof (GdkAtom)); + + for (i = 0; i < numtypes; i++) + window_private->dnd_drop_data_typesavail[i] = + gdk_atom_intern (typelist[i], FALSE); + + window_private->dnd_drop_destructive_op = destructive_op; + } +} + +/* + * This is used to reply to a GDK_DRAG_REQUEST event + * (which may be generated by XdeRequest or a confirmed drop... + */ +void +gdk_window_dnd_data_set (GdkWindow *window, + GdkEvent *event, + gpointer data, + gulong data_numbytes) +{ + GdkWindowPrivate *window_private; + XEvent sev; + GdkEventDropDataAvailable tmp_ev; + gchar *tmp; + + g_return_if_fail (window != NULL); + g_return_if_fail (event != NULL); + g_return_if_fail (data != NULL); + g_return_if_fail (data_numbytes > 0); + g_return_if_fail (event->type == GDK_DRAG_REQUEST); + + g_free (event->dragrequest.data_type); + event->dragrequest.data_type = NULL; + + window_private = (GdkWindowPrivate *) window; + g_return_if_fail (window_private->dnd_drag_accepted != 0); + + /* We set the property on our window... */ + gdk_property_change (window, window_private->dnd_drag_data_type, + XA_PRIMARY, 8, GDK_PROP_MODE_REPLACE, data, + data_numbytes); + tmp = gdk_atom_name(window_private->dnd_drag_data_type); + g_print("DnD type %s on window %ld\n", tmp, window_private->xwindow); + g_free(tmp); + + /* + * Then we send the event to tell the receiving window that the + * drop has happened + */ + tmp_ev.u.allflags = 0; + tmp_ev.u.flags.protocol_version = DND_PROTOCOL_VERSION; + tmp_ev.u.flags.isdrop = event->dragrequest.isdrop; + + sev.xclient.type = ClientMessage; + sev.xclient.format = 32; + sev.xclient.window = event->dragrequest.requestor; + sev.xclient.message_type = gdk_dnd.gdk_XdeDataAvailable; + sev.xclient.data.l[0] = window_private->xwindow; + sev.xclient.data.l[1] = tmp_ev.u.allflags; + sev.xclient.data.l[2] = window_private->dnd_drag_data_type; + + if (event->dragrequest.isdrop) + sev.xclient.data.l[3] = event->dragrequest.drop_coords.x + + (event->dragrequest.drop_coords.y << 16); + else + sev.xclient.data.l[3] = 0; + + sev.xclient.data.l[4] = 0; + + XSendEvent (gdk_display, event->dragrequest.requestor, False, + NoEventMask, &sev); +} diff --git a/gdk/x11/gdkx.h b/gdk/x11/gdkx.h new file mode 100644 index 000000000..cb8e33b44 --- /dev/null +++ b/gdk/x11/gdkx.h @@ -0,0 +1,48 @@ +/* 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. + */ +#ifndef __GDK_X_H__ +#define __GDK_X_H__ + +#include <gdk/gdkprivate.h> + + +#define GDK_ROOT_WINDOW() gdk_root_window +#define GDK_ROOT_PARENT() &gdk_root_parent +#define GDK_DISPLAY() gdk_display +#define GDK_WINDOW_XDISPLAY(win) (((GdkWindowPrivate*) win)->xdisplay) +#define GDK_WINDOW_XWINDOW(win) (((GdkWindowPrivate*) win)->xwindow) +#define GDK_IMAGE_XDISPLAY(image) (((GdkImagePrivate*) image)->xdisplay) +#define GDK_IMAGE_XIMAGE(image) (((GdkImagePrivate*) image)->ximage) +#define GDK_GC_XDISPLAY(gc) (((GdkGCPrivate*) gc)->xdisplay) +#define GDK_GC_XGC(gc) (((GdkGCPrivate*) gc)->xgc) +#define GDK_COLORMAP_XDISPLAY(cmap) (((GdkColormapPrivate*) cmap)->xdisplay) +#define GDK_COLORMAP_XCOLORMAP(cmap) (((GdkColormapPrivate*) cmap)->xcolormap) +#define GDK_VISUAL_XVISUAL(vis) (((GdkVisualPrivate*) vis)->xvisual) +#define GDK_FONT_XDISPLAY(font) (((GdkFontPrivate*) font)->xdisplay) +#define GDK_FONT_XFONT(font) (((GdkFontPrivate*) font)->xfont) + + +GdkVisual* gdkx_visual_get (VisualID xvisualid); +GdkColormap* gdkx_colormap_get (Colormap xcolormap); +/* Utility function in gdk.c - not sure where it belongs, but it's + needed in more than one place, so make it public */ +Window gdk_get_client_window (Display *dpy, + Window win); + + +#endif /* __GDK_X_H__ */ diff --git a/gdk/x11/gdkxid.c b/gdk/x11/gdkxid.c new file mode 100644 index 000000000..7ee6075c5 --- /dev/null +++ b/gdk/x11/gdkxid.c @@ -0,0 +1,74 @@ +/* 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 "gdkprivate.h" + + +static guint gdk_xid_hash (XID *xid); +static gint gdk_xid_compare (XID *a, + XID *b); + + +GHashTable *xid_ht = NULL; + + +void +gdk_xid_table_insert (XID *xid, + gpointer data) +{ + g_return_if_fail (xid != NULL); + + if (!xid_ht) + xid_ht = g_hash_table_new ((GHashFunc) gdk_xid_hash, + (GCompareFunc) gdk_xid_compare); + + g_hash_table_insert (xid_ht, xid, data); +} + +void +gdk_xid_table_remove (XID xid) +{ + if (!xid_ht) + xid_ht = g_hash_table_new ((GHashFunc) gdk_xid_hash, + (GCompareFunc) gdk_xid_compare); + + g_hash_table_remove (xid_ht, &xid); +} + +gpointer +gdk_xid_table_lookup (XID xid) +{ + gpointer data; + + data = g_hash_table_lookup (xid_ht, &xid); + + return data; +} + + +static guint +gdk_xid_hash (XID *xid) +{ + return *xid; +} + +static gint +gdk_xid_compare (XID *a, + XID *b) +{ + return (*a == *b); +} diff --git a/gdk/x11/gxid.c b/gdk/x11/gxid.c new file mode 100644 index 000000000..219c08bfe --- /dev/null +++ b/gdk/x11/gxid.c @@ -0,0 +1,844 @@ +/* + * gxid version 0.3 + * + * Copyright 1997 Owen Taylor <owt1@cornell.edu> +*/ + +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <signal.h> +#include <sys/time.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <X11/Xlib.h> +#include <X11/extensions/XInput.h> + +#include "gxid_proto.h" + +/* #define DEBUG_CLIENTS */ +/* #define DEBUG_EVENTS */ + +char *program_name; +Display *dpy; +Window root_window; /* default root window of dpy */ +int port = 0; /* port to listen on */ +int socket_fd = 0; /* file descriptor of socket */ +typedef struct GxidWindow_ GxidWindow; + +typedef struct GxidDevice_ GxidDevice; +struct GxidDevice_ { + XID id; + int exclusive; + int ispointer; + + XDevice *xdevice; + int motionnotify_type; + int changenotify_type; +}; + +struct GxidWindow_ { + Window xwindow; + /* Immediate child of root that is ancestor of window */ + Window root_child; + int num_devices; + GxidDevice **devices; +}; + +GxidDevice **devices = NULL; +int num_devices = 0; +GxidWindow **windows = NULL; +int num_windows = 0; + +void +handler(int signal) +{ + fprintf(stderr,"%s: dying on signal %d\n",program_name,signal); + if (socket_fd) + close(socket_fd); + exit(1); +} + +void +init_socket() +{ + struct sockaddr_in sin; + + socket_fd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); + if (socket_fd < 0) + { + fprintf (stderr, "%s: error getting socket\n", + program_name); + exit(1); + } + + sin.sin_family = AF_INET; + sin.sin_port = htons(port); + sin.sin_addr.s_addr = INADDR_ANY; + + if (bind(socket_fd,(struct sockaddr *)(&sin), + sizeof(struct sockaddr_in)) < 0) + { + fprintf (stderr,"%s: cannot bind to port %d\n", + program_name,port); + exit(1); + } + + if (listen(socket_fd,5) < 0) + { + fprintf (stderr,"%s: error listening on socket\n", + program_name); + exit(1); + }; +} + +#define NUM_EVENTC 2 +static void +enable_device(GxidDevice *dev) +{ + XEventClass xevc[NUM_EVENTC]; + int num_eventc = NUM_EVENTC; + int i,j; + + if (!dev->xdevice) + { + if (dev->ispointer) return; + + dev->xdevice = XOpenDevice(dpy, dev->id); + if (!dev->xdevice) return; + + DeviceMotionNotify (dev->xdevice, dev->motionnotify_type, + xevc[0]); + ChangeDeviceNotify (dev->xdevice, dev->changenotify_type, + xevc[1]); + + /* compress out zero event classes */ + for (i=0,j=0;i<NUM_EVENTC;i++) + { + if (xevc[i]) { + xevc[j] = xevc[i]; + j++; + } + } + num_eventc = j; + + XSelectExtensionEvent (dpy, root_window, xevc, num_eventc); + } +} + +/* switch the core pointer from whatever it is now to something else, + return true on success, false otherwise */ +static int +switch_core_pointer() +{ + GxidDevice *old_pointer = 0; + GxidDevice *new_pointer = 0; + int result; + int i; + + for (i=0;i<num_devices;i++) + { + if (devices[i]->ispointer) + old_pointer = devices[i]; + else + if (!new_pointer && !devices[i]->exclusive) + new_pointer = devices[i]; + } + + if (!old_pointer || !new_pointer) + return 0; + +#ifdef DEBUG_EVENTS + fprintf(stderr,"gxid: Switching core from %ld to %ld\n", + old_pointer->id,new_pointer->id); +#endif + result = XChangePointerDevice(dpy,new_pointer->xdevice, 0, 1); + if (result != Success) + { + fprintf(stderr,"gxid: Error %d switching core from %ld to %ld\n", + result, old_pointer->id, new_pointer->id); + } + else + { + new_pointer->ispointer = 1; + old_pointer->ispointer = 0; + if (!old_pointer->xdevice) + enable_device(old_pointer); + } + + return 1; +} + +void +disable_device(GxidDevice *dev) +{ + if (dev->xdevice) + { + if (dev->ispointer) + return; + XCloseDevice(dpy,dev->xdevice); + dev->xdevice = 0; + } +} + +GxidDevice * +init_device(XDeviceInfo *xdevice) +{ + GxidDevice *dev = (GxidDevice *)malloc(sizeof(GxidDevice)); + XAnyClassPtr class; + int num_axes, i; + + dev->id = xdevice->id; + dev->exclusive = 0; + dev->xdevice = NULL; + + dev->ispointer = (xdevice->use == IsXPointer); + + /* step through the classes */ + + num_axes = 0; + class = xdevice->inputclassinfo; + for (i=0;i<xdevice->num_classes;i++) + { + if (class->class == ValuatorClass) + { + XValuatorInfo *xvi = (XValuatorInfo *)class; + num_axes = xvi->num_axes; + } + class = (XAnyClassPtr)(((char *)class) + class->length); + } + + /* return NULL if insufficient axes */ + if (num_axes < 2) + { + free((void *)dev); + return NULL; + } + + if (!dev->ispointer) + enable_device(dev); + return dev; +} + +void +init_xinput() +{ + char **extensions; + XDeviceInfo *xdevices; + int num_xdevices; + int num_extensions; + int i; + + extensions = XListExtensions(dpy, &num_extensions); + for (i = 0; i < num_extensions && + (strcmp(extensions[i], "XInputExtension") != 0); i++); + XFreeExtensionList(extensions); + if (i == num_extensions) /* XInput extension not found */ + { + fprintf(stderr,"XInput extension not found\n"); + exit(1); + } + + xdevices = XListInputDevices(dpy, &num_xdevices); + devices = (GxidDevice **)malloc(num_xdevices * sizeof(GxidDevice *)); + + num_devices = 0; + for(i=0; i<num_xdevices; i++) + { + GxidDevice *dev = init_device(&xdevices[i]); + if (dev) + devices[num_devices++] = dev; + } + XFreeDeviceList(xdevices); +} + +/* If this routine needs fixing, the corresponding routine + in gdkinputgxi.h will need it too. */ + +Window +gxi_find_root_child(Display *dpy, Window w) +{ + Window root,parent; + Window *children; + int nchildren; + + parent = w; + do + { + w = parent; + XQueryTree(dpy,w,&root,&parent,&children,&nchildren); + if (children) XFree(children); + } + while (parent != root); + + return w; +} + +int +handle_claim_device(GxidClaimDevice *msg) +{ + int i,j; + XID devid = ntohl(msg->device); + XID winid = ntohl(msg->window); + int exclusive = ntohl(msg->exclusive); + GxidDevice *device = NULL; + GxidWindow *window = NULL; + +#ifdef DEBUG_CLIENTS + fprintf(stderr,"device %ld claimed (window 0x%lx)\n",devid,winid); +#endif + + for (i=0;i<num_devices;i++) + { + if (devices[i]->id == devid) + { + device = devices[i]; + break; + } + } + if (!device) + { + fprintf(stderr,"%s: Unknown device id %ld\n",program_name,devid); + return GXID_RETURN_ERROR; + } + + if (device->exclusive) + { + /* already in use */ + fprintf(stderr, + "%s: Device %ld already claimed in exclusive mode\n", + program_name,devid); + return GXID_RETURN_ERROR; + } + + if (exclusive) + { + for (i=0;i<num_windows;i++) + { + for (j=0;j<windows[i]->num_devices;j++) + if (windows[i]->devices[j]->id == devid) + { + /* already in use */ + fprintf(stderr, + "%s: Can't establish exclusive use of device %ld\n", + program_name,devid); + return GXID_RETURN_ERROR; + } + } + if (device->ispointer) + if (!switch_core_pointer()) + { + fprintf(stderr, + "%s: Can't free up core pointer %ld\n", + program_name,devid); + return GXID_RETURN_ERROR; + } + + device->exclusive = 1; + disable_device(device); + XSelectInput(dpy,winid,StructureNotifyMask); + } + else /* !exclusive */ + { + /* FIXME: this is a bit improper. We probably should do this only + when a window is first claimed. But we might be fooled if + an old client died without releasing it's windows. So until + we look for client-window closings, do it here + + (We do look for closings now...) + */ + + XSelectInput(dpy,winid,EnterWindowMask|StructureNotifyMask); + } + + for (i=0;i<num_windows;i++) + { + if (windows[i]->xwindow == winid) + { + window = windows[i]; + break; + } + } + + /* Create window structure if no devices have been previously + claimed on it */ + if (!window) + { + num_windows++; + windows = (GxidWindow **)realloc(windows, + sizeof(GxidWindow*)*num_windows); + window = (GxidWindow *)malloc(sizeof(GxidWindow)); + windows[num_windows-1] = window; + + window->xwindow = winid; + window->root_child = gxi_find_root_child(dpy,winid); + window->num_devices = 0; + window->devices = 0; + } + + + for (i=0;i<window->num_devices;i++) + { + if (window->devices[i] == device) + return GXID_RETURN_OK; + } + + window->num_devices++; + window->devices = (GxidDevice **)realloc(window->devices, + sizeof(GxidDevice*)*num_devices); + /* we need add the device to the window */ + window->devices[i] = device; + + return GXID_RETURN_OK; +} + +int +handle_release_device(GxidReleaseDevice *msg) +{ + int i,j; + XID devid = ntohl(msg->device); + XID winid = ntohl(msg->window); + + GxidDevice *device = NULL; + +#ifdef DEBUG_CLIENTS + fprintf(stderr,"device %ld released (window 0x%lx)\n",devid,winid); +#endif + + for (i=0;i<num_devices;i++) + { + if (devices[i]->id == devid) + { + device = devices[i]; + break; + } + } + if (!device) + { + fprintf(stderr,"%s: Unknown device id %ld\n",program_name,devid); + return GXID_RETURN_ERROR; + } + + for (i=0;i<num_windows;i++) + { + GxidWindow *w = windows[i]; + + if (w->xwindow == winid) + for (j=0;j<w->num_devices;j++) + if (w->devices[j]->id == devid) + { + if (j<w->num_devices-1) + w->devices[j] = w->devices[w->num_devices-1]; + w->num_devices--; + + if (w->num_devices == 0) + { + if (i<num_windows-1) + windows[i] = windows[num_windows-1]; + num_windows--; + + free((void *)w); + /* FIXME: should we deselect input? But what + what if window is already destroyed */ + } + + if (device->exclusive) + { + device->exclusive = 0; + enable_device(device); + } + return GXID_RETURN_OK; + } + } + + /* device/window combination not found */ + fprintf(stderr, + "%s: Device %ld not claimed for window 0x%lx\n", + program_name,devid,winid); + return GXID_RETURN_ERROR; +} + +void +handle_connection() +{ + GxidMessage msg; + GxidU32 type; + int length; + GxidI32 retval; + + int conn_fd; + struct sockaddr_in sin; + int sin_length; + int count; + + sin_length = sizeof(struct sockaddr_in); + conn_fd = accept(socket_fd,(struct sockaddr *)&sin,&sin_length); + if (conn_fd < 0) + { + fprintf(stderr,"%s: Error accepting connection\n", + program_name); + exit(1); + } + + /* read type and length of message */ + + count = read(conn_fd,(char *)&msg,2*sizeof(GxidU32)); + if (count != 2*sizeof(GxidU32)) + { + fprintf(stderr,"%s: Error reading message header\n", + program_name); + close(conn_fd); + return; + } + type = ntohl(msg.any.type); + length = ntohl(msg.any.length); + + /* read rest of message */ + + if (length > sizeof(GxidMessage)) + { + fprintf(stderr,"%s: Bad message length\n", + program_name); + close(conn_fd); + return; + } + + count = read(conn_fd,2*sizeof(GxidU32) + (char *)&msg, + length - 2*sizeof(GxidU32)); + if (count != length - 2*sizeof(GxidU32)) + { + fprintf(stderr,"%s: Error reading message body\n", + program_name); + close(conn_fd); + return; + } + + switch (type) + { + case GXID_CLAIM_DEVICE: + retval = handle_claim_device((GxidClaimDevice *)&msg); + break; + case GXID_RELEASE_DEVICE: + retval = handle_release_device((GxidReleaseDevice *)&msg); + break; + default: + fprintf(stderr,"%s: Unknown message type: %ld (ignoring)\n", + program_name,type); + close(conn_fd); + return; + } + + count = write(conn_fd,&retval,sizeof(GxidI32)); + if (count != sizeof(GxidI32)) + { + fprintf(stderr,"%s: Error writing return code\n", + program_name); + } + + close(conn_fd); +} + +void +handle_motion_notify(XDeviceMotionEvent *event) +{ + int i,j; + GxidDevice *old_device = NULL; + GxidDevice *new_device = NULL; + Window w, root, child; + int root_x, root_y, x, y, mask; + + for (j=0;j<num_devices;j++) + { + if (devices[j]->ispointer) + old_device = devices[j]; + if (devices[j]->id == event->deviceid) + new_device = devices[j]; + } + + if (new_device && !new_device->exclusive && !new_device->ispointer) + { + /* make sure we aren't stealing the pointer back from a slow + client */ + child = root_window; + do + { + w = child; + /* FIXME: this fails disasterously if child vanishes between + calls. (Which is prone to happening since we get events + on root just as the client exits) */ + + XQueryPointer(dpy,w,&root,&child,&root_x,&root_y, + &x,&y,&mask); + } + while (child != None); + + for (i=0;i<num_windows;i++) + if (windows[i]->xwindow == w) + for (j=0;j<windows[i]->num_devices;j++) + if (windows[i]->devices[j] == new_device) + return; + + /* FIXME: do something smarter with axes */ + XChangePointerDevice(dpy,new_device->xdevice, 0, 1); + new_device->ispointer = 1; + + old_device->ispointer = 0; + if (!old_device->xdevice) + enable_device(old_device); + } +} + +void +handle_change_notify(XChangeDeviceNotifyEvent *event) +{ + int j; + GxidDevice *old_device = NULL; + GxidDevice *new_device = NULL; + + + for (j=0;j<num_devices;j++) + { + if (devices[j]->ispointer) + old_device = devices[j]; + if (devices[j]->id == event->deviceid) + new_device = devices[j]; + } + +#ifdef DEBUG_EVENTS + fprintf(stderr,"gxid: ChangeNotify event; old = %ld; new = %ld\n", + old_device->id, new_device->id); +#endif + + if (old_device != new_device) + { + new_device->ispointer = 1; + + old_device->ispointer = 0; + if (!old_device->xdevice) + enable_device(old_device); + } +} + +void +handle_enter_notify(XEnterWindowEvent *event, GxidWindow *window) +{ + int i; + GxidDevice *old_pointer = NULL; + for (i=0;i<num_devices;i++) + { + if (devices[i]->ispointer) + { + old_pointer = devices[i]; + break; + } + } + +#ifdef DEBUG_EVENTS + fprintf(stderr,"gxid: Enter event; oldpointer = %ld\n", + old_pointer->id); +#endif + + if (old_pointer) + for (i=0;i<window->num_devices;i++) + { + if (window->devices[i] == old_pointer) + { + switch_core_pointer(); + break; + } + } +} + +void +handle_destroy_notify(XDestroyWindowEvent *event) +{ + int i,j; + + for (i=0;i<num_windows;i++) + if (windows[i]->xwindow == event->window) + { + GxidWindow *w = windows[i]; + + for (j=0;j<w->num_devices;j++) + { +#ifdef DEBUG_CLIENTS + fprintf(stderr,"device %ld released on destruction of window 0x%lx.\n", + w->devices[j]->id,w->xwindow); +#endif + + if (w->devices[j]->exclusive) + { + w->devices[j]->exclusive = 0; + enable_device(devices[j]); + } + } + + if (i<num_windows-1) + windows[i] = windows[num_windows-1]; + num_windows--; + + if (w->devices) + free((void *)w->devices); + free((void *)w); + /* FIXME: should we deselect input? But what + what if window is already destroyed */ + + return; + } +} + +void +handle_xevent() +{ + int i; + XEvent event; + + XNextEvent (dpy, &event); + +#ifdef DEBUG_EVENTS + fprintf(stderr,"Event - type = %d; window = 0x%lx\n", + event.type,event.xany.window); +#endif + + if (event.type == ConfigureNotify) + { +#ifdef DEBUG_EVENTS + XConfigureEvent *xce = (XConfigureEvent *)&event; + fprintf(stderr," configureNotify: window = 0x%lx\n",xce->window); +#endif + } + else if (event.type == EnterNotify) + { + /* pointer entered a claimed window */ + for (i=0;i<num_windows;i++) + { + if (event.xany.window == windows[i]->xwindow) + handle_enter_notify((XEnterWindowEvent *)&event,windows[i]); + } + } + else if (event.type == DestroyNotify) + { + /* A claimed window was destroyed */ + for (i=0;i<num_windows;i++) + { + if (event.xany.window == windows[i]->xwindow) + handle_destroy_notify((XDestroyWindowEvent *)&event); + } + } + else + for (i=0;i<num_devices;i++) + { + if (event.type == devices[i]->motionnotify_type) + { + handle_motion_notify((XDeviceMotionEvent *)&event); + break; + } + else if (event.type == devices[i]->changenotify_type) + { + handle_change_notify((XChangeDeviceNotifyEvent *)&event); + break; + } + } +} + +void +usage() +{ + fprintf(stderr,"Usage: %s [-d display] [-p --gxid-port port]\n", + program_name); + exit(1); +} + +int +main(int argc, char **argv) +{ + int i; + char *display_name = NULL; + fd_set readfds; + + program_name = argv[0]; + + for (i=1;i<argc;i++) + { + if (!strcmp(argv[i],"-d")) + { + if (++i >= argc) usage(); + display_name = argv[i]; + } + else if (!strcmp(argv[i],"--gxid-port") || + !strcmp(argv[i],"-p")) + { + if (++i >= argc) usage(); + port = atoi(argv[i]); + break; + } + else + usage(); + } + + if (!port) + { + char *t = getenv("GXID_PORT"); + if (t) + port = atoi(t); + else + port = 6951; + } + /* set up a signal handler so we can clean up if killed */ + + signal(SIGTERM,handler); + signal(SIGINT,handler); + + /* initialize the X connection */ + + dpy = XOpenDisplay (display_name); + if (!dpy) + { + fprintf (stderr, "%s: unable to open display '%s'\n", + program_name, XDisplayName (display_name)); + exit (1); + } + + root_window = DefaultRootWindow(dpy); + + /* We'll want to do this in the future if we are to support + gxid monitoring visibility information for clients */ +#if 0 + XSelectInput(dpy,root_window,SubstructureNotifyMask); +#endif + init_xinput(); + + /* set up our server connection */ + + init_socket(); + + /* main loop */ + + if (XPending(dpy)) /* this seems necessary to get things + in sync */ + handle_xevent(); + while (1) + { + + FD_ZERO(&readfds); + FD_SET(ConnectionNumber(dpy),&readfds); + FD_SET(socket_fd,&readfds); + + if (select(8*sizeof(readfds),&readfds, + (fd_set *)0,(fd_set *)0, (struct timeval *)0) < 0) + { + fprintf(stderr,"Error in select\n"); + exit(1); + } + + if (FD_ISSET(socket_fd,&readfds)) + handle_connection(socket_fd); + + while (XPending(dpy)) + handle_xevent(); + } + + XCloseDisplay (dpy); + exit (0); +} diff --git a/gdk/x11/gxid_lib.c b/gdk/x11/gxid_lib.c new file mode 100644 index 000000000..357b76451 --- /dev/null +++ b/gdk/x11/gxid_lib.c @@ -0,0 +1,116 @@ +/* + * gxid version 0.3 + * + * Copyright 1997 Owen Taylor <owt1@cornell.edu> +*/ + +#include "../config.h" + +#ifdef XINPUT_GXI + +#include <stdio.h> +#include <unistd.h> +#include <sys/time.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netdb.h> + +#include "gxid_lib.h" + +/* handles mechanics of communicating with a client */ +static int +gxid_send_message(char *host, int port, GxidMessage *msg) +{ + int socket_fd; + struct sockaddr_in sin; + int count; + GxidI32 retval; + struct hostent *he; + + if (!port) port = 6951; + + if (!host || strcmp(host,"localhost") ) + { + /* looking it up as localhost can be _SLOW_ on ppp systems */ + /* FIXME: Could localhost be anything other than loopback? */ + host = "127.0.0.1"; + } + + he = gethostbyname(host); + if (!he) + { + fprintf(stderr,"gxid_lib: error looking up %s\n",host); + return GXID_RETURN_ERROR; + } + + sin.sin_family = he->h_addrtype; + sin.sin_port = htons(port); + memcpy(&sin.sin_addr,he->h_addr_list[0],he->h_length); + + socket_fd = socket(AF_INET,SOCK_STREAM,0); + if (socket_fd < 0) + { + fprintf(stderr,"gxid_lib: can't get socket"); + return GXID_RETURN_ERROR; + } + + if (connect(socket_fd, (struct sockaddr *)&sin, + sizeof sin) < 0) + { + fprintf(stderr,"gxid_lib: can't connect to %s:%d\n",host,port); + close(socket_fd); + return GXID_RETURN_ERROR; + } + + count = write(socket_fd,(char *)msg,ntohl(msg->any.length)); + if (count != ntohl(msg->any.length)) + { + fprintf(stderr,"gxid_lib: error writing"); + close(socket_fd); + return GXID_RETURN_ERROR; + } + + /* now read the return code */ + count = read(socket_fd,(char *)&retval,sizeof(GxidI32)); + if (count != sizeof(GxidI32)) + { + fprintf(stderr,"gxid_lib: error reading return code"); + close(socket_fd); + return GXID_RETURN_ERROR; + } + + close (socket_fd); + return ntohl(retval); +} + +/* claim a device. If exclusive, device is claimed exclusively */ +int +gxid_claim_device(char *host, int port, GxidU32 device, GxidU32 window, + int exclusive) +{ + GxidClaimDevice msg; + msg.type = htonl(GXID_CLAIM_DEVICE); + msg.length = htonl(sizeof(GxidClaimDevice)); + msg.device = htonl(device); + msg.window = htonl(window); + msg.exclusive = htonl(exclusive); + + return gxid_send_message(host,port,(GxidMessage *)&msg); +} + +/* release a device/window pair */ +int +gxid_release_device(char *host, int port, GxidU32 device, GxidU32 window) +{ + GxidReleaseDevice msg; + msg.type = htonl(GXID_RELEASE_DEVICE); + msg.length = htonl(sizeof(GxidReleaseDevice)); + msg.device = htonl(device); + msg.window = htonl(window); + + return gxid_send_message(host,port,(GxidMessage *)&msg); +} + +#endif /* XINPUT_GXI */ + diff --git a/gdk/x11/gxid_lib.h b/gdk/x11/gxid_lib.h new file mode 100644 index 000000000..6a7103bbe --- /dev/null +++ b/gdk/x11/gxid_lib.h @@ -0,0 +1,6 @@ +#include "gxid_proto.h" + +int gxid_claim_device(char *host, int port, + GxidU32 device, GxidU32 window, int exclusive); +int gxid_release_device(char *host, int port, GxidU32 device, + GxidU32 window); diff --git a/gdk/x11/gxid_proto.h b/gdk/x11/gxid_proto.h new file mode 100644 index 000000000..24959b806 --- /dev/null +++ b/gdk/x11/gxid_proto.h @@ -0,0 +1,39 @@ +#define GXID_CLAIM_DEVICE 1 +#define GXID_RELEASE_DEVICE 2 + +#define GXID_RETURN_OK 0 +#define GXID_RETURN_ERROR -1 + +typedef struct GxidClaimDevice_ GxidClaimDevice; +typedef struct GxidReleaseDevice_ GxidReleaseDevice; +typedef struct GxidMessageAny_ GxidMessageAny; +typedef union GxidMessage_ GxidMessage; + +typedef unsigned long GxidU32; +typedef long GxidI32; + +struct GxidClaimDevice_ { + GxidU32 type; + GxidU32 length; + GxidU32 device; + GxidU32 window; + GxidU32 exclusive; +}; + +struct GxidReleaseDevice_ { + GxidU32 type; + GxidU32 length; + GxidU32 device; + GxidU32 window; +}; + +struct GxidMessageAny_ { + GxidU32 type; + GxidU32 length; +}; + +union GxidMessage_ { + GxidMessageAny any; + GxidClaimDevice claim; + GxidReleaseDevice release; +}; |