void gt_string_matching_shift_and(const char *s, unsigned long n,
const char *p, unsigned long m,
ProcessMatch process_match, void *data)
{
GtBittab *D, *B[UCHAR_MAX] = { NULL };
unsigned long i, j;
gt_assert(s && p);
if (m > n || !m || !n) /* no match possible */
return;
/* preprocessing */
for (j = 0; j < m; j++) {
if (!B[(unsigned) p[j]])
B[(unsigned) p[j]] = gt_bittab_new(m);
gt_bittab_set_bit(B[(unsigned) p[j]], j);
}
/* searching */
D = gt_bittab_new(m);
for (i = 0; i < n; i++) {
gt_bittab_shift_left_equal(D);
gt_bittab_set_bit(D, 0);
if (B[(unsigned) s[i]])
gt_bittab_and_equal(D, B[(unsigned) s[i]]);
else
gt_bittab_unset(D);
if (gt_bittab_bit_is_set(D, m - 1) && process_match) {
if (process_match(i - m + 1, data))
break;
}
}
/* free */
for (i = 0; i < UCHAR_MAX; i++)
gt_bittab_delete(B[i]);
gt_bittab_delete(D);
}
GtBittab* gt_golomb_encode(GtGolomb *golomb, unsigned long x)
{
unsigned long quotient,
remain,
mask,
idx_i;
GtBittab *code;
gt_assert(golomb);
quotient = x / golomb->median;
remain = x - quotient * golomb->median;
if (golomb->len == 0) {
code = gt_bittab_new((quotient + 1) + 1);
}
else if (remain < golomb->two_pow_len - golomb->median) {
code = gt_bittab_new((quotient + 1) + (golomb->len - 1));
mask = 1UL << (golomb->len - 2);
for (idx_i = 0; idx_i < golomb->len - 1; idx_i++) {
if (remain & mask)
gt_bittab_set_bit(code, quotient + 1 + idx_i);
mask >>= 1;
}
}
/* necessary to call consensus_sa() */
static void process_splice_form_func(GtArray *spliced_alignments_in_form,
GT_UNUSED const void *set_of_sas,
GT_UNUSED GtUword number_of_sas,
GT_UNUSED size_t size_of_sa,
void *userdata)
{
GthPGL *pgl = (GthPGL*) userdata;
GthAGS *ags;
GtBittab *assemblytab;
GtUword i;
ags = gth_ags_new(pgl);
assemblytab = gt_bittab_new(gt_array_size(pgl->saclusters));
for (i = 0; i < gt_array_size(spliced_alignments_in_form); i++) {
gt_bittab_set_bit(assemblytab, *(GtUword*)
gt_array_get(spliced_alignments_in_form, i));
}
gth_build_AGS_from_assembly(ags, assemblytab, pgl->saclusters);
gt_bittab_delete(assemblytab);
gt_array_add(pgl->assemblies, ags);
}
static void compute_C(GtBittab **C, const ConsensusSA *csa)
{
unsigned long sa, sa_1;
gt_assert(csa);
for (sa = 0; sa < csa->number_of_sas; sa++) {
for (sa_1 = 0; sa_1 < csa->number_of_sas; sa_1++) {
if (contains(csa, sa, sa_1))
gt_bittab_set_bit(C[sa], sa_1);
}
gt_assert(gt_bittab_bit_is_set(C[sa], sa));
}
}
static void compute_left_or_right(GtBittab **left_or_right,
const ConsensusSA *csa,
bool (*cmp_func) (const ConsensusSA *csa,
unsigned long sa_1,
unsigned long sa_2))
{
unsigned long sa, sa_1;
gt_assert(csa && left_or_right && *left_or_right);
for (sa = 0; sa < csa->number_of_sas; sa++) {
for (sa_1 = 0; sa_1 < csa->number_of_sas; sa_1++) {
if (cmp_func(csa, sa, sa_1) && compatible(csa, sa, sa_1))
gt_bittab_set_bit(left_or_right[sa], sa_1);
}
}
}
static int read_field_header_bittab(DescField *field,
FILE *fp, GtError *err)
{
int had_err = 0;
char cc;
GtUword char_idx,
num_of_chars = field->len / sizeof (char);
size_t bit_idx;
if (field->len % sizeof (char) != 0)
num_of_chars++;
for (char_idx = 0; char_idx < num_of_chars; char_idx++) {
had_err = gt_io_error_fread_one(cc, fp, err);
for (bit_idx = 0; !had_err && bit_idx < sizeof (char); bit_idx++) {
if (cc & (1 << bit_idx))
gt_bittab_set_bit(field->bittab,
(GtUword) ((sizeof (char) * char_idx) +
bit_idx));
}
}
return had_err;
}
int gt_clustered_set_union_find_merge_clusters(GtClusteredSet *cs,
GtUword e1,
GtUword e2,
GtError *err)
{
gt_assert(cs);
int had_err = 0;
GtClusteredSetUFClusterInfo *cluster_info_c1 = NULL;
GtClusteredSetUFClusterInfo *cluster_info_c2 = NULL;
GtUword target = 0, source = 0, c1 = 0, c2 = 0;
GtClusteredSetUF *cs_uf = (GtClusteredSetUF*) cs;
if (e1 == e2) {
gt_error_set(err, "expected "GT_WU" to be unequal "GT_WU"", e1, e2 );
had_err = -1;
}
if (e1 >= cs_uf->num_of_elems || e2 >= cs_uf->num_of_elems) {
gt_error_set(err, ""GT_WU" and "GT_WU" must not be larger than "GT_WU"",
e1, e2, cs_uf->num_of_elems);
had_err = -1;
}
if (!had_err) {
if (SINGLETON(e1)) {
/* printf(""GT_WU" is singleton\n", e1); */
if (SINGLETON(e2)) {
/* printf(""GT_WU" is singleton\n", e2);*/
gt_clustered_set_union_find_make_new_cluster(cs_uf, e1, e2, err);
gt_bittab_set_bit(cs_uf->in_cluster, e2);
}
else {
c2 = cs_uf->cluster_elems[e2].cluster_num;
CHECKCLUSTER(c2);
gt_clustered_set_union_find_append_elem(cs_uf, c2, e1, err);
}
gt_bittab_set_bit(cs_uf->in_cluster, e1);
}
else {
c1 = cs_uf->cluster_elems[e1].cluster_num;
CHECKCLUSTER(c1);
if (SINGLETON(e2)) {
gt_clustered_set_union_find_append_elem(cs_uf, c1, e2, err);
gt_bittab_set_bit(cs_uf->in_cluster, e2);
}
else {
c2 = cs_uf->cluster_elems[e2].cluster_num;
CHECKCLUSTER(c2);
cluster_info_c1 = CINFO(c1);
cluster_info_c2 = CINFO(c2);
if (cluster_info_c1->cluster_size > cluster_info_c2->cluster_size) {
target = c1;
source = c2;
}
else {
target = c1;
source = c2;
}
if (target != source)
gt_clustered_set_union_find_join_clusters(cs_uf, target, source, err);
}
}
}
return had_err;
}
static void compute_csas(ConsensusSA *csa)
{
unsigned long i, sa_i, sa_i_size = 0, sa_prime, sa_prime_size;
GtArray *splice_form;
GtBittab **C, **left, **right, **L, **R, *U_i, *SA_i, *SA_prime;
#ifndef NDEBUG
unsigned long u_i_size, u_i_minus_1_size;
gt_assert(csa && csa->set_of_sas);
#endif
/* init sets */
C = gt_malloc(sizeof (GtBittab*) * csa->number_of_sas);
left = gt_malloc(sizeof (GtBittab*) * csa->number_of_sas);
right = gt_malloc(sizeof (GtBittab*) * csa->number_of_sas);
L = gt_malloc(sizeof (GtBittab*) * csa->number_of_sas);
R = gt_malloc(sizeof (GtBittab*) * csa->number_of_sas);
for (i = 0; i < csa->number_of_sas; i++) {
C[i] = gt_bittab_new(csa->number_of_sas);
left[i] = gt_bittab_new(csa->number_of_sas);
right[i] = gt_bittab_new(csa->number_of_sas);
L[i] = gt_bittab_new(csa->number_of_sas);
R[i] = gt_bittab_new(csa->number_of_sas);
}
U_i = gt_bittab_new(csa->number_of_sas);
SA_i = gt_bittab_new(csa->number_of_sas);
SA_prime = gt_bittab_new(csa->number_of_sas);
splice_form = gt_array_new(sizeof (unsigned long));
/* compute sets */
compute_C(C, csa);
compute_left(left, csa);
compute_right(right, csa);
compute_L(L, C, left, csa->number_of_sas);
compute_R(R, C, right, csa->number_of_sas);
/* U_0 = SA */
for (i = 0; i < csa->number_of_sas; i++)
gt_bittab_set_bit(U_i, i);
#ifndef NDEBUG
/* preparation for assertion below */
u_i_minus_1_size = gt_bittab_count_set_bits(U_i);
#endif
while (gt_bittab_is_true(U_i)) {
sa_i = GT_UNDEF_ULONG;
for (sa_prime = gt_bittab_get_first_bitnum(U_i);
sa_prime != gt_bittab_get_last_bitnum(U_i);
sa_prime = gt_bittab_get_next_bitnum(U_i, sa_prime)) {
if (sa_i == GT_UNDEF_ULONG) {
sa_i = sa_prime;
gt_bittab_or(SA_i, L[sa_i], R[sa_i]);
sa_i_size = gt_bittab_count_set_bits(SA_i);
}
else {
gt_bittab_or(SA_prime, L[sa_prime], R[sa_prime]);
sa_prime_size = gt_bittab_count_set_bits(SA_prime);
if (sa_prime_size > sa_i_size) {
sa_i = sa_prime;
sa_i_size = sa_prime_size;
gt_bittab_equal(SA_i, SA_prime);
}
}
}
/* make sure the computed splice form is maximal w.r.t. to compatibility */
gt_assert(splice_form_is_valid(SA_i, csa));
/* process splice form */
if (csa->process_splice_form) {
gt_array_reset(splice_form);
gt_bittab_get_all_bitnums(SA_i, splice_form);
csa->process_splice_form(splice_form, csa->set_of_sas, csa->number_of_sas,
csa->size_of_sa, csa->userdata);
}
/* U_i = U_i-1 \ SA_i */
gt_bittab_nand(U_i, U_i, SA_i);
#ifndef NDEBUG
/* ensure that |U_i| < |U_i-1| */
u_i_size = gt_bittab_count_set_bits(U_i);
gt_assert(u_i_size < u_i_minus_1_size);
u_i_minus_1_size = u_i_size;
#endif
}
/* free sets */
for (i = 0; i < csa->number_of_sas; i++) {
gt_bittab_delete(C[i]);
gt_bittab_delete(left[i]);
gt_bittab_delete(right[i]);
gt_bittab_delete(L[i]);
gt_bittab_delete(R[i]);
}
gt_free(C);
gt_free(left);
gt_free(right);
gt_free(L);
gt_free(R);
gt_bittab_delete(U_i);
gt_bittab_delete(SA_i);
gt_bittab_delete(SA_prime);
gt_array_delete(splice_form);
}
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;
}
