zmapWindowContainerGroup.c

/*  File: zmapWindowContainerGroup.c
 *  Author: Roy Storey (rds@sanger.ac.uk)
 *  Copyright (c) 2008: Genome Research Ltd.
 *-------------------------------------------------------------------
 * ZMap is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 * or see the on-line version at http://www.gnu.org/copyleft/gpl.txt
 *-------------------------------------------------------------------
 * This file is part of the ZMap genome database package
 * originally written by:
 *
 * 	Ed Griffiths (Sanger Institute, UK) edgrif@sanger.ac.uk,
 *      Roy Storey (Sanger Institute, UK) rds@sanger.ac.uk
 *
 * Description: 
 *
 * Exported functions: See XXXXXXXXXXXXX.h
 * HISTORY:
 * Last edited: Jun  3 22:00 2009 (rds)
 * Created: Wed Dec  3 10:02:22 2008 (rds)
 * CVS info:   $Id: zmapWindowContainerGroup.c,v 1.2 2009-06-03 22:29:08 rds Exp $
 *-------------------------------------------------------------------
 */

#include <zmapWindowCanvas.h>
#include <zmapWindowContainerGroup_I.h>
#include <zmapWindowContainerChildren_I.h>
#include <zmapWindowContainerUtils.h>
#include <zmapWindow_P.h>	/* ITEM_FEATURE_DATA, ITEM_FEATURE_TYPE */
#include <math.h>

enum
  {
    CONTAINER_PROP_0,		/* zero is invalid */
    CONTAINER_PROP_VISIBLE,
    CONTAINER_PROP_COLUMN_REDRAW,
  };


typedef struct
{
  ZMapWindowContainerUpdateHook hook_func;
  gpointer                      hook_data;
} ContainerUpdateHookStruct, *ContainerUpdateHook;


static void zmap_window_container_group_class_init  (ZMapWindowContainerGroupClass container_class);
static void zmap_window_container_group_init        (ZMapWindowContainerGroup      group);
static void zmap_window_container_group_set_property(GObject               *object, 
						     guint                  param_id,
						     const GValue          *value,
						     GParamSpec            *pspec);
static void zmap_window_container_group_get_property(GObject               *object,
						     guint                  param_id,
						     GValue                *value,
						     GParamSpec            *pspec);
static void zmap_window_container_group_destroy     (GObject *object);


static void zmap_window_container_group_draw (FooCanvasItem *item, GdkDrawable *drawable,
					      GdkEventExpose *expose);
static void zmap_window_container_group_update (FooCanvasItem *item, double i2w_dx, double i2w_dy, int flags);
static void zmap_window_container_group_reposition(ZMapWindowContainerGroup container_group, 
						   double rect_x1,   double rect_y1,
						   double rect_x2,   double rect_y2,
						   double *dx_repos, double *dy_repos);

static void maximise_background_rectangle(ZMapWindowContainerGroup this_container, 
					  FooCanvasItem           *container_item,
					  FooCanvasRE             *rect);
static void crop_rectangle_to_scroll_region(gpointer rectangle_data, gpointer points_data);
static void zmap_window_container_scroll_region_get_item_bounds(FooCanvasItem *item,
								double *x1, double *y1,
								double *x2, double *y2);
static void zmap_window_container_update_with_crop(FooCanvasItem *item, 
						   double i2w_dx, double i2w_dy,
						   FooCanvasPoints *itemised_scroll_region,
						   int flags);
static void zmap_window_container_invoke_update_hooks(ZMapWindowContainerGroup container,
						      double x1, double y1, double x2, double y2);
static gint find_update_hook_cb(gconstpointer list_data, gconstpointer query_data);


#ifdef NO_NEED
static FooCanvasGroupClass *group_parent_class_G = NULL;
#endif
static FooCanvasItemClass  *item_parent_class_G  = NULL;


