mirror of
https://gitlab.gnome.org/GNOME/gtk.git
synced 2024-12-28 22:41:43 +00:00
6a690c6d3f
Fri Jan 22 19:22:39 1999 Owen Taylor <otaylor@redhat.com> * gtk/gtkeditable.c: Add flags field to GtkTargetEntry table. * gdk/gdkwindow.c (gdk_window_is_viewable): Treat foreign windows as always viewable, since we can't track their map-state reliably without speed problems. (Fixes problem where updating didn't occur properly within GtkPlug)
2550 lines
58 KiB
C
2550 lines
58 KiB
C
/* 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., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include <X11/Xlib.h>
|
|
#include <X11/Xutil.h>
|
|
#include <X11/Xatom.h>
|
|
#include <netinet/in.h>
|
|
#include "gdk.h"
|
|
#include "config.h"
|
|
#include "gdkinput.h"
|
|
#include "gdkprivate.h"
|
|
#include "MwmUtil.h"
|
|
|
|
#if HAVE_CONFIG_H
|
|
# include <config.h>
|
|
# if STDC_HEADERS
|
|
# include <stdlib.h>
|
|
# include <stdio.h>
|
|
# include <string.h>
|
|
# endif
|
|
#else
|
|
# include <stdlib.h>
|
|
# include <stdio.h>
|
|
#endif
|
|
|
|
|
|
#ifdef HAVE_SHAPE_EXT
|
|
#include <X11/extensions/shape.h>
|
|
#endif
|
|
|
|
const int gdk_event_mask_table[20] =
|
|
{
|
|
ExposureMask,
|
|
PointerMotionMask,
|
|
PointerMotionHintMask,
|
|
ButtonMotionMask,
|
|
Button1MotionMask,
|
|
Button2MotionMask,
|
|
Button3MotionMask,
|
|
ButtonPressMask | OwnerGrabButtonMask,
|
|
ButtonReleaseMask | OwnerGrabButtonMask,
|
|
KeyPressMask,
|
|
KeyReleaseMask,
|
|
EnterWindowMask,
|
|
LeaveWindowMask,
|
|
FocusChangeMask,
|
|
StructureNotifyMask,
|
|
PropertyChangeMask,
|
|
VisibilityChangeMask,
|
|
0, /* PROXIMITY_IN */
|
|
0, /* PROXIMTY_OUT */
|
|
SubstructureNotifyMask
|
|
};
|
|
const int gdk_nevent_masks = sizeof(gdk_event_mask_table)/sizeof(int);
|
|
|
|
static gboolean gdk_window_have_shape_ext (void);
|
|
|
|
/* internal function created for and used by gdk_window_xid_at_coords */
|
|
Window
|
|
gdk_window_xid_at (Window base,
|
|
gint bx,
|
|
gint by,
|
|
gint x,
|
|
gint y,
|
|
GList *excludes,
|
|
gboolean excl_child)
|
|
{
|
|
GdkWindow *window;
|
|
GdkWindowPrivate *private;
|
|
Display *disp;
|
|
Window *list = NULL;
|
|
Window child = 0, parent_win = 0, root_win = 0;
|
|
int i;
|
|
unsigned int ww, wh, wb, wd, num;
|
|
int wx, wy;
|
|
|
|
window = (GdkWindow*) &gdk_root_parent;
|
|
private = (GdkWindowPrivate*) window;
|
|
disp = private->xdisplay;
|
|
if (!XGetGeometry (disp, base, &root_win, &wx, &wy, &ww, &wh, &wb, &wd))
|
|
return 0;
|
|
wx += bx;
|
|
wy += by;
|
|
|
|
if (!((x >= wx) &&
|
|
(y >= wy) &&
|
|
(x < (int) (wx + ww)) &&
|
|
(y < (int) (wy + wh))))
|
|
return 0;
|
|
|
|
if (!XQueryTree (disp, base, &root_win, &parent_win, &list, &num))
|
|
return base;
|
|
|
|
if (list)
|
|
{
|
|
for (i = num - 1; ; i--)
|
|
{
|
|
if ((!excl_child) || (!g_list_find (excludes, (gpointer *) list[i])))
|
|
{
|
|
if ((child = gdk_window_xid_at (list[i], wx, wy, x, y, excludes, excl_child)) != 0)
|
|
{
|
|
XFree (list);
|
|
return child;
|
|
}
|
|
}
|
|
if (!i)
|
|
break;
|
|
}
|
|
XFree (list);
|
|
}
|
|
return base;
|
|
}
|
|
|
|
/*
|
|
* The following fucntion by The Rasterman <raster@redhat.com>
|
|
* This function returns the X Window ID in which the x y location is in
|
|
* (x and y being relative to the root window), excluding any windows listed
|
|
* in the GList excludes (this is a list of X Window ID's - gpointer being
|
|
* the Window ID).
|
|
*
|
|
* This is primarily designed for internal gdk use - for DND for example
|
|
* when using a shaped icon window as the drag object - you exclude the
|
|
* X Window ID of the "icon" (perhaps more if excludes may be needed) and
|
|
* You can get back an X Window ID as to what X Window ID is infact under
|
|
* those X,Y co-ordinates.
|
|
*/
|
|
Window
|
|
gdk_window_xid_at_coords (gint x,
|
|
gint y,
|
|
GList *excludes,
|
|
gboolean excl_child)
|
|
{
|
|
GdkWindow *window;
|
|
GdkWindowPrivate *private;
|
|
Display *disp;
|
|
Window *list = NULL;
|
|
Window root, child = 0, parent_win = 0, root_win = 0;
|
|
unsigned int num;
|
|
int i;
|
|
|
|
window = (GdkWindow*) &gdk_root_parent;
|
|
private = (GdkWindowPrivate*) window;
|
|
disp = private->xdisplay;
|
|
root = private->xwindow;
|
|
num = g_list_length (excludes);
|
|
|
|
XGrabServer (disp);
|
|
if (!XQueryTree (disp, root, &root_win, &parent_win, &list, &num))
|
|
{
|
|
XUngrabServer(disp);
|
|
return root;
|
|
}
|
|
if (list)
|
|
{
|
|
i = num - 1;
|
|
do
|
|
{
|
|
XWindowAttributes xwa;
|
|
|
|
XGetWindowAttributes (disp, list [i], &xwa);
|
|
|
|
if (xwa.map_state != IsViewable)
|
|
continue;
|
|
|
|
if (excl_child && g_list_find (excludes, (gpointer *) list[i]))
|
|
continue;
|
|
|
|
if ((child = gdk_window_xid_at (list[i], 0, 0, x, y, excludes, excl_child)) == 0)
|
|
continue;
|
|
|
|
if (excludes)
|
|
{
|
|
if (!g_list_find (excludes, (gpointer *) child))
|
|
{
|
|
XFree (list);
|
|
XUngrabServer (disp);
|
|
return child;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
XFree (list);
|
|
XUngrabServer (disp);
|
|
return child;
|
|
}
|
|
} while (--i > 0);
|
|
XFree (list);
|
|
}
|
|
XUngrabServer (disp);
|
|
return root;
|
|
}
|
|
|
|
void
|
|
gdk_window_init (void)
|
|
{
|
|
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.xwindow = gdk_root_window;
|
|
gdk_root_parent.xdisplay = gdk_display;
|
|
gdk_root_parent.window_type = GDK_WINDOW_ROOT;
|
|
gdk_root_parent.window.user_data = NULL;
|
|
gdk_root_parent.width = width;
|
|
gdk_root_parent.height = height;
|
|
gdk_root_parent.children = NULL;
|
|
gdk_root_parent.colormap = NULL;
|
|
gdk_root_parent.ref_count = 1;
|
|
|
|
gdk_xid_table_insert (&gdk_root_window, &gdk_root_parent);
|
|
}
|
|
|
|
static GdkAtom wm_client_leader_atom = GDK_NONE;
|
|
|
|
GdkWindow*
|
|
gdk_window_new (GdkWindow *parent,
|
|
GdkWindowAttr *attributes,
|
|
gint attributes_mask)
|
|
{
|
|
GdkWindow *window;
|
|
GdkWindowPrivate *private;
|
|
GdkWindowPrivate *parent_private;
|
|
GdkVisual *visual;
|
|
Display *parent_display;
|
|
Window xparent;
|
|
Visual *xvisual;
|
|
XSetWindowAttributes xattributes;
|
|
long xattributes_mask;
|
|
XSizeHints size_hints;
|
|
XWMHints wm_hints;
|
|
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;
|
|
if (parent_private->destroyed)
|
|
return NULL;
|
|
|
|
xparent = parent_private->xwindow;
|
|
parent_display = parent_private->xdisplay;
|
|
|
|
private = g_new (GdkWindowPrivate, 1);
|
|
window = (GdkWindow*) private;
|
|
|
|
private->parent = parent;
|
|
|
|
if (parent_private)
|
|
parent_private->children = g_list_prepend (parent_private->children, window);
|
|
|
|
private->xdisplay = parent_display;
|
|
private->destroyed = FALSE;
|
|
private->mapped = 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->filters = NULL;
|
|
private->children = NULL;
|
|
|
|
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 < gdk_nevent_masks; i++)
|
|
{
|
|
if (attributes->event_mask & (1 << (i + 1)))
|
|
xattributes.event_mask |= gdk_event_mask_table[i];
|
|
}
|
|
|
|
if (xattributes.event_mask)
|
|
xattributes_mask |= CWEventMask;
|
|
|
|
if(attributes_mask & GDK_WA_NOREDIR) {
|
|
xattributes.override_redirect =
|
|
(attributes->override_redirect == FALSE)?False:True;
|
|
xattributes_mask |= CWOverrideRedirect;
|
|
} else
|
|
xattributes.override_redirect = False;
|
|
|
|
if (attributes->wclass == GDK_INPUT_OUTPUT)
|
|
{
|
|
class = InputOutput;
|
|
depth = visual->depth;
|
|
|
|
if (attributes_mask & GDK_WA_COLORMAP)
|
|
private->colormap = attributes->colormap;
|
|
else
|
|
{
|
|
if ((((GdkVisualPrivate*)gdk_visual_get_system())->xvisual) == xvisual)
|
|
private->colormap = gdk_colormap_get_system ();
|
|
else
|
|
private->colormap = gdk_colormap_new (visual, False);
|
|
}
|
|
|
|
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*) private->colormap)->xcolormap;
|
|
xattributes_mask |= CWColormap;
|
|
|
|
xparent = gdk_root_window;
|
|
break;
|
|
|
|
case GDK_WINDOW_CHILD:
|
|
xattributes.colormap = ((GdkColormapPrivate*) private->colormap)->xcolormap;
|
|
xattributes_mask |= CWColormap;
|
|
break;
|
|
|
|
case GDK_WINDOW_DIALOG:
|
|
xattributes.colormap = ((GdkColormapPrivate*) private->colormap)->xcolormap;
|
|
xattributes_mask |= CWColormap;
|
|
|
|
xparent = gdk_root_window;
|
|
break;
|
|
|
|
case GDK_WINDOW_TEMP:
|
|
xattributes.colormap = ((GdkColormapPrivate*) private->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 = 0;
|
|
class = InputOnly;
|
|
private->colormap = NULL;
|
|
}
|
|
|
|
private->xwindow = XCreateWindow (private->xdisplay, xparent,
|
|
x, y, private->width, private->height,
|
|
0, depth, class, xvisual,
|
|
xattributes_mask, &xattributes);
|
|
gdk_window_ref (window);
|
|
gdk_xid_table_insert (&private->xwindow, window);
|
|
|
|
if (private->colormap)
|
|
gdk_colormap_ref (private->colormap);
|
|
|
|
gdk_window_set_cursor (window, ((attributes_mask & GDK_WA_CURSOR) ?
|
|
(attributes->cursor) :
|
|
NULL));
|
|
|
|
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) &&
|
|
(private->colormap != gdk_colormap_get_system ()) &&
|
|
(private->colormap != gdk_window_get_colormap (gdk_window_get_toplevel (window))))
|
|
{
|
|
GDK_NOTE (MISC, g_message ("adding colormap window\n"));
|
|
gdk_window_add_colormap_windows (window);
|
|
}
|
|
|
|
return window;
|
|
default:
|
|
|
|
return window;
|
|
}
|
|
|
|
size_hints.flags = PSize;
|
|
size_hints.width = private->width;
|
|
size_hints.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;
|
|
|
|
/* FIXME: Is there any point in doing this? Do any WM's pay
|
|
* attention to PSize, and even if they do, is this the
|
|
* correct value???
|
|
*/
|
|
XSetWMNormalHints (private->xdisplay, private->xwindow, &size_hints);
|
|
|
|
XSetWMHints (private->xdisplay, private->xwindow, &wm_hints);
|
|
|
|
if (!wm_client_leader_atom)
|
|
wm_client_leader_atom = gdk_atom_intern ("WM_CLIENT_LEADER", FALSE);
|
|
|
|
XChangeProperty (private->xdisplay, private->xwindow,
|
|
wm_client_leader_atom,
|
|
XA_WINDOW, 32, PropModeReplace,
|
|
(guchar*) &gdk_leader_window, 1);
|
|
|
|
if (attributes_mask & GDK_WA_TITLE)
|
|
title = attributes->title;
|
|
else
|
|
title = g_get_prgname ();
|
|
|
|
XmbSetWMProperties (private->xdisplay, private->xwindow,
|
|
title, title,
|
|
NULL, 0,
|
|
NULL, NULL, NULL);
|
|
|
|
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);
|
|
}
|
|
|
|
|
|
return window;
|
|
}
|
|
|
|
GdkWindow *
|
|
gdk_window_foreign_new (guint32 anid)
|
|
{
|
|
GdkWindow *window;
|
|
GdkWindowPrivate *private;
|
|
GdkWindowPrivate *parent_private;
|
|
XWindowAttributes attrs;
|
|
Window root, parent;
|
|
Window *children = NULL;
|
|
guint nchildren;
|
|
|
|
if(!XGetWindowAttributes (gdk_display, anid, &attrs)) {
|
|
g_warning("XGetWindowAttributes failed on window ID %d\n", anid);
|
|
return NULL;
|
|
}
|
|
|
|
private = g_new (GdkWindowPrivate, 1);
|
|
window = (GdkWindow*) private;
|
|
|
|
/* FIXME: This is pretty expensive. Maybe the caller should supply
|
|
* the parent */
|
|
XQueryTree (gdk_display, anid, &root, &parent, &children, &nchildren);
|
|
|
|
if (children)
|
|
XFree (children);
|
|
private->parent = gdk_xid_table_lookup (parent);
|
|
|
|
parent_private = (GdkWindowPrivate *)private->parent;
|
|
|
|
if (parent_private)
|
|
parent_private->children = g_list_prepend (parent_private->children, window);
|
|
|
|
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;
|
|
private->window_type = GDK_WINDOW_FOREIGN;
|
|
private->destroyed = FALSE;
|
|
private->mapped = (attrs.map_state != IsUnmapped);
|
|
private->extension_events = 0;
|
|
|
|
private->colormap = NULL;
|
|
|
|
private->filters = NULL;
|
|
private->children = NULL;
|
|
|
|
window->user_data = NULL;
|
|
|
|
gdk_window_ref (window);
|
|
gdk_xid_table_insert (&private->xwindow, window);
|
|
|
|
return window;
|
|
}
|
|
|
|
/* Call this function when you want a window and all its children to
|
|
* disappear. When xdestroy is true, a request to destroy the XWindow
|
|
* is sent out. When it is false, it is assumed that the XWindow has
|
|
* been or will be destroyed by destroying some ancestor of this
|
|
* window.
|
|
*/
|
|
static void
|
|
gdk_window_internal_destroy (GdkWindow *window,
|
|
gboolean xdestroy,
|
|
gboolean our_destroy)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
GdkWindowPrivate *temp_private;
|
|
GdkWindow *temp_window;
|
|
GList *children;
|
|
GList *tmp;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
|
|
switch (private->window_type)
|
|
{
|
|
case GDK_WINDOW_TOPLEVEL:
|
|
case GDK_WINDOW_CHILD:
|
|
case GDK_WINDOW_DIALOG:
|
|
case GDK_WINDOW_TEMP:
|
|
case GDK_WINDOW_FOREIGN:
|
|
if (!private->destroyed)
|
|
{
|
|
if (private->parent)
|
|
{
|
|
GdkWindowPrivate *parent_private = (GdkWindowPrivate *)private->parent;
|
|
if (parent_private->children)
|
|
parent_private->children = g_list_remove (parent_private->children, window);
|
|
}
|
|
|
|
if (private->window_type != GDK_WINDOW_FOREIGN)
|
|
{
|
|
children = tmp = private->children;
|
|
private->children = NULL;
|
|
|
|
while (tmp)
|
|
{
|
|
temp_window = tmp->data;
|
|
tmp = tmp->next;
|
|
|
|
temp_private = (GdkWindowPrivate*) temp_window;
|
|
if (temp_private)
|
|
gdk_window_internal_destroy (temp_window, FALSE,
|
|
our_destroy);
|
|
}
|
|
|
|
g_list_free (children);
|
|
}
|
|
|
|
if (private->extension_events != 0)
|
|
gdk_input_window_destroy (window);
|
|
|
|
if (private->filters)
|
|
{
|
|
tmp = private->filters;
|
|
|
|
while (tmp)
|
|
{
|
|
g_free (tmp->data);
|
|
tmp = tmp->next;
|
|
}
|
|
|
|
g_list_free (private->filters);
|
|
private->filters = NULL;
|
|
}
|
|
|
|
if (private->window_type == GDK_WINDOW_FOREIGN)
|
|
{
|
|
if (our_destroy && (private->parent != NULL))
|
|
{
|
|
/* It's somebody elses window, but in our heirarchy,
|
|
* so reparent it to the root window, and then send
|
|
* it a delete event, as if we were a WM
|
|
*/
|
|
XClientMessageEvent xevent;
|
|
|
|
gdk_window_hide (window);
|
|
gdk_window_reparent (window, NULL, 0, 0);
|
|
|
|
xevent.type = ClientMessage;
|
|
xevent.window = private->xwindow;
|
|
xevent.message_type = gdk_wm_protocols;
|
|
xevent.format = 32;
|
|
xevent.data.l[0] = gdk_wm_delete_window;
|
|
xevent.data.l[1] = CurrentTime;
|
|
|
|
XSendEvent (private->xdisplay, private->xwindow,
|
|
False, 0, (XEvent *)&xevent);
|
|
}
|
|
}
|
|
else if (xdestroy)
|
|
XDestroyWindow (private->xdisplay, private->xwindow);
|
|
|
|
if (private->colormap)
|
|
gdk_colormap_unref (private->colormap);
|
|
|
|
private->mapped = FALSE;
|
|
private->destroyed = TRUE;
|
|
}
|
|
break;
|
|
|
|
case GDK_WINDOW_ROOT:
|
|
g_error ("attempted to destroy root window");
|
|
break;
|
|
|
|
case GDK_WINDOW_PIXMAP:
|
|
g_error ("called gdk_window_destroy on a pixmap (use gdk_pixmap_unref)");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Like internal_destroy, but also destroys the reference created by
|
|
gdk_window_new. */
|
|
|
|
void
|
|
gdk_window_destroy (GdkWindow *window)
|
|
{
|
|
gdk_window_internal_destroy (window, TRUE, TRUE);
|
|
gdk_window_unref (window);
|
|
}
|
|
|
|
/* This function is called when the XWindow is really gone. */
|
|
|
|
void
|
|
gdk_window_destroy_notify (GdkWindow *window)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
|
|
if (!private->destroyed)
|
|
{
|
|
if (private->window_type == GDK_WINDOW_FOREIGN)
|
|
gdk_window_internal_destroy (window, FALSE, FALSE);
|
|
else
|
|
g_warning ("GdkWindow %#lx unexpectedly destroyed", private->xwindow);
|
|
}
|
|
|
|
gdk_xid_table_remove (private->xwindow);
|
|
gdk_window_unref (window);
|
|
}
|
|
|
|
GdkWindow*
|
|
gdk_window_ref (GdkWindow *window)
|
|
{
|
|
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
|
|
g_return_val_if_fail (window != NULL, 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)
|
|
{
|
|
if (!private->destroyed)
|
|
{
|
|
if (private->window_type == GDK_WINDOW_FOREIGN)
|
|
gdk_xid_table_remove (private->xwindow);
|
|
else
|
|
g_warning ("losing last reference to undestroyed window\n");
|
|
}
|
|
g_dataset_destroy (window);
|
|
g_free (window);
|
|
}
|
|
}
|
|
|
|
void
|
|
gdk_window_show (GdkWindow *window)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
if (!private->destroyed && !private->mapped)
|
|
{
|
|
private->mapped = TRUE;
|
|
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 && private->mapped)
|
|
{
|
|
private->mapped = FALSE;
|
|
XUnmapWindow (private->xdisplay, private->xwindow);
|
|
}
|
|
}
|
|
|
|
void
|
|
gdk_window_withdraw (GdkWindow *window)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
if (!private->destroyed)
|
|
XWithdrawWindow (private->xdisplay, private->xwindow, 0);
|
|
}
|
|
|
|
void
|
|
gdk_window_move (GdkWindow *window,
|
|
gint x,
|
|
gint y)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
if (!private->destroyed)
|
|
{
|
|
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;
|
|
if (!private->destroyed)
|
|
{
|
|
XMoveResizeWindow (private->xdisplay, private->xwindow, x, y, width, height);
|
|
|
|
if (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;
|
|
GdkWindowPrivate *old_parent_private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
if (!new_parent)
|
|
new_parent = (GdkWindow*) &gdk_root_parent;
|
|
|
|
window_private = (GdkWindowPrivate*) window;
|
|
old_parent_private = (GdkWindowPrivate*)window_private->parent;
|
|
parent_private = (GdkWindowPrivate*) new_parent;
|
|
|
|
if (!window_private->destroyed && !parent_private->destroyed)
|
|
XReparentWindow (window_private->xdisplay,
|
|
window_private->xwindow,
|
|
parent_private->xwindow,
|
|
x, y);
|
|
|
|
window_private->parent = new_parent;
|
|
|
|
if (old_parent_private)
|
|
old_parent_private->children = g_list_remove (old_parent_private->children, window);
|
|
parent_private->children = g_list_prepend (parent_private->children, window);
|
|
|
|
}
|
|
|
|
void
|
|
gdk_window_clear (GdkWindow *window)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
|
|
if (!private->destroyed)
|
|
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;
|
|
if (private->destroyed)
|
|
return;
|
|
|
|
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_geometry_hints (GdkWindow *window,
|
|
GdkGeometry *geometry,
|
|
GdkWindowHints geom_mask)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
XSizeHints size_hints;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
if (private->destroyed)
|
|
return;
|
|
|
|
size_hints.flags = 0;
|
|
|
|
if (geom_mask & GDK_HINT_POS)
|
|
size_hints.flags |= PPosition;
|
|
|
|
if (geom_mask & GDK_HINT_MIN_SIZE)
|
|
{
|
|
size_hints.flags |= PMinSize;
|
|
size_hints.min_width = geometry->min_width;
|
|
size_hints.min_height = geometry->min_height;
|
|
}
|
|
|
|
if (geom_mask & GDK_HINT_MAX_SIZE)
|
|
{
|
|
size_hints.flags |= PMaxSize;
|
|
size_hints.max_width = geometry->max_width;
|
|
size_hints.max_height = geometry->max_height;
|
|
}
|
|
|
|
if (geom_mask & GDK_HINT_BASE_SIZE)
|
|
{
|
|
size_hints.flags |= PBaseSize;
|
|
size_hints.base_width = geometry->base_width;
|
|
size_hints.base_height = geometry->base_height;
|
|
}
|
|
|
|
if (geom_mask & GDK_HINT_RESIZE_INC)
|
|
{
|
|
size_hints.flags |= PResizeInc;
|
|
size_hints.width_inc = geometry->width_inc;
|
|
size_hints.height_inc = geometry->height_inc;
|
|
}
|
|
|
|
if (geom_mask & GDK_HINT_ASPECT)
|
|
{
|
|
size_hints.flags |= PAspect;
|
|
if (geometry->min_aspect <= 1)
|
|
{
|
|
size_hints.min_aspect.x = G_MAXINT * geometry->min_aspect;
|
|
size_hints.min_aspect.y = G_MAXINT;
|
|
}
|
|
else
|
|
{
|
|
size_hints.min_aspect.x = G_MAXINT;
|
|
size_hints.min_aspect.y = G_MAXINT / geometry->min_aspect;;
|
|
}
|
|
if (geometry->max_aspect <= 1)
|
|
{
|
|
size_hints.max_aspect.x = G_MAXINT * geometry->max_aspect;
|
|
size_hints.max_aspect.y = G_MAXINT;
|
|
}
|
|
else
|
|
{
|
|
size_hints.max_aspect.x = G_MAXINT;
|
|
size_hints.max_aspect.y = G_MAXINT / geometry->max_aspect;;
|
|
}
|
|
}
|
|
|
|
if (geom_mask)
|
|
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;
|
|
if (!private->destroyed)
|
|
XmbSetWMProperties (private->xdisplay, private->xwindow,
|
|
title, title, NULL, 0, NULL, NULL, NULL);
|
|
}
|
|
|
|
void
|
|
gdk_window_set_role (GdkWindow *window,
|
|
const gchar *role)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
|
|
if (role)
|
|
XChangeProperty (private->xdisplay, private->xwindow,
|
|
gdk_atom_intern ("WM_WINDOW_ROLE", FALSE), XA_STRING,
|
|
8, PropModeReplace, role, strlen(role));
|
|
else
|
|
XDeleteProperty (private->xdisplay, private->xwindow,
|
|
gdk_atom_intern ("WM_WINDOW_ROLE", FALSE));
|
|
}
|
|
|
|
void
|
|
gdk_window_set_transient_for (GdkWindow *window,
|
|
GdkWindow *parent)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
GdkWindowPrivate *parent_private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
parent_private = (GdkWindowPrivate*) parent;
|
|
|
|
if (!private->destroyed && !parent_private->destroyed)
|
|
XSetTransientForHint (private->xdisplay,
|
|
private->xwindow, parent_private->xwindow);
|
|
}
|
|
|
|
void
|
|
gdk_window_set_background (GdkWindow *window,
|
|
GdkColor *color)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
if (!private->destroyed)
|
|
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;
|
|
|
|
if (!window_private->destroyed)
|
|
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;
|
|
|
|
if (!window_private->destroyed)
|
|
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;
|
|
|
|
if (!window_private->destroyed)
|
|
{
|
|
XSetWindowColormap (window_private->xdisplay,
|
|
window_private->xwindow,
|
|
colormap_private->xcolormap);
|
|
|
|
if (window_private->colormap)
|
|
gdk_colormap_unref (window_private->colormap);
|
|
window_private->colormap = colormap;
|
|
gdk_colormap_ref (window_private->colormap);
|
|
|
|
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;
|
|
|
|
if (!window_private->destroyed)
|
|
{
|
|
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;
|
|
/* Huh? ->parent is never set for a pixmap. We should just return
|
|
* null immeditately
|
|
*/
|
|
while (window_private && (window_private->window_type == GDK_WINDOW_PIXMAP))
|
|
window_private = (GdkWindowPrivate*) window_private->parent;
|
|
|
|
if (window_private && !window_private->destroyed)
|
|
{
|
|
if (window_private->colormap == NULL)
|
|
{
|
|
XGetWindowAttributes (window_private->xdisplay,
|
|
window_private->xwindow,
|
|
&window_attributes);
|
|
return gdk_visual_lookup (window_attributes.visual);
|
|
}
|
|
else
|
|
return ((GdkColormapPrivate *)window_private->colormap)->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;
|
|
|
|
g_return_val_if_fail (window_private->window_type != GDK_WINDOW_PIXMAP, NULL);
|
|
if (!window_private->destroyed)
|
|
{
|
|
if (window_private->colormap == NULL)
|
|
{
|
|
XGetWindowAttributes (window_private->xdisplay,
|
|
window_private->xwindow,
|
|
&window_attributes);
|
|
return gdk_colormap_lookup (window_attributes.colormap);
|
|
}
|
|
else
|
|
return window_private->colormap;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
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 = 0;
|
|
gint ty = 0;
|
|
|
|
g_return_val_if_fail (window != NULL, 0);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
|
|
if (!private->destroyed)
|
|
{
|
|
return_val = XTranslateCoordinates (private->xdisplay,
|
|
private->xwindow,
|
|
gdk_root_window,
|
|
0, 0, &tx, &ty,
|
|
&child);
|
|
|
|
}
|
|
else
|
|
return_val = 0;
|
|
|
|
if (x)
|
|
*x = tx;
|
|
if (y)
|
|
*y = ty;
|
|
|
|
return return_val;
|
|
}
|
|
|
|
gboolean
|
|
gdk_window_get_deskrelative_origin (GdkWindow *window,
|
|
gint *x,
|
|
gint *y)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
gboolean return_val = FALSE;
|
|
gint num_children, format_return;
|
|
Window win, *child, parent, root;
|
|
gint tx = 0;
|
|
gint ty = 0;
|
|
Atom type_return;
|
|
static Atom atom = 0;
|
|
gulong number_return, bytes_after_return;
|
|
guchar *data_return;
|
|
|
|
g_return_val_if_fail (window != NULL, 0);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
|
|
if (!private->destroyed)
|
|
{
|
|
if (!atom)
|
|
atom = XInternAtom(private->xdisplay, "ENLIGHTENMENT_DESKTOP", False);
|
|
win = private->xwindow;
|
|
|
|
while (XQueryTree(private->xdisplay, win, &root, &parent,
|
|
&child, (unsigned int *)&num_children))
|
|
{
|
|
if ((child) && (num_children > 0))
|
|
XFree(child);
|
|
|
|
if (!parent)
|
|
break;
|
|
else
|
|
win = parent;
|
|
|
|
if (win == root)
|
|
break;
|
|
|
|
data_return = NULL;
|
|
XGetWindowProperty(private->xdisplay, win, atom, 0, 0,
|
|
False, XA_CARDINAL, &type_return, &format_return,
|
|
&number_return, &bytes_after_return, &data_return);
|
|
if (type_return == XA_CARDINAL)
|
|
{
|
|
XFree(data_return);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return_val = XTranslateCoordinates (private->xdisplay,
|
|
private->xwindow,
|
|
win,
|
|
0, 0, &tx, &ty,
|
|
&root);
|
|
if (x)
|
|
*x = tx;
|
|
if (y)
|
|
*y = ty;
|
|
}
|
|
|
|
|
|
return return_val;
|
|
}
|
|
|
|
void
|
|
gdk_window_get_root_origin (GdkWindow *window,
|
|
gint *x,
|
|
gint *y)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
Window xwindow;
|
|
Window xparent;
|
|
Window root;
|
|
Window *children;
|
|
unsigned int nchildren;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
if (x)
|
|
*x = 0;
|
|
if (y)
|
|
*y = 0;
|
|
if (private->destroyed)
|
|
return;
|
|
|
|
while (private->parent && ((GdkWindowPrivate*) private->parent)->parent)
|
|
private = (GdkWindowPrivate*) private->parent;
|
|
if (private->destroyed)
|
|
return;
|
|
|
|
xparent = private->xwindow;
|
|
do
|
|
{
|
|
xwindow = xparent;
|
|
if (!XQueryTree (private->xdisplay, xwindow,
|
|
&root, &xparent,
|
|
&children, &nchildren))
|
|
return;
|
|
|
|
if (children)
|
|
XFree (children);
|
|
}
|
|
while (xparent != root);
|
|
|
|
if (xparent == root)
|
|
{
|
|
unsigned int ww, wh, wb, wd;
|
|
int wx, wy;
|
|
|
|
if (XGetGeometry (private->xdisplay, xwindow, &root, &wx, &wy, &ww, &wh, &wb, &wd))
|
|
{
|
|
if (x)
|
|
*x = wx;
|
|
if (y)
|
|
*y = wy;
|
|
}
|
|
}
|
|
}
|
|
|
|
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 = 0;
|
|
int winy = 0;
|
|
unsigned int xmask = 0;
|
|
|
|
if (!window)
|
|
window = (GdkWindow*) &gdk_root_parent;
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
|
|
return_val = NULL;
|
|
if (!private->destroyed &&
|
|
XQueryPointer (private->xdisplay, private->xwindow, &root, &child,
|
|
&rootx, &rooty, &winx, &winy, &xmask))
|
|
{
|
|
if (child)
|
|
return_val = gdk_window_lookup (child);
|
|
}
|
|
|
|
if (x)
|
|
*x = winx;
|
|
if (y)
|
|
*y = winy;
|
|
if (mask)
|
|
*mask = xmask;
|
|
|
|
return return_val;
|
|
}
|
|
|
|
GdkWindow*
|
|
gdk_window_at_pointer (gint *win_x,
|
|
gint *win_y)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
GdkWindow *window;
|
|
Window root;
|
|
Window xwindow;
|
|
Window xwindow_last = 0;
|
|
int rootx = -1, rooty = -1;
|
|
int winx, winy;
|
|
unsigned int xmask;
|
|
|
|
private = &gdk_root_parent;
|
|
|
|
xwindow = private->xwindow;
|
|
|
|
XGrabServer (private->xdisplay);
|
|
while (xwindow)
|
|
{
|
|
xwindow_last = xwindow;
|
|
XQueryPointer (private->xdisplay,
|
|
xwindow,
|
|
&root, &xwindow,
|
|
&rootx, &rooty,
|
|
&winx, &winy,
|
|
&xmask);
|
|
}
|
|
XUngrabServer (private->xdisplay);
|
|
|
|
window = gdk_window_lookup (xwindow_last);
|
|
|
|
if (win_x)
|
|
*win_x = window ? winx : -1;
|
|
if (win_y)
|
|
*win_y = window ? winy : -1;
|
|
|
|
return window;
|
|
}
|
|
|
|
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;
|
|
if (private->destroyed)
|
|
return NULL;
|
|
|
|
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);
|
|
}
|
|
|
|
if (xchildren)
|
|
XFree (xchildren);
|
|
}
|
|
|
|
return children;
|
|
}
|
|
|
|
GdkEventMask
|
|
gdk_window_get_events (GdkWindow *window)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
XWindowAttributes attrs;
|
|
GdkEventMask event_mask;
|
|
int i;
|
|
|
|
g_return_val_if_fail (window != NULL, 0);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
if (private->destroyed)
|
|
return 0;
|
|
|
|
XGetWindowAttributes (gdk_display, private->xwindow,
|
|
&attrs);
|
|
|
|
event_mask = 0;
|
|
for (i = 0; i < gdk_nevent_masks; i++)
|
|
{
|
|
if (attrs.your_event_mask & gdk_event_mask_table[i])
|
|
event_mask |= 1 << (i + 1);
|
|
}
|
|
|
|
return event_mask;
|
|
}
|
|
|
|
void
|
|
gdk_window_set_events (GdkWindow *window,
|
|
GdkEventMask event_mask)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
long xevent_mask;
|
|
int i;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
if (private->destroyed)
|
|
return;
|
|
|
|
xevent_mask = StructureNotifyMask;
|
|
for (i = 0; i < gdk_nevent_masks; i++)
|
|
{
|
|
if (event_mask & (1 << (i + 1)))
|
|
xevent_mask |= gdk_event_mask_table[i];
|
|
}
|
|
|
|
XSelectInput (gdk_display, private->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 (window_private->destroyed)
|
|
return;
|
|
|
|
old_windows = NULL;
|
|
if (!XGetWMColormapWindows (toplevel_private->xdisplay,
|
|
toplevel_private->xwindow,
|
|
&old_windows, &count))
|
|
{
|
|
count = 0;
|
|
}
|
|
|
|
for (i = 0; i < count; i++)
|
|
if (old_windows[i] == window_private->xwindow)
|
|
{
|
|
XFree (old_windows);
|
|
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);
|
|
}
|
|
|
|
static gboolean
|
|
gdk_window_have_shape_ext (void)
|
|
{
|
|
enum { UNKNOWN, NO, YES };
|
|
static gint have_shape = UNKNOWN;
|
|
|
|
if (have_shape == UNKNOWN)
|
|
{
|
|
int ignore;
|
|
if (XQueryExtension(gdk_display, "SHAPE", &ignore, &ignore, &ignore))
|
|
have_shape = YES;
|
|
else
|
|
have_shape = NO;
|
|
}
|
|
|
|
return (have_shape == YES);
|
|
}
|
|
|
|
/*
|
|
* This needs the X11 shape extension.
|
|
* If not available, 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;
|
|
Pixmap pixmap;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
#ifdef HAVE_SHAPE_EXT
|
|
window_private = (GdkWindowPrivate*) window;
|
|
if (window_private->destroyed)
|
|
return;
|
|
|
|
if (gdk_window_have_shape_ext())
|
|
{
|
|
if (mask)
|
|
{
|
|
GdkWindowPrivate *pixmap_private;
|
|
|
|
pixmap_private = (GdkWindowPrivate*) mask;
|
|
pixmap = (Pixmap) pixmap_private->xwindow;
|
|
}
|
|
else
|
|
{
|
|
x = 0;
|
|
y = 0;
|
|
pixmap = None;
|
|
}
|
|
|
|
XShapeCombineMask (window_private->xdisplay,
|
|
window_private->xwindow,
|
|
ShapeBounding,
|
|
x, y,
|
|
pixmap,
|
|
ShapeSet);
|
|
}
|
|
#endif /* HAVE_SHAPE_EXT */
|
|
}
|
|
|
|
void
|
|
gdk_window_add_filter (GdkWindow *window,
|
|
GdkFilterFunc function,
|
|
gpointer data)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
GList *tmp_list;
|
|
GdkEventFilter *filter;
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
if (private && private->destroyed)
|
|
return;
|
|
|
|
if(private)
|
|
tmp_list = private->filters;
|
|
else
|
|
tmp_list = gdk_default_filters;
|
|
|
|
while (tmp_list)
|
|
{
|
|
filter = (GdkEventFilter *)tmp_list->data;
|
|
if ((filter->function == function) && (filter->data == data))
|
|
return;
|
|
tmp_list = tmp_list->next;
|
|
}
|
|
|
|
filter = g_new (GdkEventFilter, 1);
|
|
filter->function = function;
|
|
filter->data = data;
|
|
|
|
if(private)
|
|
private->filters = g_list_append (private->filters, filter);
|
|
else
|
|
gdk_default_filters = g_list_append (gdk_default_filters, filter);
|
|
}
|
|
|
|
void
|
|
gdk_window_remove_filter (GdkWindow *window,
|
|
GdkFilterFunc function,
|
|
gpointer data)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
GList *tmp_list, *node;
|
|
GdkEventFilter *filter;
|
|
|
|
private = (GdkWindowPrivate*) window;
|
|
|
|
if(private)
|
|
tmp_list = private->filters;
|
|
else
|
|
tmp_list = gdk_default_filters;
|
|
|
|
while (tmp_list)
|
|
{
|
|
filter = (GdkEventFilter *)tmp_list->data;
|
|
node = tmp_list;
|
|
tmp_list = tmp_list->next;
|
|
|
|
if ((filter->function == function) && (filter->data == data))
|
|
{
|
|
if(private)
|
|
private->filters = g_list_remove_link (private->filters, node);
|
|
else
|
|
gdk_default_filters = g_list_remove_link (gdk_default_filters, tmp_list);
|
|
g_list_free_1 (node);
|
|
g_free (filter);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
gdk_window_set_override_redirect(GdkWindow *window,
|
|
gboolean override_redirect)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
XSetWindowAttributes attr;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
private = (GdkWindowPrivate*) window;
|
|
if (private->destroyed)
|
|
return;
|
|
|
|
attr.override_redirect = (override_redirect == FALSE)?False:True;
|
|
XChangeWindowAttributes(gdk_display,
|
|
((GdkWindowPrivate *)window)->xwindow,
|
|
CWOverrideRedirect,
|
|
&attr);
|
|
}
|
|
|
|
void
|
|
gdk_window_set_icon (GdkWindow *window,
|
|
GdkWindow *icon_window,
|
|
GdkPixmap *pixmap,
|
|
GdkBitmap *mask)
|
|
{
|
|
XWMHints wm_hints;
|
|
GdkWindowPrivate *window_private;
|
|
GdkWindowPrivate *private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
window_private = (GdkWindowPrivate*) window;
|
|
if (window_private->destroyed)
|
|
return;
|
|
|
|
wm_hints.flags = 0;
|
|
|
|
if (icon_window != NULL)
|
|
{
|
|
private = (GdkWindowPrivate *)icon_window;
|
|
wm_hints.flags |= IconWindowHint;
|
|
wm_hints.icon_window = private->xwindow;
|
|
}
|
|
|
|
if (pixmap != NULL)
|
|
{
|
|
private = (GdkWindowPrivate *)pixmap;
|
|
wm_hints.flags |= IconPixmapHint;
|
|
wm_hints.icon_pixmap = private->xwindow;
|
|
}
|
|
|
|
if (mask != NULL)
|
|
{
|
|
private = (GdkWindowPrivate *)mask;
|
|
wm_hints.flags |= IconMaskHint;
|
|
wm_hints.icon_mask = private->xwindow;
|
|
}
|
|
|
|
XSetWMHints (window_private->xdisplay, window_private->xwindow, &wm_hints);
|
|
}
|
|
|
|
void
|
|
gdk_window_set_icon_name (GdkWindow *window,
|
|
gchar * name)
|
|
{
|
|
GdkWindowPrivate *window_private;
|
|
XTextProperty property;
|
|
gint res;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
window_private = (GdkWindowPrivate*) window;
|
|
if (window_private->destroyed)
|
|
return;
|
|
res = XmbTextListToTextProperty (window_private->xdisplay,
|
|
&name, 1, XStdICCTextStyle,
|
|
&property);
|
|
if (res < 0)
|
|
{
|
|
g_warning("Error converting icon name to text property: %d\n", res);
|
|
return;
|
|
}
|
|
|
|
XSetWMIconName (window_private->xdisplay, window_private->xwindow,
|
|
&property);
|
|
|
|
if (property.value)
|
|
XFree (property.value);
|
|
}
|
|
|
|
void
|
|
gdk_window_set_group (GdkWindow *window,
|
|
GdkWindow *leader)
|
|
{
|
|
XWMHints wm_hints;
|
|
GdkWindowPrivate *window_private;
|
|
GdkWindowPrivate *private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
g_return_if_fail (leader != NULL);
|
|
window_private = (GdkWindowPrivate*) window;
|
|
if (window_private->destroyed)
|
|
return;
|
|
|
|
private = (GdkWindowPrivate *)leader;
|
|
wm_hints.flags = WindowGroupHint;
|
|
wm_hints.window_group = private->xwindow;
|
|
|
|
XSetWMHints (window_private->xdisplay, window_private->xwindow, &wm_hints);
|
|
}
|
|
|
|
static void
|
|
gdk_window_set_mwm_hints (GdkWindow *window,
|
|
MotifWmHints *new_hints)
|
|
{
|
|
static Atom hints_atom = None;
|
|
MotifWmHints *hints;
|
|
Atom type;
|
|
gint format;
|
|
gulong nitems;
|
|
gulong bytes_after;
|
|
|
|
GdkWindowPrivate *window_private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
window_private = (GdkWindowPrivate*) window;
|
|
if (window_private->destroyed)
|
|
return;
|
|
|
|
if (!hints_atom)
|
|
hints_atom = XInternAtom (window_private->xdisplay,
|
|
_XA_MOTIF_WM_HINTS, FALSE);
|
|
|
|
XGetWindowProperty (window_private->xdisplay, window_private->xwindow,
|
|
hints_atom, 0, sizeof(MotifWmHints)/4,
|
|
False, AnyPropertyType, &type, &format, &nitems,
|
|
&bytes_after, (guchar **)&hints);
|
|
|
|
if (type == None)
|
|
hints = new_hints;
|
|
else
|
|
{
|
|
if (new_hints->flags & MWM_HINTS_FUNCTIONS)
|
|
{
|
|
hints->flags |= MWM_HINTS_FUNCTIONS;
|
|
hints->functions = new_hints->functions;
|
|
}
|
|
if (new_hints->flags & MWM_HINTS_DECORATIONS)
|
|
{
|
|
hints->flags |= MWM_HINTS_DECORATIONS;
|
|
hints->decorations = new_hints->decorations;
|
|
}
|
|
}
|
|
|
|
XChangeProperty (window_private->xdisplay, window_private->xwindow,
|
|
hints_atom, hints_atom, 32, PropModeReplace,
|
|
(guchar *)hints, sizeof(MotifWmHints)/4);
|
|
|
|
if (hints != new_hints)
|
|
XFree (hints);
|
|
}
|
|
|
|
void
|
|
gdk_window_set_decorations (GdkWindow *window,
|
|
GdkWMDecoration decorations)
|
|
{
|
|
MotifWmHints hints;
|
|
|
|
hints.flags = MWM_HINTS_DECORATIONS;
|
|
hints.decorations = decorations;
|
|
|
|
gdk_window_set_mwm_hints (window, &hints);
|
|
}
|
|
|
|
void
|
|
gdk_window_set_functions (GdkWindow *window,
|
|
GdkWMFunction functions)
|
|
{
|
|
MotifWmHints hints;
|
|
|
|
hints.flags = MWM_HINTS_FUNCTIONS;
|
|
hints.functions = functions;
|
|
|
|
gdk_window_set_mwm_hints (window, &hints);
|
|
}
|
|
|
|
GList *
|
|
gdk_window_get_toplevels (void)
|
|
{
|
|
GList *new_list = NULL;
|
|
GList *tmp_list;
|
|
|
|
tmp_list = gdk_root_parent.children;
|
|
while (tmp_list)
|
|
{
|
|
new_list = g_list_prepend (new_list, tmp_list->data);
|
|
tmp_list = tmp_list->next;
|
|
}
|
|
|
|
return new_list;
|
|
}
|
|
|
|
/*
|
|
* propagate the shapes from all child windows of a GDK window to the parent
|
|
* window. Shamelessly ripped from Enlightenment's code
|
|
*
|
|
* - Raster
|
|
*/
|
|
|
|
struct _gdk_span
|
|
{
|
|
gint start;
|
|
gint end;
|
|
struct _gdk_span *next;
|
|
};
|
|
|
|
static void
|
|
gdk_add_to_span(struct _gdk_span **s, int x, int xx)
|
|
{
|
|
struct _gdk_span *ptr1, *ptr2, *noo, *ss;
|
|
gchar spanning;
|
|
|
|
ptr2 = NULL;
|
|
ptr1 = *s;
|
|
spanning = 0;
|
|
ss = NULL;
|
|
/* scan the spans for this line */
|
|
while (ptr1)
|
|
{
|
|
/* -- -> new span */
|
|
/* == -> existing span */
|
|
/* ## -> spans intersect */
|
|
/* if we are in the middle of spanning the span into the line */
|
|
if (spanning)
|
|
{
|
|
/* case: ---- ==== */
|
|
if (xx < ptr1->start - 1)
|
|
{
|
|
/* ends before next span - extend to here */
|
|
ss->end = xx;
|
|
return;
|
|
}
|
|
/* case: ----##=== */
|
|
else if (xx <= ptr1->end)
|
|
{
|
|
/* crosses into next span - delete next span and append */
|
|
ss->end = ptr1->end;
|
|
ss->next = ptr1->next;
|
|
g_free(ptr1);
|
|
return;
|
|
}
|
|
/* case: ---###--- */
|
|
else
|
|
{
|
|
/* overlaps next span - delete and keep checking */
|
|
ss->next = ptr1->next;
|
|
g_free(ptr1);
|
|
ptr1 = ss;
|
|
}
|
|
}
|
|
/* otherwise havent started spanning it in yet */
|
|
else
|
|
{
|
|
/* case: ---- ==== */
|
|
if (xx < ptr1->start - 1)
|
|
{
|
|
/* insert span here in list */
|
|
noo = g_malloc(sizeof(struct _gdk_span));
|
|
|
|
if (noo)
|
|
{
|
|
noo->start = x;
|
|
noo->end = xx;
|
|
noo->next = ptr1;
|
|
if (ptr2)
|
|
ptr2->next = noo;
|
|
else
|
|
*s = noo;
|
|
}
|
|
return;
|
|
}
|
|
/* case: ----##=== */
|
|
else if ((x < ptr1->start) && (xx <= ptr1->end))
|
|
{
|
|
/* expand this span to the left point of the new one */
|
|
ptr1->start = x;
|
|
return;
|
|
}
|
|
/* case: ===###=== */
|
|
else if ((x >= ptr1->start) && (xx <= ptr1->end))
|
|
{
|
|
/* throw the span away */
|
|
return;
|
|
}
|
|
/* case: ---###--- */
|
|
else if ((x < ptr1->start) && (xx > ptr1->end))
|
|
{
|
|
ss = ptr1;
|
|
spanning = 1;
|
|
ptr1->start = x;
|
|
ptr1->end = xx;
|
|
}
|
|
/* case: ===##---- */
|
|
else if ((x >= ptr1->start) && (x <= ptr1->end + 1) && (xx > ptr1->end))
|
|
{
|
|
ss = ptr1;
|
|
spanning = 1;
|
|
ptr1->end = xx;
|
|
}
|
|
/* case: ==== ---- */
|
|
/* case handled by next loop iteration - first case */
|
|
}
|
|
ptr2 = ptr1;
|
|
ptr1 = ptr1->next;
|
|
}
|
|
/* it started in the middle but spans beyond your current list */
|
|
if (spanning)
|
|
{
|
|
ptr2->end = xx;
|
|
return;
|
|
}
|
|
/* it does not start inside a span or in the middle, so add it to the end */
|
|
noo = g_malloc(sizeof(struct _gdk_span));
|
|
|
|
if (noo)
|
|
{
|
|
noo->start = x;
|
|
noo->end = xx;
|
|
if (ptr2)
|
|
{
|
|
noo->next = ptr2->next;
|
|
ptr2->next = noo;
|
|
}
|
|
else
|
|
{
|
|
noo->next = NULL;
|
|
*s = noo;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
static void
|
|
gdk_add_rectangles (Display *disp, Window win, struct _gdk_span **spans,
|
|
gint basew, gint baseh, gint x, gint y)
|
|
{
|
|
gint a, k;
|
|
gint x1, y1, x2, y2;
|
|
gint rn, ord;
|
|
XRectangle *rl;
|
|
|
|
rl = XShapeGetRectangles(disp, win, ShapeBounding, &rn, &ord);
|
|
if (rl)
|
|
{
|
|
/* go through all clip rects in this window's shape */
|
|
for (k = 0; k < rn; k++)
|
|
{
|
|
/* for each clip rect, add it to each line's spans */
|
|
x1 = x + rl[k].x;
|
|
x2 = x + rl[k].x + (rl[k].width - 1);
|
|
y1 = y + rl[k].y;
|
|
y2 = y + rl[k].y + (rl[k].height - 1);
|
|
if (x1 < 0)
|
|
x1 = 0;
|
|
if (y1 < 0)
|
|
y1 = 0;
|
|
if (x2 >= basew)
|
|
x2 = basew - 1;
|
|
if (y2 >= baseh)
|
|
y2 = baseh - 1;
|
|
for (a = y1; a <= y2; a++)
|
|
{
|
|
if ((x2 - x1) >= 0)
|
|
gdk_add_to_span(&spans[a], x1, x2);
|
|
}
|
|
}
|
|
XFree(rl);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gdk_propagate_shapes(Display *disp, Window win, gboolean merge)
|
|
{
|
|
Window rt, par, *list = NULL;
|
|
gint i, j, num = 0, num_rects = 0;
|
|
gint x, y, contig;
|
|
guint w, h, d;
|
|
gint baseh, basew;
|
|
XRectangle *rects = NULL;
|
|
struct _gdk_span **spans = NULL, *ptr1, *ptr2, *ptr3;
|
|
XWindowAttributes xatt;
|
|
|
|
XGetGeometry(disp, win, &rt, &x, &y, &w, &h, &d, &d);
|
|
if (h <= 0)
|
|
return;
|
|
basew = w;
|
|
baseh = h;
|
|
spans = g_malloc(sizeof(struct _gdk_span *) * h);
|
|
|
|
for (i = 0; i < h; i++)
|
|
spans[i] = NULL;
|
|
XQueryTree(disp, win, &rt, &par, &list, (unsigned int *)&num);
|
|
if (list)
|
|
{
|
|
/* go through all child windows and create/insert spans */
|
|
for (i = 0; i < num; i++)
|
|
{
|
|
if (XGetWindowAttributes(disp, list[i], &xatt) && (xatt.map_state != IsUnmapped))
|
|
if (XGetGeometry(disp, list[i], &rt, &x, &y, &w, &h, &d, &d))
|
|
gdk_add_rectangles (disp, list[i], spans, basew, baseh, x, y);
|
|
}
|
|
if (merge)
|
|
gdk_add_rectangles (disp, win, spans, basew, baseh, x, y);
|
|
|
|
/* go through the spans list and build a list of rects */
|
|
rects = g_malloc(sizeof(XRectangle) * 256);
|
|
num_rects = 0;
|
|
for (i = 0; i < baseh; i++)
|
|
{
|
|
ptr1 = spans[i];
|
|
/* go through the line for all spans */
|
|
while (ptr1)
|
|
{
|
|
rects[num_rects].x = ptr1->start;
|
|
rects[num_rects].y = i;
|
|
rects[num_rects].width = ptr1->end - ptr1->start + 1;
|
|
rects[num_rects].height = 1;
|
|
j = i + 1;
|
|
/* if there are more lines */
|
|
contig = 1;
|
|
/* while contigous rects (same start/end coords) exist */
|
|
while ((contig) && (j < baseh))
|
|
{
|
|
/* search next line for spans matching this one */
|
|
contig = 0;
|
|
ptr2 = spans[j];
|
|
ptr3 = NULL;
|
|
while (ptr2)
|
|
{
|
|
/* if we have an exact span match set contig */
|
|
if ((ptr2->start == ptr1->start) &&
|
|
(ptr2->end == ptr1->end))
|
|
{
|
|
contig = 1;
|
|
/* remove the span - not needed */
|
|
if (ptr3)
|
|
{
|
|
ptr3->next = ptr2->next;
|
|
g_free(ptr2);
|
|
ptr2 = NULL;
|
|
}
|
|
else
|
|
{
|
|
spans[j] = ptr2->next;
|
|
g_free(ptr2);
|
|
ptr2 = NULL;
|
|
}
|
|
break;
|
|
}
|
|
/* gone past the span point no point looking */
|
|
else if (ptr2->start < ptr1->start)
|
|
break;
|
|
if (ptr2)
|
|
{
|
|
ptr3 = ptr2;
|
|
ptr2 = ptr2->next;
|
|
}
|
|
}
|
|
/* if a contiguous span was found increase the rect h */
|
|
if (contig)
|
|
{
|
|
rects[num_rects].height++;
|
|
j++;
|
|
}
|
|
}
|
|
/* up the rect count */
|
|
num_rects++;
|
|
/* every 256 new rects increase the rect array */
|
|
if ((num_rects % 256) == 0)
|
|
rects = g_realloc(rects, sizeof(XRectangle) * (num_rects + 256));
|
|
ptr1 = ptr1->next;
|
|
}
|
|
}
|
|
/* set the rects as the shape mask */
|
|
if (rects)
|
|
{
|
|
XShapeCombineRectangles(disp, win, ShapeBounding, 0, 0, rects, num_rects,
|
|
ShapeSet, YXSorted);
|
|
g_free(rects);
|
|
}
|
|
XFree(list);
|
|
}
|
|
/* free up all the spans we made */
|
|
for (i = 0; i < baseh; i++)
|
|
{
|
|
ptr1 = spans[i];
|
|
while (ptr1)
|
|
{
|
|
ptr2 = ptr1;
|
|
ptr1 = ptr1->next;
|
|
g_free(ptr2);
|
|
}
|
|
}
|
|
g_free(spans);
|
|
}
|
|
|
|
void
|
|
gdk_window_set_child_shapes (GdkWindow *window)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
#ifdef HAVE_SHAPE_EXT
|
|
private = (GdkWindowPrivate*) window;
|
|
if (private->destroyed)
|
|
return;
|
|
|
|
if (gdk_window_have_shape_ext())
|
|
gdk_propagate_shapes (private->xdisplay, private->xwindow, FALSE);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
gdk_window_merge_child_shapes (GdkWindow *window)
|
|
{
|
|
GdkWindowPrivate *private;
|
|
|
|
g_return_if_fail (window != NULL);
|
|
|
|
#ifdef HAVE_SHAPE_EXT
|
|
private = (GdkWindowPrivate*) window;
|
|
if (private->destroyed)
|
|
return;
|
|
|
|
if (gdk_window_have_shape_ext())
|
|
gdk_propagate_shapes (private->xdisplay, private->xwindow, TRUE);
|
|
#endif
|
|
}
|
|
|
|
/*************************************************************
|
|
* gdk_window_is_visible:
|
|
* Check if the given window is mapped.
|
|
* arguments:
|
|
* window:
|
|
* results:
|
|
* is the window mapped
|
|
*************************************************************/
|
|
|
|
gboolean
|
|
gdk_window_is_visible (GdkWindow *window)
|
|
{
|
|
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
|
|
|
|
g_return_val_if_fail (window != NULL, FALSE);
|
|
|
|
return private->mapped;
|
|
}
|
|
|
|
/*************************************************************
|
|
* gdk_window_is_viewable:
|
|
* Check if the window and all ancestors of the window
|
|
* are mapped. (This is not necessarily "viewable" in
|
|
* the X sense, since we only check as far as we have
|
|
* GDK window parents, not to the root window)
|
|
* arguments:
|
|
* window:
|
|
* results:
|
|
* is the window viewable
|
|
*************************************************************/
|
|
|
|
gboolean
|
|
gdk_window_is_viewable (GdkWindow *window)
|
|
{
|
|
GdkWindowPrivate *private = (GdkWindowPrivate *)window;
|
|
|
|
g_return_val_if_fail (window != NULL, FALSE);
|
|
|
|
while (private &&
|
|
(private != &gdk_root_parent) &&
|
|
(private->window_type != GDK_WINDOW_FOREIGN))
|
|
{
|
|
if (!private->mapped)
|
|
return FALSE;
|
|
|
|
private = (GdkWindowPrivate *)private->parent;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
gdk_drawable_set_data (GdkDrawable *drawable,
|
|
const gchar *key,
|
|
gpointer data,
|
|
GDestroyNotify destroy_func)
|
|
{
|
|
g_dataset_set_data_full (drawable, key, data, destroy_func);
|
|
}
|