/* File: zmapWindowCollectionFeature.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: Apr 28 09:50 2010 (edgrif)
* Created: Wed Dec 3 10:02:22 2008 (rds)
* CVS info: $Id: zmapWindowCollectionFeature.c,v 1.26 2010-05-19 15:21:04 mh17 Exp $
*-------------------------------------------------------------------
*/
#include <math.h>
#include <glib.h>
#include <zmapWindowCollectionFeature_I.h>
typedef enum {FIRST_MATCH, LAST_MATCH} MatchType ;
typedef struct
{
ZMapWindowCanvasItem parent;
FooCanvasGroup *new_parent;
double x, y;
} ParentPositionStruct, *ParentPosition;
typedef struct
{
ZMapWindowCanvasItem parent;
FooCanvasItem *previous;
ZMapFeature prev_feature;
GdkColor perfect;
GdkColor colinear;
GdkColor non_colinear;
double x;
ZMapFeatureCompareFunc compare_func;
gpointer compare_data;
} ColinearMarkerDataStruct, *ColinearMarkerData;
static void zmap_window_collection_feature_class_init (ZMapWindowCollectionFeatureClass collection_class);
static void zmap_window_collection_feature_init (ZMapWindowCollectionFeature group);
static void zmap_window_collection_feature_set_property(GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec);
static void zmap_window_collection_feature_get_property(GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec);
static void zmap_window_collection_feature_destroy (GObject *object);
static double zmap_window_collection_feature_item_point (FooCanvasItem *item, double x, double y, int cx, int cy,
FooCanvasItem **actual_item);
static FooCanvasItem *zmap_window_collection_feature_add_interval(ZMapWindowCanvasItem collection,
ZMapFeatureSubPartSpan unused,
double top, double bottom,
double left, double right);
static ZMapFeatureTypeStyle zmap_window_collection_feature_get_style(ZMapWindowCanvasItem canvas_item);
static ZMapFeatureTypeStyle get_sub_feature_style(ZMapWindowCanvasItem canvas_item,GQuark id);
/* Accessory functions, some from foo-canvas.c */
static double get_glyph_mid_point(FooCanvasItem *item);
static void group_remove(gpointer data, gpointer user_data);
static void add_colinear_lines(gpointer data, gpointer user_data);
static void markMatchIfIncomplete(ZMapWindowCanvasItem collection,
ZMapStrand ref_strand, MatchType match_type,
FooCanvasItem *item, ZMapFeature feature) ;
static gboolean fragments_splice(char *fragment_a, char *fragment_b);
static void process_feature(ZMapFeature prev_feature);
static ZMapWindowCanvasItemClass canvas_parent_class_G = NULL;
static FooCanvasItemClass *item_parent_class_G = NULL;
GType zMapWindowCollectionFeatureGetType(void)
{
static GType group_type = 0;
if (!group_type) {
static const GTypeInfo group_info = {
sizeof (zmapWindowCollectionFeatureClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) zmap_window_collection_feature_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (zmapWindowCollectionFeature),
0, /* n_preallocs */
(GInstanceInitFunc) zmap_window_collection_feature_init
};
group_type = g_type_register_static (zMapWindowCanvasItemGetType(),
ZMAP_WINDOW_COLLECTION_FEATURE_NAME,
&group_info,
0);
}
return group_type;
}
ZMapWindowCanvasItem zMapWindowCollectionFeatureCreate(FooCanvasGroup *parent)
{
ZMapWindowCanvasItem canvas_item = NULL;
FooCanvasItem *item;
//#define DEBUG_PINK_COLLECTION_FEATURE_BACKGROUND
item = foo_canvas_item_new(parent, zMapWindowCollectionFeatureGetType(),
"x", 0.0,
"y", 0.0,
NULL);
if(item && ZMAP_IS_CANVAS_ITEM(item))
{
#ifdef DEBUG_PINK_COLLECTION_FEATURE_BACKGROUND
FooCanvasItem *background;
#endif /* DEBUG_PINK_COLLECTION_FEATURE_BACKGROUND */
canvas_item = ZMAP_CANVAS_ITEM(item);
if(ZMAP_CANVAS_ITEM_GET_CLASS(canvas_item)->post_create)
(* ZMAP_CANVAS_ITEM_GET_CLASS(canvas_item)->post_create)(canvas_item);
#ifdef DEBUG_PINK_COLLECTION_FEATURE_BACKGROUND
if((background = canvas_item->items[WINDOW_ITEM_BACKGROUND]))
{
GdkColor fill = {0};
gdk_color_parse("pink", &fill);
foo_canvas_item_set(background, "fill_color_gdk", &fill, NULL);
}
#endif
zMapWindowCanvasItemCheckSize(canvas_item);
}
return canvas_item;
}
void zMapWindowCollectionFeatureRemoveSubFeatures(ZMapWindowCanvasItem collection,
gboolean keep_in_place_x,
gboolean keep_in_place_y)
{
ParentPositionStruct parent_data = {NULL};
FooCanvasItem *item;
FooCanvasGroup *group;
item = FOO_CANVAS_ITEM(collection);
group = FOO_CANVAS_GROUP(item);
parent_data.new_parent = FOO_CANVAS_GROUP(item->parent);
parent_data.parent = collection;
parent_data.x = parent_data.y = 0.0;
if(keep_in_place_x)
parent_data.x = group->xpos;
if(keep_in_place_y)
parent_data.y = group->ypos;
g_list_foreach(group->item_list, group_remove, &parent_data);
g_list_free(group->item_list);
group->item_list = group->item_list_end = NULL;
return ;
}
void zMapWindowCollectionFeatureStaticReparent(ZMapWindowCanvasItem reparentee,
ZMapWindowCanvasItem new_parent)
{
FooCanvasItem *item;
FooCanvasGroup *parent_group, *child_group;
double x, y;
parent_group = FOO_CANVAS_GROUP(new_parent);
child_group = FOO_CANVAS_GROUP(reparentee);
item = FOO_CANVAS_ITEM(reparentee);
zMapWindowCanvasItemReparent(item, parent_group);
x = child_group->xpos - parent_group->xpos;
y = child_group->ypos - parent_group->ypos;
foo_canvas_item_set(item,
"x", x,
"y", y,
NULL);
new_parent->feature = NULL;//reparentee->feature;
return;
}
void zMapWindowCollectionFeatureAddColinearMarkers(ZMapWindowCanvasItem collection,
ZMapFeatureCompareFunc compare_func,
gpointer compare_data)
{
ColinearMarkerDataStruct colinear_data = {NULL};
FooCanvasGroup *group;
group = FOO_CANVAS_GROUP(collection);
colinear_data.parent = collection;
if(group->item_list)
{
ZMapFeatureTypeStyle style;
double x2;
char *perfect_colour = ZMAP_WINDOW_MATCH_PERFECT ;
char *colinear_colour = ZMAP_WINDOW_MATCH_COLINEAR ;
char *noncolinear_colour = ZMAP_WINDOW_MATCH_NOTCOLINEAR ;
colinear_data.previous = FOO_CANVAS_ITEM(group->item_list->data);
colinear_data.prev_feature = ZMAP_CANVAS_ITEM(colinear_data.previous)->feature;
colinear_data.compare_func = compare_func;
colinear_data.compare_data = compare_data;
style = (ZMAP_CANVAS_ITEM_GET_CLASS(colinear_data.previous)->get_style)(ZMAP_CANVAS_ITEM(colinear_data.previous));
x2 = zMapStyleGetWidth(style);
colinear_data.x = (x2 * 0.5);
gdk_color_parse(perfect_colour, &colinear_data.perfect) ;
gdk_color_parse(colinear_colour, &colinear_data.colinear) ;
gdk_color_parse(noncolinear_colour, &colinear_data.non_colinear) ;
g_list_foreach(group->item_list->next, add_colinear_lines, &colinear_data);
}
return ;
}
void zMapWindowCollectionFeatureAddIncompleteMarkers(ZMapWindowCanvasItem collection,
gboolean revcomped_features)
{
FooCanvasGroup *group;
if ((group = FOO_CANVAS_GROUP(collection)) && (group->item_list))
{
ZMapWindowCanvasItem canvas_item ;
FooCanvasItem *first_item, *last_item ;
ZMapFeature first_feature, last_feature ;
ZMapStrand ref_strand ;
/* Assume that match is forward so first match is first item, last match is last item. */
first_item = FOO_CANVAS_ITEM(group->item_list->data);
canvas_item = ZMAP_CANVAS_ITEM(first_item);
first_feature = canvas_item->feature;
last_item = FOO_CANVAS_ITEM(group->item_list_end->data);
canvas_item = ZMAP_CANVAS_ITEM(last_item);
last_feature = canvas_item->feature;
/* Now we have a feature we can retrieve which strand of the reference sequence the
* alignment is to. */
ref_strand = first_feature->strand ;
/* If the alignment is to the reverse strand of the reference sequence then swop first and last. */
if (ref_strand == ZMAPSTRAND_REVERSE)
{
last_item = FOO_CANVAS_ITEM(group->item_list->data);
canvas_item = ZMAP_CANVAS_ITEM(last_item);
last_feature = canvas_item->feature;
first_item = FOO_CANVAS_ITEM(group->item_list_end->data);
canvas_item = ZMAP_CANVAS_ITEM(first_item);
first_feature = canvas_item->feature;
}
/* If either the first or last match features are truncated then add the incomplete marker. */
markMatchIfIncomplete(collection, ref_strand, FIRST_MATCH, first_item, first_feature) ;
markMatchIfIncomplete(collection, ref_strand, LAST_MATCH, last_item, last_feature) ;
}
return ;
}
void zMapWindowCollectionFeatureAddSpliceMarkers(ZMapWindowCanvasItem collection)
{
FooCanvasGroup *group;
double x_coord;
gboolean canonical ;
ZMapFeatureTypeStyle style;
group = FOO_CANVAS_GROUP(collection);
canonical = FALSE ;
if(group->item_list && group->item_list->next)
{
GList *list;
ZMapFeature prev_feature;
ZMapFeature curr_feature;
if((prev_feature = zMapWindowCanvasItemGetFeature(group->item_list->data)))
process_feature(prev_feature);
if((list = group->item_list->next))
x_coord = get_glyph_mid_point(list->data);
while(list && prev_feature)
{
char *prev, *curr;
gboolean prev_reversed, curr_reversed;
curr_feature = zMapWindowCanvasItemGetFeature(list->data);
prev_reversed = prev_feature->strand == ZMAPSTRAND_REVERSE;
curr_reversed = curr_feature->strand == ZMAPSTRAND_REVERSE;
process_feature(curr_feature);
prev = zMapFeatureGetDNA((ZMapFeatureAny)prev_feature,
prev_feature->x2 + 1,
prev_feature->x2 + 2,
prev_reversed);
curr = zMapFeatureGetDNA((ZMapFeatureAny)curr_feature,
curr_feature->x1 - 2,
curr_feature->x1 - 1,
curr_reversed);
if(prev && curr && fragments_splice(prev, curr))
{
FooCanvasGroup *parent;
GQuark id;
parent = FOO_CANVAS_GROUP(collection->items[WINDOW_ITEM_OVERLAY]);
style = (ZMAP_CANVAS_ITEM_GET_CLASS(collection)->get_style)(collection);
if(style && (id = zMapStyleGetSubFeature(style,ZMAPSTYLE_SUB_FEATURE_NON_CONCENCUS_SPLICE)))
{
style = get_sub_feature_style(collection,id);
if(style)
{
zMapWindowGlyphItemCreate(parent,style,3,
x_coord,prev_feature->x2 - group->ypos,0, FALSE);
zMapWindowGlyphItemCreate(parent,style,5,
x_coord,curr_feature->x1 - group->ypos - 1,0 ,FALSE);
}
}
}
/* free */
if(prev)
g_free(prev);
if(curr)
g_free(curr);
/* move on. */
prev_feature = curr_feature;
list = list->next;
}
}
return ;
}
/*
* Internal routines.
*/
static FooCanvasItem *zmap_window_collection_feature_add_interval(ZMapWindowCanvasItem collection,
ZMapFeatureSubPartSpan unused,
double top, double bottom,
double left, double right)
{
FooCanvasItem *item = NULL;
/* these will be the joining bits */
return item;
}
static void zmap_window_collection_feature_set_colour(ZMapWindowCanvasItem canvas_item,
FooCanvasItem *interval,
ZMapFeatureSubPartSpan sub_feature,
ZMapStyleColourType colour_type,
GdkColor *default_fill)
{
if(ZMAP_IS_CANVAS_ITEM(interval))
{
if(ZMAP_CANVAS_ITEM_GET_CLASS(interval)->set_colour)
(ZMAP_CANVAS_ITEM_GET_CLASS(interval)->set_colour)(canvas_item, interval, sub_feature,
colour_type, default_fill);
}
else
{
/* chain up? Actually I think we need to do something else... */
if(canvas_parent_class_G->set_colour)
(canvas_parent_class_G->set_colour)(canvas_item, interval, sub_feature,
colour_type, default_fill);
}
return ;
}
static ZMapFeatureTypeStyle zmap_window_collection_feature_get_style(ZMapWindowCanvasItem canvas_item)
{
ZMapFeatureTypeStyle style = NULL;
ZMapWindowContainerGroup container_parent;
FooCanvasItem *item;
FooCanvasGroup *group;
g_return_val_if_fail(canvas_item != NULL, NULL);
item = FOO_CANVAS_ITEM(canvas_item);
group = FOO_CANVAS_GROUP(canvas_item);
if(item->parent && item->parent->parent && group->item_list)
{
ZMapWindowCanvasItem first_item;
first_item = ZMAP_CANVAS_ITEM(group->item_list->data);
container_parent = zmapWindowContainerCanvasItemGetContainer(item);
/* can optimise this a bit, by including the featureset_i header... */
style = zmapWindowContainerFeatureSetStyleFromID((ZMapWindowContainerFeatureSet)container_parent,
first_item->feature->style_id);
}
return style;
}
// our style references others, which will be in the container's hash table
// this needs to go somewhere else: maybe CanvasItem.c?
static ZMapFeatureTypeStyle get_sub_feature_style(ZMapWindowCanvasItem canvas_item,GQuark id)
{
ZMapFeatureTypeStyle sub_style = NULL;
ZMapWindowContainerGroup container_parent;
FooCanvasItem *item;
FooCanvasGroup *group;
g_return_val_if_fail(canvas_item != NULL, NULL);
item = FOO_CANVAS_ITEM(canvas_item);
group = FOO_CANVAS_GROUP(canvas_item);
if(item->parent && item->parent->parent && group->item_list)
{
container_parent = zmapWindowContainerCanvasItemGetContainer(item);
sub_style = zmapWindowContainerFeatureSetStyleFromID((ZMapWindowContainerFeatureSet)container_parent, id);
}
return sub_style;
}
/* object impl */
static void zmap_window_collection_feature_class_init (ZMapWindowCollectionFeatureClass collection_class)
{
ZMapWindowCanvasItemClass canvas_class;
FooCanvasItemClass *item_class;
GObjectClass *gobject_class;
gobject_class = (GObjectClass *) collection_class;
canvas_class = (ZMapWindowCanvasItemClass)collection_class;
item_class = (FooCanvasItemClass *)collection_class;
gobject_class->set_property = zmap_window_collection_feature_set_property;
gobject_class->get_property = zmap_window_collection_feature_get_property;
// g_object_class_override_property(gobject_class, COLLECTION_INTERVAL_TYPE,
// ZMAP_WINDOW_CANVAS_INTERVAL_TYPE);
item_class->point = zmap_window_collection_feature_item_point;
item_parent_class_G = g_type_class_peek (foo_canvas_group_get_type());
canvas_parent_class_G = g_type_class_peek(zMapWindowCanvasItemGetType());
item_class->bounds = item_parent_class_G->bounds;
canvas_class->add_interval = zmap_window_collection_feature_add_interval;
canvas_class->set_colour = zmap_window_collection_feature_set_colour;
canvas_class->check_data = NULL;
canvas_class->get_style = zmap_window_collection_feature_get_style;
gobject_class->dispose = zmap_window_collection_feature_destroy;
return ;
}
static void zmap_window_collection_feature_init (ZMapWindowCollectionFeature collection)
{
ZMapWindowCanvasItem canvas_item;
canvas_item = ZMAP_CANVAS_ITEM(collection);
canvas_item->auto_resize_background = TRUE;
return ;
}
static void zmap_window_collection_feature_set_property(GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
ZMapWindowCanvasItem canvas_item;
ZMapWindowCollectionFeature collection;
g_return_if_fail(ZMAP_IS_WINDOW_COLLECTION_FEATURE(object));
collection = ZMAP_WINDOW_COLLECTION_FEATURE(object);
canvas_item = ZMAP_CANVAS_ITEM(object);
switch(param_id)
{
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
break;
}
return ;
}
static void zmap_window_collection_feature_get_property(GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec)
{
return ;
}
static double window_collection_feature_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_collection_feature_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_collection_feature_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;
}
static void zmap_window_collection_feature_destroy (GObject *object)
{
GObjectClass *object_class;
zMapWindowCollectionFeatureRemoveSubFeatures(ZMAP_CANVAS_ITEM(object), TRUE, TRUE);
object_class = (GObjectClass *)canvas_parent_class_G;
if(object_class->dispose)
(object_class->dispose)(object);
return ;
}
/* Accessory functions, some copied as they were statics in foo-canvas.c */
static double get_glyph_mid_point(FooCanvasItem *item)
{
double x, x1, x2, y1, y2;
foo_canvas_item_get_bounds(item, &x1, &y1, &x2, &y2);
/* centre point - half width + rounding */
x = (((x2 - x1) * 0.5) + x1) + 0.5;
return x;
}
static void group_remove(gpointer data, gpointer user_data)
{
FooCanvasItem *item2remove = FOO_CANVAS_ITEM(data);
ParentPosition parent_data = (ParentPosition)user_data;
double x, y;
if(ZMAP_IS_CANVAS_ITEM(data))
{
g_object_get(G_OBJECT(item2remove),
"x", &x,
"y", &y,
NULL);
zMapWindowCanvasItemReparent(item2remove, parent_data->new_parent);
x += parent_data->x;
y += parent_data->y;
foo_canvas_item_set(item2remove,
"x", x,
"y", y,
NULL);
}
return ;
}
static void add_colinear_lines(gpointer data, gpointer user_data)
{
ColinearMarkerData colinear_data = (ColinearMarkerData)user_data;
ZMapWindowCanvasItem canvas_item = NULL;
FooCanvasItem *current = FOO_CANVAS_ITEM(data);
FooCanvasItem *previous;
ZMapFeature prev_feature, curr_feature;
GdkColor *draw_colour;
FooCanvasPoints line_points;
double coords[4], y1, y2;
ColinearityType colinearity = 0;
// enum {COLINEAR_INVALID, COLINEAR_NOT, COLINEAR_IMPERFECT, COLINEAR_PERFECT};
// defined in zmapWindow_P.h
previous = colinear_data->previous;
colinear_data->previous = current;
prev_feature = colinear_data->prev_feature;
curr_feature = ZMAP_CANVAS_ITEM(current)->feature;
colinear_data->prev_feature = curr_feature;
canvas_item = ZMAP_CANVAS_ITEM(colinear_data->parent);
if(colinear_data->compare_func)
{
colinearity = (colinear_data->compare_func)(prev_feature, curr_feature,
colinear_data->compare_data);
if(colinearity != COLINEAR_INVALID)
{
FooCanvasGroup *canvas_group;
FooCanvasItem *colinear_line;
double py1, py2, cy1, cy2;
if (colinearity == COLINEAR_NOT)
draw_colour = &colinear_data->non_colinear ;
else if (colinearity == COLINEAR_IMPERFECT)
draw_colour = &colinear_data->colinear ;
else
draw_colour = &colinear_data->perfect ;
foo_canvas_item_get_bounds(previous, NULL, &py1, NULL, &py2);
foo_canvas_item_get_bounds(current, NULL, &cy1, NULL, &cy2);
canvas_group = (FooCanvasGroup *)canvas_item;
y1 = floor(py2);
y2 = ceil (cy1);
y1 = prev_feature->x2 - canvas_group->ypos;
y2 = curr_feature->x1 - canvas_group->ypos - 1.0; /* Ext2Zero */
coords[0] = colinear_data->x;
coords[1] = y1;
coords[2] = colinear_data->x;
coords[3] = y2;
line_points.coords = coords;
line_points.num_points = 2;
line_points.ref_count = 1;
colinear_line = foo_canvas_item_new(FOO_CANVAS_GROUP(canvas_item->items[WINDOW_ITEM_UNDERLAY]),
foo_canvas_line_get_type(),
"width_pixels", 1,
"points", &line_points,
"fill_color_gdk", draw_colour,
NULL);
// canvas_item->debug = 1;
/* mh17: not sure if this is valid/safe..
* can't find any definition anywhere of what map and realize signify,
* can only see that they set the MAPPED and REALIZED flags
* However, this causes the underlay and overlay features to draw as required.
* Q: would CollectionFeature be better coded as another layer of CanvasItemGroup?
* then we'd only have one lot of code to debug
*/
// see also gylphs
// these don't work!
if(!(colinear_line->object.flags & FOO_CANVAS_ITEM_REALIZED))
FOO_CANVAS_ITEM_GET_CLASS(colinear_line)->realize (colinear_line);
if(!(colinear_line->object.flags & FOO_CANVAS_ITEM_MAPPED))
FOO_CANVAS_ITEM_GET_CLASS(colinear_line)->map (colinear_line);
zmapWindowLongItemCheckPointFull(colinear_line, &line_points, 0.0, 0.0, 0.0, 0.0);
}
}
return ;
}
/* Mark a first or last feature in a series of alignment features as incomplete.
* The first feature is incomplete if it's start > 1, the last is incomplete
* if it's end < homol_length.
*
* Code is complicated by markers/coord testing needing to be reversed for
* alignments to reverse strand. */
static void markMatchIfIncomplete(ZMapWindowCanvasItem collection,
ZMapStrand ref_strand, MatchType match_type,
FooCanvasItem *item, ZMapFeature feature)
{
int start, end ;
if (match_type == FIRST_MATCH)
{
start = 1 ;
end = feature->feature.homol.y1 ;
}
else
{
start = feature->feature.homol.y2 ;
end = feature->feature.homol.length ;
}
if (start < end)
{
double x_coord, y_coord ;
int diff;
ZMapFeatureTypeStyle style, sub_style = NULL;
FooCanvasItem *foo;
GQuark id;
gboolean rev_strand = FALSE;
if(feature->strand == ZMAPSTRAND_REVERSE)
rev_strand = TRUE;;
style = (ZMAP_CANVAS_ITEM_GET_CLASS(collection)->get_style)(collection) ;
// if homology is configured and we have the style...
if(style && (id = zMapStyleGetSubFeature(style,ZMAPSTYLE_SUB_FEATURE_HOMOLOGY)))
sub_style = get_sub_feature_style(collection,id);
// otherwise (eg style from ACEDB) if legacy switched on then invent it
if(!sub_style)
sub_style = zMapStyleLegacyStyle((char *) zmapStyleSubFeature2ExactStr(ZMAPSTYLE_SUB_FEATURE_HOMOLOGY));
if(sub_style)
{
x_coord = get_glyph_mid_point(item) ;
if ((match_type == FIRST_MATCH && ref_strand == ZMAPSTRAND_FORWARD)
|| (match_type == LAST_MATCH && ref_strand == ZMAPSTRAND_REVERSE))
{
y_coord = feature->x1 - ((FooCanvasGroup *)collection)->ypos - 1.0 ; /* Ext2Zero */
}
else
{
y_coord = feature->x2 - ((FooCanvasGroup *)collection)->ypos;
}
diff = end - start;
foo = FOO_CANVAS_ITEM(zMapWindowGlyphItemCreate(FOO_CANVAS_GROUP(collection->items[WINDOW_ITEM_OVERLAY]),
sub_style, (match_type == FIRST_MATCH) ? 5 : 3,
x_coord,y_coord,diff, rev_strand));
/* mh17: not sure if this is valid/safe..we're not using the layers that have been set up so carefully
* can't find any definition anywhere of what map and realize signify,
* can only see that they set the MAPPED and REALIZED flags
* However, this causes the underlay and overlay features to draw as required.
* Q: would CollectionFeature be better coded as another layer of CanvasItemGroup?
* then we'd only have one lot of code to debug
*/
// see also colinear lines
// these don't work!
if(foo)
{
if(!(foo->object.flags & FOO_CANVAS_ITEM_REALIZED))
FOO_CANVAS_ITEM_GET_CLASS(foo)->realize (foo);
if(!(foo->object.flags & FOO_CANVAS_ITEM_MAPPED))
FOO_CANVAS_ITEM_GET_CLASS(foo)->map (foo);
}
}
}
return ;
}
static gboolean fragments_splice(char *fragment_a, char *fragment_b)
{
gboolean splice = FALSE;
char spliceosome[5];
if(fragment_a == NULL || fragment_b == NULL)
{
splice = FALSE;
}
else
{
spliceosome[0] = fragment_a[0];
spliceosome[1] = fragment_a[1];
spliceosome[2] = fragment_b[0];
spliceosome[3] = fragment_b[1];
spliceosome[4] = '\0';
if(g_ascii_strcasecmp(&spliceosome[0], "GTAG") == 0)
{
splice = TRUE;
}
else if(g_ascii_strcasecmp(&spliceosome[0], "GCAG") == 0)
{
splice = TRUE;
}
else if(g_ascii_strcasecmp(&spliceosome[0], "ATAC") == 0)
{
splice = TRUE;
}
}
#ifdef ED_G_NEVER_INCLUDE_THIS_CODE
if(splice)
{
// printf("splices: %s\n", &spliceosome[0]);
}
#endif /* ED_G_NEVER_INCLUDE_THIS_CODE */
return splice;
}
static void process_feature(ZMapFeature prev_feature)
{
int i;
gboolean reversed;
reversed = prev_feature->strand == ZMAPSTRAND_REVERSE;
if(prev_feature->feature.homol.align &&
prev_feature->feature.homol.align->len > 1)
{
ZMapAlignBlock prev_align, curr_align;
prev_align = &(g_array_index(prev_feature->feature.homol.align,
ZMapAlignBlockStruct, 0));;
for(i = 1; i < prev_feature->feature.homol.align->len; i++)
{
char *prev, *curr;
curr_align = &(g_array_index(prev_feature->feature.homol.align,
ZMapAlignBlockStruct, i));
if(prev_align->t2 + 4 < curr_align->t1)
{
prev = zMapFeatureGetDNA((ZMapFeatureAny)prev_feature,
prev_align->t2 + 1,
prev_align->t2 + 2,
reversed);
curr = zMapFeatureGetDNA((ZMapFeatureAny)prev_feature,
curr_align->t1 - 2,
curr_align->t1 - 1,
reversed);
if(prev && curr)
fragments_splice(prev, curr);
if(prev)
g_free(prev);
if(curr)
g_free(curr);
}
prev_align = curr_align;
}
}
return ;
}