GType zmapWindowContainerGroupGetType(void)
{
  static GType group_type = 0;
  
  if (!group_type) {
    static const GTypeInfo group_info = 
      {
	sizeof (zmapWindowContainerGroupClass),
	(GBaseInitFunc) NULL,
	(GBaseFinalizeFunc) NULL,
	(GClassInitFunc) zmap_window_container_group_class_init,
	NULL,           /* class_finalize */
	NULL,           /* class_data */
	sizeof (zmapWindowContainerGroup),
	0,              /* n_preallocs */
	(GInstanceInitFunc) zmap_window_container_group_init
	
      };
    
    group_type = g_type_register_static (FOO_TYPE_CANVAS_GROUP,
					 ZMAP_WINDOW_CONTAINER_GROUP_NAME,
					 &group_info,
					 0);
  }
  
  return group_type;
}


ZMapWindowContainerGroup zmapWindowContainerGroupCreate(FooCanvasGroup        *parent,
							ZMapContainerLevelType level,
							double                 child_spacing,
							GdkColor              *background_fill_colour,
							GdkColor              *background_border_colour)
{
  ZMapWindowContainerGroup container  = NULL;
  ZMapWindowContainerGroup parent_container  = NULL;
  FooCanvasItem *features   = NULL;
  FooCanvasItem *overlay    = NULL;
  FooCanvasItem *underlay   = NULL;
  FooCanvasItem *background = NULL;
  FooCanvasItem *item;
  FooCanvasGroup *group;
  GType container_type;
  double this_spacing = 200.0;

  if(ZMAP_IS_CONTAINER_GROUP(parent))
    {
      zMapAssertNotReached();
      
      parent = (FooCanvasGroup *)zmapWindowContainerGetFeatures((ZMapWindowContainerGroup)parent);
    }
  else
    {
      if((parent_container = (ZMapWindowContainerGroup)(((FooCanvasItem *)parent)->parent)))
	{
	  this_spacing     = parent_container->child_spacing;
	  level            = parent_container->level + 1;
	}
    }
  
  container_type = ZMAP_TYPE_CONTAINER_GROUP;
  
  switch(level)
    {
    case ZMAPCONTAINER_LEVEL_ROOT:
      container_type = ZMAP_TYPE_CONTAINER_CONTEXT;
      break;
    case ZMAPCONTAINER_LEVEL_ALIGN:
      container_type = ZMAP_TYPE_CONTAINER_ALIGNMENT;
      break;
    case ZMAPCONTAINER_LEVEL_BLOCK:
      container_type = ZMAP_TYPE_CONTAINER_BLOCK;
      break;
    case ZMAPCONTAINER_LEVEL_STRAND:
      container_type = ZMAP_TYPE_CONTAINER_STRAND;
      break;
    case ZMAPCONTAINER_LEVEL_FEATURESET:
      container_type = ZMAP_TYPE_CONTAINER_FEATURESET;
      break;
    default:
      container_type = ZMAP_TYPE_CONTAINER_GROUP;
      break;
    }

  item = foo_canvas_item_new(parent, container_type, 
			     "x", 0.0,
			     "y", 0.0,
			     NULL);
      
  if(item && ZMAP_IS_CONTAINER_GROUP(item))
    {
      group     = FOO_CANVAS_GROUP(item);
      container = ZMAP_CONTAINER_GROUP(item);
      container->level         = level;	/* level */
      container->child_spacing = child_spacing;
      container->this_spacing  = this_spacing;
      container->flags.column_redraw = FALSE;

      background = foo_canvas_item_new(group, ZMAP_TYPE_CONTAINER_BACKGROUND,
				       "original-background", background_fill_colour,
				       NULL);

      underlay   = foo_canvas_item_new(group, ZMAP_TYPE_CONTAINER_UNDERLAY, NULL);

      features   = foo_canvas_item_new(group, ZMAP_TYPE_CONTAINER_FEATURES, NULL);

      overlay    = foo_canvas_item_new(group, ZMAP_TYPE_CONTAINER_OVERLAY,  NULL);

    }
  
  return container;
}


/* Currently this function only works with columns, but the intention
 * is that it could work with blocks and aligns too at some later
 * point in time... */
