zmapWindowContainerChildren.c

/*  File: zmapWindowContainerFeatures.c
 *  Author: Roy Storey (rds@sanger.ac.uk)
 *  Copyright (c) 2006-2010: 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: May 24 15:17 2010 (edgrif)
 * Created: Mon Apr 27 18:01:23 2009 (rds)
 * CVS info:   $Id: zmapWindowContainerChildren.c,v 1.5 2010-05-24 14:18:51 edgrif Exp $
 *-------------------------------------------------------------------
 */

#include <ZMap/zmapBase.h>
#include <zmapWindowContainerGroup_I.h>
#include <zmapWindowContainerChildren_I.h>


enum
  {
    OVERLAY_PROP_0,
    OVERLAY_PROP_MAX_WIDTH,
    OVERLAY_PROP_MAX_HEIGHT,
  };

enum
  {
    BACKGROUND_PROP_0,			/* zero is invalid property id */
    BACKGROUND_ORIGINAL_BACKGROUND,
    BACKGROUND_PROP_LAST,
    BACKGROUND_OVERRIDE_WIDTH_PIXELS,
    BACKGROUND_OVERRIDE_WIDTH_UNITS,
  };


static void zmap_window_container_overlay_class_init  (ZMapWindowContainerOverlayClass overlay_class);
static void zmap_window_container_overlay_init        (ZMapWindowContainerOverlay overlay);
static void zmap_window_container_overlay_set_property(GObject               *object, 
						       guint                  param_id,
						       const GValue          *value,
						       GParamSpec            *pspec);
static void zmap_window_container_overlay_get_property(GObject               *object,
						       guint                  param_id,
						       GValue                *value,
						       GParamSpec            *pspec);

static void maximise_child_rectangle_no_update(FooCanvasRE *rectangle, 
					       double ix1, double iy1, 
					       double ix2, double iy2,
					       gboolean in_x, gboolean in_y);
static gboolean invoke_maximise_child_rectangle(GList *item_list,
						double x1, double y1,
						double x2, double y2,
						gboolean in_x,
						gboolean in_y);

static void zmap_window_container_features_class_init  (ZMapWindowContainerFeaturesClass container_class);
static void zmap_window_container_features_init        (ZMapWindowContainerFeatures collection);
static void zmap_window_container_features_set_property(GObject               *object, 
							guint                  param_id,
							const GValue          *value,
							GParamSpec            *pspec);
static void zmap_window_container_features_get_property(GObject               *object,
							guint                  param_id,
							GValue                *value,
							GParamSpec            *pspec);

static void zmap_window_container_underlay_class_init  (ZMapWindowContainerUnderlayClass underlay_class);
static void zmap_window_container_underlay_init        (ZMapWindowContainerUnderlay underlay);
static void zmap_window_container_underlay_set_property(GObject               *object, 
							guint                  param_id,
							const GValue          *value,
							GParamSpec            *pspec);
static void zmap_window_container_underlay_get_property(GObject               *object, 
							guint                  param_id,
							GValue                *value,
							GParamSpec            *pspec);

static void zmap_window_container_background_class_init  (ZMapWindowContainerBackgroundClass background_class);
static void zmap_window_container_background_init        (ZMapWindowContainerBackground background);
static void zmap_window_container_background_set_property(GObject               *object, 
							  guint                  param_id,
							  const GValue          *value,
							  GParamSpec            *pspec);
static void zmap_window_container_background_get_property(GObject               *object,
							  guint                  param_id,
							  GValue                *value,
							  GParamSpec            *pspec);




/* 
 *                     External routines
 */


/* 
 *       Functions for functions within a group.
 * 
 */
GType zmapWindowContainerFeaturesGetType(void)
{
  static GType group_type = 0;

  if (group_type == 0) 
    {
      static const GTypeInfo group_info = {
	sizeof (zmapWindowContainerFeaturesClass),
	(GBaseInitFunc) NULL,
	(GBaseFinalizeFunc) NULL,
	(GClassInitFunc) zmap_window_container_features_class_init,
	NULL,           /* class_finalize */
	NULL,           /* class_data */
	sizeof (zmapWindowContainerFeatures),
	0,              /* n_preallocs */
	(GInstanceInitFunc) zmap_window_container_features_init
      };

      group_type = g_type_register_static (foo_canvas_group_get_type(),
					   ZMAP_WINDOW_CONTAINER_FEATURES_NAME,
					   &group_info,
					   0);
    } /* group_type == 0 */

  return group_type;
}



FooCanvasItem *zmapWindowContainerFeaturesGetNextSibling(FooCanvasItem             *current_item,
							 ZMapContainerItemDirection direction,
							 gboolean                   wrap,
							 zmapWindowContainerItemTestCallback item_test_func_cb,
							 gpointer                            user_data)
{
  FooCanvasItem *next_item = NULL;

  

  return next_item;
}



