Clamp max window width/height to 32767, not 32768 since we have to be able

Mon Nov  5 10:01:49 2001  Owen Taylor  <otaylor@redhat.com>

	* gdk/x11/gdkgeometry-x11.c (gdk_window_compute_position):
	Clamp max window width/height to 32767, not 32768 since
	we have to be able to deal with a dx/y of -32768 without
	getting a width of 65536 when guffaw scrolling.

	* gdk/x11/gdkgeometry-x11.c: Implement gdk_window_scroll()
	for the guffaw scrolling case, fixing some problems with
	copy-area case as well. Fix BadValue bug with moving windows
	by large amounts.

	* gdk/x11/gdkgeometry-x11.c (gdk_window_clip_changed): Update
	clip in window structue before calling gdk_window_invalidate_region
	since that trims new invalidations to the window's visible
	region.

	* gdk/x11/gdkwindow-x11.c (gdk_window_set_static_gravities):
	Really set the static window gravity on the children, not
	repeatedly on the window.

	* gtk/testgtk.c: Add a torture test for big windows and
	gdk_window_scroll().

1 files changed, 215 insertions, 123 deletions

diff --git a/gdk/x11/gdkgeometry-x11.c b/gdk/x11/gdkgeometry-x11.c
index 64fc00f03a..b479ab5e75 100644
--- a/gdk/x11/gdkgeometry-x11.c
+++ b/gdk/x11/gdkgeometry-x11.c
@@ -110,6 +110,169 @@ _gdk_window_init_position (GdkWindow *window)
   gdk_window_compute_position (impl, &parent_pos, &impl->position_info);
 }
 