gboolean zmapWindowContainerSetVisibility(FooCanvasGroup *container_parent, gboolean visible)
{
  gboolean setable = FALSE;     /* Most columns aren't */

  /* We make sure that the container_parent is 
   * - A parent
   * - Is a featureset... This is probably a limit too far.
   */
  if(ZMAP_IS_CONTAINER_GROUP(container_parent))
    {
      if(visible)
	foo_canvas_item_show((FooCanvasItem *)container_parent);
      else
	foo_canvas_item_hide((FooCanvasItem *)container_parent);

      setable = TRUE;
    }

  return setable ;
}

void zmapWindowContainerRequestReposition(ZMapWindowContainerGroup container)
{
  ZMapWindowContainerGroup context_container;

  context_container = zmapWindowContainerUtilsGetParentLevel(container, ZMAPCONTAINER_LEVEL_ROOT);

  if(context_container)
    {
      g_object_set(G_OBJECT(context_container),
		   "need-reposition", TRUE,
		   NULL);
    }

  return ;
}

void zmapWindowContainerGroupBackgroundSize(ZMapWindowContainerGroup container, double height)
{
  container->height = height;

  return ;
}

void zmapWindowContainerGroupChildRedrawRequired(ZMapWindowContainerGroup container, 
						 gboolean redraw_required)
{
  container->flags.column_redraw = redraw_required;

  return ;
}

void zmapWindowContainerGroupSetBackgroundColour(ZMapWindowContainerGroup container,
						 GdkColor *new_colour)
{
  ZMapWindowContainerBackground background;

  if((background = zmapWindowContainerGetBackground(container)))
    zmapWindowContainerBackgroundSetColour(background, new_colour);

  return ;
}

void zmapWindowContainerGroupResetBackgroundColour(ZMapWindowContainerGroup container)
{
  ZMapWindowContainerBackground background;

  if((background = zmapWindowContainerGetBackground(container)))
    zmapWindowContainerBackgroundResetColour(background);

  return ;
}

void zmapWindowContainerGroupAddUpdateHook(ZMapWindowContainerGroup container,
					   ZMapWindowContainerUpdateHook hook,
					   gpointer user_data)
{
  ContainerUpdateHook update_hook = NULL;

  if((update_hook = g_new0(ContainerUpdateHookStruct, 1)))
    {
      update_hook->hook_func = hook;
      update_hook->hook_data = user_data;

      container->update_hooks = g_slist_append(container->update_hooks, 
					       update_hook);
    }

  return ;
}

void zmapWindowContainerGroupRemoveUpdateHook(ZMapWindowContainerGroup container,
					      ZMapWindowContainerUpdateHook hook,
					      gpointer user_data)
{
  ContainerUpdateHookStruct update_hook = {NULL};
  GSList *slist = NULL;

  update_hook.hook_func = hook;
  update_hook.hook_data = user_data;

  if((slist = g_slist_find_custom(container->update_hooks,
				  &update_hook,
				  find_update_hook_cb)))
    {
      g_free(slist->data);
      container->update_hooks = g_slist_remove(container->update_hooks, slist->data);
    }
}

ZMapWindowContainerGroup zmapWindowContainerGroupDestroy(ZMapWindowContainerGroup container)
{
  g_object_unref(G_OBJECT(container));

  container = NULL;

  return container;
}















/* object impl */
static void zmap_window_container_group_class_init  (ZMapWindowContainerGroupClass container_class)
{
  ZMapWindowContainerGroupClass canvas_class;
  FooCanvasItemClass *item_class;
  GObjectClass *gobject_class;
  GParamSpec *param_spec;

  gobject_class = (GObjectClass *) container_class;
  canvas_class  = (ZMapWindowContainerGroupClass)container_class;
  item_class    = (FooCanvasItemClass *)container_class;

  gobject_class->set_property = zmap_window_container_group_set_property;
  gobject_class->get_property = zmap_window_container_group_get_property;

  if((param_spec = g_object_class_find_property(gobject_class, "visible")))
    {
      g_object_class_override_property(gobject_class, CONTAINER_PROP_VISIBLE,
				       g_param_spec_get_name(param_spec));
    }

  g_object_class_install_property(gobject_class, CONTAINER_PROP_COLUMN_REDRAW,
				  g_param_spec_boolean("column-redraw", "column redraw",
						       "Column needs redrawing when zoom changes",
						       FALSE, ZMAP_PARAM_STATIC_RW));

  item_parent_class_G  = (FooCanvasItemClass *)(g_type_class_peek_parent(container_class));

  zMapAssert(item_parent_class_G);
  zMapAssert(item_parent_class_G->update);

  item_class->draw     = zmap_window_container_group_draw;
  item_class->update   = zmap_window_container_group_update;

  container_class->reposition_group = zmap_window_container_group_reposition;

  gobject_class->dispose = zmap_window_container_group_destroy;

  return ;
}