GType zmapWindowContainerOverlayGetType(void)
{
  static GType group_type = 0;

  if (!group_type) 
    {
      static const GTypeInfo group_info = {
	sizeof (zmapWindowContainerOverlayClass),
	(GBaseInitFunc) NULL,
	(GBaseFinalizeFunc) NULL,
	(GClassInitFunc) zmap_window_container_overlay_class_init,
	NULL,           /* class_finalize */
	NULL,           /* class_data */
	sizeof (zmapWindowContainerOverlay),
	0,              /* n_preallocs */
	(GInstanceInitFunc) zmap_window_container_overlay_init
      };
    
      group_type = g_type_register_static (foo_canvas_group_get_type(),
					   ZMAP_WINDOW_CONTAINER_OVERLAY_NAME,
					   &group_info,
					   0);
    } /* group_type == 0 */
  
  return group_type;
}

gboolean zmapWindowContainerOverlayMaximiseItems(ZMapWindowContainerOverlay overlay,
						 double x1, double y1,
						 double x2, double y2)
{
  gboolean need_update = FALSE;
  FooCanvasGroup *group;
  GList *list;

  group = (FooCanvasGroup *)overlay;

  if((overlay->flags.max_width || overlay->flags.max_height) &&
     (list = g_list_first(group->item_list)))
    {
      need_update = invoke_maximise_child_rectangle(list, x1, y1, x2, y2,
						    overlay->flags.max_width,
						    overlay->flags.max_height);
    }

  return need_update;
}



GType zmapWindowContainerUnderlayGetType(void)
{
  static GType group_type = 0;

  if (!group_type) 
    {
      static const GTypeInfo group_info = {
	sizeof (zmapWindowContainerUnderlayClass),
	(GBaseInitFunc) NULL,
	(GBaseFinalizeFunc) NULL,
	(GClassInitFunc) zmap_window_container_underlay_class_init,
	NULL,           /* class_finalize */
	NULL,           /* class_data */
	sizeof (zmapWindowContainerUnderlay),
	0,              /* n_preallocs */
	(GInstanceInitFunc) zmap_window_container_underlay_init
      };

      group_type = g_type_register_static (FOO_TYPE_CANVAS_GROUP,
					   ZMAP_WINDOW_CONTAINER_UNDERLAY_NAME,
					   &group_info,
					   0);
    } /* group_type == 0 */

  return group_type;
}

gboolean zmapWindowContainerUnderlayMaximiseItems(ZMapWindowContainerUnderlay underlay,
						  double x1, double y1,
						  double x2, double y2)
{
  gboolean need_update = FALSE;
  FooCanvasGroup *group;
  GList *list;

  group = (FooCanvasGroup *)underlay;

  if((underlay->flags.max_width || underlay->flags.max_height) &&
     (list = g_list_first(group->item_list)))
    {
      need_update = invoke_maximise_child_rectangle(list, x1, y1, x2, y2,
						    underlay->flags.max_width,
						    underlay->flags.max_height);
    }

  return need_update;
}




GType zmapWindowContainerBackgroundGetType(void)
{
  static GType group_type = 0;

  if (!group_type) 
    {
      static const GTypeInfo group_info = 
	{
	  sizeof (zmapWindowContainerBackgroundClass),
	  (GBaseInitFunc) NULL,
	  (GBaseFinalizeFunc) NULL,
	  (GClassInitFunc) zmap_window_container_background_class_init,
	  NULL,           /* class_finalize */
	  NULL,           /* class_data */
	  sizeof (zmapWindowContainerBackground),
	  0,              /* n_preallocs */
	  (GInstanceInitFunc) zmap_window_container_background_init
	};

      group_type = g_type_register_static (foo_canvas_rect_get_type(),
					   ZMAP_WINDOW_CONTAINER_BACKGROUND_NAME,
					   &group_info,
					   0);
    } /* group_type == 0 */

  return group_type;
}

void zmapWindowContainerBackgroundSetColour(ZMapWindowContainerBackground background,
					    GdkColor *new_colour)
{
  if(FOO_IS_CANVAS_ITEM(background))
    {
      foo_canvas_item_set((FooCanvasItem *)background,
			  "fill-color-gdk", new_colour,
			  NULL);
    }

  return ;
}

void zmapWindowContainerBackgroundResetColour(ZMapWindowContainerBackground background)
{
  GdkColor *background_colour;

  if(background->has_bg_colour)
    {
      background_colour = &(background->original_colour);
      zmapWindowContainerBackgroundSetColour(background, background_colour);
    }

  return ;
}







/* 
 *                     Internal routines
 */