+static void
+gdk_window_copy_area_scroll (GdkWindow    *window,
+			     GdkRectangle *dest_rect,
+			     gint          dx,
+			     gint          dy)
+{
+  GdkWindowObject *obj = GDK_WINDOW_OBJECT (window);
+  GList *tmp_list;
+
+  if (dest_rect->width > 0 && dest_rect->height > 0)
+    {
+      GC gc;
+      XGCValues values;
+
+      values.graphics_exposures = True;
+      gc = XCreateGC (GDK_WINDOW_XDISPLAY (window),
+		      GDK_WINDOW_XID (window),
+		      GCGraphicsExposures, &values);
+
+      gdk_window_queue_translation (window, dx, dy);
+
+      XCopyArea (GDK_WINDOW_XDISPLAY (window),
+		 GDK_WINDOW_XID (window),
+		 GDK_WINDOW_XID (window),
+		 gc,
+		 dest_rect->x - dx, dest_rect->y - dy,
+		 dest_rect->width, dest_rect->height,
+		 dest_rect->x, dest_rect->y);
+
+      XFreeGC (GDK_WINDOW_XDISPLAY (window), gc);
+    }
+
+  tmp_list = obj->children;
+  while (tmp_list)
+    {
+      GdkWindow *child = GDK_WINDOW (tmp_list->data);
+      GdkWindowObject *child_obj = GDK_WINDOW_OBJECT (child);
+	  
+      gdk_window_move (child, child_obj->x + dx, child_obj->y + dy);
+      
+      tmp_list = tmp_list->next;
+    }
+}
+
+static void
+compute_intermediate_position (GdkXPositionInfo *position_info,
+			       GdkXPositionInfo *new_info,
+			       gint              d_xoffset,
+			       gint              d_yoffset,
+			       GdkRectangle     *new_position)
+{
+  gint new_x0, new_x1, new_y0, new_y1;
+  
+  /* Wrap d_xoffset, d_yoffset into [-32768,32767] range. For the
+   * purposes of subwindow movement, it doesn't matter if we are
+   * off by a factor of 65536, and if we don't do this range
+   * reduction, we'll end up with invalid widths.
+   */
+  d_xoffset = (gint16)d_xoffset;
+  d_yoffset = (gint16)d_yoffset;
+  
+  if (d_xoffset < 0)
+    {
+      new_x0 = position_info->x + d_xoffset;
+      new_x1 = position_info->x + position_info->width;
+    }
+  else
+    {
+      new_x0 = position_info->x;
+      new_x1 = position_info->x + new_info->width + d_xoffset;
+    }
+
+  new_position->x = new_x0;
+  new_position->width = new_x1 - new_x0;
+  
+  if (d_yoffset < 0)
+    {
+      new_y0 = position_info->y + d_yoffset;
+      new_y1 = position_info->y + position_info->height;
+    }
+  else
+    {
+      new_y0 = position_info->y;
+      new_y1 = position_info->y + new_info->height + d_yoffset;
+    }
+  
+  new_position->y = new_y0;
+  new_position->height = new_y1 - new_y0;
+}
+
+static void
+gdk_window_guffaw_scroll (GdkWindow    *window,
+			  gint          dx,
+			  gint          dy)
+{
+  GdkWindowObject *obj = GDK_WINDOW_OBJECT (window);
+  GdkWindowImplX11 *impl = GDK_WINDOW_IMPL_X11 (obj->impl);
+
+  gint d_xoffset = -dx;
+  gint d_yoffset = -dy;
+  GdkRectangle new_position;
+  GdkXPositionInfo new_info;
+  GdkWindowParentPos parent_pos;
+  GList *tmp_list;
+  
+  gdk_window_compute_parent_pos (impl, &parent_pos);
+  gdk_window_compute_position (impl, &parent_pos, &new_info);
+
+  parent_pos.x += obj->x;
+  parent_pos.y += obj->y;
+  parent_pos.x11_x += new_info.x;
+  parent_pos.x11_y += new_info.y;
+  parent_pos.clip_rect = new_info.clip_rect;
+
+  gdk_window_tmp_unset_bg (window);
+
+  if (d_xoffset < 0 || d_yoffset < 0)
+    gdk_window_queue_translation (window, MIN (d_xoffset, 0), MIN (d_yoffset, 0));
+	
+  gdk_window_set_static_gravities (window, TRUE);
+
+  compute_intermediate_position (&impl->position_info, &new_info, d_xoffset, d_yoffset,
+				 &new_position);
+  
+  XMoveResizeWindow (GDK_WINDOW_XDISPLAY (window),
+		     GDK_WINDOW_XID (window),
+		     new_position.x, new_position.y, new_position.width, new_position.height);
+  
+  tmp_list = obj->children;
+  while (tmp_list)
+    {
+      GDK_WINDOW_OBJECT(tmp_list->data)->x -= d_xoffset;
+      GDK_WINDOW_OBJECT(tmp_list->data)->y -= d_yoffset;
+
+      gdk_window_premove (tmp_list->data, &parent_pos);
+      tmp_list = tmp_list->next;
+    }
+  
+  XMoveWindow (GDK_WINDOW_XDISPLAY (window),
+	       GDK_WINDOW_XID (window),
+	       new_position.x - d_xoffset, new_position.y - d_yoffset);
+  
+  if (d_xoffset > 0 || d_yoffset > 0)
+    gdk_window_queue_translation (window, MAX (d_xoffset, 0), MAX (d_yoffset, 0));
+  
+  XMoveResizeWindow (GDK_WINDOW_XDISPLAY (window),
+		     GDK_WINDOW_XID (window),
+		     impl->position_info.x, impl->position_info.y,
+		     impl->position_info.width, impl->position_info.height);
+  
+  if (impl->position_info.no_bg)
+    gdk_window_tmp_reset_bg (window);
+  
+  impl->position_info = new_info;
+  
+  tmp_list = obj->children;
+  while (tmp_list)
+    {
+      gdk_window_postmove (tmp_list->data, &parent_pos);
+      tmp_list = tmp_list->next;
+    }
+}
+
 /**
  * gdk_window_scroll:
  * @window: a #GdkWindow
@@ -131,97 +294,60 @@ gdk_window_scroll (GdkWindow *window,
 		   gint       dy)
 {
   gboolean can_guffaw_scroll = FALSE;
+  GdkRegion *invalidate_region;
   GdkWindowImplX11 *impl;
   GdkWindowObject *obj;
+  GdkRectangle dest_rect;
   
   g_return_if_fail (GDK_IS_WINDOW (window));
 
-  obj = GDK_WINDOW_OBJECT (window);
+  if (GDK_WINDOW_DESTROYED (window))
+    return;
   
+  obj = GDK_WINDOW_OBJECT (window);
   impl = GDK_WINDOW_IMPL_X11 (obj->impl);  
-  
-  if (GDK_WINDOW_DESTROYED (window))
+
+  if (dx == 0 && dy == 0)
     return;
   
   /* Move the current invalid region */
   if (obj->update_area)
     gdk_region_offset (obj->update_area, dx, dy);
   