static void zmap_window_container_group_init        (ZMapWindowContainerGroup container)
{

  g_object_set_data(G_OBJECT(container), CONTAINER_TYPE_KEY, GINT_TO_POINTER(CONTAINER_GROUP_PARENT));

  return ;
}

static void zmap_window_container_group_set_property(GObject               *object, 
						     guint                  param_id,
						     const GValue          *value,
						     GParamSpec            *pspec)

{
  ZMapWindowContainerGroup container;

  g_return_if_fail(ZMAP_IS_CONTAINER_GROUP(object));

  container = ZMAP_CONTAINER_GROUP(object);

  switch(param_id)
    {
    case CONTAINER_PROP_VISIBLE:
      {
	gboolean visible = FALSE;

	visible = g_value_get_boolean(value);
	switch(container->level)
	  {
	  case ZMAPCONTAINER_LEVEL_FEATURESET:
	    if(visible)
	      {
		foo_canvas_item_show(FOO_CANVAS_ITEM(object));
	      }
	    else
	      {
		foo_canvas_item_hide(FOO_CANVAS_ITEM(object));
	      }
	    break;
	  default:
	    break;
	  } /* switch(container->level) */
      }
      break;
    case CONTAINER_PROP_COLUMN_REDRAW:
      {
	switch(container->level)
	  {
	  case ZMAPCONTAINER_LEVEL_FEATURESET:
	    container->flags.column_redraw = g_value_get_boolean(value);
	    break;
	  default:
	    break;
	  } /* switch(container->level) */
      }
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
      break;
    } /* switch(param_id) */

  return ;
}

static void zmap_window_container_group_get_property(GObject               *object,
						     guint                  param_id,
						     GValue                *value,
						     GParamSpec            *pspec)
{

  switch(param_id)
    {
    case CONTAINER_PROP_VISIBLE:
      {
	FooCanvasItem *item;
	item = FOO_CANVAS_ITEM(object);
	g_value_set_boolean (value, item->object.flags & FOO_CANVAS_ITEM_VISIBLE);
      }
      break;
    case CONTAINER_PROP_COLUMN_REDRAW:
      {
	ZMapWindowContainerGroup container;

	container = ZMAP_CONTAINER_GROUP(object);

	switch(container->level)
	  {
	  case ZMAPCONTAINER_LEVEL_FEATURESET:
	    g_value_set_boolean(value, container->flags.column_redraw);
	    break;
	  default:
	    break;
	  } /* switch(container->level) */
      }
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
      break;
    } /* switch(param_id) */

  return ;
}
#ifdef POINT_REQUIRED
static double window_container_group_invoke_point (FooCanvasItem *item, 
						      double x, double y, 
						      int cx, int cy,
						      FooCanvasItem **actual_item)
{
  /* Calculate x & y in item local coordinates */
  
  if (FOO_CANVAS_ITEM_GET_CLASS (item)->point)
    return FOO_CANVAS_ITEM_GET_CLASS (item)->point (item, x, y, cx, cy, actual_item);
  
  return 1e18;
}