static void zmap_window_container_features_class_init  (ZMapWindowContainerFeaturesClass container_class)
{
  GObjectClass *gobject_class;
  
  gobject_class = (GObjectClass *) container_class;


#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
  /* Not included yet....is it correct this is here ?? */

  canvas_class->obj_size = sizeof(zmapWindowContainerFeaturesStruct) ;
  canvas_class->obj_total = 0 ;
#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */


  gobject_class->set_property = zmap_window_container_features_set_property;
  gobject_class->get_property = zmap_window_container_features_get_property;
  
  return ;
}

static void zmap_window_container_features_init        (ZMapWindowContainerFeatures collection)
{

  /* nothing to do here... */
  g_object_set_data(G_OBJECT(collection), CONTAINER_TYPE_KEY, GINT_TO_POINTER(CONTAINER_GROUP_FEATURES));

  return ;
}

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

{
  switch(param_id)
    {
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
      break;
    }

  return ;
}

static void zmap_window_container_features_get_property(GObject               *object,
							guint                  param_id,
							GValue                *value,
							GParamSpec            *pspec)
{
  switch(param_id)
    {
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
      break;
    }
  
  return ;
}




static void zmap_window_container_overlay_class_init  (ZMapWindowContainerOverlayClass overlay_class)
{
  GObjectClass *gobject_class;
  
  gobject_class = (GObjectClass *) overlay_class;

  gobject_class->set_property = zmap_window_container_overlay_set_property;
  gobject_class->get_property = zmap_window_container_overlay_get_property;

  g_object_class_install_property(gobject_class, OVERLAY_PROP_MAX_WIDTH,
				  g_param_spec_boolean("maximise-x", "maximise x axis",
						       "Column needs maximising in the x axis",
						       FALSE, ZMAP_PARAM_STATIC_RW));

  g_object_class_install_property(gobject_class, OVERLAY_PROP_MAX_HEIGHT,
				  g_param_spec_boolean("maximise-y", "maximise y axis",
						       "Column needs maximising in the y axis",
						       FALSE, ZMAP_PARAM_STATIC_RW));

  
  return ;
}

static void zmap_window_container_overlay_init        (ZMapWindowContainerOverlay overlay)
{

  g_object_set_data(G_OBJECT(overlay), CONTAINER_TYPE_KEY, GINT_TO_POINTER(CONTAINER_GROUP_OVERLAYS));

  overlay->flags.max_width  = FALSE;
  overlay->flags.max_height = FALSE;

  return ;
}

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

{
  ZMapWindowContainerOverlay overlay;

  overlay = ZMAP_CONTAINER_OVERLAY(object);

  switch(param_id)
    {
    case OVERLAY_PROP_MAX_HEIGHT:
      overlay->flags.max_height = g_value_get_boolean(value);
      break;
    case OVERLAY_PROP_MAX_WIDTH:
      overlay->flags.max_width  = g_value_get_boolean(value);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
      break;
    }

  return ;
}

static void zmap_window_container_overlay_get_property(GObject               *object,
						       guint                  param_id,
						       GValue                *value,
						       GParamSpec            *pspec)
{
  switch(param_id)
    {
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
      break;
    }
  
  return ;
}



static void zmap_window_container_underlay_class_init  (ZMapWindowContainerUnderlayClass underlay_class)
{
  GObjectClass *gobject_class;
  
  gobject_class = (GObjectClass *) underlay_class;

  gobject_class->set_property = zmap_window_container_underlay_set_property;
  gobject_class->get_property = zmap_window_container_underlay_get_property;

  return ;
}

static void zmap_window_container_underlay_init        (ZMapWindowContainerUnderlay underlay)
{

  g_object_set_data(G_OBJECT(underlay), CONTAINER_TYPE_KEY, GINT_TO_POINTER(CONTAINER_GROUP_OVERLAYS));

  return ;
}

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

{
  ZMapWindowContainerUnderlay underlay;

  underlay = ZMAP_CONTAINER_UNDERLAY(object);

  switch(param_id)
    {
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
      break;
    }

  return ;
}

static void zmap_window_container_underlay_get_property(GObject               *object,
							guint                  param_id,
							GValue                *value,
							GParamSpec            *pspec)
{
  switch(param_id)
    {
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
      break;
    }
  
  return ;
}


