* 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
+ * 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
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
+ * 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.
*/
-#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
+/*
+ * 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 "gdkwindow.h"
+#include "gdkinternals.h"
+#include "gdk.h" /* For gdk_rectangle_union() */
+#include "gdkpixmap.h"
+#include "gdkdrawable.h"
+#include "gdkpixmap.h"
+#include "gdkscreen.h"
+#include "gdkalias.h"
-#ifdef HAVE_SHAPE_EXT
-#include <X11/extensions/shape.h>
-#endif
+#define USE_BACKING_STORE /* Appears to work on Win32, too, now. */
-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
+typedef struct _GdkWindowPaint GdkWindowPaint;
+
+struct _GdkWindowPaint
+{
+ GdkRegion *region;
+ GdkPixmap *pixmap;
+ gint x_offset;
+ gint y_offset;
+ cairo_surface_t *surface;
};
-const int gdk_nevent_masks = sizeof (gdk_event_mask_table) / sizeof (int);
-
-/* Forward declarations */
-static gboolean gdk_window_gravity_works (void);
-static void gdk_window_set_static_win_gravity (GdkWindow *window,
- gboolean on);
-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)
+static GdkGC *gdk_window_create_gc (GdkDrawable *drawable,
+ GdkGCValues *values,
+ GdkGCValuesMask mask);
+static void gdk_window_draw_rectangle (GdkDrawable *drawable,
+ GdkGC *gc,
+ gboolean filled,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+static void gdk_window_draw_arc (GdkDrawable *drawable,
+ GdkGC *gc,
+ gboolean filled,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ gint angle1,
+ gint angle2);
+static void gdk_window_draw_polygon (GdkDrawable *drawable,
+ GdkGC *gc,
+ gboolean filled,
+ GdkPoint *points,
+ gint npoints);
+static void gdk_window_draw_text (GdkDrawable *drawable,
+ GdkFont *font,
+ GdkGC *gc,
+ gint x,
+ gint y,
+ const gchar *text,
+ gint text_length);
+static void gdk_window_draw_text_wc (GdkDrawable *drawable,
+ GdkFont *font,
+ GdkGC *gc,
+ gint x,
+ gint y,
+ const GdkWChar *text,
+ gint text_length);
+static void gdk_window_draw_drawable (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPixmap *src,
+ gint xsrc,
+ gint ysrc,
+ gint xdest,
+ gint ydest,
+ gint width,
+ gint height);
+static void gdk_window_draw_points (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPoint *points,
+ gint npoints);
+static void gdk_window_draw_segments (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkSegment *segs,
+ gint nsegs);
+static void gdk_window_draw_lines (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPoint *points,
+ gint npoints);
+
+static void gdk_window_draw_glyphs (GdkDrawable *drawable,
+ GdkGC *gc,
+ PangoFont *font,
+ gint x,
+ gint y,
+ PangoGlyphString *glyphs);
+static void gdk_window_draw_glyphs_transformed (GdkDrawable *drawable,
+ GdkGC *gc,
+ PangoMatrix *matrix,
+ PangoFont *font,
+ gint x,
+ gint y,
+ PangoGlyphString *glyphs);
+
+static void gdk_window_draw_image (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkImage *image,
+ gint xsrc,
+ gint ysrc,
+ gint xdest,
+ gint ydest,
+ gint width,
+ gint height);
+
+static void gdk_window_draw_pixbuf (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPixbuf *pixbuf,
+ gint src_x,
+ gint src_y,
+ gint dest_x,
+ gint dest_y,
+ gint width,
+ gint height,
+ GdkRgbDither dither,
+ gint x_dither,
+ gint y_dither);
+
+static void gdk_window_draw_trapezoids (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkTrapezoid *trapezoids,
+ gint n_trapezoids);
+
+static GdkImage* gdk_window_copy_to_image (GdkDrawable *drawable,
+ GdkImage *image,
+ gint src_x,
+ gint src_y,
+ gint dest_x,
+ gint dest_y,
+ gint width,
+ gint height);
+
+static cairo_surface_t *gdk_window_ref_cairo_surface (GdkDrawable *drawable);
+
+static void gdk_window_real_get_size (GdkDrawable *drawable,
+ gint *width,
+ gint *height);
+
+static GdkVisual* gdk_window_real_get_visual (GdkDrawable *drawable);
+static gint gdk_window_real_get_depth (GdkDrawable *drawable);
+static GdkScreen* gdk_window_real_get_screen (GdkDrawable *drawable);
+static void gdk_window_real_set_colormap (GdkDrawable *drawable,
+ GdkColormap *cmap);
+static GdkColormap* gdk_window_real_get_colormap (GdkDrawable *drawable);
+
+static GdkDrawable* gdk_window_get_composite_drawable (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ gint *composite_x_offset,
+ gint *composite_y_offset);
+static GdkRegion* gdk_window_get_clip_region (GdkDrawable *drawable);
+static GdkRegion* gdk_window_get_visible_region (GdkDrawable *drawable);
+
+static void gdk_window_free_paint_stack (GdkWindow *window);
+
+static void gdk_window_init (GdkWindowObject *window);
+static void gdk_window_class_init (GdkWindowObjectClass *klass);
+static void gdk_window_finalize (GObject *object);
+static void gdk_window_clear_backing_rect (GdkWindow *window,
+ gint x,
+ gint y,
+ gint width,
+ gint height);
+
+static gpointer parent_class = NULL;
+
+GType
+gdk_window_object_get_type (void)
+{
+ static GType object_type = 0;
+
+ if (!object_type)
{
- 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);
+ static const GTypeInfo object_info =
+ {
+ sizeof (GdkWindowObjectClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) gdk_window_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GdkWindowObject),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) gdk_window_init,
+ };
+
+ object_type = g_type_register_static (GDK_TYPE_DRAWABLE,
+ "GdkWindow",
+ &object_info, 0);
}
- XUngrabServer (disp);
- return root;
+
+ return object_type;
}
-void
-gdk_window_init (void)
+static void
+gdk_window_init (GdkWindowObject *window)
{
- 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;
+ /* 0-initialization is good for all other fields. */
+
+ window->window_type = GDK_WINDOW_CHILD;
+
+ window->state = GDK_WINDOW_STATE_WITHDRAWN;
- gdk_xid_table_insert (&gdk_root_window, &gdk_root_parent);
+ window->impl = g_object_new (_gdk_window_impl_get_type (), NULL);
}
-static GdkAtom wm_client_leader_atom = GDK_NONE;
+static void
+gdk_window_class_init (GdkWindowObjectClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GdkDrawableClass *drawable_class = GDK_DRAWABLE_CLASS (klass);
+
+ parent_class = g_type_class_peek_parent (klass);
+
+ object_class->finalize = gdk_window_finalize;
+
+ drawable_class->create_gc = gdk_window_create_gc;
+ drawable_class->draw_rectangle = gdk_window_draw_rectangle;
+ drawable_class->draw_arc = gdk_window_draw_arc;
+ drawable_class->draw_polygon = gdk_window_draw_polygon;
+ drawable_class->draw_text = gdk_window_draw_text;
+ drawable_class->draw_text_wc = gdk_window_draw_text_wc;
+ drawable_class->draw_drawable = gdk_window_draw_drawable;
+ drawable_class->draw_points = gdk_window_draw_points;
+ drawable_class->draw_segments = gdk_window_draw_segments;
+ drawable_class->draw_lines = gdk_window_draw_lines;
+ drawable_class->draw_glyphs = gdk_window_draw_glyphs;
+ drawable_class->draw_glyphs_transformed = gdk_window_draw_glyphs_transformed;
+ drawable_class->draw_image = gdk_window_draw_image;
+ drawable_class->draw_pixbuf = gdk_window_draw_pixbuf;
+ drawable_class->draw_trapezoids = gdk_window_draw_trapezoids;
+ drawable_class->get_depth = gdk_window_real_get_depth;
+ drawable_class->get_screen = gdk_window_real_get_screen;
+ drawable_class->get_size = gdk_window_real_get_size;
+ drawable_class->set_colormap = gdk_window_real_set_colormap;
+ drawable_class->get_colormap = gdk_window_real_get_colormap;
+ drawable_class->get_visual = gdk_window_real_get_visual;
+ drawable_class->_copy_to_image = gdk_window_copy_to_image;
+ drawable_class->ref_cairo_surface = gdk_window_ref_cairo_surface;
+ drawable_class->get_clip_region = gdk_window_get_clip_region;
+ drawable_class->get_visible_region = gdk_window_get_visible_region;
+ drawable_class->get_composite_drawable = gdk_window_get_composite_drawable;
+}
-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;
-
- private->xdisplay = parent_display;
- private->destroyed = FALSE;
- private->mapped = FALSE;
- private->guffaw_gravity = 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 (parent_private && parent_private->guffaw_gravity)
- {
- xattributes.win_gravity = StaticGravity;
- xattributes_mask |= CWWinGravity;
- }
-
- 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));
-
- if (parent_private)
- parent_private->children = g_list_prepend (parent_private->children, window);
+static void
+gdk_window_finalize (GObject *object)
+{
+ GdkWindow *window = GDK_WINDOW (object);
+ GdkWindowObject *obj = (GdkWindowObject *) object;
- switch (private->window_type)
+ if (!GDK_WINDOW_DESTROYED (window))
{
- 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))))
+ if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN)
{
- GDK_NOTE (MISC, g_message ("adding colormap window\n"));
- gdk_window_add_colormap_windows (window);
+ g_warning ("losing last reference to undestroyed window\n");
+ _gdk_window_destroy (window, FALSE);
}
-
- 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);
+ else
+ /* We use TRUE here, to keep us from actually calling
+ * XDestroyWindow() on the window
+ */
+ _gdk_window_destroy (window, TRUE);
}
+
+ g_object_unref (obj->impl);
+ obj->impl = NULL;
-
- return window;
+ G_OBJECT_CLASS (parent_class)->finalize (object);
}
-GdkWindow *
-gdk_window_foreign_new (guint32 anid)
-{
- GdkWindow *window;
- GdkWindowPrivate *private;
- GdkWindowPrivate *parent_private;
- XWindowAttributes attrs;
- Window root, parent;
- Window *children = NULL;
- guint nchildren;
- gboolean result;
-
- gdk_error_trap_push ();
- result = XGetWindowAttributes (gdk_display, anid, &attrs);
- if (gdk_error_trap_pop () || !result)
- return NULL;
+static void
+window_remove_filters (GdkWindow *window)
+{
+ GdkWindowObject *obj = (GdkWindowObject*) window;
- /* FIXME: This is pretty expensive. Maybe the caller should supply
- * the parent */
- gdk_error_trap_push ();
- result = XQueryTree (gdk_display, anid, &root, &parent, &children, &nchildren);
- if (gdk_error_trap_pop () || !result)
- return NULL;
-
- private = g_new (GdkWindowPrivate, 1);
- window = (GdkWindow*) private;
-
- 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->guffaw_gravity = FALSE;
- 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;
+ if (obj->filters)
+ {
+ GList *tmp_list;
+
+ for (tmp_list = obj->filters; tmp_list; tmp_list = tmp_list->next)
+ g_free (tmp_list->data);
+
+ g_list_free (obj->filters);
+ obj->filters = NULL;
+ }
}
-/* 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.
- */
+/**
+ * _gdk_window_destroy_hierarchy:
+ * @window: a #GdkWindow
+ * @recursing: If TRUE, then this is being called because a parent
+ * was destroyed. This generally means that the call to the
+ * windowing system to destroy the window can be omitted, since
+ * it will be destroyed as a result of the parent being destroyed.
+ * Unless @foreign_destroy.
+ * @foreign_destroy: If TRUE, the window or a parent was destroyed by some
+ * external agency. The window has already been destroyed and no
+ * windowing system calls should be made. (This may never happen
+ * for some windowing systems.)
+ *
+ * Internal function to destroy a window. Like gdk_window_destroy(),
+ * but does not drop the reference count created by gdk_window_new().
+ **/
static void
-gdk_window_internal_destroy (GdkWindow *window,
- gboolean xdestroy,
- gboolean our_destroy)
+_gdk_window_destroy_hierarchy (GdkWindow *window,
+ gboolean recursing,
+ gboolean foreign_destroy)
{
- GdkWindowPrivate *private;
- GdkWindowPrivate *temp_private;
+ GdkWindowObject *private;
+ GdkWindowObject *temp_private;
GdkWindow *temp_window;
GList *children;
GList *tmp;
g_return_if_fail (window != NULL);
- private = (GdkWindowPrivate*) window;
+ private = (GdkWindowObject*) window;
- switch (private->window_type)
+ if (GDK_WINDOW_DESTROYED (window))
+ return;
+
+ switch (GDK_WINDOW_TYPE (window))
{
case GDK_WINDOW_TOPLEVEL:
case GDK_WINDOW_CHILD:
case GDK_WINDOW_DIALOG:
case GDK_WINDOW_TEMP:
case GDK_WINDOW_FOREIGN:
- if (!private->destroyed)
+ if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_FOREIGN && !foreign_destroy)
+ {
+ /* Logically, it probably makes more sense to send
+ * a "destroy yourself" message to the foreign window
+ * whether or not it's in our heirarchy; but for historical
+ * reasons, we only send "destroy yourself" messages to
+ * foreign windows in our heirarchy.
+ */
+ if (private->parent)
+ _gdk_windowing_window_destroy_foreign (window);
+
+ /* Also for historical reasons, we remove any filters
+ * on a foreign window when it or a parent is destroyed;
+ * this likely causes problems if two separate portions
+ * of code are maintaining filter lists on a foreign window.
+ */
+ window_remove_filters (window);
+ }
+ else
{
+ private->state |= GDK_WINDOW_STATE_WITHDRAWN;
+
if (private->parent)
{
- GdkWindowPrivate *parent_private = (GdkWindowPrivate *)private->parent;
+ GdkWindowObject *parent_private = (GdkWindowObject *)private->parent;
if (parent_private->children)
parent_private->children = g_list_remove (parent_private->children, window);
}
+
+ _gdk_window_clear_update_area (window);
+ gdk_window_free_paint_stack (window);
+
+ if (private->bg_pixmap &&
+ private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
+ private->bg_pixmap != GDK_NO_BG)
+ {
+ g_object_unref (private->bg_pixmap);
+ private->bg_pixmap = NULL;
+ }
- if (private->window_type != GDK_WINDOW_FOREIGN)
+ if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_FOREIGN)
+ g_assert (private->children == NULL);
+ else
{
children = tmp = private->children;
private->children = NULL;
temp_window = tmp->data;
tmp = tmp->next;
- temp_private = (GdkWindowPrivate*) temp_window;
+ temp_private = (GdkWindowObject*) temp_window;
if (temp_private)
- gdk_window_internal_destroy (temp_window, FALSE,
- our_destroy);
+ _gdk_window_destroy_hierarchy (temp_window,
+ TRUE, foreign_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_error_trap_push ();
- 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);
- gdk_flush ();
- gdk_error_trap_pop ();
- }
- }
- else if (xdestroy)
- XDestroyWindow (private->xdisplay, private->xwindow);
-
- if (private->colormap)
- gdk_colormap_unref (private->colormap);
-
- private->mapped = FALSE;
+ _gdk_windowing_window_destroy (window, recursing, foreign_destroy);
+ private->parent = NULL;
private->destroyed = TRUE;
+
+ window_remove_filters (window);
+
+ gdk_drawable_set_colormap (GDK_DRAWABLE (window), NULL);
}
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. */
-
+/**
+ * _gdk_window_destroy:
+ * @window: a #GdkWindow
+ * @foreign_destroy: If TRUE, the window or a parent was destroyed by some
+ * external agency. The window has already been destroyed and no
+ * windowing system calls should be made. (This may never happen
+ * for some windowing systems.)
+ *
+ * Internal function to destroy a window. Like gdk_window_destroy(),
+ * but does not drop the reference count created by gdk_window_new().
+ **/
void
-gdk_window_destroy (GdkWindow *window)
+_gdk_window_destroy (GdkWindow *window,
+ gboolean foreign_destroy)
{
- gdk_window_internal_destroy (window, TRUE, TRUE);
- gdk_window_unref (window);
+ _gdk_window_destroy_hierarchy (window, FALSE, foreign_destroy);
}
-/* This function is called when the XWindow is really gone. */
-
+/**
+ * gdk_window_destroy:
+ * @window: a #GdkWindow
+ *
+ * Destroys the window system resources associated with @window and decrements @window's
+ * reference count. The window system resources for all children of @window are also
+ * destroyed, but the children's reference counts are not decremented.
+ *
+ * Note that a window will not be destroyed automatically when its reference count
+ * reaches zero. You must call this function yourself before that happens.
+ *
+ **/
void
-gdk_window_destroy_notify (GdkWindow *window)
+gdk_window_destroy (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);
+ _gdk_window_destroy_hierarchy (window, FALSE, FALSE);
+ g_object_unref (window);
}
-GdkWindow*
-gdk_window_ref (GdkWindow *window)
+/**
+ * gdk_window_set_user_data:
+ * @window: a #GdkWindow
+ * @user_data: user data
+ *
+ * For most purposes this function is deprecated in favor of
+ * g_object_set_data(). However, for historical reasons GTK+ stores
+ * the #GtkWidget that owns a #GdkWindow as user data on the
+ * #GdkWindow. So, custom widget implementations should use
+ * this function for that. If GTK+ receives an event for a #GdkWindow,
+ * and the user data for the window is non-%NULL, GTK+ will assume the
+ * user data is a #GtkWidget, and forward the event to that widget.
+ *
+ **/
+void
+gdk_window_set_user_data (GdkWindow *window,
+ gpointer user_data)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
- g_return_val_if_fail (window != NULL, NULL);
+ g_return_if_fail (window != NULL);
- private->ref_count += 1;
- return window;
+ ((GdkWindowObject*)window)->user_data = user_data;
}
+/**
+ * gdk_window_get_user_data:
+ * @window: a #GdkWindow
+ * @data: return location for user data
+ *
+ * Retrieves the user data for @window, which is normally the widget
+ * that @window belongs to. See gdk_window_set_user_data().
+ *
+ **/
void
-gdk_window_unref (GdkWindow *window)
+gdk_window_get_user_data (GdkWindow *window,
+ gpointer *data)
{
- 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);
- }
+ *data = ((GdkWindowObject*)window)->user_data;
}
-void
-gdk_window_show (GdkWindow *window)
+/**
+ * gdk_window_get_window_type:
+ * @window: a #GdkWindow
+ *
+ * Gets the type of the window. See #GdkWindowType.
+ *
+ * Return value: type of window
+ **/
+GdkWindowType
+gdk_window_get_window_type (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
- g_return_if_fail (window != NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), (GdkWindowType) -1);
- private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
- {
- private->mapped = TRUE;
- XRaiseWindow (private->xdisplay, private->xwindow);
- XMapWindow (private->xdisplay, private->xwindow);
- }
+ return GDK_WINDOW_TYPE (window);
}
+/**
+ * gdk_window_get_position:
+ * @window: a #GdkWindow
+ * @x: X coordinate of window
+ * @y: Y coordinate of window
+ *
+ * Obtains the position of the window as reported in the
+ * most-recently-processed #GdkEventConfigure. Contrast with
+ * gdk_window_get_geometry() which queries the X server for the
+ * current window position, regardless of which events have been
+ * received or processed.
+ *
+ * The position coordinates are relative to the window's parent window.
+ *
+ **/
void
-gdk_window_hide (GdkWindow *window)
+gdk_window_get_position (GdkWindow *window,
+ gint *x,
+ gint *y)
{
- GdkWindowPrivate *private;
+ GdkWindowObject *obj;
- g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
- {
- private->mapped = FALSE;
- XUnmapWindow (private->xdisplay, private->xwindow);
- }
+ obj = (GdkWindowObject*) window;
+
+ if (x)
+ *x = obj->x;
+ if (y)
+ *y = obj->y;
}
-void
-gdk_window_withdraw (GdkWindow *window)
+/**
+ * gdk_window_get_parent:
+ * @window: a #GdkWindow
+ *
+ * Obtains the parent of @window, as known to GDK. Does not query the
+ * X server; thus this returns the parent as passed to gdk_window_new(),
+ * not the actual parent. This should never matter unless you're using
+ * Xlib calls mixed with GDK calls on the X11 platform. It may also
+ * matter for toplevel windows, because the window manager may choose
+ * to reparent them.
+ *
+ * Return value: parent of @window
+ **/
+GdkWindow*
+gdk_window_get_parent (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
- g_return_if_fail (window != NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
- private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
- XWithdrawWindow (private->xdisplay, private->xwindow, 0);
+ return (GdkWindow*) ((GdkWindowObject*) window)->parent;
}
-void
-gdk_window_move (GdkWindow *window,
- gint x,
- gint y)
+/**
+ * gdk_window_get_toplevel:
+ * @window: a #GdkWindow
+ *
+ * Gets the toplevel window that's an ancestor of @window.
+ *
+ * Return value: the toplevel window containing @window
+ **/
+GdkWindow*
+gdk_window_get_toplevel (GdkWindow *window)
{
- GdkWindowPrivate *private;
+ GdkWindowObject *obj;
- g_return_if_fail (window != NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
+
+ obj = (GdkWindowObject *)window;
+ while (GDK_WINDOW_TYPE (obj) == GDK_WINDOW_CHILD)
+ obj = (GdkWindowObject *)obj->parent;
- 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;
- }
- }
+ return GDK_WINDOW (obj);
}
-void
-gdk_window_resize (GdkWindow *window,
- gint width,
- gint height)
+/**
+ * gdk_window_get_children:
+ * @window: a #GdkWindow
+ *
+ * Gets the list of children of @window known to GDK.
+ * This function only returns children created via GDK,
+ * so for example it's useless when used with the root window;
+ * it only returns windows an application created itself.
+ *
+ * The returned list must be freed, but the elements in the
+ * list need not be.
+ *
+ * Return value: list of child windows inside @window
+ **/
+GList*
+gdk_window_get_children (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
- g_return_if_fail (window != NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
+
+ if (GDK_WINDOW_DESTROYED (window))
+ return NULL;
+
+ return g_list_copy (GDK_WINDOW_OBJECT (window)->children);
+}
+
+/**
+ * gdk_window_peek_children:
+ * @window: a #GdkWindow
+ *
+ * Like gdk_window_get_children(), but does not copy the list of
+ * children, so the list does not need to be freed.
+ *
+ * Return value: a reference to the list of child windows in @window
+ **/
+GList *
+gdk_window_peek_children (GdkWindow *window)
+{
+ g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
+
+ if (GDK_WINDOW_DESTROYED (window))
+ return NULL;
+
+ return GDK_WINDOW_OBJECT (window)->children;
+}
+
+/**
+ * gdk_window_add_filter:
+ * @window: a #GdkWindow
+ * @function: filter callback
+ * @data: data to pass to filter callback
+ *
+ * Adds an event filter to @window, allowing you to intercept events
+ * before they reach GDK. This is a low-level operation and makes it
+ * easy to break GDK and/or GTK+, so you have to know what you're
+ * doing. Pass %NULL for @window to get all events for all windows,
+ * instead of events for a specific window.
+ *
+ **/
+void
+gdk_window_add_filter (GdkWindow *window,
+ GdkFilterFunc function,
+ gpointer data)
+{
+ GdkWindowObject *private;
+ GList *tmp_list;
+ GdkEventFilter *filter;
- if (width < 1)
- width = 1;
- if (height < 1)
- height = 1;
+ g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
+
+ private = (GdkWindowObject*) window;
+ if (private && GDK_WINDOW_DESTROYED (window))
+ return;
- private = (GdkWindowPrivate*) window;
+ if (private)
+ tmp_list = private->filters;
+ else
+ tmp_list = _gdk_default_filters;
- if (!private->destroyed &&
- ((private->resize_count > 0) ||
- (private->width != (guint16) width) ||
- (private->height != (guint16) height)))
+ while (tmp_list)
{
- XResizeWindow (private->xdisplay, private->xwindow, width, height);
- private->resize_count += 1;
-
- if (private->window_type == GDK_WINDOW_CHILD)
- {
- private->width = width;
- private->height = height;
- }
+ 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);
}
+/**
+ * gdk_window_remove_filter:
+ * @window: a #GdkWindow
+ * @function: previously-added filter function
+ * @data: user data for previously-added filter function
+ *
+ * Remove a filter previously added with gdk_window_add_filter().
+ *
+ **/
void
-gdk_window_move_resize (GdkWindow *window,
- gint x,
- gint y,
- gint width,
- gint height)
+gdk_window_remove_filter (GdkWindow *window,
+ GdkFilterFunc function,
+ gpointer data)
{
- GdkWindowPrivate *private;
+ GdkWindowObject *private;
+ GList *tmp_list, *node;
+ GdkEventFilter *filter;
- g_return_if_fail (window != NULL);
+ g_return_if_fail (window == NULL || GDK_IS_WINDOW (window));
+
+ private = (GdkWindowObject*) window;
- if (width < 1)
- width = 1;
- if (height < 1)
- height = 1;
+ if (private)
+ tmp_list = private->filters;
+ else
+ tmp_list = _gdk_default_filters;
- private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
+ while (tmp_list)
{
- XMoveResizeWindow (private->xdisplay, private->xwindow, x, y, width, height);
-
- if (private->guffaw_gravity)
- {
- GList *tmp_list = private->children;
- while (tmp_list)
- {
- GdkWindowPrivate *child_private = tmp_list->data;
-
- child_private->x -= x - private->x;
- child_private->y -= y - private->y;
-
- tmp_list = tmp_list->next;
- }
- }
+ filter = (GdkEventFilter *)tmp_list->data;
+ node = tmp_list;
+ tmp_list = tmp_list->next;
- if (private->window_type == GDK_WINDOW_CHILD)
+ if ((filter->function == function) && (filter->data == data))
{
- private->x = x;
- private->y = y;
- private->width = width;
- private->height = height;
+ if (private)
+ private->filters = g_list_remove_link (private->filters, node);
+ else
+ _gdk_default_filters = g_list_remove_link (_gdk_default_filters, node);
+ g_list_free_1 (node);
+ g_free (filter);
+
+ return;
}
}
}
-void
-gdk_window_reparent (GdkWindow *window,
- GdkWindow *new_parent,
- gint x,
- gint y)
+/**
+ * gdk_screen_get_toplevel_windows:
+ * @screen: The #GdkScreen where the toplevels are located.
+ *
+ * Obtains a list of all toplevel windows known to GDK on the screen @screen.
+ * A toplevel window is a child of the root window (see
+ * gdk_get_default_root_window()).
+ *
+ * The returned list should be freed with g_list_free(), but
+ * its elements need not be freed.
+ *
+ * Return value: list of toplevel windows, free with g_list_free()
+ *
+ * Since: 2.2
+ **/
+GList *
+gdk_screen_get_toplevel_windows (GdkScreen *screen)
{
- 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;
+ GdkWindow * root_window;
+ GList *new_list = NULL;
+ GList *tmp_list;
- if (old_parent_private)
- old_parent_private->children = g_list_remove (old_parent_private->children, window);
+ g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
- if ((old_parent_private &&
- (!old_parent_private->guffaw_gravity != !parent_private->guffaw_gravity)) ||
- (!old_parent_private && parent_private->guffaw_gravity))
- gdk_window_set_static_win_gravity (window, parent_private->guffaw_gravity);
+ root_window = gdk_screen_get_root_window (screen);
+
+ tmp_list = ((GdkWindowObject *)root_window)->children;
+ while (tmp_list)
+ {
+ if (GDK_WINDOW_TYPE (tmp_list->data) != GDK_WINDOW_FOREIGN)
+ new_list = g_list_prepend (new_list, tmp_list->data);
+ tmp_list = tmp_list->next;
+ }
- parent_private->children = g_list_prepend (parent_private->children, window);
+ return new_list;
}
-void
-gdk_window_clear (GdkWindow *window)
+/**
+ * gdk_window_get_toplevels:
+ *
+ * Obtains a list of all toplevel windows known to GDK on the default
+ * screen (see gdk_window_get_toplevels_for_screen()).
+ * A toplevel window is a child of the root window (see
+ * gdk_get_default_root_window()).
+ *
+ * The returned list should be freed with g_list_free(), but
+ * its elements need not be freed.
+ *
+ * Return value: list of toplevel windows, free with g_list_free()
+ **/
+GList *
+gdk_window_get_toplevels (void)
{
- GdkWindowPrivate *private;
-
- g_return_if_fail (window != NULL);
-
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
- XClearWindow (private->xdisplay, private->xwindow);
+ return gdk_screen_get_toplevel_windows (gdk_screen_get_default ());
}
-void
-gdk_window_clear_area (GdkWindow *window,
- gint x,
- gint y,
- gint width,
- gint height)
+/**
+ * gdk_window_is_visible:
+ * @window: a #GdkWindow
+ *
+ * Checks whether the window has been mapped (with gdk_window_show() or
+ * gdk_window_show_unraised()).
+ *
+ * Return value: %TRUE if the window is mapped
+ **/
+gboolean
+gdk_window_is_visible (GdkWindow *window)
{
- GdkWindowPrivate *private;
-
- g_return_if_fail (window != NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
- XClearArea (private->xdisplay, private->xwindow,
- x, y, width, height, False);
+ return GDK_WINDOW_IS_MAPPED (window);
}
-void
-gdk_window_clear_area_e (GdkWindow *window,
- gint x,
- gint y,
- gint width,
- gint height)
+/**
+ * gdk_window_is_viewable:
+ * @window: a #GdkWindow
+ *
+ * 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.)
+ *
+ * Return value: %TRUE if the window is viewable
+ **/
+gboolean
+gdk_window_is_viewable (GdkWindow *window)
{
- GdkWindowPrivate *private;
+ GdkWindowObject *private = (GdkWindowObject *)window;
+ GdkScreen *screen;
+ GdkWindow *root_window;
- g_return_if_fail (window != NULL);
-
- private = (GdkWindowPrivate*) window;
-
- if (!private->destroyed)
- XClearArea (private->xdisplay, private->xwindow,
- x, y, width, height, True);
-}
+ g_return_val_if_fail (window != NULL, FALSE);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
-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);
+ screen = gdk_drawable_get_screen (window);
+ root_window = gdk_screen_get_root_window (screen);
- 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)
+ while (private &&
+ (private != (GdkWindowObject *)root_window) &&
+ (GDK_WINDOW_TYPE (private) != GDK_WINDOW_FOREIGN))
{
- XCopyArea (dest_private->xdisplay, src_private->xwindow, dest_private->xwindow,
- gc_private->xgc,
- source_x, source_y,
- width, height,
- x, y);
+ if (GDK_WINDOW_DESTROYED (private) || !GDK_WINDOW_IS_MAPPED (private))
+ return FALSE;
+
+ private = (GdkWindowObject *)private->parent;
}
-}
-
-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);
+ return TRUE;
}
-void
-gdk_window_lower (GdkWindow *window)
+/**
+ * gdk_window_get_state:
+ * @window: a #GdkWindow
+ *
+ * Gets the bitwise OR of the currently active window state flags,
+ * from the #GdkWindowState enumeration.
+ *
+ * Return value: window state bitfield
+ **/
+GdkWindowState
+gdk_window_get_state (GdkWindow *window)
{
- GdkWindowPrivate *private;
+ GdkWindowObject *private = (GdkWindowObject *)window;
- g_return_if_fail (window != NULL);
-
- private = (GdkWindowPrivate*) window;
+ g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
- if (!private->destroyed)
- XLowerWindow (private->xdisplay, private->xwindow);
+ return private->state;
}
+/**
+ * gdk_window_begin_paint_rect:
+ * @window: a #GdkWindow
+ * @rectangle: rectangle you intend to draw to
+ *
+ * A convenience wrapper around gdk_window_begin_paint_region() which
+ * creates a rectangular region for you. See
+ * gdk_window_begin_paint_region() for details.
+ *
+ **/
void
-gdk_window_set_user_data (GdkWindow *window,
- gpointer user_data)
+gdk_window_begin_paint_rect (GdkWindow *window,
+ GdkRectangle *rectangle)
{
+ GdkRegion *region;
+
g_return_if_fail (window != NULL);
-
- window->user_data = user_data;
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ region = gdk_region_rectangle (rectangle);
+ gdk_window_begin_paint_region (window, region);
+ gdk_region_destroy (region);
}
-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;
+#ifdef GDK_WINDOWING_X11
+#include "x11/gdkx.h"
+#endif
+
+/**
+ * gdk_window_begin_paint_region:
+ * @window: a #GdkWindow
+ * @region: region you intend to draw to
+ *
+ * Indicates that you are beginning the process of redrawing @region.
+ * A backing store (offscreen buffer) large enough to contain @region
+ * will be created. The backing store will be initialized with the
+ * background color or background pixmap for @window. Then, all
+ * drawing operations performed on @window will be diverted to the
+ * backing store. When you call gdk_window_end_paint(), the backing
+ * store will be copied to @window, making it visible onscreen. Only
+ * the part of @window contained in @region will be modified; that is,
+ * drawing operations are clipped to @region.
+ *
+ * The net result of all this is to remove flicker, because the user
+ * sees the finished product appear all at once when you call
+ * gdk_window_end_paint(). If you draw to @window directly without
+ * calling gdk_window_begin_paint_region(), the user may see flicker
+ * as individual drawing operations are performed in sequence. The
+ * clipping and background-initializing features of
+ * gdk_window_begin_paint_region() are conveniences for the
+ * programmer, so you can avoid doing that work yourself.
+ *
+ * When using GTK+, the widget system automatically places calls to
+ * gdk_window_begin_paint_region() and gdk_window_end_paint() around
+ * emissions of the expose_event signal. That is, if you're writing an
+ * expose event handler, you can assume that the exposed area in
+ * #GdkEventExpose has already been cleared to the window background,
+ * is already set as the clip region, and already has a backing store.
+ * Therefore in most cases, application code need not call
+ * gdk_window_begin_paint_region(). (You can disable the automatic
+ * calls around expose events on a widget-by-widget basis by calling
+ * gtk_widget_set_double_buffered().)
+ *
+ * If you call this function multiple times before calling the
+ * matching gdk_window_end_paint(), the backing stores are pushed onto
+ * a stack. gdk_window_end_paint() copies the topmost backing store
+ * onscreen, subtracts the topmost region from all other regions in
+ * the stack, and pops the stack. All drawing operations affect only
+ * the topmost backing store in the stack. One matching call to
+ * gdk_window_end_paint() is required for each call to
+ * gdk_window_begin_paint_region().
+ *
+ **/
+void
+gdk_window_begin_paint_region (GdkWindow *window,
+ GdkRegion *region)
+{
+#ifdef USE_BACKING_STORE
+ GdkWindowObject *private = (GdkWindowObject *)window;
+ GdkRectangle clip_box;
+ GdkWindowPaint *paint;
+ GSList *list;
g_return_if_fail (window != NULL);
-
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ if (GDK_WINDOW_DESTROYED (window))
return;
+
+ gdk_region_get_clipbox (region, &clip_box);
+
+ paint = g_new (GdkWindowPaint, 1);
+ paint->region = gdk_region_copy (region);
+ paint->x_offset = clip_box.x;
+ paint->y_offset = clip_box.y;
+ paint->pixmap =
+ gdk_pixmap_new (window,
+ MAX (clip_box.width, 1), MAX (clip_box.height, 1), -1);
+
+ paint->surface = _gdk_drawable_ref_cairo_surface (paint->pixmap);
+ cairo_surface_set_device_offset (paint->surface,
+ - paint->x_offset, - paint->y_offset);
- 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)
+ for (list = private->paint_stack; list != NULL; list = list->next)
{
- size_hints.flags |= PMinSize;
- size_hints.min_width = min_width;
- size_hints.min_height = min_height;
+ GdkWindowPaint *tmp_paint = list->data;
+
+ gdk_region_subtract (tmp_paint->region, paint->region);
}
- if (flags & GDK_HINT_MAX_SIZE)
+ private->paint_stack = g_slist_prepend (private->paint_stack, paint);
+
+ if (!gdk_region_empty (region))
{
- size_hints.flags |= PMaxSize;
- size_hints.max_width = max_width;
- size_hints.max_height = max_height;
+ gdk_window_clear_backing_rect (window,
+ clip_box.x, clip_box.y,
+ clip_box.width, clip_box.height);
}
-
- if (flags)
- XSetWMNormalHints (private->xdisplay, private->xwindow, &size_hints);
+#endif /* USE_BACKING_STORE */
}
-void
-gdk_window_set_geometry_hints (GdkWindow *window,
- GdkGeometry *geometry,
- GdkWindowHints geom_mask)
+/**
+ * gdk_window_end_paint:
+ * @window: a #GdkWindow
+ *
+ * Indicates that the backing store created by the most recent call to
+ * gdk_window_begin_paint_region() should be copied onscreen and
+ * deleted, leaving the next-most-recent backing store or no backing
+ * store at all as the active paint region. See
+ * gdk_window_begin_paint_region() for full details. It is an error to
+ * call this function without a matching
+ * gdk_window_begin_paint_region() first.
+ *
+ **/
+void
+gdk_window_end_paint (GdkWindow *window)
{
- GdkWindowPrivate *private;
- XSizeHints size_hints;
-
+#ifdef USE_BACKING_STORE
+ GdkWindowObject *private = (GdkWindowObject *)window;
+ GdkWindowPaint *paint;
+ GdkGC *tmp_gc;
+ GdkRectangle clip_box;
+ gint x_offset, y_offset;
+
g_return_if_fail (window != NULL);
-
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ if (GDK_WINDOW_DESTROYED (window))
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)
+
+ if (private->paint_stack == NULL)
{
- size_hints.flags |= PMaxSize;
- size_hints.max_width = geometry->max_width;
- size_hints.max_height = geometry->max_height;
+ g_warning (G_STRLOC": no preceding call to gdk_window_begin_paint_region(), see documentation");
+ return;
}
+
+ paint = private->paint_stack->data;
+ private->paint_stack = g_slist_delete_link (private->paint_stack,
+ private->paint_stack);
+
+ gdk_region_get_clipbox (paint->region, &clip_box);
+
+ tmp_gc = _gdk_drawable_get_scratch_gc (window, FALSE);
+
+ _gdk_windowing_window_get_offsets (window, &x_offset, &y_offset);
+
+ gdk_gc_set_clip_region (tmp_gc, paint->region);
+ gdk_gc_set_clip_origin (tmp_gc, - x_offset, - y_offset);
+
+ gdk_draw_drawable (private->impl, tmp_gc, paint->pixmap,
+ clip_box.x - paint->x_offset,
+ clip_box.y - paint->y_offset,
+ clip_box.x - x_offset, clip_box.y - y_offset,
+ clip_box.width, clip_box.height);
+
+ /* Reset clip region of the cached GdkGC */
+ gdk_gc_set_clip_region (tmp_gc, NULL);
+
+ cairo_surface_destroy (paint->surface);
+ g_object_unref (paint->pixmap);
+ gdk_region_destroy (paint->region);
+ g_free (paint);
+#endif /* USE_BACKING_STORE */
+}
+
+static void
+gdk_window_free_paint_stack (GdkWindow *window)
+{
+ GdkWindowObject *private = (GdkWindowObject *)window;
- if (geom_mask & GDK_HINT_BASE_SIZE)
+ if (private->paint_stack)
{
- size_hints.flags |= PBaseSize;
- size_hints.base_width = geometry->base_width;
- size_hints.base_height = geometry->base_height;
+ GSList *tmp_list = private->paint_stack;
+
+ while (tmp_list)
+ {
+ GdkWindowPaint *paint = tmp_list->data;
+
+ if (tmp_list == private->paint_stack)
+ g_object_unref (paint->pixmap);
+
+ gdk_region_destroy (paint->region);
+ g_free (paint);
+
+ tmp_list = tmp_list->next;
+ }
+
+ g_slist_free (private->paint_stack);
+ private->paint_stack = NULL;
}
+}
+
+static void
+gdk_window_get_offsets (GdkWindow *window,
+ gint *x_offset,
+ gint *y_offset)
+{
+ GdkWindowObject *private = (GdkWindowObject *)window;
- if (geom_mask & GDK_HINT_RESIZE_INC)
+ if (private->paint_stack)
{
- size_hints.flags |= PResizeInc;
- size_hints.width_inc = geometry->width_inc;
- size_hints.height_inc = geometry->height_inc;
+ GdkWindowPaint *paint = private->paint_stack->data;
+ *x_offset = paint->x_offset;
+ *y_offset = paint->y_offset;
}
+ else
+ _gdk_windowing_window_get_offsets (window, x_offset, y_offset);
+}
+
+/**
+ * gdk_window_get_internal_paint_info:
+ * @window: a #GdkWindow
+ * @real_drawable: location to store the drawable to which drawing should be
+ * done.
+ * @x_offset: location to store the X offset between coordinates in @window,
+ * and the underlying window system primitive coordinates for
+ * *@real_drawable.
+ * @y_offset: location to store the Y offset between coordinates in @window,
+ * and the underlying window system primitive coordinates for
+ * *@real_drawable.
+ *
+ * If you bypass the GDK layer and use windowing system primitives to
+ * draw directly onto a #GdkWindow, then you need to deal with two
+ * details: there may be an offset between GDK coordinates and windowing
+ * system coordinates, and GDK may have redirected drawing to a offscreen
+ * pixmap as the result of a gdk_window_begin_paint_region() calls.
+ * This function allows retrieving the information you need to compensate
+ * for these effects.
+ *
+ * This function exposes details of the GDK implementation, and is thus
+ * likely to change in future releases of GDK.
+ **/
+void
+gdk_window_get_internal_paint_info (GdkWindow *window,
+ GdkDrawable **real_drawable,
+ gint *x_offset,
+ gint *y_offset)
+{
+ gint x_off, y_off;
- if (geom_mask & GDK_HINT_ASPECT)
+ GdkWindowObject *private;
+
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ private = (GdkWindowObject *)window;
+
+ if (real_drawable)
{
- 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
+ if (private->paint_stack)
{
- 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;
+ GdkWindowPaint *paint = private->paint_stack->data;
+ *real_drawable = paint->pixmap;
}
else
- {
- size_hints.max_aspect.x = G_MAXINT;
- size_hints.max_aspect.y = G_MAXINT / geometry->max_aspect;;
- }
+ *real_drawable = window;
}
-
- if (geom_mask)
- XSetWMNormalHints (private->xdisplay, private->xwindow, &size_hints);
-}
-void
-gdk_window_set_title (GdkWindow *window,
- const gchar *title)
+ gdk_window_get_offsets (window, &x_off, &y_off);
+
+ if (x_offset)
+ *x_offset = x_off;
+ if (y_offset)
+ *y_offset = y_off;
+}
+
+#define OFFSET_GC(gc) \
+ gint x_offset, y_offset; \
+ gint old_clip_x = gc->clip_x_origin; \
+ gint old_clip_y = gc->clip_y_origin; \
+ gint old_ts_x = gc->ts_x_origin; \
+ gint old_ts_y = gc->ts_y_origin; \
+ gdk_window_get_offsets (drawable, &x_offset, &y_offset); \
+ if (x_offset != 0 || y_offset != 0) \
+ { \
+ gdk_gc_set_clip_origin (gc, old_clip_x - x_offset, \
+ old_clip_y - y_offset); \
+ gdk_gc_set_ts_origin (gc, old_ts_x - x_offset, \
+ old_ts_y - y_offset); \
+ }
+
+#define RESTORE_GC(gc) \
+ if (x_offset != 0 || y_offset != 0) \
+ { \
+ gdk_gc_set_clip_origin (gc, old_clip_x, old_clip_y); \
+ gdk_gc_set_ts_origin (gc, old_ts_x, old_ts_y); \
+ }
+
+static GdkGC *
+gdk_window_create_gc (GdkDrawable *drawable,
+ GdkGCValues *values,
+ GdkGCValuesMask mask)
{
- GdkWindowPrivate *private;
-
- g_return_if_fail (window != NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (drawable), NULL);
- private = (GdkWindowPrivate*) window;
- if (!private->destroyed)
- XmbSetWMProperties (private->xdisplay, private->xwindow,
- title, title, NULL, 0, NULL, NULL, NULL);
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return NULL;
+
+ return gdk_gc_new_with_values (((GdkWindowObject *) drawable)->impl,
+ values, mask);
}
-void
-gdk_window_set_role (GdkWindow *window,
- const gchar *role)
-{
- GdkWindowPrivate *private;
-
- g_return_if_fail (window != NULL);
+static void
+gdk_window_draw_rectangle (GdkDrawable *drawable,
+ GdkGC *gc,
+ gboolean filled,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
+{
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+ OFFSET_GC (gc);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return;
- private = (GdkWindowPrivate*) window;
-
- if (role)
- XChangeProperty (private->xdisplay, private->xwindow,
- gdk_atom_intern ("WM_WINDOW_ROLE", FALSE), XA_STRING,
- 8, PropModeReplace, role, strlen (role));
+ if (private->paint_stack)
+ {
+ GdkWindowPaint *paint = private->paint_stack->data;
+ gdk_draw_rectangle (paint->pixmap, gc, filled,
+ x - x_offset, y - y_offset, width, height);
+ }
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);
-}
+ gdk_draw_rectangle (private->impl, gc, filled,
+ x - x_offset, y - y_offset, width, height);
-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);
+ RESTORE_GC (gc);
}
-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;
+static void
+gdk_window_draw_arc (GdkDrawable *drawable,
+ GdkGC *gc,
+ gboolean filled,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ gint angle1,
+ gint angle2)
+{
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+ OFFSET_GC (gc);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return;
- if (pixmap)
- xpixmap = pixmap_private->xwindow;
+ if (private->paint_stack)
+ {
+ GdkWindowPaint *paint = private->paint_stack->data;
+ gdk_draw_arc (paint->pixmap, gc, filled,
+ x - x_offset, y - y_offset,
+ width, height, angle1, angle2);
+ }
else
- xpixmap = None;
-
- if (parent_relative)
- xpixmap = ParentRelative;
-
- if (!window_private->destroyed)
- XSetWindowBackgroundPixmap (window_private->xdisplay, window_private->xwindow, xpixmap);
+ gdk_draw_arc (private->impl, gc, filled,
+ x - x_offset, y - y_offset,
+ width, height, angle1, angle2);
+ RESTORE_GC (gc);
}
-void
-gdk_window_set_cursor (GdkWindow *window,
- GdkCursor *cursor)
+static void
+gdk_window_draw_polygon (GdkDrawable *drawable,
+ GdkGC *gc,
+ gboolean filled,
+ GdkPoint *points,
+ gint npoints)
{
- GdkWindowPrivate *window_private;
- GdkCursorPrivate *cursor_private;
- Cursor xcursor;
-
- g_return_if_fail (window != NULL);
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+ GdkPoint *new_points;
- 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);
-}
+ OFFSET_GC (gc);
-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 (GDK_WINDOW_DESTROYED (drawable))
+ return;
- if (!window_private->destroyed)
+ if (x_offset != 0 || y_offset != 0)
{
- XSetWindowColormap (window_private->xdisplay,
- window_private->xwindow,
- colormap_private->xcolormap);
+ int i;
- 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);
+ new_points = g_new (GdkPoint, npoints);
+ for (i=0; i<npoints; i++)
+ {
+ new_points[i].x = points[i].x - x_offset;
+ new_points[i].y = points[i].y - y_offset;
+ }
}
-}
+ else
+ new_points = points;
-void
-gdk_window_get_user_data (GdkWindow *window,
- gpointer *data)
-{
- g_return_if_fail (window != NULL);
+ if (private->paint_stack)
+ {
+ GdkWindowPaint *paint = private->paint_stack->data;
+ gdk_draw_polygon (paint->pixmap, gc, filled, new_points, npoints);
+
+ }
+ else
+ gdk_draw_polygon (private->impl, gc, filled, new_points, npoints);
- *data = window->user_data;
+ if (new_points != points)
+ g_free (new_points);
+
+ RESTORE_GC (gc);
}
-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)
+static void
+gdk_window_draw_text (GdkDrawable *drawable,
+ GdkFont *font,
+ GdkGC *gc,
+ gint x,
+ gint y,
+ const gchar *text,
+ gint text_length)
+{
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+ OFFSET_GC (gc);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return;
+
+ if (private->paint_stack)
{
- 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;
+ GdkWindowPaint *paint = private->paint_stack->data;
+ gdk_draw_text (paint->pixmap, font, gc,
+ x - x_offset, y - y_offset, text, text_length);
+
}
-}
+ else
+ gdk_draw_text (private->impl, font, gc,
+ x - x_offset, y - y_offset, text, text_length);
-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;
+ RESTORE_GC (gc);
}
-void
-gdk_window_get_size (GdkWindow *window,
- gint *width,
- gint *height)
-{
- GdkWindowPrivate *window_private;
-
- g_return_if_fail (window != NULL);
-
- window_private = (GdkWindowPrivate*) window;
+static void
+gdk_window_draw_text_wc (GdkDrawable *drawable,
+ GdkFont *font,
+ GdkGC *gc,
+ gint x,
+ gint y,
+ const GdkWChar *text,
+ gint text_length)
+{
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+ OFFSET_GC (gc);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return;
- if (width)
- *width = window_private->width;
- if (height)
- *height = window_private->height;
-}
+ if (private->paint_stack)
+ {
+ GdkWindowPaint *paint = private->paint_stack->data;
+ gdk_draw_text_wc (paint->pixmap, font, gc,
+ x - x_offset, y - y_offset, text, text_length);
+ }
+ else
+ gdk_draw_text_wc (private->impl, font, gc,
+ x - x_offset, y - y_offset, text, text_length);
+
+ RESTORE_GC (gc);
+}
+
+static GdkDrawable*
+gdk_window_get_composite_drawable (GdkDrawable *drawable,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ gint *composite_x_offset,
+ gint *composite_y_offset)
+{
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+ GSList *list;
+ GdkPixmap *tmp_pixmap;
+ GdkRectangle rect;
+ GdkGC *tmp_gc;
+ gboolean overlap_buffer;
+
+ _gdk_windowing_window_get_offsets (drawable,
+ composite_x_offset,
+ composite_y_offset);
+
+ if ((GDK_IS_WINDOW (drawable) && GDK_WINDOW_DESTROYED (drawable))
+ || private->paint_stack == NULL)
+ {
+ /* No backing store */
+ return g_object_ref (drawable);
+ }
-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
+ /* See if the buffered part is overlapping the part we want
+ * to get
*/
- while (window_private && (window_private->window_type == GDK_WINDOW_PIXMAP))
- window_private = (GdkWindowPrivate*) window_private->parent;
+ rect.x = x;
+ rect.y = y;
+ rect.width = width;
+ rect.height = height;
+
+ overlap_buffer = FALSE;
- if (window_private && !window_private->destroyed)
+ for (list = private->paint_stack; list != NULL; list = list->next)
{
- if (window_private->colormap == NULL)
+ GdkWindowPaint *paint = list->data;
+ GdkOverlapType overlap;
+
+ overlap = gdk_region_rect_in (paint->region, &rect);
+
+ if (overlap == GDK_OVERLAP_RECTANGLE_IN)
{
- XGetWindowAttributes (window_private->xdisplay,
- window_private->xwindow,
- &window_attributes);
- return gdk_visual_lookup (window_attributes.visual);
+ *composite_x_offset = paint->x_offset;
+ *composite_y_offset = paint->y_offset;
+
+ return g_object_ref (paint->pixmap);
+ }
+ else if (overlap == GDK_OVERLAP_RECTANGLE_PART)
+ {
+ overlap_buffer = TRUE;
+ break;
}
- else
- return ((GdkColormapPrivate *)window_private->colormap)->visual;
}
-
- return NULL;
+
+ if (!overlap_buffer)
+ return g_object_ref (drawable);
+
+ tmp_pixmap = gdk_pixmap_new (drawable, width, height, -1);
+ tmp_gc = _gdk_drawable_get_scratch_gc (tmp_pixmap, FALSE);
+
+ /* Copy the current window contents */
+ gdk_draw_drawable (tmp_pixmap,
+ tmp_gc,
+ private->impl,
+ x - *composite_x_offset,
+ y - *composite_y_offset,
+ 0, 0,
+ width, height);
+
+ /* paint the backing stores */
+ for (list = private->paint_stack; list != NULL; list = list->next)
+ {
+ GdkWindowPaint *paint = list->data;
+
+ gdk_gc_set_clip_region (tmp_gc, paint->region);
+ gdk_gc_set_clip_origin (tmp_gc, -x, -y);
+
+ gdk_draw_drawable (tmp_pixmap, tmp_gc, paint->pixmap,
+ x - paint->x_offset,
+ y - paint->y_offset,
+ 0, 0, width, height);
+ }
+
+ /* Reset clip region of the cached GdkGC */
+ gdk_gc_set_clip_region (tmp_gc, NULL);
+
+ /* Set these to location of tmp_pixmap within the window */
+ *composite_x_offset = x;
+ *composite_y_offset = y;
+
+ return tmp_pixmap;
}
-GdkColormap*
-gdk_window_get_colormap (GdkWindow *window)
+static GdkRegion*
+gdk_window_get_clip_region (GdkDrawable *drawable)
{
- 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)
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+ GdkRegion *result;
+
+ result = gdk_drawable_get_clip_region (private->impl);
+
+ if (private->paint_stack)
{
- if (window_private->colormap == NULL)
+ GdkRegion *paint_region = gdk_region_new ();
+ GSList *tmp_list = private->paint_stack;
+
+ while (tmp_list)
{
- XGetWindowAttributes (window_private->xdisplay,
- window_private->xwindow,
- &window_attributes);
- return gdk_colormap_lookup (window_attributes.colormap);
+ GdkWindowPaint *paint = tmp_list->data;
+
+ gdk_region_union (paint_region, paint->region);
+
+ tmp_list = tmp_list->next;
}
- else
- return window_private->colormap;
+
+ gdk_region_intersect (result, paint_region);
+ gdk_region_destroy (paint_region);
}
-
- return NULL;
+
+ return result;
}
-GdkWindowType
-gdk_window_get_type (GdkWindow *window)
+static GdkRegion*
+gdk_window_get_visible_region (GdkDrawable *drawable)
{
- GdkWindowPrivate *window_private;
-
- g_return_val_if_fail (window != NULL, (GdkWindowType) -1);
+ GdkWindowObject *private = (GdkWindowObject*) drawable;
- window_private = (GdkWindowPrivate*) window;
- return window_private->window_type;
+ return gdk_drawable_get_visible_region (private->impl);
}
-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)
+static void
+gdk_window_draw_drawable (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPixmap *src,
+ gint xsrc,
+ gint ysrc,
+ gint xdest,
+ gint ydest,
+ gint width,
+ gint height)
+{
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+ OFFSET_GC (gc);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return;
+
+ /* If we have a backing pixmap draw to that */
+ if (private->paint_stack)
{
- return_val = XTranslateCoordinates (private->xdisplay,
- private->xwindow,
- gdk_root_window,
- 0, 0, &tx, &ty,
- &child);
-
+ GdkWindowPaint *paint = private->paint_stack->data;
+ gdk_draw_drawable (paint->pixmap, gc,
+ src, xsrc, ysrc,
+ xdest - x_offset, ydest - y_offset, width, height);
+
}
else
- return_val = 0;
-
- if (x)
- *x = tx;
- if (y)
- *y = ty;
-
- return return_val;
+ gdk_draw_drawable (private->impl, gc,
+ src, xsrc, ysrc,
+ xdest - x_offset, ydest - y_offset,
+ width, height);
+
+ RESTORE_GC (gc);
}
-gboolean
-gdk_window_get_deskrelative_origin (GdkWindow *window,
- gint *x,
- gint *y)
+static void
+gdk_window_draw_points (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPoint *points,
+ gint npoints)
{
- 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);
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+ GdkPoint *new_points;
- private = (GdkWindowPrivate*) window;
+ OFFSET_GC (gc);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return;
- if (!private->destroyed)
+ if (x_offset != 0 || y_offset != 0)
{
- if (!atom)
- atom = XInternAtom (private->xdisplay, "ENLIGHTENMENT_DESKTOP", False);
- win = private->xwindow;
-
- while (XQueryTree (private->xdisplay, win, &root, &parent,
- &child, (unsigned int *)&num_children))
+ gint i;
+
+ new_points = g_new (GdkPoint, npoints);
+ for (i=0; i<npoints; i++)
{
- 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;
- }
+ new_points[i].x = points[i].x - x_offset;
+ new_points[i].y = points[i].y - y_offset;
}
-
- return_val = XTranslateCoordinates (private->xdisplay,
- private->xwindow,
- win,
- 0, 0, &tx, &ty,
- &root);
- if (x)
- *x = tx;
- if (y)
- *y = ty;
}
-
-
- return return_val;
+ else
+ new_points = points;
+
+ if (private->paint_stack)
+ {
+ GdkWindowPaint *paint = private->paint_stack->data;
+ gdk_draw_points (paint->pixmap, gc, new_points, npoints);
+ }
+ else
+ gdk_draw_points (private->impl, gc, points, npoints);
+
+ if (new_points != points)
+ g_free (new_points);
+
+ RESTORE_GC (gc);
}
-void
-gdk_window_get_root_origin (GdkWindow *window,
- gint *x,
- gint *y)
+static void
+gdk_window_draw_segments (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkSegment *segs,
+ gint nsegs)
{
- 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)
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+ GdkSegment *new_segs;
+
+ OFFSET_GC (gc);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
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)
+ if (x_offset != 0 || y_offset != 0)
{
- unsigned int ww, wh, wb, wd;
- int wx, wy;
-
- if (XGetGeometry (private->xdisplay, xwindow, &root, &wx, &wy, &ww, &wh, &wb, &wd))
+ gint i;
+
+ new_segs = g_new (GdkSegment, nsegs);
+ for (i=0; i<nsegs; i++)
{
- if (x)
- *x = wx;
- if (y)
- *y = wy;
+ new_segs[i].x1 = segs[i].x1 - x_offset;
+ new_segs[i].y1 = segs[i].y1 - y_offset;
+ new_segs[i].x2 = segs[i].x2 - x_offset;
+ new_segs[i].y2 = segs[i].y2 - y_offset;
}
}
-}
+ else
+ new_segs = segs;
-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 (private->paint_stack)
{
- if (child)
- return_val = gdk_window_lookup (child);
+ GdkWindowPaint *paint = private->paint_stack->data;
+ gdk_draw_segments (paint->pixmap, gc, new_segs, nsegs);
}
+ else
+ gdk_draw_segments (private->impl, gc, new_segs, nsegs);
- if (x)
- *x = winx;
- if (y)
- *y = winy;
- if (mask)
- *mask = xmask;
-
- return return_val;
+ if (new_segs != segs)
+ g_free (new_segs);
+
+ RESTORE_GC (gc);
}
-GdkWindow*
-gdk_window_at_pointer (gint *win_x,
- gint *win_y)
+static void
+gdk_window_draw_lines (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPoint *points,
+ gint npoints)
{
- 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;
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+ GdkPoint *new_points;
+
+ OFFSET_GC (gc);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return;
- XGrabServer (private->xdisplay);
- while (xwindow)
+ if (x_offset != 0 || y_offset != 0)
{
- xwindow_last = xwindow;
- XQueryPointer (private->xdisplay,
- xwindow,
- &root, &xwindow,
- &rootx, &rooty,
- &winx, &winy,
- &xmask);
+ gint i;
+
+ new_points = g_new (GdkPoint, npoints);
+ for (i=0; i<npoints; i++)
+ {
+ new_points[i].x = points[i].x - x_offset;
+ new_points[i].y = points[i].y - y_offset;
+ }
}
- 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;
-}
+ else
+ new_points = points;
-GdkWindow*
-gdk_window_get_parent (GdkWindow *window)
-{
- g_return_val_if_fail (window != NULL, NULL);
-
- return ((GdkWindowPrivate*) window)->parent;
+ if (private->paint_stack)
+ {
+ GdkWindowPaint *paint = private->paint_stack->data;
+ gdk_draw_lines (paint->pixmap, gc, new_points, npoints);
+ }
+ else
+ gdk_draw_lines (private->impl, gc, new_points, npoints);
+
+ if (new_points != points)
+ g_free (new_points);
+
+ RESTORE_GC (gc);
}
-GdkWindow*
-gdk_window_get_toplevel (GdkWindow *window)
+static void
+gdk_window_draw_glyphs (GdkDrawable *drawable,
+ GdkGC *gc,
+ PangoFont *font,
+ gint x,
+ gint y,
+ PangoGlyphString *glyphs)
{
- GdkWindowPrivate *private;
-
- g_return_val_if_fail (window != NULL, NULL);
-
- private = (GdkWindowPrivate*) window;
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+
+ OFFSET_GC (gc);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return;
- while (private->window_type == GDK_WINDOW_CHILD)
+ if (private->paint_stack)
{
- window = ((GdkWindowPrivate*) window)->parent;
- private = (GdkWindowPrivate*) window;
+ GdkWindowPaint *paint = private->paint_stack->data;
+
+ gdk_draw_glyphs (paint->pixmap, gc, font, x - x_offset, y - y_offset, glyphs);
}
-
- return window;
+ else
+ gdk_draw_glyphs (private->impl, gc, font,
+ x - x_offset, y - y_offset, glyphs);
+
+ RESTORE_GC (gc);
}
-GList*
-gdk_window_get_children (GdkWindow *window)
+static void
+gdk_window_draw_glyphs_transformed (GdkDrawable *drawable,
+ GdkGC *gc,
+ PangoMatrix *matrix,
+ PangoFont *font,
+ gint x,
+ gint y,
+ PangoGlyphString *glyphs)
{
- 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)
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+ PangoMatrix tmp_matrix;
+
+ OFFSET_GC (gc);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return;
+
+ if (x_offset != 0 || y_offset != 0)
{
- for (i = 0; i < nchildren; i++)
+ if (matrix)
{
- child = gdk_window_lookup (xchildren[i]);
- if (child)
- children = g_list_prepend (children, child);
+ tmp_matrix = *matrix;
+ tmp_matrix.x0 -= x_offset;
+ tmp_matrix.y0 -= y_offset;
+ matrix = &tmp_matrix;
+ }
+ else
+ {
+ x -= x_offset * PANGO_SCALE;
+ y -= y_offset * PANGO_SCALE;
}
-
- if (xchildren)
- XFree (xchildren);
}
- return children;
+ if (private->paint_stack)
+ {
+ GdkWindowPaint *paint = private->paint_stack->data;
+
+ gdk_draw_glyphs_transformed (paint->pixmap, gc, matrix, font, x, y, glyphs);
+ }
+ else
+ gdk_draw_glyphs_transformed (private->impl, gc, matrix, font, x, y, glyphs);
+
+ RESTORE_GC (gc);
}
-GdkEventMask
-gdk_window_get_events (GdkWindow *window)
+static void
+gdk_window_set_bg_pattern (GdkWindow *window,
+ cairo_t *cr,
+ int x_offset,
+ int y_offset)
{
- 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++)
+ GdkWindowObject *private = (GdkWindowObject *)window;
+
+ if (private->bg_pixmap == GDK_PARENT_RELATIVE_BG && private->parent)
{
- if (attrs.your_event_mask & gdk_event_mask_table[i])
- event_mask |= 1 << (i + 1);
+ x_offset += private->x;
+ y_offset += private->y;
+ gdk_window_set_bg_pattern (GDK_WINDOW (private->parent), cr,
+ x_offset, y_offset);
+ }
+ else if (private->bg_pixmap &&
+ private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
+ private->bg_pixmap != GDK_NO_BG)
+ {
+ cairo_surface_t *surface = _gdk_drawable_ref_cairo_surface (private->bg_pixmap);
+ cairo_pattern_t *pattern = cairo_pattern_create_for_surface (surface);
+ cairo_surface_destroy (surface);
+
+ if (x_offset != 0 || y_offset != 0)
+ {
+ cairo_matrix_t matrix;
+ cairo_matrix_init_translate (&matrix, x_offset, y_offset);
+ cairo_pattern_set_matrix (pattern, &matrix);
+ }
+
+ cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
+ cairo_set_source (cr, pattern);
+ cairo_pattern_destroy (pattern);
+ }
+ else
+ {
+ gdk_cairo_set_source_color (cr, &private->bg_color);
}
-
- return event_mask;
}
-void
-gdk_window_set_events (GdkWindow *window,
- GdkEventMask event_mask)
+static void
+gdk_window_clear_backing_rect (GdkWindow *window,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
{
- GdkWindowPrivate *private;
- long xevent_mask;
- int i;
-
- g_return_if_fail (window != NULL);
-
- private = (GdkWindowPrivate*) window;
- if (private->destroyed)
+ GdkWindowObject *private = (GdkWindowObject *)window;
+ GdkWindowPaint *paint = private->paint_stack->data;
+ cairo_t *cr;
+
+ if (GDK_WINDOW_DESTROYED (window))
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);
+
+ cr = cairo_create (paint->surface);
+
+ gdk_window_set_bg_pattern (window, cr, 0, 0);
+
+ cairo_rectangle (cr, x, y, width, height);
+ cairo_clip (cr);
+
+ gdk_cairo_region (cr, paint->region);
+ cairo_fill (cr);
+
+ cairo_destroy (cr);
}
+/**
+ * gdk_window_clear:
+ * @window: a #GdkWindow
+ *
+ * Clears an entire @window to the background color or background pixmap.
+ **/
void
-gdk_window_add_colormap_windows (GdkWindow *window)
+gdk_window_clear (GdkWindow *window)
{
- GdkWindow *toplevel;
- GdkWindowPrivate *toplevel_private;
- GdkWindowPrivate *window_private;
- Window *old_windows;
- Window *new_windows;
- int i, count;
+ gint width, height;
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ gdk_drawable_get_size (GDK_DRAWABLE (window), &width, &height);
- 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);
+ gdk_window_clear_area (window, 0, 0,
+ width, height);
}
-static gboolean
-gdk_window_have_shape_ext (void)
+/**
+ * gdk_window_clear_area:
+ * @window: a #GdkWindow
+ * @x: x coordinate of rectangle to clear
+ * @y: y coordinate of rectangle to clear
+ * @width: width of rectangle to clear
+ * @height: height of rectangle to clear
+ *
+ * Clears an area of @window to the background color or background pixmap.
+ *
+ **/
+void
+gdk_window_clear_area (GdkWindow *window,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
{
- 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;
- }
+ GdkWindowObject *private = (GdkWindowObject *)window;
+
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- return (have_shape == YES);
+ if (private->paint_stack)
+ gdk_window_clear_backing_rect (window, x, y, width, height);
+ else
+ _gdk_windowing_window_clear_area (window, x, y, width, height);
}
-/*
- * This needs the X11 shape extension.
- * If not available, shaped windows will look
- * ugly, but programs still work. Stefan Wille
- */
+/**
+ * gdk_window_clear_area_e:
+ * @window: a #GdkWindow
+ * @x: x coordinate of rectangle to clear
+ * @y: y coordinate of rectangle to clear
+ * @width: width of rectangle to clear
+ * @height: height of rectangle to clear
+ *
+ * Like gdk_window_clear_area(), but also generates an expose event for
+ * the cleared area.
+ *
+ * This function has a stupid name because it dates back to the mists
+ * time, pre-GDK-1.0.
+ *
+ **/
void
-gdk_window_shape_combine_mask (GdkWindow *window,
- GdkBitmap *mask,
- gint x, gint y)
+gdk_window_clear_area_e (GdkWindow *window,
+ gint x,
+ gint y,
+ gint width,
+ gint height)
{
- GdkWindowPrivate *window_private;
- Pixmap pixmap;
-
+ GdkWindowObject *private = (GdkWindowObject *)window;
+
g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
-#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 */
+ if (private->paint_stack)
+ gdk_window_clear_backing_rect (window, x, y, width, height);
+
+ _gdk_windowing_window_clear_area_e (window, x, y, width, height);
}
-void
-gdk_window_add_filter (GdkWindow *window,
- GdkFilterFunc function,
- gpointer data)
+static void
+gdk_window_draw_image (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkImage *image,
+ gint xsrc,
+ gint ysrc,
+ gint xdest,
+ gint ydest,
+ gint width,
+ gint height)
{
- GdkWindowPrivate *private;
- GList *tmp_list;
- GdkEventFilter *filter;
-
- private = (GdkWindowPrivate*) window;
- if (private && private->destroyed)
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+
+ OFFSET_GC (gc);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
return;
- if (private)
- tmp_list = private->filters;
- else
- tmp_list = gdk_default_filters;
-
- while (tmp_list)
+ if (private->paint_stack)
{
- filter = (GdkEventFilter *)tmp_list->data;
- if ((filter->function == function) && (filter->data == data))
- return;
- tmp_list = tmp_list->next;
+ GdkWindowPaint *paint = private->paint_stack->data;
+ gdk_draw_image (paint->pixmap, gc, image, xsrc, ysrc,
+ xdest - x_offset, ydest - y_offset,
+ width, height);
+
}
-
- 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);
+ gdk_draw_image (private->impl, gc, image, xsrc, ysrc,
+ xdest - x_offset, ydest - y_offset,
+ width, height);
+
+ RESTORE_GC (gc);
}
-void
-gdk_window_remove_filter (GdkWindow *window,
- GdkFilterFunc function,
- gpointer data)
-{
- GdkWindowPrivate *private;
- GList *tmp_list, *node;
- GdkEventFilter *filter;
+static void
+gdk_window_draw_pixbuf (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkPixbuf *pixbuf,
+ gint src_x,
+ gint src_y,
+ gint dest_x,
+ gint dest_y,
+ gint width,
+ gint height,
+ GdkRgbDither dither,
+ gint x_dither,
+ gint y_dither)
+{
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return;
- private = (GdkWindowPrivate*) window;
+ if (gc)
+ {
+ OFFSET_GC (gc);
- if (private)
- tmp_list = private->filters;
+ if (private->paint_stack)
+ {
+ GdkWindowPaint *paint = private->paint_stack->data;
+ gdk_draw_pixbuf (paint->pixmap, gc, pixbuf, src_x, src_y,
+ dest_x - x_offset, dest_y - y_offset,
+ width, height,
+ dither, x_dither - x_offset, y_dither - y_offset);
+ }
+ else
+ gdk_draw_pixbuf (private->impl, gc, pixbuf, src_x, src_y,
+ dest_x - x_offset, dest_y - y_offset,
+ width, height,
+ dither, x_dither, y_dither);
+
+ RESTORE_GC (gc);
+ }
else
- tmp_list = gdk_default_filters;
-
- while (tmp_list)
{
- filter = (GdkEventFilter *)tmp_list->data;
- node = tmp_list;
- tmp_list = tmp_list->next;
+ gint x_offset, y_offset;
+ gdk_window_get_offsets (drawable, &x_offset, &y_offset);
- if ((filter->function == function) && (filter->data == data))
+ if (private->paint_stack)
{
- 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;
+ GdkWindowPaint *paint = private->paint_stack->data;
+ gdk_draw_pixbuf (paint->pixmap, gc, pixbuf, src_x, src_y,
+ dest_x - x_offset, dest_y - y_offset,
+ width, height,
+ dither, x_dither - x_offset, y_dither - y_offset);
}
+ else
+ gdk_draw_pixbuf (private->impl, gc, pixbuf, src_x, src_y,
+ dest_x - x_offset, dest_y - y_offset,
+ width, height,
+ dither, x_dither, y_dither);
}
}
-void
-gdk_window_set_override_redirect (GdkWindow *window,
- gboolean override_redirect)
+static void
+gdk_window_draw_trapezoids (GdkDrawable *drawable,
+ GdkGC *gc,
+ GdkTrapezoid *trapezoids,
+ gint n_trapezoids)
{
- 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);
-}
+ GdkWindowObject *private = (GdkWindowObject *)drawable;
+ GdkTrapezoid *new_trapezoids = NULL;
-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)
+ OFFSET_GC (gc);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
return;
+
+ if (x_offset != 0 || y_offset != 0)
+ {
+ gint i;
- wm_hints = XGetWMHints (window_private->xdisplay, window_private->xwindow);
- if (!wm_hints)
- wm_hints = XAllocWMHints ();
+ new_trapezoids = g_new (GdkTrapezoid, n_trapezoids);
+ for (i=0; i < n_trapezoids; i++)
+ {
+ new_trapezoids[i].y1 = trapezoids[i].y1 - y_offset;
+ new_trapezoids[i].x11 = trapezoids[i].x11 - x_offset;
+ new_trapezoids[i].x21 = trapezoids[i].x21 - x_offset;
+ new_trapezoids[i].y2 = trapezoids[i].y2 - y_offset;
+ new_trapezoids[i].x12 = trapezoids[i].x12 - x_offset;
+ new_trapezoids[i].x22 = trapezoids[i].x22 - x_offset;
+ }
- if (icon_window != NULL)
- {
- private = (GdkWindowPrivate *)icon_window;
- wm_hints->flags |= IconWindowHint;
- wm_hints->icon_window = private->xwindow;
+ trapezoids = new_trapezoids;
}
-
- if (pixmap != NULL)
+
+ if (private->paint_stack)
{
- private = (GdkWindowPrivate *)pixmap;
- wm_hints->flags |= IconPixmapHint;
- wm_hints->icon_pixmap = private->xwindow;
+ GdkWindowPaint *paint = private->paint_stack->data;
+ gdk_draw_trapezoids (paint->pixmap, gc, trapezoids, n_trapezoids);
}
+ else
+ gdk_draw_trapezoids (private->impl, gc, trapezoids, n_trapezoids);
- if (mask != NULL)
- {
- private = (GdkWindowPrivate *)mask;
- wm_hints->flags |= IconMaskHint;
- wm_hints->icon_mask = private->xwindow;
- }
+ if (new_trapezoids)
+ g_free (new_trapezoids);
- XSetWMHints (window_private->xdisplay, window_private->xwindow, wm_hints);
- XFree (wm_hints);
+ RESTORE_GC (gc);
}
-void
-gdk_window_set_icon_name (GdkWindow *window,
- gchar * name)
+static void
+gdk_window_real_get_size (GdkDrawable *drawable,
+ gint *width,
+ gint *height)
{
- 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);
+ g_return_if_fail (GDK_IS_WINDOW (drawable));
+
+ gdk_drawable_get_size (GDK_WINDOW_OBJECT (drawable)->impl,
+ width, height);
}
-void
-gdk_window_set_group (GdkWindow *window,
- GdkWindow *leader)
+static GdkVisual*
+gdk_window_real_get_visual (GdkDrawable *drawable)
{
- 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;
+ GdkColormap *colormap;
+
+ g_return_val_if_fail (GDK_IS_WINDOW (drawable), NULL);
- wm_hints = XGetWMHints (window_private->xdisplay, window_private->xwindow);
- if (!wm_hints)
- wm_hints = XAllocWMHints ();
+ colormap = gdk_drawable_get_colormap (drawable);
+ return colormap ? gdk_colormap_get_visual (colormap) : NULL;
+}
+
+static gint
+gdk_window_real_get_depth (GdkDrawable *drawable)
+{
+ g_return_val_if_fail (GDK_IS_WINDOW (drawable), 0);
- wm_hints->flags |= WindowGroupHint;
- wm_hints->window_group = private->xwindow;
+ return ((GdkWindowObject *)GDK_WINDOW (drawable))->depth;
+}
- XSetWMHints (window_private->xdisplay, window_private->xwindow, wm_hints);
- XFree (wm_hints);
+static GdkScreen*
+gdk_window_real_get_screen (GdkDrawable *drawable)
+{
+ return gdk_drawable_get_screen (GDK_WINDOW_OBJECT (drawable)->impl);
}
static void
-gdk_window_set_mwm_hints (GdkWindow *window,
- MotifWmHints *new_hints)
+gdk_window_real_set_colormap (GdkDrawable *drawable,
+ GdkColormap *cmap)
{
- 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)
+ g_return_if_fail (GDK_IS_WINDOW (drawable));
+
+ if (GDK_WINDOW_DESTROYED (drawable))
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)/sizeof (long),
- 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)/sizeof (long));
-
- if (hints != new_hints)
- XFree (hints);
+ gdk_drawable_set_colormap (((GdkWindowObject*)drawable)->impl, cmap);
}
-void
-gdk_window_set_decorations (GdkWindow *window,
- GdkWMDecoration decorations)
+static GdkColormap*
+gdk_window_real_get_colormap (GdkDrawable *drawable)
{
- MotifWmHints hints;
-
- hints.flags = MWM_HINTS_DECORATIONS;
- hints.decorations = decorations;
+ g_return_val_if_fail (GDK_IS_WINDOW (drawable), NULL);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return NULL;
- gdk_window_set_mwm_hints (window, &hints);
+ return gdk_drawable_get_colormap (((GdkWindowObject*)drawable)->impl);
}
-
-void
-gdk_window_set_functions (GdkWindow *window,
- GdkWMFunction functions)
+
+static GdkImage*
+gdk_window_copy_to_image (GdkDrawable *drawable,
+ GdkImage *image,
+ gint src_x,
+ gint src_y,
+ gint dest_x,
+ gint dest_y,
+ gint width,
+ gint height)
{
- MotifWmHints hints;
+ gint x_offset, y_offset;
+
+ g_return_val_if_fail (GDK_IS_WINDOW (drawable), NULL);
+
+ if (GDK_WINDOW_DESTROYED (drawable))
+ return NULL;
+
+ /* If we're here, a composite image was not necessary, so
+ * we can ignore the paint stack.
+ */
- hints.flags = MWM_HINTS_FUNCTIONS;
- hints.functions = functions;
+ _gdk_windowing_window_get_offsets (drawable, &x_offset, &y_offset);
- gdk_window_set_mwm_hints (window, &hints);
+ return gdk_drawable_copy_to_image (((GdkWindowObject*)drawable)->impl,
+ image,
+ src_x - x_offset,
+ src_y - y_offset,
+ dest_x, dest_y,
+ width, height);
}
-GList *
-gdk_window_get_toplevels (void)
+static cairo_surface_t *
+gdk_window_ref_cairo_surface (GdkDrawable *drawable)
{
- GList *new_list = NULL;
- GList *tmp_list;
+ GdkWindowObject *private = (GdkWindowObject*) drawable;
+ cairo_surface_t *surface;
+ gint x_offset, y_offset;
- tmp_list = gdk_root_parent.children;
- while (tmp_list)
+ gdk_window_get_offsets (GDK_WINDOW (drawable), &x_offset, &y_offset);
+
+ if (private->paint_stack)
{
- new_list = g_list_prepend (new_list, tmp_list->data);
- tmp_list = tmp_list->next;
+ GdkWindowPaint *paint = private->paint_stack->data;
+
+ surface = paint->surface;
+ cairo_surface_reference (surface);
}
-
- return new_list;
+ else
+ surface = _gdk_drawable_ref_cairo_surface (private->impl);
+
+ return surface;
}
-/*
- * propagate the shapes from all child windows of a GDK window to the parent
- * window. Shamelessly ripped from Enlightenment's code
- *
- * - Raster
+/* Code for dirty-region queueing
*/
+static GSList *update_windows = NULL;
+static guint update_idle = 0;
+static gboolean debug_updates = FALSE;
-struct _gdk_span
+static gboolean
+gdk_window_update_idle (gpointer data)
{
- gint start;
- gint end;
- struct _gdk_span *next;
-};
+ GDK_THREADS_ENTER ();
+ gdk_window_process_all_updates ();
+ GDK_THREADS_LEAVE ();
+
+ return FALSE;
+}
+
+static void
+gdk_window_schedule_update (GdkWindow *window)
+{
+ if (window && GDK_WINDOW_OBJECT (window)->update_freeze_count)
+ return;
+
+ if (!update_idle)
+ {
+ update_idle = g_idle_add_full (GDK_PRIORITY_REDRAW,
+ gdk_window_update_idle, NULL, NULL);
+ }
+}
static void
-gdk_add_to_span (struct _gdk_span **s,
- gint x,
- gint 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)
+gdk_window_process_updates_internal (GdkWindow *window)
+{
+ GdkWindowObject *private = (GdkWindowObject *)window;
+ gboolean save_region = FALSE;
+
+ /* If an update got queued during update processing, we can get a
+ * window in the update queue that has an empty update_area.
+ * just ignore it.
+ */
+ if (private->update_area)
{
- /* -- -> new span */
- /* == -> existing span */
- /* ## -> spans intersect */
- /* if we are in the middle of spanning the span into the line */
- if (spanning)
+ GdkRegion *update_area = private->update_area;
+ private->update_area = NULL;
+
+ if (_gdk_event_func && gdk_window_is_viewable (window))
{
- /* 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: ---###--- */
+ GdkRectangle window_rect;
+ GdkRegion *expose_region;
+ GdkRegion *window_region;
+ gint width, height;
+
+ if (debug_updates)
+ {
+ /* Make sure we see the red invalid area before redrawing. */
+ gdk_display_sync (gdk_drawable_get_display (window));
+ g_usleep (70000);
+ }
+
+ save_region = _gdk_windowing_window_queue_antiexpose (window, update_area);
+
+ if (save_region)
+ expose_region = gdk_region_copy (update_area);
else
+ expose_region = update_area;
+
+ gdk_drawable_get_size (GDK_DRAWABLE (private), &width, &height);
+
+ window_rect.x = 0;
+ window_rect.y = 0;
+ window_rect.width = width;
+ window_rect.height = height;
+
+ window_region = gdk_region_rectangle (&window_rect);
+ gdk_region_intersect (expose_region,
+ window_region);
+ gdk_region_destroy (window_region);
+
+ if (!gdk_region_empty (expose_region) &&
+ (private->event_mask & GDK_EXPOSURE_MASK))
{
- /* overlaps next span - delete and keep checking */
- ss->next = ptr1->next;
- g_free (ptr1);
- ptr1 = ss;
+ GdkEvent event;
+
+ event.expose.type = GDK_EXPOSE;
+ event.expose.window = g_object_ref (window);
+ event.expose.count = 0;
+ event.expose.region = expose_region;
+ gdk_region_get_clipbox (expose_region, &event.expose.area);
+
+ (*_gdk_event_func) (&event, _gdk_event_data);
+
+ g_object_unref (window);
}
+
+ if (expose_region != update_area)
+ gdk_region_destroy (expose_region);
}
- /* 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;
+ if (!save_region)
+ gdk_region_destroy (update_area);
}
- /* it started in the middle but spans beyond your current list */
- if (spanning)
+}
+
+static void
+flush_all_displays (void)
+{
+ GSList *displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
+ GSList *tmp_list;
+
+ for (tmp_list = displays; tmp_list; tmp_list = tmp_list->next)
+ gdk_display_flush (tmp_list->data);
+
+ g_slist_free (displays);
+}
+
+/**
+ * gdk_window_process_all_updates:
+ *
+ * Calls gdk_window_process_updates() for all windows (see #GdkWindow)
+ * in the application.
+ *
+ **/
+void
+gdk_window_process_all_updates (void)
+{
+ GSList *old_update_windows = update_windows;
+ GSList *tmp_list = update_windows;
+
+ if (update_idle)
+ g_source_remove (update_idle);
+
+ update_windows = NULL;
+ update_idle = 0;
+
+ g_slist_foreach (old_update_windows, (GFunc)g_object_ref, NULL);
+
+ while (tmp_list)
{
- ptr2->end = xx;
- return;
+ GdkWindowObject *private = (GdkWindowObject *)tmp_list->data;
+
+ if (private->update_freeze_count)
+ update_windows = g_slist_prepend (update_windows, private);
+ else
+ gdk_window_process_updates_internal (tmp_list->data);
+
+ g_object_unref (tmp_list->data);
+ tmp_list = tmp_list->next;
}
- /* it does not start inside a span or in the middle, so add it to the end */
- noo = g_malloc (sizeof (struct _gdk_span));
+
+ g_slist_free (old_update_windows);
+
+ flush_all_displays ();
+}
+
+/**
+ * gdk_window_process_updates:
+ * @window: a #GdkWindow
+ * @update_children: whether to also process updates for child windows
+ *
+ * Sends one or more expose events to @window. The areas in each
+ * expose event will cover the entire update area for the window (see
+ * gdk_window_invalidate_region() for details). Normally GDK calls
+ * gdk_window_process_all_updates() on your behalf, so there's no
+ * need to call this function unless you want to force expose events
+ * to be delivered immediately and synchronously (vs. the usual
+ * case, where GDK delivers them in an idle handler). Occasionally
+ * this is useful to produce nicer scrolling behavior, for example.
+ *
+ **/
+void
+gdk_window_process_updates (GdkWindow *window,
+ gboolean update_children)
+{
+ GdkWindowObject *private = (GdkWindowObject *)window;
+
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
- if (noo)
+ if (private->update_area && !private->update_freeze_count)
+ {
+ gdk_window_process_updates_internal (window);
+ update_windows = g_slist_remove (update_windows, window);
+ }
+
+ if (update_children)
{
- noo->start = x;
- noo->end = xx;
- if (ptr2)
- {
- noo->next = ptr2->next;
- ptr2->next = noo;
- }
- else
+ GList *tmp_list = private->children;
+ while (tmp_list)
{
- noo->next = NULL;
- *s = noo;
+ gdk_window_process_updates (tmp_list->data, TRUE);
+ tmp_list = tmp_list->next;
}
}
- 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)
+/**
+ * gdk_window_invalidate_rect:
+ * @window: a #GdkWindow
+ * @rect: rectangle to invalidate
+ * @invalidate_children: whether to also invalidate child windows
+ *
+ * A convenience wrapper around gdk_window_invalidate_region() which
+ * invalidates a rectangular region. See
+ * gdk_window_invalidate_region() for details.
+ *
+ **/
+void
+gdk_window_invalidate_rect (GdkWindow *window,
+ GdkRectangle *rect,
+ gboolean invalidate_children)
+{
+ GdkRectangle window_rect;
+ GdkRegion *region;
+ GdkWindowObject *private = (GdkWindowObject *)window;
+
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ if (GDK_WINDOW_DESTROYED (window))
+ return;
+
+ if (private->input_only || !GDK_WINDOW_IS_MAPPED (window))
+ return;
+
+ if (!rect)
{
- /* 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);
+ window_rect.x = 0;
+ window_rect.y = 0;
+ gdk_drawable_get_size (GDK_DRAWABLE (window),
+ &window_rect.width,
+ &window_rect.height);
+ rect = &window_rect;
}
+
+ region = gdk_region_rectangle (rect);
+ gdk_window_invalidate_region (window, region, invalidate_children);
+ gdk_region_destroy (region);
}
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)
+draw_ugly_color (GdkWindow *window,
+ GdkRegion *region)
+{
+ /* Draw ugly color all over the newly-invalid region */
+ GdkColor ugly_color = { 0, 50000, 10000, 10000 };
+ GdkGC *ugly_gc;
+ GdkRectangle clipbox;
+
+ ugly_gc = gdk_gc_new (window);
+ gdk_gc_set_rgb_fg_color (ugly_gc, &ugly_color);
+ gdk_gc_set_clip_region (ugly_gc, region);
+
+ gdk_region_get_clipbox (region, &clipbox);
+
+ gdk_draw_rectangle (window,
+ ugly_gc,
+ TRUE,
+ clipbox.x, clipbox.y,
+ clipbox.width, clipbox.height);
+
+ g_object_unref (ugly_gc);
+}
+
+/**
+ * gdk_window_invalidate_maybe_recurse:
+ * @window: a #GdkWindow
+ * @region: a #GdkRegion
+ * @child_func: function to use to decide if to recurse to a child,
+ * %NULL means never recurse.
+ * @user_data: data passed to @child_func
+ *
+ * Adds @region to the update area for @window. The update area is the
+ * region that needs to be redrawn, or "dirty region." The call
+ * gdk_window_process_updates() sends one or more expose events to the
+ * window, which together cover the entire update area. An
+ * application would normally redraw the contents of @window in
+ * response to those expose events.
+ *
+ * GDK will call gdk_window_process_all_updates() on your behalf
+ * whenever your program returns to the main loop and becomes idle, so
+ * normally there's no need to do that manually, you just need to
+ * invalidate regions that you know should be redrawn.
+ *
+ * The @child_func parameter controls whether the region of
+ * each child window that intersects @region will also be invalidated.
+ * Only children for which @child_func returns TRUE will have the area
+ * invalidated.
+ **/
+void
+gdk_window_invalidate_maybe_recurse (GdkWindow *window,
+ GdkRegion *region,
+ gboolean (*child_func) (GdkWindow *, gpointer),
+ gpointer user_data)
+{
+ GdkWindowObject *private = (GdkWindowObject *)window;
+ GdkRegion *visible_region;
+ GList *tmp_list;
+
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ if (GDK_WINDOW_DESTROYED (window))
+ return;
+
+ if (private->input_only || !GDK_WINDOW_IS_MAPPED (window))
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)
+
+ visible_region = gdk_drawable_get_visible_region (window);
+ gdk_region_intersect (visible_region, region);
+
+ tmp_list = private->children;
+ while (tmp_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);
+ GdkWindowObject *child = tmp_list->data;
- /* 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++)
+ if (!child->input_only)
{
- ptr1 = spans[i];
- /* go through the line for all spans */
- while (ptr1)
+ GdkRegion *child_region;
+ GdkRectangle child_rect;
+
+ gdk_window_get_position ((GdkWindow *)child,
+ &child_rect.x, &child_rect.y);
+ gdk_drawable_get_size ((GdkDrawable *)child,
+ &child_rect.width, &child_rect.height);
+
+ child_region = gdk_region_rectangle (&child_rect);
+
+ /* remove child area from the invalid area of the parent */
+ if (GDK_WINDOW_IS_MAPPED (child))
+ gdk_region_subtract (visible_region, child_region);
+
+ if (child_func && (*child_func) ((GdkWindow *)child, user_data))
{
- 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;
+ gdk_region_offset (region, - child_rect.x, - child_rect.y);
+ gdk_region_offset (child_region, - child_rect.x, - child_rect.y);
+ gdk_region_intersect (child_region, region);
+
+ gdk_window_invalidate_maybe_recurse ((GdkWindow *)child,
+ child_region, child_func, user_data);
+
+ gdk_region_offset (region, child_rect.x, child_rect.y);
}
+
+ gdk_region_destroy (child_region);
}
- /* 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);
+
+ tmp_list = tmp_list->next;
}
- /* free up all the spans we made */
- for (i = 0; i < baseh; i++)
+
+ if (!gdk_region_empty (visible_region))
{
- ptr1 = spans[i];
- while (ptr1)
+ if (debug_updates)
+ draw_ugly_color (window, region);
+
+ if (private->update_area)
{
- ptr2 = ptr1;
- ptr1 = ptr1->next;
- g_free (ptr2);
+ gdk_region_union (private->update_area, visible_region);
+ }
+ else
+ {
+ update_windows = g_slist_prepend (update_windows, window);
+ private->update_area = gdk_region_copy (visible_region);
+
+ gdk_window_schedule_update (window);
}
}
- g_free (spans);
+
+ gdk_region_destroy (visible_region);
}
-void
-gdk_window_set_child_shapes (GdkWindow *window)
+static gboolean
+true_predicate (GdkWindow *window,
+ gpointer user_data)
{
- 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
+ return TRUE;
}
+/**
+ * gdk_window_invalidate_region:
+ * @window: a #GdkWindow
+ * @region: a #GdkRegion
+ * @invalidate_children: %TRUE to also invalidate child windows
+ *
+ * Adds @region to the update area for @window. The update area is the
+ * region that needs to be redrawn, or "dirty region." The call
+ * gdk_window_process_updates() sends one or more expose events to the
+ * window, which together cover the entire update area. An
+ * application would normally redraw the contents of @window in
+ * response to those expose events.
+ *
+ * GDK will call gdk_window_process_all_updates() on your behalf
+ * whenever your program returns to the main loop and becomes idle, so
+ * normally there's no need to do that manually, you just need to
+ * invalidate regions that you know should be redrawn.
+ *
+ * The @invalidate_children parameter controls whether the region of
+ * each child window that intersects @region will also be invalidated.
+ * If %FALSE, then the update area for child windows will remain
+ * unaffected. See gdk_window_invalidate_maybe_recurse if you need
+ * fine grained control over which children are invalidated.
+ **/
void
-gdk_window_merge_child_shapes (GdkWindow *window)
+gdk_window_invalidate_region (GdkWindow *window,
+ GdkRegion *region,
+ gboolean invalidate_children)
{
- 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_invalidate_maybe_recurse (window, region,
+ invalidate_children ?
+ true_predicate : (gboolean (*) (GdkWindow *, gpointer))NULL,
+ NULL);
}
-/*************************************************************
- * 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)
+/**
+ * gdk_window_get_update_area:
+ * @window: a #GdkWindow
+ *
+ * Transfers ownership of the update area from @window to the caller
+ * of the function. That is, after calling this function, @window will
+ * no longer have an invalid/dirty region; the update area is removed
+ * from @window and handed to you. If a window has no update area,
+ * gdk_window_get_update_area() returns %NULL. You are responsible for
+ * calling gdk_region_destroy() on the returned region if it's non-%NULL.
+ *
+ * Return value: the update area for @window
+ **/
+GdkRegion *
+gdk_window_get_update_area (GdkWindow *window)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
-
- g_return_val_if_fail (window != NULL, FALSE);
-
- return private->mapped;
-}
+ GdkWindowObject *private = (GdkWindowObject *)window;
+ GdkRegion *tmp_region;
-/*************************************************************
- * 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
- *************************************************************/
+ g_return_val_if_fail (window != NULL, NULL);
+ g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
-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->update_area)
{
- if (!private->mapped)
- return FALSE;
+ tmp_region = private->update_area;
+ private->update_area = NULL;
+
+ update_windows = g_slist_remove (update_windows, window);
- private = (GdkWindowPrivate *)private->parent;
+ return tmp_region;
}
-
- return TRUE;
+ else
+ return NULL;
}
-void
-gdk_drawable_set_data (GdkDrawable *drawable,
- const gchar *key,
- gpointer data,
- GDestroyNotify destroy_func)
+/**
+ * _gdk_window_clear_update_area:
+ * @window: a #GdkWindow.
+ *
+ * Internal function to clear the update area for a window. This
+ * is called when the window is hidden or destroyed.
+ **/
+void
+_gdk_window_clear_update_area (GdkWindow *window)
{
- g_dataset_set_data_full (drawable, key, data, destroy_func);
-}
+ GdkWindowObject *private = (GdkWindowObject *)window;
+ g_return_if_fail (window != NULL);
+ g_return_if_fail (GDK_IS_WINDOW (window));
-/* Support for windows that can be guffaw-scrolled
- * (See http://www.gtk.org/~otaylor/whitepapers/guffaw-scrolling.txt)
- */
-
-static gboolean
-gdk_window_gravity_works (void)
-{
- enum { UNKNOWN, NO, YES };
- static gint gravity_works = UNKNOWN;
-
- if (gravity_works == UNKNOWN)
+ if (private->update_area)
{
- GdkWindowAttr attr;
- GdkWindow *parent;
- GdkWindow *child;
- gint y;
-
- /* This particular server apparently has a bug so that the test
- * works but the actual code crashes it
- */
- if ((!strcmp (XServerVendor (gdk_display), "Sun Microsystems, Inc.")) &&
- (VendorRelease (gdk_display) == 3400))
- {
- gravity_works = NO;
- return FALSE;
- }
-
- attr.window_type = GDK_WINDOW_TEMP;
- attr.wclass = GDK_INPUT_OUTPUT;
- attr.x = 0;
- attr.y = 0;
- attr.width = 100;
- attr.height = 100;
- attr.event_mask = 0;
-
- parent = gdk_window_new (NULL, &attr, GDK_WA_X | GDK_WA_Y);
-
- attr.window_type = GDK_WINDOW_CHILD;
- child = gdk_window_new (parent, &attr, GDK_WA_X | GDK_WA_Y);
-
- gdk_window_set_static_win_gravity (child, TRUE);
+ update_windows = g_slist_remove (update_windows, window);
- gdk_window_resize (parent, 100, 110);
- gdk_window_move (parent, 0, -10);
- gdk_window_move_resize (parent, 0, 0, 100, 100);
-
- gdk_window_resize (parent, 100, 110);
- gdk_window_move (parent, 0, -10);
- gdk_window_move_resize (parent, 0, 0, 100, 100);
-
- gdk_window_get_geometry (child, NULL, &y, NULL, NULL, NULL);
-
- gdk_window_destroy (parent);
- gdk_window_destroy (child);
-
- gravity_works = ((y == -20) ? YES : NO);
+ gdk_region_destroy (private->update_area);
+ private->update_area = NULL;
}
-
- return (gravity_works == YES);
}
-static void
-gdk_window_set_static_bit_gravity (GdkWindow *window, gboolean on)
+/**
+ * gdk_window_freeze_updates:
+ * @window: a #GdkWindow
+ *
+ * Temporarily freezes a window such that it won't receive expose
+ * events. The window will begin receiving expose events again when
+ * gdk_window_thaw_updates() is called. If gdk_window_freeze_updates()
+ * has been called more than once, gdk_window_thaw_updates() must be called
+ * an equal number of times to begin processing exposes.
+ **/
+void
+gdk_window_freeze_updates (GdkWindow *window)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
- XSetWindowAttributes xattributes;
-
+ GdkWindowObject *private = (GdkWindowObject *)window;
+
g_return_if_fail (window != NULL);
-
- xattributes.bit_gravity = on ? StaticGravity : ForgetGravity;
- XChangeWindowAttributes (private->xdisplay,
- private->xwindow,
- CWBitGravity, &xattributes);
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ private->update_freeze_count++;
}
-static void
-gdk_window_set_static_win_gravity (GdkWindow *window, gboolean on)
+/**
+ * gdk_window_thaw_updates:
+ * @window: a #GdkWindow
+ *
+ * Thaws a window frozen with gdk_window_freeze_updates().
+ **/
+void
+gdk_window_thaw_updates (GdkWindow *window)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
- XSetWindowAttributes xattributes;
-
+ GdkWindowObject *private = (GdkWindowObject *)window;
+
g_return_if_fail (window != NULL);
-
- xattributes.win_gravity = on ? StaticGravity : NorthWestGravity;
-
- XChangeWindowAttributes (private->xdisplay,
- private->xwindow,
- CWWinGravity, &xattributes);
-}
+ g_return_if_fail (GDK_IS_WINDOW (window));
+ g_return_if_fail (private->update_freeze_count > 0);
-/*************************************************************
- * gdk_window_set_static_gravities:
- * Set the bit gravity of the given window to static,
- * and flag it so all children get static subwindow
- * gravity.
- * arguments:
- * window: window for which to set static gravity
- * use_static: Whether to turn static gravity on or off.
- * results:
- * Does the XServer support static gravity?
- *************************************************************/
+ if (--private->update_freeze_count == 0)
+ gdk_window_schedule_update (window);
+}
-gboolean
-gdk_window_set_static_gravities (GdkWindow *window,
- gboolean use_static)
+/**
+ * gdk_window_set_debug_updates:
+ * @setting: %TRUE to turn on update debugging
+ *
+ * With update debugging enabled, calls to
+ * gdk_window_invalidate_region() clear the invalidated region of the
+ * screen to a noticeable color, and GDK pauses for a short time
+ * before sending exposes to windows during
+ * gdk_window_process_updates(). The net effect is that you can see
+ * the invalid region for each window and watch redraws as they
+ * occur. This allows you to diagnose inefficiencies in your application.
+ *
+ * In essence, because the GDK rendering model prevents all flicker,
+ * if you are redrawing the same region 400 times you may never
+ * notice, aside from noticing a speed problem. Enabling update
+ * debugging causes GTK to flicker slowly and noticeably, so you can
+ * see exactly what's being redrawn when, in what order.
+ *
+ * The --gtk-debug=updates command line option passed to GTK+ programs
+ * enables this debug option at application startup time. That's
+ * usually more useful than calling gdk_window_set_debug_updates()
+ * yourself, though you might want to use this function to enable
+ * updates sometime after application startup time.
+ *
+ **/
+void
+gdk_window_set_debug_updates (gboolean setting)
{
- GdkWindowPrivate *private = (GdkWindowPrivate *)window;
- GList *tmp_list;
-
- g_return_val_if_fail (window != NULL, FALSE);
+ debug_updates = setting;
+}
+
+/**
+ * gdk_window_constrain_size:
+ * @geometry: a #GdkGeometry structure
+ * @flags: a mask indicating what portions of @geometry are set
+ * @width: desired width of window
+ * @height: desired height of the window
+ * @new_width: location to store resulting width
+ * @new_height: location to store resulting height
+ *
+ * Constrains a desired width and height according to a
+ * set of geometry hints (such as minimum and maximum size).
+ */
+void
+gdk_window_constrain_size (GdkGeometry *geometry,
+ guint flags,
+ gint width,
+ gint height,
+ gint *new_width,
+ gint *new_height)
+{
+ /* This routine is partially borrowed from fvwm.
+ *
+ * Copyright 1993, Robert Nation
+ * You may use this code for any purpose, as long as the original
+ * copyright remains in the source code and all documentation
+ *
+ * which in turn borrows parts of the algorithm from uwm
+ */
+ gint min_width = 0;
+ gint min_height = 0;
+ gint base_width = 0;
+ gint base_height = 0;
+ gint xinc = 1;
+ gint yinc = 1;
+ gint max_width = G_MAXINT;
+ gint max_height = G_MAXINT;
+
+#define FLOOR(value, base) ( ((gint) ((value) / (base))) * (base) )
+
+ if ((flags & GDK_HINT_BASE_SIZE) && (flags & GDK_HINT_MIN_SIZE))
+ {
+ base_width = geometry->base_width;
+ base_height = geometry->base_height;
+ min_width = geometry->min_width;
+ min_height = geometry->min_height;
+ }
+ else if (flags & GDK_HINT_BASE_SIZE)
+ {
+ base_width = geometry->base_width;
+ base_height = geometry->base_height;
+ min_width = geometry->base_width;
+ min_height = geometry->base_height;
+ }
+ else if (flags & GDK_HINT_MIN_SIZE)
+ {
+ base_width = geometry->min_width;
+ base_height = geometry->min_height;
+ min_width = geometry->min_width;
+ min_height = geometry->min_height;
+ }
+
+ if (flags & GDK_HINT_MAX_SIZE)
+ {
+ max_width = geometry->max_width ;
+ max_height = geometry->max_height;
+ }
+
+ if (flags & GDK_HINT_RESIZE_INC)
+ {
+ xinc = MAX (xinc, geometry->width_inc);
+ yinc = MAX (yinc, geometry->height_inc);
+ }
- if (!use_static == !private->guffaw_gravity)
- return TRUE;
+ /* clamp width and height to min and max values
+ */
+ width = CLAMP (width, min_width, max_width);
+ height = CLAMP (height, min_height, max_height);
- if (use_static && !gdk_window_gravity_works ())
- return FALSE;
+ /* shrink to base + N * inc
+ */
+ width = base_width + FLOOR (width - base_width, xinc);
+ height = base_height + FLOOR (height - base_height, yinc);
+
+ /* constrain aspect ratio, according to:
+ *
+ * width
+ * min_aspect <= -------- <= max_aspect
+ * height
+ */
- private->guffaw_gravity = use_static;
+ if (flags & GDK_HINT_ASPECT &&
+ geometry->min_aspect > 0 &&
+ geometry->max_aspect > 0)
+ {
+ gint delta;
+
+ if (geometry->min_aspect * height > width)
+ {
+ delta = FLOOR (height - width / geometry->min_aspect, yinc);
+ if (height - delta >= min_height)
+ height -= delta;
+ else
+ {
+ delta = FLOOR (height * geometry->min_aspect - width, xinc);
+ if (width + delta <= max_width)
+ width += delta;
+ }
+ }
+
+ if (geometry->max_aspect * height < width)
+ {
+ delta = FLOOR (width - height * geometry->max_aspect, xinc);
+ if (width - delta >= min_width)
+ width -= delta;
+ else
+ {
+ delta = FLOOR (width / geometry->max_aspect - height, yinc);
+ if (height + delta <= max_height)
+ height += delta;
+ }
+ }
+ }
+
+#undef FLOOR
- gdk_window_set_static_bit_gravity (window, use_static);
+ *new_width = width;
+ *new_height = height;
+}
+
+/**
+ * gdk_window_get_pointer:
+ * @window: a #GdkWindow
+ * @x: return location for X coordinate of pointer
+ * @y: return location for Y coordinate of pointer
+ * @mask: return location for modifier mask
+ *
+ * Obtains the current pointer position and modifier state.
+ * The position is given in coordinates relative to @window.
+ *
+ * Return value: the window containing the pointer (as with
+ * gdk_window_at_pointer()), or %NULL if the window containing the
+ * pointer isn't known to GDK
+ **/
+GdkWindow*
+gdk_window_get_pointer (GdkWindow *window,
+ gint *x,
+ gint *y,
+ GdkModifierType *mask)
+{
+ GdkDisplay *display;
+ gint tmp_x, tmp_y;
+ GdkModifierType tmp_mask;
+ GdkWindow *child;
- tmp_list = private->children;
- while (tmp_list)
+ g_return_val_if_fail (window == NULL || GDK_IS_WINDOW (window), NULL);
+
+ if (window)
{
- gdk_window_set_static_win_gravity (window, use_static);
+ display = gdk_drawable_get_display (window);
+ }
+ else
+ {
+ GdkScreen *screen = gdk_screen_get_default ();
+
+ display = gdk_screen_get_display (screen);
+ window = gdk_screen_get_root_window (screen);
- tmp_list = tmp_list->next;
+ GDK_NOTE (MULTIHEAD,
+ g_message ("Passing NULL for window to gdk_window_get_pointer()\n"
+ "is not multihead safe"));
}
-
- return TRUE;
+
+ child = display->pointer_hooks->window_get_pointer (display, window, &tmp_x, &tmp_y, &tmp_mask);
+
+ if (x)
+ *x = tmp_x;
+ if (y)
+ *y = tmp_y;
+ if (mask)
+ *mask = tmp_mask;
+
+ return child;
+}
+
+/**
+ * gdk_window_at_pointer:
+ * @win_x: return location for origin of the window under the pointer
+ * @win_y: return location for origin of the window under the pointer
+ *
+ * Obtains the window underneath the mouse pointer, returning the
+ * location of that window in @win_x, @win_y. Returns %NULL if the
+ * window under the mouse pointer is not known to GDK (if the window
+ * belongs to another application and a #GdkWindow hasn't been created
+ * for it with gdk_window_foreign_new())
+ *
+ * NOTE: For multihead-aware widgets or applications use
+ * gdk_display_get_window_at_pointer() instead.
+ *
+ * Return value: window under the mouse pointer
+ **/
+GdkWindow*
+gdk_window_at_pointer (gint *win_x,
+ gint *win_y)
+{
+ return gdk_display_get_window_at_pointer (gdk_display_get_default (), win_x, win_y);
+}
+
+/**
+ * gdk_get_default_root_window:
+ *
+ * Obtains the root window (parent all other windows are inside)
+ * for the default display and screen.
+ *
+ * Return value: the default root window
+ **/
+GdkWindow *
+gdk_get_default_root_window (void)
+{
+ return gdk_screen_get_root_window (gdk_screen_get_default ());
}
+
+/**
+ * gdk_window_foreign_new:
+ * @anid: a native window handle.
+ *
+ * Wraps a native window for the default display in a #GdkWindow.
+ * This may fail if the window has been destroyed.
+ *
+ * For example in the X backend, a native window handle is an Xlib
+ * <type>XID</type>.
+ *
+ * Return value: the newly-created #GdkWindow wrapper for the
+ * native window or %NULL if the window has been destroyed.
+ **/
+GdkWindow *
+gdk_window_foreign_new (GdkNativeWindow anid)
+{
+ return gdk_window_foreign_new_for_display (gdk_display_get_default (), anid);
+}
+
+#define __GDK_WINDOW_C__
+#include "gdkaliasdef.c"