/* Point handler for canvas groups */
static double zmap_window_container_group_item_point (FooCanvasItem *item, 
						      double x,  double y, 
						      int    cx, int    cy,
						      FooCanvasItem **actual_item)
{
  FooCanvasGroup *group;
  FooCanvasItem *child, *point_item;
  GList *list = NULL;
  int x1, y1, x2, y2;
  double gx, gy;
  double dist, best;

  group = FOO_CANVAS_GROUP (item);
  
  x1 = cx - item->canvas->close_enough;
  y1 = cy - item->canvas->close_enough;
  x2 = cx + item->canvas->close_enough;
  y2 = cy + item->canvas->close_enough;
  
  best = 0.0;
  *actual_item = NULL;
  
  gx = x - group->xpos;
  gy = y - group->ypos;

  dist = 0.0; /* keep gcc happy */

  list = group->item_list;

  while(list)
    {
      child = list->data;

      if ((child->object.flags & FOO_CANVAS_ITEM_MAPPED)
	  && FOO_CANVAS_ITEM_GET_CLASS (child)->point) 
	{
	  dist = window_container_group_invoke_point (child, gx, gy, cx, cy, &point_item);
	  if(point_item && ((int)(dist * item->canvas->pixels_per_unit_x + 0.5) <= item->canvas->close_enough) &&
	     (dist <= best))
	    {
	      best = dist;
	      *actual_item = point_item;
	    }
	} 
      list = list->next;
    }
  
  if(actual_item == NULL && item_parent_class_G->point)
    best = (item_parent_class_G->point)(item, x, y, cx, cy, actual_item);

  return best;
}
#endif

static void zmap_window_container_group_destroy     (GObject *object)
{
  ZMapWindowContainerGroup container;
  GObjectClass *object_class;

  object_class = (GObjectClass *)item_parent_class_G;
  container = (ZMapWindowContainerGroup)object;

  
  g_slist_foreach(container->update_hooks, (GFunc)g_free, NULL);
  g_slist_free(container->update_hooks);
  container->update_hooks = NULL;

  if(object_class->dispose)
    (object_class->dispose)(object);

  return ;
}


static void zmap_window_container_group_draw (FooCanvasItem *item, GdkDrawable *drawable,
					      GdkEventExpose *expose)
{
  if(item_parent_class_G->draw)
    (item_parent_class_G->draw)(item, drawable, expose);

  return ;
}

static void maximise_background_rectangle(ZMapWindowContainerGroup this_container, 
					  FooCanvasItem           *container_item,
					  FooCanvasRE             *rect)
{
  FooCanvasItem *rect_item;
  double irx1, irx2, iry1, iry2;
  int container_x2, container_y2; /* container canvas coords, calculated from group->update above. */
  
  irx1 = iry1 = 0.0;	/* placed @ 0,0 */
  
  /* We can't trust item->x1 and item->y1 as empty child
   * groups return 0,0->0,0 hence extend all parents to
   * 0,0! */
  container_x2 = (int)(container_item->x2);
  container_y2 = (int)(container_item->y2);

  rect_item = (FooCanvasItem *)rect; /*  */

  foo_canvas_item_i2w(rect_item, &irx1, &iry1);
  foo_canvas_c2w(rect_item->canvas, container_x2, container_y2, &irx2, &iry2);

  if((iry2 - iry1 + 1) < this_container->height)
    iry2 = this_container->height + iry1;
  
  rect->x1 = irx1;
  rect->y1 = iry1;
  rect->x2 = irx2;
  rect->y2 = iry2;

  if(rect->x1 == rect->x2)
    rect->x2 = rect->x1 + this_container->this_spacing;

  foo_canvas_item_w2i(rect_item, &(rect->x1), &(rect->y1));
  foo_canvas_item_w2i(rect_item, &(rect->x2), &(rect->y2));

  /* rect->x1 & rect->y1 should == 0.0 */

  return ;
}