static void zmap_window_container_background_class_init  (ZMapWindowContainerBackgroundClass background_class)
{
  GObjectClass *gobject_class;
  GParamSpec *param_spec;
  const gchar *override_properties[] = {
    "width_pixels", "width_units", 
    NULL
  };
  const gchar **property;
  guint param_id = BACKGROUND_PROP_LAST;


  gobject_class = (GObjectClass *)background_class;

  gobject_class->get_property = zmap_window_container_background_get_property;
  gobject_class->set_property = zmap_window_container_background_set_property;

  g_object_class_install_property(gobject_class,
				  BACKGROUND_ORIGINAL_BACKGROUND,
				  g_param_spec_boxed ("original-background", NULL, NULL,
						      GDK_TYPE_COLOR,
						      G_PARAM_READWRITE));

  /* replacing zMapDrawBoxSolid() by making border widths unavailable. */

  property = &override_properties[0];

  while(property && *property)
    {
      if((param_spec = g_object_class_find_property(gobject_class, *property)))
	{
	  g_object_class_override_property(gobject_class, param_id, 
					   g_param_spec_get_name(param_spec));
	}
      param_id++;
      property++;
    }

  return ;
}

static void zmap_window_container_background_init        (ZMapWindowContainerBackground collection)
{
  FooCanvasRE *box;

  /* replacing zMapDrawBoxSolid(). i.e. a rectangle with _no_ border */

  box = FOO_CANVAS_RE(collection);

  g_object_set_data(G_OBJECT(collection), CONTAINER_TYPE_KEY, GINT_TO_POINTER(CONTAINER_GROUP_BACKGROUND));
  
  box->width_pixels = FALSE;
  box->width        = 0;

  return ;
}

static void zmap_window_container_background_set_property(GObject               *object, 
							  guint                  param_id,
							  const GValue          *value,
							  GParamSpec            *pspec)
{
  ZMapWindowContainerBackground background;
  FooCanvasRE *box;

  g_return_if_fail(object != NULL);
  g_return_if_fail(ZMAP_IS_CONTAINER_BACKGROUND(object));

  switch(param_id)
    {
    case BACKGROUND_ORIGINAL_BACKGROUND:
      {
	GdkColor *colour;

	if((colour = g_value_get_boxed(value)))
	  {
	    g_object_set(object, "fill-color-gdk", colour, NULL);
	    
	    background = ZMAP_CONTAINER_BACKGROUND(object);
	    
	    background->original_colour = *colour; /* struct copy */
	    background->has_bg_colour   = TRUE;
	  }
      }
      break;
    case BACKGROUND_OVERRIDE_WIDTH_UNITS:
    case BACKGROUND_OVERRIDE_WIDTH_PIXELS:
      {
	box = FOO_CANVAS_RE(object);

	box->width_pixels = FALSE;
	box->width        = 0;
      }
      break;
    case BACKGROUND_PROP_LAST:
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
      break;
    }

  return ;
}

static void zmap_window_container_background_get_property(GObject               *object,
							  guint                  param_id,
							  GValue                *value,
							  GParamSpec            *pspec)
{
  g_return_if_fail(object != NULL);
  g_return_if_fail(ZMAP_IS_CONTAINER_BACKGROUND(object));

  switch(param_id)
    {
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
      break;
    }

  return ;
}


/* The common functions */

static void maximise_child_rectangle_no_update(FooCanvasRE *rectangle,
					       double ix1, double iy1,
					       double ix2, double iy2,
					       gboolean in_x, gboolean in_y)
{
  if(in_x)
    {
      rectangle->x1 = ix1;
      rectangle->x2 = ix2;
    }

  if(in_y)
    {
      rectangle->y1 = iy1;
      rectangle->y2 = iy2;
    }

  return ;
}

static gboolean invoke_maximise_child_rectangle(GList *item_list,
						double x1, double y1,
						double x2, double y2,
						gboolean in_x,
						gboolean in_y)
{
  gboolean need_update = FALSE;
  gboolean maximise_non_rectangles = FALSE;	/* setting to true will require extra work! */
  
  do
    {
      /* We only maximise rectangles... Didn't I say that. */
      if(FOO_IS_CANVAS_RE(item_list->data))
	{
	  maximise_child_rectangle_no_update((FooCanvasRE *)(item_list->data),
					     x1, y1, x2, y2,
					     in_x, in_y);
	  need_update = TRUE;
	}
      else if(maximise_non_rectangles)
	{
	  double nx1, ny1, nx2, ny2; /* new coords */
	  
	  foo_canvas_item_get_bounds((FooCanvasItem *)(item_list->data),
				     &nx1, &ny1, &nx2, &ny2);
	  
	  if(in_x)
	    {
	      nx1 = x1;
	      nx2 = x2;
	    }
	  if(in_y)
	    {
	      ny1 = y1;
	      ny2 = y2;
	    }
	  
	  /* This won't work for items that don't have x1,x2,y1,y2 properties! */
	  foo_canvas_item_set((FooCanvasItem *)(item_list->data),
			      "x1", nx1, "y1", ny1,
			      "x2", nx2, "y2", ny2,
			      NULL);
	}
    }
  while((item_list = item_list->next));
  
  return need_update;
}