+  invalidate_region = gdk_region_rectangle (&impl->position_info.clip_rect);
+  
+  dest_rect = impl->position_info.clip_rect;
+  dest_rect.x += dx;
+  dest_rect.y += dy;
+  gdk_rectangle_intersect (&dest_rect, &impl->position_info.clip_rect, &dest_rect);
+
+  if (dest_rect.width > 0 && dest_rect.height > 0)
+    {
+      GdkRegion *tmp_region;
+
+      tmp_region = gdk_region_rectangle (&dest_rect);
+      gdk_region_subtract (invalidate_region, tmp_region);
+      gdk_region_destroy (tmp_region);
+    }
+  
+  gdk_window_invalidate_region (window, invalidate_region, TRUE);
+  gdk_region_destroy (invalidate_region);
+
   /* We can guffaw scroll if we are a child window, and the parent
-   * does not extend beyond our edges.
+   * does not extend beyond our edges. Otherwise, we use XCopyArea, then
+   * move any children later
    */
-  
   if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD)
     {
       GdkWindowImplX11 *parent_impl = GDK_WINDOW_IMPL_X11 (obj->parent->impl);  
-      can_guffaw_scroll = (obj->x <= 0 &&
-			   obj->y <= 0 &&
-			   obj->x + impl->width >= parent_impl->width &&
-			   obj->y + impl->height >= parent_impl->height);
+      can_guffaw_scroll = ((dx == 0 || (obj->x <= 0 && obj->x + impl->width >= parent_impl->width)) &&
+			   (dy == 0 || (obj->y <= 0 && obj->y + impl->height >= parent_impl->height)));
     }
 
   if (!obj->children || !can_guffaw_scroll)
-    {
-      /* Use XCopyArea, then move any children later
-       */
-      GList *tmp_list;
-      GdkRegion *invalidate_region;
-      GdkRectangle dest_rect;
-
-      invalidate_region = gdk_region_rectangle (&impl->position_info.clip_rect);
-      
-      dest_rect = impl->position_info.clip_rect;
-      dest_rect.x += dx;
-      dest_rect.y += dy;
-      gdk_rectangle_intersect (&dest_rect, &impl->position_info.clip_rect, &dest_rect);
-
-      if (dest_rect.width > 0 && dest_rect.height > 0)
-	{
-	  GC gc;
-	  XGCValues values;
-	  GdkRegion *tmp_region;
-
-	  tmp_region = gdk_region_rectangle (&dest_rect);
-	  gdk_region_subtract (invalidate_region, tmp_region);
-	  gdk_region_destroy (tmp_region);
-	  
-	  gdk_window_queue_translation (window, dx, dy);
-
-	  values.graphics_exposures = True;
-	  gc = XCreateGC (GDK_WINDOW_XDISPLAY (window),
-                          GDK_WINDOW_XID (window),
-			  GCGraphicsExposures, &values);
-
-	  XCopyArea (GDK_WINDOW_XDISPLAY (window),
-		     GDK_WINDOW_XID (window),
-		     GDK_WINDOW_XID (window),
-		     gc,
-		     dest_rect.x - dx, dest_rect.y - dy,
-		     dest_rect.width, dest_rect.height,
-		     dest_rect.x, dest_rect.y);
-
-	  XFreeGC (GDK_WINDOW_XDISPLAY (window), gc);
-	}
-
-      gdk_window_invalidate_region (window, invalidate_region, TRUE);
-      gdk_region_destroy (invalidate_region);
-
-      tmp_list = obj->children;
-      while (tmp_list)
-	{
-	  GdkWindow * child = GDK_WINDOW (tmp_list->data);
-	  
-	  gdk_window_move (child, obj->x + dx, obj->y + dy);
-	  
-	  tmp_list = tmp_list->next;
-	}
-    }
+    gdk_window_copy_area_scroll (window, &dest_rect, dx, dy);
   else