static void crop_rectangle_to_scroll_region(gpointer rectangle_data, gpointer points_data)
{
  FooCanvasRE *rect;
  FooCanvas *foo_canvas;
  FooCanvasItem *crop_item;
  FooCanvasPoints *scroll_region = (FooCanvasPoints *)points_data;
  double scroll_x1, scroll_y1, scroll_x2, scroll_y2;
  double iwx1, iwy1, iwx2, iwy2;
  
  rect       = (FooCanvasRE *)rectangle_data;
  crop_item  = (FooCanvasItem *)rect;
  foo_canvas = crop_item->canvas;

  iwx1 = rect->x1;
  iwy1 = rect->y1;
  iwx2 = rect->x2;
  iwy2 = rect->y2;
  
  if((scroll_region == NULL))
    {
      /* x unused ATM */
      scroll_x1 = foo_canvas->scroll_x1;
      scroll_x2 = foo_canvas->scroll_x2;
      
      scroll_y1 = foo_canvas->scroll_y1;
      scroll_y2 = foo_canvas->scroll_y2;
      
      foo_canvas_item_w2i(crop_item, &scroll_x1, &scroll_y1);
      foo_canvas_item_w2i(crop_item, &scroll_x2, &scroll_y2);
    }
  else
    {
      scroll_x1 = scroll_region->coords[0];
      scroll_y1 = scroll_region->coords[1];
      scroll_x2 = scroll_region->coords[2];
      scroll_y2 = scroll_region->coords[3];
    }

  if (!(iwy2 < scroll_y1) && !(iwy1 > scroll_y2) && ((iwy1 < scroll_y1) || (iwy2 > scroll_y2)))
    {
      if(iwy1 < scroll_y1)
	{
	  rect->y1 = scroll_y1 - 1.0;
	}
      
      if(iwy2 > scroll_y2)
	{
	  rect->y2 = scroll_y2 + 1.0;
	}
    }

  return ;
}

static void zmap_window_container_scroll_region_get_item_bounds(FooCanvasItem *item,
								double *x1, double *y1,
								double *x2, double *y2)
{
  FooCanvas *foo_canvas;
  double scroll_x1, scroll_y1, scroll_x2, scroll_y2;

  foo_canvas = item->canvas;

  scroll_x1 = foo_canvas->scroll_x1;
  scroll_x2 = foo_canvas->scroll_x2;

  scroll_y1 = foo_canvas->scroll_y1;
  scroll_y2 = foo_canvas->scroll_y2;
  
  foo_canvas_item_w2i(item, &scroll_x1, &scroll_y1);
  foo_canvas_item_w2i(item, &scroll_x2, &scroll_y2);
  
  if(x1)
    *x1 = scroll_x1;
  if(y1)
    *y1 = scroll_y1;
  if(x2)
    *x2 = scroll_x2;
  if(y2)
    *y2 = scroll_y2;

  return ;
}

/* container update flags */
enum
  {
    CONTAINER_UPDATE_CROP_REQUIRED = 1 << 3,
  };

static void zmap_window_container_update_with_crop(FooCanvasItem *item, 
						   double i2w_dx, double i2w_dy,
						   FooCanvasPoints *itemised_scroll_region,
						   int flags)
{
  if(FOO_IS_CANVAS_GROUP(item))
    {
      FooCanvasGroup *group;
      GList *list;

      group = (FooCanvasGroup *)item;

      if((list = group->item_list))
	{
	  double sub_i2w_dx, sub_i2w_dy;

	  sub_i2w_dx = i2w_dx + group->xpos;
	  sub_i2w_dy = i2w_dx + group->ypos;

	  itemised_scroll_region->coords[0] -= group->xpos;
	  itemised_scroll_region->coords[1] -= group->ypos;
	  itemised_scroll_region->coords[2] -= group->xpos;
	  itemised_scroll_region->coords[3] -= group->ypos;

	  do
	    {
	      zmap_window_container_update_with_crop((FooCanvasItem *)(list->data), 
						     sub_i2w_dx, sub_i2w_dy,
						     itemised_scroll_region, flags);
	    }
	  while((list = list->next));

	  itemised_scroll_region->coords[0] += group->xpos;
	  itemised_scroll_region->coords[1] += group->ypos;
	  itemised_scroll_region->coords[2] += group->xpos;
	  itemised_scroll_region->coords[3] += group->ypos;

	}
    }
  else if(flags & CONTAINER_UPDATE_CROP_REQUIRED)
    {
      if(FOO_IS_CANVAS_RE(item))
	crop_rectangle_to_scroll_region((FooCanvasRE *)item, NULL);
    }

  if(FOO_CANVAS_ITEM_GET_CLASS(item)->update)
    (FOO_CANVAS_ITEM_GET_CLASS(item)->update)(item, i2w_dx, i2w_dy, flags);

  return ;
}

