/* TODO combine field_char_dist */
static int write_field_char_dists(DescField *field,
FILE *fp, GtError *err)
{
int had_err = 0;
GtUword char_idx,
distr_len;
EncsecDistriData data;
data.fp = fp;
data.minimum_element = 0;
data.written_elems = 0;
data.had_err = 0;
data.err = err;
for (char_idx = 0; !had_err && char_idx < field->max_len; char_idx++) {
if (char_idx >= field->len ||
!gt_bittab_bit_is_set(field->bittab, char_idx)) {
distr_len = get_hashmap_distri_size(field->chars[char_idx]);
had_err = gt_io_error_fwrite_one(distr_len, fp, err);
if (!had_err)
field->chars[char_idx] = io_hashmap_distri(field->chars[char_idx],
distr_len,
&data, err);
if (field->chars[char_idx] == NULL)
had_err = 1;
}
}
return had_err;
}
static int read_field_char_dists(DescField *field,
FILE *fp, GtError *err)
{
int had_err = 0;
GtUword char_idx,
distr_len;
EncsecDistriData data;
data.err = err;
data.had_err = 0;
data.fp = fp;
for (char_idx = 0; !had_err && char_idx < field->max_len; char_idx++) {
if (char_idx >= field->len ||
!gt_bittab_bit_is_set(field->bittab, char_idx)) {
had_err = gt_io_error_fread_one(distr_len, fp, err);
field->chars[char_idx] = io_hashmap_distri(field->chars[char_idx],
distr_len,
&data, err);
if (field->chars[char_idx] == NULL)
had_err = 1;
}
}
return had_err;
}
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);
}
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 int write_field_header_bittab(DescField *field, FILE *fp, GtError *err)
{
int had_err = 0;
GtUword char_idx,
num_of_chars = field->len / sizeof (char);
char cc = 0;
size_t bit_idx;
if (field->len % sizeof (char) != 0)
num_of_chars++;
for (char_idx = 0; !had_err && char_idx < num_of_chars; char_idx++) {
for (bit_idx = 0; !had_err && bit_idx < sizeof (char); bit_idx++) {
if (gt_bittab_bit_is_set(field->bittab,
(GtUword) ((sizeof (char) * char_idx) +
bit_idx)))
cc |= 1 << bit_idx;
}
had_err = gt_io_error_fwrite_one(cc, fp, err);
cc = 0;
}
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;
}