-    {
-      /* Guffaw scroll
-       */
-      g_warning ("gdk_window_scroll(): guffaw scrolling not yet implemented");
-    }
+    gdk_window_guffaw_scroll (window, dx, dy);
 }
 
 void
@@ -278,38 +404,19 @@ _gdk_window_move_resize_child (GdkWindow *window,
   
   if (d_xoffset != 0 || d_yoffset != 0)
     {
-      gint new_x0, new_y0, new_x1, new_y1;
+      GdkRectangle new_position;
 
       gdk_window_set_static_gravities (window, TRUE);
 
       if (d_xoffset < 0 || d_yoffset < 0)
 	gdk_window_queue_translation (window, MIN (d_xoffset, 0), MIN (d_yoffset, 0));
-	
-      if (d_xoffset < 0)
-	{
-	  new_x0 = impl->position_info.x + d_xoffset;
-	  new_x1 = impl->position_info.x + impl->position_info.width;
-	}
-      else
-	{
-	  new_x0 = impl->position_info.x;
-	  new_x1 = impl->position_info.x + new_info.width + d_xoffset;
-	}
 
-      if (d_yoffset < 0)
-	{
-	  new_y0 = impl->position_info.y + d_yoffset;
-	  new_y1 = impl->position_info.y + impl->position_info.height;
-	}
-      else
-	{
-	  new_y0 = impl->position_info.y;
-	  new_y1 = impl->position_info.y + new_info.height + d_yoffset;
-	}
+      compute_intermediate_position (&impl->position_info, &new_info, d_xoffset, d_yoffset,
+				     &new_position);
       
       XMoveResizeWindow (GDK_WINDOW_XDISPLAY (window),
 			 GDK_WINDOW_XID (window),
-			 new_x0, new_y0, new_x1 - new_x0, new_y1 - new_y0);
+			 new_position.x, new_position.y, new_position.width, new_position.height);
       
       tmp_list = obj->children;
       while (tmp_list)
@@ -320,7 +427,7 @@ _gdk_window_move_resize_child (GdkWindow *window,
 
       XMoveWindow (GDK_WINDOW_XDISPLAY (window),
 		   GDK_WINDOW_XID (window),
-		   new_x0 + dx, new_y0 + dy);
+		   new_position.x + dx, new_position.y + dy);
       
       if (d_xoffset > 0 || d_yoffset > 0)
 	gdk_window_queue_translation (window, MAX (d_xoffset, 0), MAX (d_yoffset, 0));
@@ -400,7 +507,7 @@ gdk_window_compute_position (GdkWindowImplX11   *window,
   
   info->big = FALSE;
   
-  if (window->width <= 32768)
+  if (window->width <= 32767)
     {
       info->width = window->width;
       info->x = parent_pos->x + wrapper->x - parent_pos->x11_x;
@@ -408,11 +515,11 @@ gdk_window_compute_position (GdkWindowImplX11   *window,
   else
     {
       info->big = TRUE;
-      info->width = 32768;
+      info->width = 32767;
       if (parent_pos->x + wrapper->x < -16384)
 	{
 	  if (parent_pos->x + wrapper->x + window->width < 16384)
-	    info->x = parent_pos->x + wrapper->x + window->width - 32768 - parent_pos->x11_x;
+	    info->x = parent_pos->x + wrapper->x + window->width - info->width - parent_pos->x11_x;
 	  else
 	    info->x = -16384 - parent_pos->x11_y;
 	}
@@ -420,7 +527,7 @@ gdk_window_compute_position (GdkWindowImplX11   *window,
 	info->x = parent_pos->x + wrapper->x - parent_pos->x11_x;
     }
 
-  if (window->height <= 32768)
+  if (window->height <= 32767)
     {
       info->height = window->height;
       info->y = parent_pos->y + wrapper->y - parent_pos->x11_y;
@@ -428,11 +535,11 @@ gdk_window_compute_position (GdkWindowImplX11   *window,
   else
     {
       info->big = TRUE;
-      info->height = 32768;
+      info->height = 32767;
       if (parent_pos->y + wrapper->y < -16384)
 	{
 	  if (parent_pos->y + wrapper->y + window->height < 16384)
-	    info->y = parent_pos->y + wrapper->y + window->height - 32768 - parent_pos->x11_y;
+	    info->y = parent_pos->y + wrapper->y + window->height - info->height - parent_pos->x11_y;
 	  else
 	    info->y = -16384 - parent_pos->x11_y;
 	}
@@ -576,36 +683,17 @@ gdk_window_premove (GdkWindow          *window,
   
   if (d_xoffset != 0 || d_yoffset != 0)
     {
-      gint new_x0, new_y0, new_x1, new_y1;
+      GdkRectangle new_position;
 
       if (d_xoffset < 0 || d_yoffset < 0)
 	gdk_window_queue_translation (window, MIN (d_xoffset, 0), MIN (d_yoffset, 0));
-	
-      if (d_xoffset < 0)
-	{
-	  new_x0 = impl->position_info.x + d_xoffset;
-	  new_x1 = impl->position_info.x + impl->position_info.width;
-	}
-      else
-	{
-	  new_x0 = impl->position_info.x;
-	  new_x1 = impl->position_info.x + new_info.width + d_xoffset;
-	}
 
-      if (d_yoffset < 0)
-	{
-	  new_y0 = impl->position_info.y + d_yoffset;
-	  new_y1 = impl->position_info.y + impl->position_info.height;
-	}
-      else
-	{
-	  new_y0 = impl->position_info.y;
-	  new_y1 = impl->position_info.y + new_info.height + d_yoffset;
-	}
+      compute_intermediate_position (&impl->position_info, &new_info, d_xoffset, d_yoffset,
+				     &new_position);
 
       XMoveResizeWindow (GDK_DRAWABLE_XDISPLAY (window),
 			 GDK_DRAWABLE_XID (window),
-			 new_x0, new_y0, new_x1 - new_x0, new_y1 - new_y0);
+			 new_position.x, new_position.y, new_position.width, new_position.height);
     }
 
   tmp_list = obj->children;
@@ -818,6 +906,11 @@ gdk_window_clip_changed (GdkWindow *window, GdkRectangle *old_clip, GdkRectangle
   old_clip_region = gdk_region_rectangle (old_clip);
   new_clip_region = gdk_region_rectangle (new_clip);
 
+  /* We need to update this here because gdk_window_invalidate_region makes
+   * use if it (through gdk_drawable_get_visible_region
+   */
+  impl->position_info.clip_rect = *new_clip;
+  
   /* Trim invalid region of window to new clip rectangle
    */
   if (obj->update_area)
@@ -835,4 +928,3 @@ gdk_window_clip_changed (GdkWindow *window, GdkRectangle *old_clip, GdkRectangle
   gdk_region_destroy (new_clip_region);
   gdk_region_destroy (old_clip_region);
 }
-