static void zmap_window_container_invoke_update_hooks(ZMapWindowContainerGroup container,
						      double x1, double y1, double x2, double y2)
{
  if(container->update_hooks)
    {
      FooCanvasPoints bounds;
      double coords[4] = {0.0};
      GSList *hooks;
      
      hooks = container->update_hooks;

      coords[0] = x1;
      coords[1] = y1;
      coords[2] = x2;
      coords[3] = y2;
      
      bounds.coords     = &coords[0];
      bounds.ref_count  = 1;
      bounds.num_points = 2;
      
      do
	{
	  ContainerUpdateHook update_hook;
	  
	  update_hook = (ContainerUpdateHook)(hooks->data);
	  
	  if(update_hook->hook_func)
	    (update_hook->hook_func)(container, &bounds, container->level, update_hook->hook_data);
	}
      while((hooks = hooks->next));
    }

  return ;
}

/* This takes care of the x positioning of the containers as well as the maximising in the y coords. */
static void zmap_window_container_group_update (FooCanvasItem *item, double i2w_dx, double i2w_dy, int flags)
{
  ZMapWindowContainerGroup   this_container = NULL;
  ZMapWindowContainerGroup parent_container = NULL;
  ZMapWindowContainerOverlay   overlay = NULL;
  ZMapWindowContainerUnderlay underlay = NULL;
  FooCanvasRE *rect = NULL;
  FooCanvasItem *parent_parent = NULL;
  FooCanvasGroup *canvas_group;
  GList *item_list;
  double current_x = 0.0;
  double current_y = 0.0;
  gboolean item_visible;
  gboolean doing_reposition;
  gboolean need_cropping;
  gboolean add_strand_border = FALSE;

  canvas_group   = (FooCanvasGroup *)item;
  item_visible   = ((item->object.flags & FOO_CANVAS_ITEM_VISIBLE) == FOO_CANVAS_ITEM_VISIBLE);

  this_container = (ZMapWindowContainerGroup)item;
  this_container->reposition_x = current_x;
  this_container->reposition_y = current_y;

  /* This was in the previous version of the code, copying across... */
  if(add_strand_border && this_container->level == ZMAPCONTAINER_LEVEL_STRAND)
    this_container->reposition_x += this_container->child_spacing;

  if(item->parent && (parent_parent = item->parent->parent))
    {
      parent_container = (ZMapWindowContainerGroup)parent_parent;
#ifdef ACTUALLY_FLAGS_SUBVERSION_IS_BETTER
      /* we could subvert flags parameter, but this is slightly
       * better.  Needs to be propgated through the tree. */
      if(!this_container->flags.need_reposition)
	this_container->flags.need_reposition = parent_container->flags.need_reposition;

      this_container->flags.need_cropping = parent_container->flags.need_cropping;
#endif
      current_x = parent_container->reposition_x;
      current_y = parent_container->reposition_y;
    }

  doing_reposition = ((flags & ZMAP_CANVAS_UPDATE_NEED_REPOSITION) == ZMAP_CANVAS_UPDATE_NEED_REPOSITION);
  need_cropping    = ((flags & ZMAP_CANVAS_UPDATE_CROP_REQUIRED)   == ZMAP_CANVAS_UPDATE_CROP_REQUIRED);

  if(doing_reposition)
    {
      GList *list, *list_end, tmp_features = {NULL}, tmp_background = {NULL}; 
      gboolean print_debug = FALSE;

      if((item_list = canvas_group->item_list))
	{
	  /* reposition immediate descendants (features, background overlay, underlay) */
	  do
	    {
	      if(FOO_IS_CANVAS_GROUP(item_list->data))
		{
		  FooCanvasGroup *group = (FooCanvasGroup *)(item_list->data);
		  
		  if(group->xpos != 0.0)
		    group->xpos = 0.0;
		  if(group->ypos != 0.0)
		    group->ypos = 0.0;
		  
		  if(ZMAP_IS_CONTAINER_OVERLAY(item_list->data))
		    overlay = (ZMapWindowContainerOverlay)(item_list->data);
		  else if(ZMAP_IS_CONTAINER_UNDERLAY(item_list->data))
		    underlay = (ZMapWindowContainerUnderlay)(item_list->data);
		}
	      else if(ZMAP_IS_CONTAINER_BACKGROUND(item_list->data))
		{
		  rect = FOO_CANVAS_RE(item_list->data);
		  
		  if(rect->x1 != 0.0)
		    rect->x1 = 0.0;
		  if(rect->y1 != 0.0)
		    rect->y1 = 0.0;
		  
		  rect->x2 = 1.0;	/* There's no way to know width */
		  rect->y2 = this_container->height; /* We know height though. */
		}
	      /* no recursion here... */
	    }
	  while((item_list = item_list->next));
	}


      if(print_debug)
	{
	  switch(this_container->level)
	    {
	    case ZMAPCONTAINER_LEVEL_ROOT:       printf("context: ");    break;
	    case ZMAPCONTAINER_LEVEL_ALIGN:      printf("align: ");      break;
	    case ZMAPCONTAINER_LEVEL_BLOCK:      printf("block: ");      break;
	    case ZMAPCONTAINER_LEVEL_STRAND:     printf("strand: ");     break;
	    case ZMAPCONTAINER_LEVEL_FEATURESET: printf("featureset: "); break;
	    default:
	      break;
	    }
	  
	  printf("current_x=%f, current_y=%f\n", current_x, current_y);
	}

      if(item_visible)
	{
	  FooCanvasGroup *real_group;

	  real_group       = (FooCanvasGroup *)this_container;

	  /* There's _no_ need to use group->translate, nor move by dx,dy. Just set the positions */
	  real_group->xpos = current_x;
	  /* We don't do y at the moment. no real idea what should happen here. */
	  /* real_group->ypos = current_y; */
	}

      /* We _only_ update the background and features at this time. Underlays and overlays will get done later */
      tmp_background.next = &tmp_features;
      tmp_background.data = zmapWindowContainerGetBackground(this_container);
      tmp_background.prev = NULL;

      tmp_features.next = NULL;
      tmp_features.data = zmapWindowContainerGetFeatures(this_container);
      tmp_features.prev = &tmp_background;

      list     = canvas_group->item_list;
      list_end = canvas_group->item_list_end;

      canvas_group->item_list     = &tmp_background;
      canvas_group->item_list_end = &tmp_features;

      (item_parent_class_G->update)(item, i2w_dx, i2w_dy, flags);

      canvas_group->item_list     = list;
      canvas_group->item_list_end = list_end;

    }
  else
    {
      (item_parent_class_G->update)(item, i2w_dx, i2w_dy, flags);
    }

  if(rect && item_visible)
    {
      gboolean need_2nd_update = TRUE;

      if(doing_reposition)
	{
	  maximise_background_rectangle(this_container, item, rect);

	  /* Update the current reposition_x, and reposition_y coords */
	  if(parent_container)
	    {
	      double dx, dy;
	      
	      if(ZMAP_CONTAINER_GROUP_GET_CLASS(this_container)->reposition_group)
		(ZMAP_CONTAINER_GROUP_GET_CLASS(this_container)->reposition_group)(this_container, 
										   rect->x1, rect->y1, 
										   rect->x2, rect->y2, 
										   &dx, &dy);
	      
	      parent_container->reposition_x += dx;
	      parent_container->reposition_y += dy;
	    }

	  zmap_window_container_invoke_update_hooks(this_container, 
						    rect->x1, rect->y1,
						    rect->x2, rect->y2);
	}

      /* The background needs updating now so that the canvas knows
       * where it is (canvas coords) for events. We are only setting
       * the points to match the containers bounds or within so no
       * need to re-update the whole tree...phew... */
      if(need_2nd_update || need_cropping)
	{
	  FooCanvasItem *update_items[3] = {NULL};
	  FooCanvasPoints scroll_region;
	  double coords[4];
	  int i = 0, update_flags = flags;

	  i2w_dx += canvas_group->xpos;
	  i2w_dy += canvas_group->ypos;

	  update_items[i++] = (FooCanvasItem *)rect;
	  update_items[i++] = (FooCanvasItem *)overlay;
	  update_items[i++] = (FooCanvasItem *)underlay;

	  if(need_cropping)
	    update_flags |= CONTAINER_UPDATE_CROP_REQUIRED;