AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-18 09:00:34 +00:00
Code Issues Projects Releases Wiki Activity
4f8dbd4a8d
gtk/gdk/x11/gdkmain-x11.c

625 lines
17 KiB
C
Raw Blame History

/* 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 Lesser 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include "config.h"
#include <glib/gprintf.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#include <errno.h>
#include <X11/Xatom.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#ifdef HAVE_XKB
#include <X11/XKBlib.h>
#endif
#include "gdk.h"
#include "gdkx.h"
#include "gdkasync.h"
#include "gdkdisplay-x11.h"
#include "gdkinternals.h"
#include "gdkprivate-x11.h"
#include "gdkintl.h"
#include <gdk/gdkdeviceprivate.h>
typedef struct _GdkPredicate GdkPredicate;
typedef struct _GdkErrorTrap GdkErrorTrap;
struct _GdkPredicate
{
GdkEventFunc func;
gpointer data;
};
struct _GdkErrorTrap
{
int (*old_handler) (Display *, XErrorEvent *);
gint error_warnings;
gint error_code;
};
/*
* Private function declarations
*/
#ifndef HAVE_XCONVERTCASE
static void gdkx_XConvertCase (KeySym symbol,
KeySym *lower,
KeySym *upper);
#define XConvertCase gdkx_XConvertCase
#endif
static int gdk_x_error (Display *display,
XErrorEvent *error);
static int gdk_x_io_error (Display *display);
/* Private variable declarations
*/
static GSList *gdk_error_traps = NULL; /* List of error traps */
static GSList *gdk_error_trap_free_list = NULL; /* Free list */
const GOptionEntry _gdk_windowing_args[] = {
{ "sync", 0, 0, G_OPTION_ARG_NONE, &_gdk_synchronize,
/* Description of --sync in --help output */ N_("Make X calls synchronous"), NULL },
{ NULL }
};
void
_gdk_windowing_init (void)
{
_gdk_x11_initialize_locale ();
XSetErrorHandler (gdk_x_error);
XSetIOErrorHandler (gdk_x_io_error);
_gdk_selection_property = gdk_atom_intern_static_string ("GDK_SELECTION");
}
GdkGrabStatus
_gdk_x11_convert_grab_status (gint status)
{
switch (status)
{
case GrabSuccess:
return GDK_GRAB_SUCCESS;
case AlreadyGrabbed:
return GDK_GRAB_ALREADY_GRABBED;
case GrabInvalidTime:
return GDK_GRAB_INVALID_TIME;
case GrabNotViewable:
return GDK_GRAB_NOT_VIEWABLE;
case GrabFrozen:
return GDK_GRAB_FROZEN;
}
g_assert_not_reached();
return 0;
}
static void
has_pointer_grab_callback (GdkDisplay *display,
gpointer data,
gulong serial)
{
GdkDevice *device = data;
_gdk_display_device_grab_update (display, device, serial);
}
GdkGrabStatus
_gdk_windowing_device_grab (GdkDevice *device,
GdkWindow *window,
GdkWindow *native,
gboolean owner_events,
GdkEventMask event_mask,
GdkWindow *confine_to,
GdkCursor *cursor,
guint32 time)
{
GdkDisplay *display;
GdkGrabStatus status = GDK_GRAB_SUCCESS;
if (!window || GDK_WINDOW_DESTROYED (window))
return GDK_GRAB_NOT_VIEWABLE;
display = gdk_device_get_display (device);
#ifdef G_ENABLE_DEBUG
if (_gdk_debug_flags & GDK_DEBUG_NOGRABS)
status = GrabSuccess;
else
#endif
status = GDK_DEVICE_GET_CLASS (device)->grab (device,
native,
owner_events,
event_mask,
confine_to,
cursor,
time);
if (status == GDK_GRAB_SUCCESS)
_gdk_x11_roundtrip_async (display,
has_pointer_grab_callback,
device);
return status;
}
/**
* _gdk_xgrab_check_unmap:
* @window: a #GdkWindow
* @serial: serial from Unmap event (or from NextRequest(display)
* if the unmap is being done by this client.)
*
* Checks to see if an unmap request or event causes the current
* grab window to become not viewable, and if so, clear the
* the pointer we keep to it.
**/
void
_gdk_xgrab_check_unmap (GdkWindow *window,
gulong serial)
{
GdkDisplay *display = gdk_drawable_get_display (window);
GdkDeviceManager *device_manager;
GList *devices, *d;
device_manager = gdk_display_get_device_manager (display);
/* Get all devices */
devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
/* End all grabs on the newly hidden window */
for (d = devices; d; d = d->next)
_gdk_display_end_device_grab (display, d->data, serial, window, TRUE);
g_list_free (devices);
}
/**
* _gdk_xgrab_check_destroy:
* @window: a #GdkWindow
*
* Checks to see if window is the current grab window, and if
* so, clear the current grab window.
**/
void
_gdk_xgrab_check_destroy (GdkWindow *window)
{
GdkDisplay *display = gdk_drawable_get_display (window);
GdkDeviceManager *device_manager;
GdkDeviceGrabInfo *grab;
GList *devices, *d;
device_manager = gdk_display_get_device_manager (display);
/* Get all devices */
devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
for (d = devices; d; d = d->next)
{
/* Make sure there is no lasting grab in this native window */
grab = _gdk_display_get_last_device_grab (display, d->data);
if (grab && grab->native_window == window)
{
/* We don't know the actual serial to end, but it
doesn't really matter as this only happens
after we get told of the destroy from the
server so we know its ended in the server,
just make sure its ended. */
grab->serial_end = grab->serial_start;
grab->implicit_ungrab = TRUE;
}
}
g_list_free (devices);
}
void
_gdk_windowing_display_set_sm_client_id (GdkDisplay *display,
const gchar *sm_client_id)
{
GdkDisplayX11 *display_x11 = GDK_DISPLAY_X11 (display);
if (display->closed)
return;
if (sm_client_id && strcmp (sm_client_id, ""))
{
XChangeProperty (display_x11->xdisplay, display_x11->leader_window,
gdk_x11_get_xatom_by_name_for_display (display, "SM_CLIENT_ID"),
XA_STRING, 8, PropModeReplace, (guchar *)sm_client_id,
strlen (sm_client_id));
}
else
XDeleteProperty (display_x11->xdisplay, display_x11->leader_window,
gdk_x11_get_xatom_by_name_for_display (display, "SM_CLIENT_ID"));
}
/* Close all open displays
*/
void
_gdk_windowing_exit (void)
{
GSList *tmp_list = _gdk_displays;
while (tmp_list)
{
XCloseDisplay (GDK_DISPLAY_XDISPLAY (tmp_list->data));
tmp_list = tmp_list->next;
}
}
/*
*--------------------------------------------------------------
* 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)
{
if (error->error_code)
{
if (_gdk_error_warnings)
{
gchar buf[64];
gchar *msg;
XGetErrorText (display, error->error_code, buf, 63);
msg =
g_strdup_printf ("The program '%s' received an X Window System error.\n"
"This probably reflects a bug in the program.\n"
"The error was '%s'.\n"
" (Details: serial %ld error_code %d request_code %d minor_code %d)\n"
" (Note to programmers: normally, X errors are reported asynchronously;\n"
" that is, you will receive the error a while after causing it.\n"
" To debug your program, run it with the --sync command line\n"
" option to change this behavior. You can then get a meaningful\n"
" backtrace from your debugger if you break on the gdk_x_error() function.)",
g_get_prgname (),
buf,
error->serial,
error->error_code,
error->request_code,
error->minor_code);
#ifdef G_ENABLE_DEBUG
g_error ("%s", msg);
#else /* !G_ENABLE_DEBUG */
g_fprintf (stderr, "%s\n", msg);
exit (1);
#endif /* G_ENABLE_DEBUG */
}
_gdk_error_code = error->error_code;
}
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)
{
/* This is basically modelled after the code in XLib. We need
* an explicit error handler here, so we can disable our atexit()
* which would otherwise cause a nice segfault.
* We fprintf(stderr, instead of g_warning() because g_warning()
* could possibly be redirected to a dialog
*/
if (errno == EPIPE)
{
g_fprintf (stderr,
"The application '%s' lost its connection to the display %s;\n"
"most likely the X server was shut down or you killed/destroyed\n"
"the application.\n",
g_get_prgname (),
display ? DisplayString (display) : gdk_get_display_arg_name ());
}
else
{
g_fprintf (stderr, "%s: Fatal IO error %d (%s) on X server %s.\n",
g_get_prgname (),
errno, g_strerror (errno),
display ? DisplayString (display) : gdk_get_display_arg_name ());
}
exit(1);
}
/*************************************************************
* gdk_error_trap_push:
* Push an error trap. X errors will be trapped until
* the corresponding gdk_error_pop(), which will return
* the error code, if any.
* arguments:
*
* results:
*************************************************************/
void
gdk_error_trap_push (void)
{
GSList *node;
GdkErrorTrap *trap;
if (gdk_error_trap_free_list)
{
node = gdk_error_trap_free_list;
gdk_error_trap_free_list = gdk_error_trap_free_list->next;
}
else
{
node = g_slist_alloc ();
node->data = g_new (GdkErrorTrap, 1);
}
node->next = gdk_error_traps;
gdk_error_traps = node;
trap = node->data;
trap->old_handler = XSetErrorHandler (gdk_x_error);
trap->error_code = _gdk_error_code;
trap->error_warnings = _gdk_error_warnings;
_gdk_error_code = 0;
_gdk_error_warnings = 0;
}
/*************************************************************
* gdk_error_trap_pop:
* Pop an error trap added with gdk_error_push()
* arguments:
*
* results:
* 0, if no error occured, otherwise the error code.
*************************************************************/
gint
gdk_error_trap_pop (void)
{
GSList *node;
GdkErrorTrap *trap;
gint result;
g_return_val_if_fail (gdk_error_traps != NULL, 0);
node = gdk_error_traps;
gdk_error_traps = gdk_error_traps->next;
node->next = gdk_error_trap_free_list;
gdk_error_trap_free_list = node;
result = _gdk_error_code;
trap = node->data;
_gdk_error_code = trap->error_code;
_gdk_error_warnings = trap->error_warnings;
XSetErrorHandler (trap->old_handler);
return result;
}
gchar *
gdk_get_display (void)
{
return g_strdup (gdk_display_get_name (gdk_display_get_default ()));
}
/**
* _gdk_send_xevent:
* @display: #GdkDisplay which @window is on
* @window: window ID to which to send the event
* @propagate: %TRUE if the event should be propagated if the target window
* doesn't handle it.
* @event_mask: event mask to match against, or 0 to send it to @window
* without regard to event masks.
* @event_send: #XEvent to send
*
* Send an event, like XSendEvent(), but trap errors and check
* the result.
*
* Return value: %TRUE if sending the event succeeded.
**/
gint
_gdk_send_xevent (GdkDisplay *display,
Window window,
gboolean propagate,
glong event_mask,
XEvent *event_send)
{
gboolean result;
if (display->closed)
return FALSE;
gdk_error_trap_push ();
result = XSendEvent (GDK_DISPLAY_XDISPLAY (display), window,
propagate, event_mask, event_send);
XSync (GDK_DISPLAY_XDISPLAY (display), False);
if (gdk_error_trap_pop ())
return FALSE;
return result;
}
void
_gdk_region_get_xrectangles (const cairo_region_t *region,
gint x_offset,
gint y_offset,
XRectangle **rects,
gint *n_rects)
{
XRectangle *rectangles;
cairo_rectangle_int_t box;
gint i, n;
n = cairo_region_num_rectangles (region);
rectangles = g_new (XRectangle, n);
for (i = 0; i < n; i++)
{
cairo_region_get_rectangle (region, i, &box);
rectangles[i].x = CLAMP (box.x + x_offset, G_MINSHORT, G_MAXSHORT);
rectangles[i].y = CLAMP (box.y + y_offset, G_MINSHORT, G_MAXSHORT);
rectangles[i].width = CLAMP (box.width, G_MINSHORT, G_MAXSHORT);
rectangles[i].height = CLAMP (box.height, G_MINSHORT, G_MAXSHORT);
}
*n_rects = n;
*rects = rectangles;
}
/**
* gdk_x11_grab_server:
*
* Call gdk_x11_display_grab() on the default display.
* To ungrab the server again, use gdk_x11_ungrab_server().
*
* gdk_x11_grab_server()/gdk_x11_ungrab_server() calls can be nested.
**/
void
gdk_x11_grab_server (void)
{
gdk_x11_display_grab (gdk_display_get_default ());
}
/**
* gdk_x11_ungrab_server:
*
* Ungrab the default display after it has been grabbed with
* gdk_x11_grab_server().
**/
void
gdk_x11_ungrab_server (void)
{
gdk_x11_display_ungrab (gdk_display_get_default ());
}
/**
* gdk_x11_get_default_screen:
*
* Gets the default GTK+ screen number.
*
* Return value: returns the screen number specified by
* the --display command line option or the DISPLAY environment
* variable when gdk_init() calls XOpenDisplay().
**/
gint
gdk_x11_get_default_screen (void)
{
return gdk_screen_get_number (gdk_screen_get_default ());
}
/**
* gdk_x11_get_default_root_xwindow:
*
* Gets the root window of the default screen
* (see gdk_x11_get_default_screen()).
*
* Return value: an Xlib <type>Window</type>.
**/
Window
gdk_x11_get_default_root_xwindow (void)
{
return GDK_SCREEN_XROOTWIN (gdk_screen_get_default ());
}
/**
* gdk_x11_get_default_xdisplay:
*
* Gets the default GTK+ display.
*
* Return value: the Xlib <type>Display*</type> for the display
* specified in the <option>--display</option> command line option
* or the <envar>DISPLAY</envar> environment variable.
**/
Display *
gdk_x11_get_default_xdisplay (void)
{
return GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
}
void
_gdk_windowing_event_data_copy (const GdkEvent *src,
GdkEvent *dst)
{
}
void
_gdk_windowing_event_data_free (GdkEvent *event)
{
}
Reference in New Issue View Git Blame Copy Permalink