GtTextWidthCalculator* gt_text_width_calculator_cairo_new(cairo_t *context,
GtStyle *style,
GtError *err)
{
GtTextWidthCalculatorCairo *twcc;
GtTextWidthCalculator *twc;
double theight = TEXT_SIZE_DEFAULT;
char buf[64];
twc = gt_text_width_calculator_create(gt_text_width_calculator_cairo_class());
twcc = gt_text_width_calculator_cairo_cast(twc);
if (style)
twcc->style = gt_style_ref(style);
if (!context)
{
twcc->mysurf = cairo_image_surface_create(GT_TWC_FORMAT, GT_TWC_WIDTH,
GT_TWC_HEIGHT);
twcc->context = cairo_create(twcc->mysurf);
twcc->own_context = true;
} else {
twcc->context = context;
twcc->own_context = false;
}
if (twcc->style)
{
if (gt_style_get_num(twcc->style,
"format", "block_caption_font_size",
&theight, NULL, err) == GT_STYLE_QUERY_ERROR) {
gt_text_width_calculator_delete(twc);
return NULL;
}
cairo_save(twcc->context);
}
twcc->layout = pango_cairo_create_layout(twcc->context);
snprintf(buf, 64, "Sans %d", (int) theight);
twcc->desc = pango_font_description_from_string(buf);
pango_layout_set_font_description(twcc->layout, twcc->desc);
pango_font_description_free(twcc->desc);
return twc;
}
static int layout_tracks(void *key, void *value, void *data,
GtError *err)
{
unsigned long i,
max = 50;
GtTrack *track = NULL;
GtLayoutTraverseInfo *lti = (GtLayoutTraverseInfo*) data;
GtArray *list = (GtArray*) value;
GtStr *gt_track_key;
GtBlock *block;
int had_err = 0;
bool split = true;
double tmp = 50;
gt_assert(list);
/* to get a deterministic layout, we sort the GtBlocks for each type */
if (lti->layout->block_ordering_func) {
gt_array_sort_stable_with_data(list, blocklist_block_compare,
lti->layout);
}
/* XXX: get first block for track property lookups, this should be reworked
to allow arbitrary track keys! */
block = *(GtBlock**) gt_array_get(list, 0);
gt_track_key = gt_str_new_cstr((char*) key);
/* obtain default settings*/
if (gt_style_get_bool(lti->layout->style, "format", "split_lines", &split,
NULL, err) == GT_STYLE_QUERY_ERROR) {
had_err = 1;
}
if (!had_err) {
if (gt_style_get_num(lti->layout->style,
"format", "max_num_lines",
&tmp, NULL, err) == GT_STYLE_QUERY_ERROR) {
had_err = 1;
}
}
/* obtain track-specific settings, should be changed to query arbitrary
track keys! */
if (!had_err) {
if (gt_style_get_bool(lti->layout->style, gt_block_get_type(block),
"split_lines", &split, NULL,
err) == GT_STYLE_QUERY_ERROR) {
had_err = 1;
}
}
if (!had_err) {
if (gt_style_get_num(lti->layout->style, gt_block_get_type(block),
"max_num_lines", &tmp, NULL,
err) == GT_STYLE_QUERY_ERROR) {
had_err = 1;
}
}
if (!had_err) {
max = (unsigned long) tmp;
track = gt_track_new(gt_track_key, max, split,
gt_line_breaker_captions_new(lti->layout,
lti->layout->width,
lti->layout->style));
lti->layout->nof_tracks++;
for (i = 0; !had_err && i < gt_array_size(list); i++) {
block = *(GtBlock**) gt_array_get(list, i);
had_err = gt_track_insert_block(track, block, err);
}
}
if (!had_err) {
gt_hashmap_add(lti->layout->tracks, gt_cstr_dup(gt_str_get(gt_track_key)),
track);
}
else
{
gt_track_delete(track);
}
gt_str_delete(gt_track_key);
return had_err;
}
int gt_layout_get_height(GtLayout *layout, unsigned long *result,
GtError *err)
{
int had_err = 0;
GtTracklineInfo lines;
double tmp, head_track_space = HEAD_TRACK_SPACE_DEFAULT;
bool show_track_captions = true;
unsigned long height, i;
gt_assert(layout);
had_err = layout_all_tracks(layout, err);
if (!had_err) {
/* get dynamic heights from tracks */
lines.style = layout->style;
lines.height = 0;
if (gt_hashmap_foreach(layout->tracks, add_tracklines, &lines, err) < 0) {
return -1;
}
height = lines.height;
if (gt_style_get_bool(layout->style,
"format","show_track_captions",
&show_track_captions,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
/* add custom track space allotment */
if (show_track_captions)
{
double theight = TEXT_SIZE_DEFAULT,
captionspace = CAPTION_BAR_SPACE_DEFAULT;
if (gt_style_get_num(layout->style,
"format", "track_caption_font_size",
&theight, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num(layout->style,
"format", "track_caption_space",
&captionspace, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
height += gt_array_size(layout->custom_tracks)
* (theight + captionspace);
}
for (i=0;i<gt_array_size(layout->custom_tracks);i++)
{
GtCustomTrack *ct = *(GtCustomTrack**) gt_array_get(layout->custom_tracks,
i);
height += gt_custom_track_get_height(ct);
if (gt_style_get_num(layout->style, "format", "track_vspace", &tmp,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
height += tmp;
}
/* add header space and footer */
if (gt_style_get_num(layout->style, "format", "ruler_space",
&head_track_space, NULL,
err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
height += HEADER_SPACE + head_track_space + FOOTER_SPACE;
*result = height;
return 0;
}
return had_err;
}
int gt_track_unit_test(GtError *err)
{
int had_err = 0;
GtBlock *b[4];
GtRange r[4];
GtTrack *track;
GtGenomeNode *parent[4], *gn[4];
GtStr *title;
double height, tmp;
GtStyle *sty;
unsigned long i;
GtLineBreaker *lb;
double t_rest = 0,
l_rest = 0;
gt_error_check(err);
title = gt_str_new_cstr("test");
r[0].start=100UL;
r[0].end=1000UL;
r[1].start=1001UL;
r[1].end=1500UL;
r[2].start=700UL;
r[2].end=1200UL;
r[3].start=10UL;
r[3].end=200UL;
for (i=0; i<4; i++)
{
parent[i] = gt_feature_node_new(title, gt_ft_gene, r[i].start, r[i].end,
GT_STRAND_FORWARD);
gn[i] = gt_feature_node_new(title, gt_ft_exon, r[i].start, r[i].end,
GT_STRAND_FORWARD);
gt_feature_node_add_child((GtFeatureNode*) parent[i],
(GtFeatureNode*) gn[i]);
gt_feature_node_add_attribute((GtFeatureNode*) parent[i], GT_GFF_NAME,
"parent");
gt_feature_node_add_attribute((GtFeatureNode*) gn[i], GT_GFF_NAME, "child");
}
for (i=0; i<4; i++)
{
b[i] = gt_block_new();
gt_block_set_range(b[i], r[i]);
gt_block_insert_element(b[i], (GtFeatureNode*) parent[i]);
gt_block_insert_element(b[i], (GtFeatureNode*) gn[i]);
}
lb = gt_line_breaker_bases_new();
sty = gt_style_new(err);
if (gt_style_get_num(sty, "format", "track_caption_font_size", &tmp,
NULL, err) == GT_STYLE_QUERY_NOT_SET) {
tmp = TEXT_SIZE_DEFAULT;
}
t_rest += tmp;
if (gt_style_get_num(sty, "format", "track_caption_space", &tmp,
NULL, err) == GT_STYLE_QUERY_NOT_SET) {
tmp = CAPTION_BAR_SPACE_DEFAULT;
}
t_rest += tmp;
if (gt_style_get_num(sty, "format", "track_vspace", &tmp,
NULL, err) == GT_STYLE_QUERY_NOT_SET) {
tmp = TRACK_VSPACE_DEFAULT;
}
t_rest += tmp;
if (gt_style_get_num(sty, "format", "bar_vspace", &l_rest,
NULL, err) == GT_STYLE_QUERY_NOT_SET) {
l_rest = BAR_VSPACE_DEFAULT;
}
track = gt_track_new(title, GT_UNDEF_ULONG, true, lb);
gt_ensure(had_err, track);
gt_ensure(had_err, gt_track_get_title(track) == title);
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 0);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_insert_block(track, b[0], err) == 0);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 1);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + l_rest + BAR_HEIGHT_DEFAULT);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_insert_block(track, b[1], err) == 0);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 1);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + l_rest + BAR_HEIGHT_DEFAULT);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_insert_block(track, b[2], err) == 0);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 2);
gt_ensure(had_err, gt_track_insert_block(track, b[3], err) == 0);
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_lines(track) == 2);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest + BAR_HEIGHT_DEFAULT));
gt_ensure(had_err, !gt_error_is_set(err));
gt_style_set_num(sty, "exon", "bar_height", 42);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest+42));
gt_ensure(had_err, !gt_error_is_set(err));
gt_style_set_num(sty, "gene", "bar_height", 23);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest+42));
gt_ensure(had_err, !gt_error_is_set(err));
gt_style_unset(sty, "exon", "bar_height");
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest+23));
gt_ensure(had_err, !gt_error_is_set(err));
gt_style_unset(sty, "gene", "bar_height");
gt_style_set_num(sty, "format", "bar_height", 99);
gt_ensure(had_err, gt_track_get_height(track, &height, sty, err) == 0);
gt_ensure(had_err, height == t_rest + 2*(l_rest+99));
gt_ensure(had_err, !gt_error_is_set(err));
gt_ensure(had_err, gt_track_get_number_of_discarded_blocks(track) == 0);
gt_track_delete(track);
gt_str_delete(title);
gt_style_delete(sty);
for (i=0; i<4; i++)
{
gt_block_delete(b[i]);
gt_genome_node_delete(parent[i]);
}
return had_err;
}
int gt_track_get_height(const GtTrack *track, double *height,
const GtStyle *sty, GtError *err)
{
unsigned long i;
double track_height = 0,
bheight = TEXT_SIZE_DEFAULT,
theight = TEXT_SIZE_DEFAULT,
tcaptionspace = CAPTION_BAR_SPACE_DEFAULT,
bcaptionspace = CAPTION_BAR_SPACE_DEFAULT,
tmp = TRACK_VSPACE_DEFAULT;
bool show_track_captions = true,
show_block_captions = true;
gt_assert(track && sty);
if (gt_style_get_num(sty, "format", "block_caption_font_size", &bheight,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num(sty, "format", "track_caption_font_size", &theight,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num(sty, "format", "track_caption_space", &tcaptionspace,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num(sty, "format", "block_caption_space", &bcaptionspace,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num(sty, "format", "block_caption_font_size", &bheight,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num(sty, "format", "track_caption_font_size", &theight,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
for (i = 0; i < gt_array_size(track->lines); i++)
{
double itmp = BAR_VSPACE_DEFAULT,
tmp = 0.0;
int rval;
GtLine *line;
line = *(GtLine**) gt_array_get(track->lines, i);
rval = gt_line_get_height(line, &tmp, sty, err);
if (rval < 0)
return -1;
track_height += tmp;
show_block_captions = true;
if (gt_style_get_bool(sty,
"format","show_block_captions",
&show_block_captions,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
/* add caption space if necessary */
if (gt_line_has_captions(line) && show_block_captions)
{
track_height += bheight + bcaptionspace;
}
/* add vertical spacer */
if (gt_style_get_num(sty,
"format", "bar_vspace",
&itmp, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
track_height += itmp;
}
/* determine display of track captions */
if (gt_style_get_bool(sty,
"format","show_track_captions",
&show_track_captions,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
/* add track caption height and spacer */
if (show_track_captions)
track_height += theight + tcaptionspace;
if (gt_style_get_num(sty,
"format", "track_vspace",
&tmp, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
track_height += tmp;
*height = track_height;
return 0;
}
/* Renders a ruler with dynamic scale labeling and optional grid. */
int gt_canvas_cairo_draw_ruler(GtCanvas *canvas, GtRange viewrange,
GtError *err)
{
double step, minorstep, vmajor, vminor,
theight = gt_graphics_get_text_height(canvas->pvt->g);
long base_length, tick;
GtColor rulercol, gridcol;
GtStr *left_str, *right_str, *unit;
char str[BUFSIZ];
GtStyleQueryStatus rval;
bool showgrid = true;
gt_assert(canvas);
if (gt_style_get_bool(canvas->pvt->sty, "format", "show_grid", &showgrid,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num(canvas->pvt->sty, "format", "ruler_font_size",
&theight, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
/* get unit value from style, default: empty */
unit = gt_str_new();
if (gt_style_get_str(canvas->pvt->sty,
"format", "unit",
unit, NULL, err) == GT_STYLE_QUERY_ERROR) {
gt_str_delete(unit);
return -1;
}
/* get additional description texts from style */
left_str = gt_str_new();
rval = gt_style_get_str(canvas->pvt->sty, "format",
"ruler_left_text", left_str, NULL, err);
switch (rval) {
case GT_STYLE_QUERY_NOT_SET:
gt_str_append_cstr(left_str, FIVE_PRIME_STRING);
break;
case GT_STYLE_QUERY_ERROR:
gt_str_delete(unit);
gt_str_delete(left_str);
return -1;
break; /* shouldn't reach this */
default:
break;
}
right_str = gt_str_new();
rval = gt_style_get_str(canvas->pvt->sty, "format",
"ruler_right_text", right_str, NULL, err);
switch (rval) {
case GT_STYLE_QUERY_NOT_SET:
gt_str_append_cstr(right_str, THREE_PRIME_STRING);
break;
case GT_STYLE_QUERY_ERROR:
gt_str_delete(unit);
gt_str_delete(left_str);
gt_str_delete(right_str);
return -1;
break; /* shouldn't reach this */
default:
break;
}
/* reset font to default */
gt_graphics_set_font(canvas->pvt->g,
"Sans",
SLANT_NORMAL,
WEIGHT_NORMAL,
theight);
rulercol.red = rulercol.green = rulercol.blue = RULER_GREY;
rulercol.alpha = 1.0;
gridcol.red = gridcol.green = gridcol.blue = GRID_GREY;
gridcol.alpha = 1.0;
/* determine range and step of the scale */
base_length = gt_range_length(&viewrange);
/* determine tick steps */
step = pow(10,ceil(log10(base_length))-1);
minorstep = step/10.0;
/* calculate starting positions */
vminor = (double) (floor(viewrange.start / minorstep))*minorstep;
vmajor = (double) (floor(viewrange.start / step))*step;
/* draw major ticks */
for (tick = vmajor; tick <= viewrange.end; tick += step)
{
double drawtick = (gt_coords_convert_point(viewrange, tick)
* (canvas->pvt->width-2*canvas->pvt->margins))
+ canvas->pvt->margins;
if (tick < viewrange.start) continue;
gt_graphics_draw_vertical_line(canvas->pvt->g,
drawtick,
canvas->pvt->y + 30,
rulercol,
10,
1.0);
gt_format_ruler_label(str, tick, gt_str_get(unit), BUFSIZ);
gt_graphics_draw_text_centered(canvas->pvt->g,
drawtick,
canvas->pvt->y + 20,
str);
}
/* draw minor ticks */
if (minorstep >= 1)
{
for (tick = vminor; tick <= viewrange.end; tick += minorstep)
{
double drawtick;
if (tick < viewrange.start)
continue;
drawtick = (gt_coords_convert_point(viewrange, tick)
* (canvas->pvt->width-2*canvas->pvt->margins))
+ canvas->pvt->margins;
if (showgrid)
{
gt_graphics_draw_vertical_line(canvas->pvt->g,
drawtick,
canvas->pvt->y + 40,
gridcol,
canvas->pvt->height - 40 - 15,
1.0);
}
gt_graphics_draw_vertical_line(canvas->pvt->g,
drawtick,
canvas->pvt->y + 35,
rulercol,
5,
1.0);
}
}
/* draw ruler line */
gt_graphics_draw_horizontal_line(canvas->pvt->g,
canvas->pvt->margins,
canvas->pvt->y + 40,
rulercol,
canvas->pvt->width - 2
* canvas->pvt->margins,
1.25);
gt_graphics_draw_text_right(canvas->pvt->g,
canvas->pvt->margins - 10,
canvas->pvt->y + 39 + (theight/2),
gt_str_get(left_str));
gt_graphics_draw_text(canvas->pvt->g,
canvas->pvt->width - canvas->pvt->margins + 10,
canvas->pvt->y + 39 + (theight/2),
gt_str_get(right_str));
gt_str_delete(unit);
gt_str_delete(left_str);
gt_str_delete(right_str);
return 0;
}
int gt_canvas_cairo_visit_custom_track(GtCanvas *canvas,
GtCustomTrack *ct,
GtError *err)
{
bool show_track_captions = true;
double space;
int had_err = 0;
GtColor color;
gt_assert(canvas && ct);
if (gt_style_get_bool(canvas->pvt->sty,
"format", "show_track_captions",
&show_track_captions,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_color(canvas->pvt->sty, "format", "track_title_color",
&color, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (show_track_captions)
{
double theight = gt_graphics_get_text_height(canvas->pvt->g),
captionspace = CAPTION_BAR_SPACE_DEFAULT;
if (gt_style_get_num(canvas->pvt->sty,
"format", "track_caption_font_size",
&theight, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
/* draw track title */
gt_graphics_set_font(canvas->pvt->g,
"Sans",
SLANT_NORMAL,
WEIGHT_NORMAL,
theight);
gt_graphics_draw_colored_text(canvas->pvt->g,
canvas->pvt->margins,
canvas->pvt->y,
color,
gt_custom_track_get_title(ct));
if (gt_style_get_num(canvas->pvt->sty,
"format", "track_caption_space",
&captionspace, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
canvas->pvt->y += theight + captionspace;
}
/* call rendering function */
had_err = gt_custom_track_render(ct,
canvas->pvt->g,
canvas->pvt->y,
canvas->pvt->viewrange,
canvas->pvt->sty,
err);
canvas->pvt->y += gt_custom_track_get_height(ct);
/* put spacers after track */
space = TRACK_VSPACE_DEFAULT;
if (gt_style_get_num(canvas->pvt->sty, "format", "track_vspace", &space,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
canvas->pvt->y += space;
return had_err;
}
int gt_canvas_cairo_visit_track_pre(GtCanvas *canvas, GtTrack *track,
GtError *err)
{
int had_err = 0;
unsigned long exceeded;
bool show_track_captions = true;
GtColor color;
gt_assert(canvas && track);
if (gt_style_get_bool(canvas->pvt->sty,
"format", "show_track_captions",
&show_track_captions,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_color(canvas->pvt->sty,
"format", "track_title_color",
&color, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
/* debug */
gt_log_log("processing track %s", gt_str_get(gt_track_get_title(track)));
if (show_track_captions)
{
double theight = gt_graphics_get_text_height(canvas->pvt->g),
captionspace = CAPTION_BAR_SPACE_DEFAULT;
if (gt_style_get_num(canvas->pvt->sty,
"format", "track_caption_font_size",
&theight, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num(canvas->pvt->sty,
"format", "track_caption_space",
&captionspace, NULL, err ) == GT_STYLE_QUERY_ERROR) {
return -1;
}
gt_graphics_set_font(canvas->pvt->g,
"Sans",
SLANT_NORMAL,
WEIGHT_NORMAL,
theight);
canvas->pvt->y += theight;
/* draw track title */
gt_graphics_draw_colored_text(canvas->pvt->g,
canvas->pvt->margins,
canvas->pvt->y,
color,
gt_str_get(gt_track_get_title(track)));
/* draw 'line maximum exceeded' message */
if ((exceeded = gt_track_get_number_of_discarded_blocks(track)) > 0)
{
char buf[BUFSIZ];
const char *msg;
double width;
GtColor red;
red.red = LINE_EXCEEDED_MSG_R;
red.green = LINE_EXCEEDED_MSG_G;
red.blue = LINE_EXCEEDED_MSG_B;
red.alpha = 1.0;
if (exceeded == 1) {
msg = "(1 block not shown due to exceeded line limit)";
strncpy(buf, msg, BUFSIZ);
} else {
msg = "(%lu blocks not shown due to exceeded line limit)";
/*@ignore@*/
snprintf(buf, BUFSIZ, msg, exceeded);
/*@end@*/
}
width = gt_graphics_get_text_width(canvas->pvt->g,
gt_str_get(gt_track_get_title(track)));
gt_graphics_draw_colored_text(canvas->pvt->g,
canvas->pvt->margins+width+10.0,
canvas->pvt->y,
red,
buf);
}
canvas->pvt->y += captionspace;
}
return had_err;
}
int gt_canvas_cairo_visit_element(GtCanvas *canvas, GtElement *elem,
GtError *err)
{
int had_err = 0, arrow_status = ARROW_NONE;
GtRange elem_range = gt_element_get_range(elem);
GtDrawingRange draw_range;
double elem_start = GT_UNDEF_DOUBLE,
elem_width = GT_UNDEF_DOUBLE,
stroke_width = STROKE_WIDTH_DEFAULT,
bar_height = BAR_HEIGHT_DEFAULT,
arrow_width = ARROW_WIDTH_DEFAULT;
GtColor elem_color, grey, fill_color;
const char *type;
GtStyleQueryStatus rval;
GtStr *style;
GtStrand strand = gt_element_get_strand(elem);
gt_assert(canvas && elem);
/* This shouldn't happen. */
if (!gt_range_overlap(&elem_range, &canvas->pvt->viewrange))
return -1;
type = gt_element_get_type(elem);
grey.red = grey.green = grey.blue = .85;
grey.alpha = 0.5;
/* get default or image-wide bar height */
if (gt_style_get_num(canvas->pvt->sty, "format", "bar_height", &bar_height,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
/* try to get type-specific bar height */
if (gt_style_get_num_with_track(canvas->pvt->sty, type, "bar_height",
&bar_height,
gt_element_get_node_ref(elem),
gt_track_get_title(canvas->pvt->current_track),
err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
/* get default or image-wide arrow width */
if (gt_style_get_num(canvas->pvt->sty, "format", "arrow_width", &arrow_width,
NULL, err)== GT_STYLE_QUERY_ERROR) {
return -1;
}
/* try to get type-specific arrow width */
if (gt_style_get_num_with_track(canvas->pvt->sty, type, "arrow_width",
&arrow_width,
gt_element_get_node_ref(elem),
gt_track_get_title(canvas->pvt->current_track),
err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if ((strand == GT_STRAND_REVERSE || strand == GT_STRAND_BOTH)
/*&& delem == gt_dlist_first(elems)*/)
arrow_status = ARROW_LEFT;
if ((strand == GT_STRAND_FORWARD || strand == GT_STRAND_BOTH)
/*&& gt_dlistelem_next(delem) == NULL*/)
arrow_status = (arrow_status == ARROW_LEFT ? ARROW_BOTH : ARROW_RIGHT);
gt_log_log("processing element from %lu to %lu, strand %d\n",
elem_range.start, elem_range.end, (int) strand);
draw_range = gt_coords_calc_generic_range(elem_range, canvas->pvt->viewrange);
draw_range.start *= (canvas->pvt->width-2*canvas->pvt->margins);
draw_range.end *= (canvas->pvt->width-2*canvas->pvt->margins);
elem_start = draw_range.start + canvas->pvt->margins;
elem_width = draw_range.end - draw_range.start;
gt_assert(elem_start != GT_UNDEF_DOUBLE && elem_width != GT_UNDEF_DOUBLE);
if (gt_element_is_marked(elem)) {
if (gt_style_get_color_with_track(canvas->pvt->sty, type, "stroke_marked",
&elem_color, gt_element_get_node_ref(elem),
gt_track_get_title(canvas->pvt->current_track),
err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num_with_track(canvas->pvt->sty, "format",
"stroke_marked_width",
&stroke_width, gt_element_get_node_ref(elem),
gt_track_get_title(canvas->pvt->current_track),
err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
}
else {
if (gt_style_get_color_with_track(canvas->pvt->sty, type, "stroke",
&elem_color,
gt_element_get_node_ref(elem),
gt_track_get_title(canvas->pvt->current_track),
err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num_with_track(canvas->pvt->sty, "format", "stroke_width",
&stroke_width,
gt_element_get_node_ref(elem),
gt_track_get_title(canvas->pvt->current_track),
err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num_with_track(canvas->pvt->sty, type, "stroke_width",
&stroke_width,
gt_element_get_node_ref(elem),
gt_track_get_title(canvas->pvt->current_track),
err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
}
if (gt_style_get_color_with_track(canvas->pvt->sty, type, "fill",
&fill_color,
gt_element_get_node_ref(elem),
gt_track_get_title(canvas->pvt->current_track),
err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (canvas->pvt->bt &&
gt_double_smaller_double(draw_range.end-draw_range.start, 1.1))
{
if ((unsigned long) draw_range.start > gt_bittab_size(canvas->pvt->bt))
return had_err;
if (gt_bittab_bit_is_set(canvas->pvt->bt, (unsigned long) draw_range.start))
return had_err;
gt_graphics_draw_vertical_line(canvas->pvt->g,
elem_start,
canvas->pvt->y - bar_height/2,
elem_color,
bar_height,
stroke_width);
gt_bittab_set_bit(canvas->pvt->bt, (unsigned long) draw_range.start);
}
/* register coordinates in GtImageInfo object if available */
if (canvas->pvt->ii)
{
GtRecMap *rm = gt_rec_map_new(elem_start, canvas->pvt->y - bar_height/2,
elem_start+elem_width,
canvas->pvt->y+bar_height/2,
(GtFeatureNode*)
gt_element_get_node_ref(elem));
gt_image_info_add_rec_map(canvas->pvt->ii, rm);
}
if (canvas->pvt->bt && draw_range.end-draw_range.start <= 1.1)
{
return had_err;
}
gt_log_log("drawing element from %f to %f, arrow status: %d",
draw_range.start, draw_range.end, arrow_status);
/* draw each element according to style set in the style */
style = gt_str_new();
rval = gt_style_get_str_with_track(canvas->pvt->sty, type, "style", style,
gt_element_get_node_ref(elem),
gt_track_get_title(canvas->pvt->current_track),
err);
switch (rval) {
case GT_STYLE_QUERY_NOT_SET:
gt_str_set(style, "box"); /* default style */
break;
case GT_STYLE_QUERY_ERROR:
gt_str_delete(style);
gt_assert(gt_error_is_set(err));
return -1;
default:
break;
}
if (strcmp(gt_str_get(style), "box") == 0)
{
gt_graphics_draw_box(canvas->pvt->g,
elem_start,
canvas->pvt->y - bar_height/2,
elem_width,
bar_height,
fill_color,
arrow_status,
arrow_width,
stroke_width,
elem_color,
false);
}
else if (strcmp(gt_str_get(style), "rectangle") == 0)
{
gt_graphics_draw_box(canvas->pvt->g,
elem_start,
canvas->pvt->y - bar_height/2,
elem_width,
bar_height,
fill_color,
ARROW_NONE,
arrow_width,
stroke_width,
elem_color,
false);
}
else if (strcmp(gt_str_get(style), "caret") == 0)
{
gt_graphics_draw_caret(canvas->pvt->g,
elem_start,
canvas->pvt->y - bar_height/2,
elem_width,
bar_height,
ARROW_NONE,
arrow_width,
stroke_width,
elem_color);
}
else if (strcmp(gt_str_get(style), "dashes") == 0)
{
gt_graphics_draw_dashes(canvas->pvt->g,
elem_start,
canvas->pvt->y - bar_height/2,
elem_width,
bar_height,
arrow_status,
arrow_width,
stroke_width,
elem_color);
}
else if (strcmp(gt_str_get(style), "line") == 0)
{
gt_graphics_draw_horizontal_line(canvas->pvt->g,
elem_start,
canvas->pvt->y - bar_height/2,
elem_color,
elem_width,
1.0);
}
else
{
gt_graphics_draw_box(canvas->pvt->g,
elem_start,
canvas->pvt->y - bar_height/2,
elem_width,
bar_height,
fill_color,
arrow_status,
arrow_width,
stroke_width,
elem_color,
false);
}
gt_str_delete(style);
/* draw arrowheads at clipped margins */
if (draw_range.clip == CLIPPED_LEFT || draw_range.clip == CLIPPED_BOTH)
gt_graphics_draw_arrowhead(canvas->pvt->g,
canvas->pvt->margins - 10,
canvas->pvt->y - 4,
grey,
ARROW_LEFT);
if (draw_range.clip == CLIPPED_RIGHT || draw_range.clip == CLIPPED_BOTH)
gt_graphics_draw_arrowhead(canvas->pvt->g,
canvas->pvt->width-canvas->pvt->margins + 10,
canvas->pvt->y - 4,
grey,
ARROW_RIGHT);
return had_err;
}
int gt_canvas_cairo_visit_block(GtCanvas *canvas, GtBlock *block,
GtError *err)
{
int had_err = 0, arrow_status = ARROW_NONE;
GtRange block_range;
GtDrawingRange draw_range;
GtColor grey, fillcolor, strokecolor;
double block_start,
block_width,
bar_height = BAR_HEIGHT_DEFAULT,
min_len_block = MIN_LEN_BLOCK_DEFAULT,
arrow_width = ARROW_WIDTH_DEFAULT,
stroke_width = STROKE_WIDTH_DEFAULT;
const char *caption, *btype;
GtStrand strand;
double maxbarheight;
btype = gt_block_get_type(block);
gt_assert(canvas && block);
grey.red = grey.green = grey.blue = DEFAULT_GREY_TONE;
grey.alpha = 0.5;
strand = gt_block_get_strand(block);
block_range = gt_block_get_range(block);
if (gt_block_get_max_height(block, &maxbarheight, canvas->pvt->sty, err)) {
return -1;
}
if (gt_style_get_num(canvas->pvt->sty, "format", "bar_height", &bar_height,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num(canvas->pvt->sty, "format", "min_len_block",
&min_len_block,NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num(canvas->pvt->sty, "format", "arrow_width", &arrow_width,
NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num(canvas->pvt->sty, "format", "stroke_width",
&stroke_width, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_color_with_track(canvas->pvt->sty,
btype, "stroke", &strokecolor,
gt_block_get_top_level_feature(block),
gt_track_get_title(canvas->pvt->current_track),
err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (strand == GT_STRAND_REVERSE || strand == GT_STRAND_BOTH)
arrow_status = ARROW_LEFT;
if (strand == GT_STRAND_FORWARD || strand == GT_STRAND_BOTH)
arrow_status = (arrow_status == ARROW_LEFT ? ARROW_BOTH : ARROW_RIGHT);
/* calculate scaled drawing coordinates for this canvas */
draw_range = gt_coords_calc_generic_range(block_range,
canvas->pvt->viewrange);
draw_range.start *= canvas->pvt->width-2*canvas->pvt->margins;
draw_range.end *= canvas->pvt->width-2*canvas->pvt->margins;
block_start = draw_range.start + canvas->pvt->margins;
block_width = draw_range.end - draw_range.start;
/* draw block caption */
if (gt_block_caption_is_visible(block))
{
caption = gt_str_get(gt_block_get_caption(block));
if (caption)
{
double theight = gt_graphics_get_text_height(canvas->pvt->g),
captionspace = CAPTION_BAR_SPACE_DEFAULT;
if (gt_style_get_num(canvas->pvt->sty,
"format", "block_caption_space",
&captionspace, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
if (gt_style_get_num(canvas->pvt->sty,
"format", "block_caption_font_size",
&theight, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
gt_graphics_set_font(canvas->pvt->g,
"Sans",
SLANT_NORMAL,
WEIGHT_NORMAL,
theight);
gt_graphics_draw_text_clip(canvas->pvt->g,
block_start,
canvas->pvt->y - bar_height/2
- captionspace,
caption);
}
}
/* do not draw further details in very small blocks */
if (!gt_block_has_only_one_fullsize_element(block)
&& gt_double_smaller_double(block_width, min_len_block))
{
/* optimise drawing for very narrow blocks,
if <= 1px/pt width, draw as simple lines */
if (canvas->pvt->bt && draw_range.end-draw_range.start <= 1.1)
{
if (!gt_bittab_bit_is_set(canvas->pvt->bt,
(unsigned long) draw_range.start)) {
gt_graphics_draw_vertical_line(canvas->pvt->g,
block_start,
canvas->pvt->y - bar_height/2,
strokecolor,
bar_height,
stroke_width);
gt_bittab_set_bit(canvas->pvt->bt, (unsigned long) draw_range.start);
}
} else {
if (gt_style_get_color_with_track(canvas->pvt->sty,
btype, "fill",
&fillcolor,
gt_block_get_top_level_feature(block),
gt_track_get_title(canvas->pvt->current_track),
err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
gt_graphics_draw_box(canvas->pvt->g,
block_start,
canvas->pvt->y - bar_height/2,
block_width,
bar_height,
fillcolor,
arrow_status,
arrow_width,
stroke_width,
strokecolor,
true);
/* draw arrowheads at clipped margins */
if (draw_range.clip == CLIPPED_LEFT || draw_range.clip == CLIPPED_BOTH)
gt_graphics_draw_arrowhead(canvas->pvt->g,
canvas->pvt->margins - 10,
canvas->pvt->y - 4,
grey,
ARROW_LEFT);
if (draw_range.clip == CLIPPED_RIGHT || draw_range.clip == CLIPPED_BOTH)
gt_graphics_draw_arrowhead(canvas->pvt->g,
canvas->pvt->width-canvas->pvt->margins
+ 10,
canvas->pvt->y - 4,
grey,
ARROW_RIGHT);
}
/* register coordinates in GtImageInfo object if available */
if (canvas->pvt->ii)
{
GtRecMap *rm = gt_rec_map_new(block_start,
canvas->pvt->y - bar_height/2,
block_start + block_width,
canvas->pvt->y + bar_height/2,
(GtFeatureNode*) /* XXX */
gt_block_get_top_level_feature(block));
gt_image_info_add_rec_map(canvas->pvt->ii, rm);
gt_rec_map_set_omitted_children(rm, true);
}
/* signal break */
return 1;
}
/* get stroke color */
if (gt_style_get_color(canvas->pvt->sty,
"format", "default_stroke_color",
&strokecolor, NULL, err) == GT_STYLE_QUERY_ERROR) {
return -1;
}
/* draw parent block boundaries */
gt_graphics_draw_dashes(canvas->pvt->g,
block_start,
canvas->pvt->y - bar_height/2,
block_width,
bar_height,
ARROW_NONE,
arrow_width,
stroke_width,
strokecolor);
return had_err;
}
static int process_node(GtDiagram *d, GtFeatureNode *node,
GtFeatureNode *parent, GtError *err)
{
GtRange elem_range;
bool *collapse;
GtShouldGroupByParent *group;
const char *feature_type = NULL,
*parent_gft = NULL;
double tmp;
GtStyleQueryStatus rval;
GtUword max_show_width = GT_UNDEF_UWORD,
par_max_show_width = GT_UNDEF_UWORD;
gt_assert(d && node);
gt_log_log(">> getting '%s'", gt_feature_node_get_type(node));
/* skip pseudonodes */
if (gt_feature_node_is_pseudo(node))
return 0;
feature_type = gt_feature_node_get_type(node);
gt_assert(feature_type);
/* discard elements that do not overlap with visible range */
elem_range = gt_genome_node_get_range((GtGenomeNode*) node);
if (!gt_range_overlap(&d->range, &elem_range))
return 0;
/* get maximal view widths in nucleotides to show this type */
rval = gt_style_get_num(d->style, feature_type, "max_show_width", &tmp, NULL,
err);
switch (rval) {
case GT_STYLE_QUERY_OK:
max_show_width = tmp;
break;
case GT_STYLE_QUERY_ERROR:
return -1;
break; /* should never be reached */
default:
/* do not change default value */
break;
}
/* for non-root nodes, get maximal view with to show parent */
if (parent)
{
if (!gt_feature_node_is_pseudo(parent))
{
parent_gft = gt_feature_node_get_type(parent);
rval = gt_style_get_num(d->style,
parent_gft, "max_show_width",
&tmp, NULL, err);
switch (rval) {
case GT_STYLE_QUERY_OK:
par_max_show_width = tmp;
break;
case GT_STYLE_QUERY_ERROR:
return -1;
break; /* should never be reached */
default:
/* do not change default value */
break;
}
} else
par_max_show_width = GT_UNDEF_UWORD;
}
/* check if this type is to be displayed at all */
if (max_show_width != GT_UNDEF_UWORD &&
gt_range_length(&d->range) > max_show_width)
{
return 0;
}
/* disregard parent node if it is configured not to be shown */
if (parent
&& par_max_show_width != GT_UNDEF_UWORD
&& gt_range_length(&d->range) > par_max_show_width)
{
parent = NULL;
}
/* check if this is a collapsing type, cache result */
if ((collapse = (bool*) gt_hashmap_get(d->collapsingtypes,
feature_type)) == NULL)
{
collapse = gt_malloc(sizeof (bool));
*collapse = false;
if (gt_style_get_bool(d->style, feature_type, "collapse_to_parent",
collapse, NULL, err) == GT_STYLE_QUERY_ERROR) {
gt_free(collapse);
return -1;
}
gt_hashmap_add(d->collapsingtypes, (void*) feature_type, collapse);
}
/* check if type should be grouped by parent, cache result */
if ((group = (GtShouldGroupByParent*) gt_hashmap_get(d->groupedtypes,
feature_type)) == NULL)
{
bool tmp;
group = gt_malloc(sizeof (GtShouldGroupByParent));
rval = gt_style_get_bool(d->style, feature_type, "group_by_parent",
&tmp, NULL, err);
switch (rval) {
case GT_STYLE_QUERY_OK:
if (tmp)
*group = GT_GROUP_BY_PARENT;
else
*group = GT_DO_NOT_GROUP_BY_PARENT;
break;
case GT_STYLE_QUERY_NOT_SET:
*group = GT_UNDEFINED_GROUPING;
break;
case GT_STYLE_QUERY_ERROR:
gt_free(group);
return -1;
break; /* should never be reached */
}
gt_hashmap_add(d->groupedtypes, (void*) feature_type, group);
}
/* decide where to place this feature: */
if (*collapse)
{
/* user has specified collapsing to parent for this type */
if (parent && !gt_feature_node_is_pseudo(parent)) {
/* collapsing child nodes are added to upwards blocks,
but never collapse into pseudo nodes */
add_recursive(d, node, parent, node);
} else {
/* if no parent or only pseudo-parent, do not collapse */
if (add_to_current(d, node, parent, err) < 0) {
return -1;
}
}
}
else /* (!*collapse) */
{
if (parent) {
bool do_not_overlap = false;
do_not_overlap = gt_feature_node_direct_children_do_not_overlap_st(parent,
node);
if (*group == GT_GROUP_BY_PARENT
|| (do_not_overlap && *group == GT_UNDEFINED_GROUPING))
{
if (gt_feature_node_is_pseudo(parent)
&& gt_feature_node_is_multi(node))
{
if (add_to_rep(d, node, parent, err) < 0) {
return -1;
}
} else if
(gt_feature_node_number_of_children(parent) > 1)
{
if (add_to_parent(d, node, parent, err) < 0) {
return -1;
}
} else {
if (add_to_current(d, node, parent, err) < 0) {
return -1;
}
}
} else {
if (gt_feature_node_is_pseudo(parent)
&& gt_feature_node_is_multi(node))
{
if (add_to_rep(d, node, parent, err) < 0) {
return -1;
}
} else {
if (add_to_current(d, node, parent, err) < 0) {
return -1;
}
}
}
} else {
/* root nodes always get their own block */
if (add_to_current(d, node, parent, err) < 0) {
return -1;
}
}
}
/* we can now assume that this node (or its representative)
has been processed into the reverse lookup structure */
#ifndef NDEBUG
if (gt_feature_node_is_multi(node))
{
GtFeatureNode *rep;
rep = gt_feature_node_get_multi_representative((GtFeatureNode*) node);
gt_assert(gt_hashmap_get(d->nodeinfo, rep));
}
else
gt_assert(gt_hashmap_get(d->nodeinfo, node));
#endif
return 0;
}
