source: branches/alilink/EDIT4/ED4_cursor.cxx

Last change on this file was 18126, checked in by westram, 6 years ago
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 60.6 KB
Line 
1#include <cctype>
2#include <climits>
3
4#include <arbdbt.h>
5#include <aw_awars.hxx>
6#include <AW_helix.hxx>
7#include <BI_basepos.hxx>
8#include <aw_msg.hxx>
9#include <arb_progress.h>
10#include <aw_root.hxx>
11#include <iupac.h>
12
13#include <ed4_extern.hxx>
14
15#include "ed4_class.hxx"
16#include "ed4_edit_string.hxx"
17#include "ed4_tools.hxx"
18#include "ed4_awars.hxx"
19#include "ed4_ProteinViewer.hxx"
20#include "ed4_seq_colors.hxx"
21
22#include <arb_strbuf.h>
23#include <arb_defs.h>
24
25/* --------------------------------------------------------------------------------
26   CursorShape
27   -------------------------------------------------------------------------------- */
28
29#define MAXLINES  30
30#define MAXPOINTS (2*MAXLINES)
31
32class ED4_CursorShape {
33    int points;
34    int xpos[MAXPOINTS];
35    int ypos[MAXPOINTS];
36
37    int lines;
38    int start[MAXLINES];
39    int end[MAXLINES];
40
41    int char_width;
42
43    bool reverse;
44
45    int point(int x, int y) {
46        e4_assert(points<MAXPOINTS);
47        if (reverse) {
48            xpos[points] = char_width-x;
49        }
50        else {
51            xpos[points] = x;
52        }
53        ypos[points] = y;
54        return points++;
55    }
56    int line(int p1, int p2) {
57        e4_assert(p1>=0 && p1<points);
58        e4_assert(p2>=0 && p2<points);
59
60        e4_assert(lines<MAXLINES);
61        start[lines] = p1;
62        end[lines] = p2;
63
64        return lines++;
65    }
66    int horizontal_line(int x, int y, int half_width) {
67        return line(point(x-half_width, y), point(x+half_width, y));
68    }
69
70public:
71
72    ED4_CursorShape(ED4_CursorType type, int term_height, int character_width, bool reverse_cursor);
73    ~ED4_CursorShape() {}
74
75    void draw(AW_device *device, int x, int y) const {
76        e4_assert(lines);
77        for (int l=0; l<lines; l++) {
78            int p1 = start[l];
79            int p2 = end[l];
80            device->line(ED4_G_CURSOR, xpos[p1]+x, ypos[p1]+y, xpos[p2]+x, ypos[p2]+y, AW_SCREEN);
81        }
82        device->flush();
83    }
84
85    void get_bounding_box(int x, int y, int &xmin, int &ymin, int &xmax, int &ymax) const {
86        e4_assert(points);
87        xmin = ymin = INT_MAX;
88        xmax = ymax = INT_MIN;
89        for (int p=0; p<points; p++) {
90            if (xpos[p]<xmin)      { xmin = xpos[p]; }
91            else if (xpos[p]>xmax) { xmax = xpos[p]; }
92            if (ypos[p]<ymin)      { ymin = ypos[p]; }
93            else if (ypos[p]>ymax) { ymax = ypos[p]; }
94        }
95
96        xmin += x; xmax += x;
97        ymin += y; ymax += y;
98    }
99
100
101};
102
103ED4_CursorShape::ED4_CursorShape(ED4_CursorType typ, /* int x, int y, */ int term_height, int character_width, bool reverse_cursor) {
104    lines      = 0;
105    points     = 0;
106    reverse    = reverse_cursor;
107    char_width = character_width;
108
109    int x = 0;
110    int y = 0;
111
112    switch (typ) {
113#define UPPER_OFFSET    (-1)
114#define LOWER_OFFSET    (term_height-1)
115#define CWIDTH          (character_width)
116
117        case ED4_RIGHT_ORIENTED_CURSOR_THIN:
118        case ED4_RIGHT_ORIENTED_CURSOR: {
119            // --CWIDTH--
120            //
121            // 0--------1               UPPER_OFFSET (from top)
122            // |3-------4
123            // ||
124            // ||
125            // ||
126            // ||
127            // ||
128            // ||
129            // 25                       LOWER_OFFSET (from top)
130            //
131            //
132            //  x
133
134            if (typ == ED4_RIGHT_ORIENTED_CURSOR) { // non-thin version
135                int p0 = point(x-1, y+UPPER_OFFSET);
136
137                line(p0, point(x+CWIDTH-1, y+UPPER_OFFSET)); // 0->1
138                line(p0, point(x-1, y+LOWER_OFFSET)); // 0->2
139            }
140
141            int p3 = point(x, y+UPPER_OFFSET+1);
142
143            line(p3, point(x+CWIDTH-1, y+UPPER_OFFSET+1)); // 3->4
144            line(p3, point(x, y+LOWER_OFFSET)); // 3->5
145
146            break;
147
148#undef UPPER_OFFSET
149#undef LOWER_OFFSET
150#undef CWIDTH
151
152        }
153        case ED4_TRADITIONAL_CURSOR_CONNECTED:
154        case ED4_TRADITIONAL_CURSOR_BOTTOM:
155        case ED4_TRADITIONAL_CURSOR: {
156            int small_version = (term_height <= 10) ? 1 : 0;
157
158
159#define UPPER_OFFSET    0
160#define LOWER_OFFSET    (term_height-1)
161#define CWIDTH          3
162
163            //  -----2*CWIDTH----
164            //
165            //  0---------------1       UPPER_OFFSET (from top)
166            //     4---------5
167            //        8---9
168            //         C/C
169            //
170            //         D/D
171            //        A---B
172            //     6---------7
173            //  2---------------3       LOWER_OFFSET (from top)
174
175            bool draw_upper = typ != ED4_TRADITIONAL_CURSOR_BOTTOM;
176
177            if (draw_upper) horizontal_line(x, y+UPPER_OFFSET, CWIDTH-small_version); // 0/1
178            horizontal_line(x, y+LOWER_OFFSET, CWIDTH-small_version); // 2/3
179
180            if (draw_upper) horizontal_line(x, y+UPPER_OFFSET+1, (CWIDTH*2)/3-small_version); // 4/5
181            horizontal_line(x, y+LOWER_OFFSET-1, (CWIDTH*2)/3-small_version); // 6/7
182
183            if (!small_version) {
184                if (draw_upper) horizontal_line(x, y+UPPER_OFFSET+2, CWIDTH/3); // 8/9
185                horizontal_line(x, y+LOWER_OFFSET-2, CWIDTH/3); // A/B
186            }
187
188            int pu = point(x, y+UPPER_OFFSET+3-small_version);
189            int pl = point(x, y+LOWER_OFFSET-3+small_version);
190
191            if (draw_upper) line(pu, pu);   // C/C
192            line(pl, pl);   // D/D
193
194            if (typ == ED4_TRADITIONAL_CURSOR_CONNECTED) {
195                int pu2 = point(x, y+UPPER_OFFSET+5-small_version);
196                int pl2 = point(x, y+LOWER_OFFSET-5+small_version);
197                line(pu2, pl2);
198            }
199
200            break;
201
202#undef UPPER_OFFSET
203#undef LOWER_OFFSET
204#undef CWIDTH
205
206        }
207        case ED4_FUCKING_BIG_CURSOR: {
208
209#define OUTER_HEIGHT    (term_height/4)
210#define INNER_HEIGHT    (term_height-1)
211#define CWIDTH          12
212#define STEPS           6
213#define THICKNESS       2
214
215#if (2*STEPS+THICKNESS > MAXLINES)
216#error Bad definitions!
217#endif
218
219            //          2               3               |
220            //            \           /                 | OUTER_HEIGHT
221            //               \     /                    |
222            //                  0               |       |
223            //                  |               | INNER_HEIGHT
224            //                  |               |
225            //                  1               |
226            //                /    \                    --
227            //             /          \                 --
228            //          4               5
229            //
230            //          -----------------
231            //                2*WIDTH
232
233            int s;
234            for (s=0; s<STEPS; s++) {
235                int size = ((STEPS-s)*CWIDTH)/STEPS;
236
237                horizontal_line(x, y-OUTER_HEIGHT+s,                    size);
238                horizontal_line(x, y+INNER_HEIGHT+OUTER_HEIGHT-s,       size);
239            }
240
241            int y_upper = ypos[s-4];
242            int y_lower = ypos[s-2];
243
244            int t;
245            for (t=0; t<THICKNESS; t++) {
246                int xp = x-(THICKNESS/2)+t+1;
247                line(point(xp, y_upper), point(xp, y_lower));
248            }
249
250            break;
251
252#undef OUTER_HEIGHT
253#undef INNER_HEIGHT
254#undef CWIDTH
255#undef STEPS
256#undef THICKNESS
257
258        }
259        default: {
260            e4_assert(0);
261            break;
262        }
263    }
264}
265
266/* --------------------------------------------------------------------------------
267   ED4_cursor
268   -------------------------------------------------------------------------------- */
269
270static bool allow_update_global_cursorpos = true;
271
272ED4_returncode ED4_cursor::draw_cursor(AW_pos x, AW_pos y) { // @@@ remove return value
273    if (cursor_shape) {
274        delete cursor_shape;
275        cursor_shape = NULp;
276    }
277
278    cursor_shape = new ED4_CursorShape(ctype,
279                                       SEQ_TERM_TEXT_YOFFSET+2,
280                                       ED4_ROOT->font_group.get_width(ED4_G_SEQUENCES),
281                                       !awar_edit_rightward);
282
283    cursor_shape->draw(window()->get_device(), int(x), int(y));
284
285#if defined(TRACE_REFRESH)
286    printf("draw_cursor(%i, %i)\n", int(x), int(y));
287#endif // TRACE_REFRESH
288   
289    return ED4_R_OK;
290}
291
292ED4_returncode ED4_cursor::delete_cursor(AW_pos del_mark, ED4_base *target_terminal) {
293    AW_pos x, y;
294    target_terminal->calc_world_coords(&x, &y);
295    ED4_base *temp_parent = target_terminal->get_parent(LEV_SPECIES);
296    if (!temp_parent || temp_parent->flag.hidden || !is_partly_visible()) {
297        return ED4_R_BREAK;
298    }
299   
300    x = del_mark;
301    win->world_to_win_coords(&x, &y);
302
303    // refresh own terminal + terminal above + terminal below
304
305    const int     MAX_AFFECTED = 3;
306    int           affected     = 0;
307    ED4_terminal *affected_terminal[MAX_AFFECTED];
308
309    affected_terminal[affected++] = target_terminal->to_terminal();
310
311    {
312        ED4_terminal *term = target_terminal->to_terminal();
313        bool backward = true;
314
315        while (1) {
316            int done = 0;
317
318            term = backward ? term->get_prev_terminal() : term->get_next_terminal();
319            if (!term) done = 1;
320            else if ((term->is_sequence_terminal()) && !term->is_in_folded_group()) {
321                affected_terminal[affected++] = term;
322                done                          = 1;
323            }
324
325            if (done) {
326                if (!backward) break;
327                backward = false;
328                term = target_terminal->to_terminal();
329            }
330        }
331    }
332
333    bool refresh_was_requested[MAX_AFFECTED];
334    e4_assert(affected >= 1 && affected <= MAX_AFFECTED);
335    for (int a = 0; a<affected; ++a) {
336        ED4_terminal *term       = affected_terminal[a];
337        refresh_was_requested[a] = term->update_info.refresh;
338        term->request_refresh();
339    }
340
341    // clear rectangle where cursor is displayed
342
343    AW_device *dev = win->get_device();
344    dev->push_clip_scale();
345
346    int xmin, xmax, ymin, ymax;
347
348    e4_assert(cursor_shape);
349    cursor_shape->get_bounding_box(int(x), int(y), xmin, ymin, xmax, ymax);
350
351#if defined(TRACE_REFRESH)
352    printf("delete_cursor(%i, %i)\n", int(x), int(y));
353#endif // TRACE_REFRESH
354
355    dev->set_font_overlap(true);
356
357#define EXPAND_SIZE 0
358    if (dev->reduceClipBorders(ymin-EXPAND_SIZE, ymax+EXPAND_SIZE, xmin-EXPAND_SIZE, xmax+EXPAND_SIZE)) {
359        dev->clear_part(xmin, ymin, xmax-xmin+1, ymax-ymin+1, AW_ALL_DEVICES);
360        // refresh terminal to hide cursor
361        ED4_LocalWinContext uses(window());
362        LocallyModify<bool> flag(allowed_to_draw, false);
363        ED4_ROOT->special_window_refresh(false);
364    }
365    dev->pop_clip_scale();
366
367    // restore old refresh flags (to avoid refresh of 3 complete terminals when cursor changes)
368    for (int a = 0; a<affected; ++a) {
369        affected_terminal[a]->update_info.refresh = refresh_was_requested[a];
370    }
371
372    return ED4_R_OK;
373}
374
375
376ED4_cursor::ED4_cursor(ED4_window *win_) : win(win_) {
377    init();
378    allowed_to_draw = true;
379    cursor_shape    = NULp;
380
381    ctype = (ED4_CursorType)(ED4_ROOT->aw_root->awar(ED4_AWAR_CURSOR_TYPE)->read_int()%ED4_CURSOR_TYPES);
382}
383void ED4_cursor::init() {
384    // used by ED4_terminal-d-tor
385    owner_of_cursor   = NULp;
386    cursor_abs_x      = 0;
387    screen_position   = 0;
388}
389ED4_cursor::~ED4_cursor() {
390    delete cursor_shape;
391}
392
393int ED4_cursor::get_sequence_pos() const {
394    ED4_remap *remap = ED4_ROOT->root_group_man->remap();
395    size_t max_scrpos = remap->get_max_screen_pos();
396
397    return remap->screen_to_sequence(size_t(screen_position)<=max_scrpos ? screen_position : max_scrpos);
398}
399
400bool ED4_species_manager::setCursorTo(ED4_cursor *cursor, int seq_pos, bool unfold_groups, ED4_CursorJumpType jump_type) {
401    ED4_group_manager *group_manager_to_unfold = is_in_folded_group();
402
403    if (unfold_groups) {
404        bool did_unfold = false;
405
406        while (group_manager_to_unfold && unfold_groups) {
407            group_manager_to_unfold->unfold();
408            did_unfold              = true;
409            group_manager_to_unfold = is_in_folded_group();
410        }
411
412        if (did_unfold) ED4_ROOT->refresh_all_windows(1); // needed to recalculate world cache of target terminal
413    }
414
415    if (!group_manager_to_unfold) { // species manager is visible (now)
416        ED4_terminal *terminal = search_spec_child_rek(LEV_SEQUENCE_STRING)->to_terminal();
417        if (terminal) {
418            if (seq_pos == -1) seq_pos = cursor->get_sequence_pos();
419            cursor->set_to_terminal(terminal, seq_pos, jump_type);
420            return true;
421        }
422    }
423
424    return false;
425}
426
427static void jump_to_corresponding_seq_terminal(ED4_species_name_terminal *name_term, bool unfold_groups) {
428    ED4_species_manager *species_manager = name_term->get_parent(LEV_SPECIES)->to_species_manager();
429    ED4_cursor          *cursor          = &current_cursor();
430    bool                 jumped          = false;
431
432    if (species_manager) jumped = species_manager->setCursorTo(cursor, -1, unfold_groups, ED4_JUMP_KEEP_POSITION);
433    if (!jumped) cursor->HideCursor();
434}
435
436static bool ignore_selected_species_changes_cb = false;
437static bool ignore_selected_SAI_changes_cb     = false;
438
439static void select_named_sequence_terminal(const char *name) {
440    GB_transaction ta(GLOBAL_gb_main);
441    ED4_species_name_terminal *name_term = ED4_find_species_or_SAI_name_terminal(name);
442    if (name_term) {
443        ED4_MostRecentWinContext context; // use the last used window for selection
444
445        // lookup current name term
446        ED4_species_name_terminal *cursor_name_term = NULp;
447        {
448            ED4_cursor *cursor = &current_cursor();
449            if (cursor) {
450                ED4_sequence_terminal *cursor_seq_term = NULp;
451
452                if (cursor->owner_of_cursor) {
453                    ED4_terminal *cursor_term = cursor->owner_of_cursor->to_text_terminal();
454                    if (cursor_term->is_sequence_terminal()) {
455                        cursor_seq_term = cursor_term->to_sequence_terminal();
456                    }
457                    else { // cursor is in a non-sequence text terminal -> search for corresponding sequence terminal
458                        ED4_multi_sequence_manager *seq_man = cursor_term->get_parent(LEV_MULTI_SEQUENCE)->to_multi_sequence_manager();
459                        if (seq_man) {
460                            cursor_seq_term = seq_man->search_spec_child_rek(LEV_SEQUENCE_STRING)->to_sequence_terminal();
461                        }
462                    }
463                }
464                if (cursor_seq_term) {
465                    cursor_name_term = cursor_seq_term->corresponding_species_name_terminal();
466                }
467            }
468        }
469
470        if (name_term!=cursor_name_term) { // do not change if already there!
471#if defined(TRACE_JUMPS)
472            printf("Jumping to species/SAI '%s'\n", name);
473#endif
474            jump_to_corresponding_seq_terminal(name_term, false);
475        }
476        else {
477#if defined(TRACE_JUMPS)
478            printf("Change ignored because same name term!\n");
479#endif
480        }
481    }
482}
483
484void ED4_selected_SAI_changed_cb(AW_root * /* aw_root */) {
485    if (!ignore_selected_SAI_changes_cb) {
486        char *name = GBT_read_string(GLOBAL_gb_main, AWAR_SAI_NAME);
487
488        if (name && name[0]) {
489#if defined(TRACE_JUMPS)
490            printf("Selected SAI is '%s'\n", name);
491#endif // DEBUG
492            LocallyModify<bool> flag(allow_update_global_cursorpos, false);
493            select_named_sequence_terminal(name);
494            free(name);
495        }
496    }
497}
498
499void ED4_selected_species_changed_cb(AW_root * /* aw_root */) {
500    if (!ignore_selected_species_changes_cb) {
501        char *name = GBT_read_string(GLOBAL_gb_main, AWAR_SPECIES_NAME);
502        if (name && name[0]) {
503#if defined(TRACE_JUMPS)
504            printf("Selected species is '%s'\n", name);
505#endif
506            LocallyModify<bool> flag(allow_update_global_cursorpos, false);
507            select_named_sequence_terminal(name);
508        }
509        free(name);
510    }
511    else {
512#if defined(TRACE_JUMPS)
513        printf("Change ignored because ignore_selected_species_changes_cb!\n");
514#endif
515    }
516}
517
518void ED4_jump_to_current_species(AW_window *aww) {
519    ED4_LocalWinContext uses(aww);
520    char *name = GBT_read_string(GLOBAL_gb_main, AWAR_SPECIES_NAME);
521    if (name && name[0]) {
522        GB_transaction ta(GLOBAL_gb_main);
523#if defined(TRACE_JUMPS)
524        printf("Jump to selected species (%s)\n", name);
525#endif
526        ED4_species_name_terminal *name_term = ED4_find_species_name_terminal(name);
527
528        if (name_term) {
529            jump_to_corresponding_seq_terminal(name_term, true);
530        }
531        else {
532            aw_message(GBS_global_string("Species '%s' is not loaded - use GET to load it.", name));
533        }
534    }
535    else {
536        aw_message("Please select a species");
537    }
538}
539
540static bool multi_species_man_consensus_id_starts_with(ED4_base *base, const char *start) { // TRUE if consensus id starts with 'start'
541    ED4_multi_species_manager *ms_man    = base->to_multi_species_manager();
542    ED4_base                  *consensus = ms_man->search_spec_child_rek(LEV_SPECIES);
543
544    if (consensus) {
545        ED4_base *consensus_name = consensus->to_manager()->search_spec_child_rek(LEV_SPECIES_NAME);
546
547        if (consensus_name) {
548            if (strncmp(consensus_name->id, start, strlen(start))==0) {
549                ED4_multi_species_manager *cons_ms_man = consensus_name->get_parent(LEV_MULTI_SPECIES)->to_multi_species_manager();
550                return cons_ms_man==ms_man;
551            }
552        }
553    }
554
555    return false;
556}
557
558ED4_multi_species_manager *ED4_find_MoreSequences_manager() {
559    // returns manager into which new species should be inserted
560    ED4_base *manager = ED4_ROOT->root_group_man->find_first_that(LEV_MULTI_SPECIES, makeED4_basePredicate(multi_species_man_consensus_id_starts_with, "More Sequences"));
561    return manager ? manager->to_multi_species_manager() : NULp;
562}
563
564void ED4_init_notFoundMessage() {
565    not_found_counter = 0;
566    not_found_message = GBS_stropen(10000);
567    // GBS_strcat(not_found_message,"Species not found: ");
568}
569void ED4_finish_and_show_notFoundMessage() {
570    if (not_found_counter != 0) {
571        if (not_found_counter>MAX_SHOWN_MISSING_SPECIES) {
572            GBS_strcat(not_found_message, GBS_global_string("(skipped display of %zu more species)\n", not_found_counter-MAX_SHOWN_MISSING_SPECIES));
573        }
574        aw_message(GBS_mempntr(not_found_message));
575        aw_message(GBS_global_string("Couldn't load %zu species:", not_found_counter));
576    }
577    GBS_strforget(not_found_message);
578    not_found_message = NULp;
579}
580
581static ED4_species_name_terminal *insert_new_species_terminal(GB_CSTR species_name, bool is_SAI) {
582    ED4_multi_species_manager *insert_into_manager = ED4_find_MoreSequences_manager();
583    ED4_group_manager         *group_man           = insert_into_manager->get_parent(LEV_GROUP)->to_group_manager();
584
585    ED4_init_notFoundMessage();
586    {
587        char *buffer = ARB_alloc<char>(strlen(species_name)+3);
588        sprintf(buffer, "-%c%s", is_SAI ? 'S' : 'L', species_name);
589
590        int index = 0;
591        ED4_ROOT->database->fill_species(insert_into_manager, ED4_ROOT->ref_terminals, buffer, &index, insert_into_manager->calc_group_depth(), NULp);
592        free(buffer);
593    }
594    ED4_finish_and_show_notFoundMessage();
595
596    {
597        GBDATA *gb_item = is_SAI ? GBT_find_SAI(GLOBAL_gb_main, species_name) : GBT_find_species(GLOBAL_gb_main, species_name);
598
599        if (gb_item) {
600            GBDATA *gbd = GBT_find_sequence(gb_item, ED4_ROOT->alignment_name);
601            if (gbd) {
602                char *data = GB_read_string(gbd);
603                int   len  = GB_read_string_count(gbd);
604
605                group_man->update_bases(NULp, 0, data, len);
606            }
607        }
608    }
609
610    ED4_species_name_terminal *name_term = is_SAI
611        ? ED4_find_SAI_name_terminal(species_name)
612        : ED4_find_species_name_terminal(species_name);
613
614    if (name_term) {
615        // new AAseqTerminals should be created if it is in ProtView mode
616        if (ED4_ROOT->alignment_type == GB_AT_DNA && !is_SAI) {
617            PV_AddCorrespondingOrfTerminals(name_term);
618        }
619        ED4_ROOT->main_manager->request_resize(); // @@@ instead needs to be called whenever adding or deleting PV-terminals
620        // it should create new AA Sequence terminals if the protein viewer is enabled
621    }
622    insert_into_manager->invalidate_species_counters();
623
624    return name_term;
625}
626
627void ED4_get_and_jump_to_selected_SAI(AW_window *aww) {
628    const char *sai_name = aww->get_root()->awar(AWAR_SAI_NAME)->read_char_pntr();
629
630    if (sai_name && sai_name[0]) {
631        ED4_MostRecentWinContext   context;
632        GB_transaction             ta(GLOBAL_gb_main);
633        ED4_species_name_terminal *name_term = ED4_find_SAI_name_terminal(sai_name);
634        bool                       loaded    = false;
635
636        if (!name_term) {
637            name_term = insert_new_species_terminal(sai_name, true);
638            loaded    = true;
639        }
640        if (name_term) {
641            jump_to_corresponding_seq_terminal(name_term, true);
642            if (!loaded) aw_message(GBS_global_string("SAI '%s' is already loaded.", sai_name));
643        }
644        else {
645            aw_message(GBS_global_string("Failed to load SAI '%s'", sai_name));
646        }
647    }
648}
649
650void ED4_get_and_jump_to_species(GB_CSTR species_name) {
651    e4_assert(species_name && species_name[0]);
652
653    GB_transaction             ta(GLOBAL_gb_main);
654    ED4_species_name_terminal *name_term = ED4_find_species_name_terminal(species_name);
655    bool                       loaded    = false;
656
657    if (!name_term) { // insert new species
658        name_term = insert_new_species_terminal(species_name, false);
659        loaded    = true;
660    }
661    if (name_term) {
662        jump_to_corresponding_seq_terminal(name_term, true);
663        if (!loaded) aw_message(GBS_global_string("Species '%s' is already loaded.", species_name));
664    }
665    else {
666        aw_message(GBS_global_string("Failed to get species '%s'", species_name));
667    }
668}
669
670void ED4_get_and_jump_to_current(AW_window *aww) {
671    ED4_LocalWinContext  uses(aww);
672    char                *name = GBT_read_string(GLOBAL_gb_main, AWAR_SPECIES_NAME);
673    if (name && name[0]) {
674        ED4_get_and_jump_to_species(name);
675    }
676    else {
677        aw_message("Please select a species");
678    }
679}
680
681void ED4_get_marked_from_menu(AW_window *) {
682#define BUFFERSIZE 1000
683    GB_transaction ta(GLOBAL_gb_main);
684    long marked = GBT_count_marked_species(GLOBAL_gb_main);
685
686    if (marked) {
687        GBDATA *gb_species = GBT_first_marked_species(GLOBAL_gb_main);
688        char   *buffer     = new char[BUFFERSIZE+1];
689        char   *bp         = buffer;
690
691        ED4_multi_species_manager *insert_into_manager = ED4_find_MoreSequences_manager();
692        ED4_group_manager         *group_man           = insert_into_manager->get_parent(LEV_GROUP)->to_group_manager();
693
694        int   group_depth       = insert_into_manager->calc_group_depth();
695        int   index             = 0;
696        int   inserted          = 0;
697        char *default_alignment = GBT_get_default_alignment(GLOBAL_gb_main);
698
699        arb_progress progress("Loading species", marked);
700
701        ED4_init_notFoundMessage();
702
703        while (gb_species) {
704            const char *name = GBT_read_name(gb_species);
705            ED4_species_name_terminal *name_term = ED4_find_species_name_terminal(name);
706
707            if (!name_term) { // species not found -> insert
708                {
709                    int namelen = strlen(name);
710                    int buffree = BUFFERSIZE-int(bp-buffer);
711
712                    if ((namelen+2)>buffree) {
713                        *bp = 0;
714                        ED4_ROOT->database->fill_species(insert_into_manager, ED4_ROOT->ref_terminals, buffer, &index, group_depth, NULp);
715                        bp = buffer;
716                        index = 0;
717                    }
718
719                    *bp++ = 1;
720                    *bp++ = 'L';
721                    memcpy(bp, name, namelen);
722                    bp += namelen;
723                }
724
725                {
726                    GBDATA *gbd = GBT_find_sequence(gb_species, default_alignment);
727
728                    if (gbd) {
729                        char *data = GB_read_string(gbd);
730                        int len = GB_read_string_count(gbd);
731                        group_man->table().add(data, len);
732                    }
733                }
734
735                inserted++;
736            }
737            gb_species = GBT_next_marked_species(gb_species);
738            progress.inc();
739        }
740
741        if (bp>buffer) {
742            *bp++ = 0;
743            ED4_ROOT->database->fill_species(insert_into_manager, ED4_ROOT->ref_terminals, buffer, &index, group_depth, NULp);
744        }
745
746        aw_message(GBS_global_string("Loaded %i of %li marked species.", inserted, marked));
747
748        ED4_finish_and_show_notFoundMessage();
749
750        if (inserted) {
751            // new AAseqTerminals should be created if it is in ProtView mode
752            if (ED4_ROOT->alignment_type == GB_AT_DNA) {
753                PV_AddOrfTerminalsToLoadedSpecies();
754            }
755            ED4_ROOT->main_manager->request_resize(); // @@@ instead needs to be called whenever adding or deleting PV-terminals
756        }
757
758        delete [] buffer;
759        free(default_alignment);
760    }
761    else {
762        aw_message("No species marked.");
763    }
764
765#undef BUFFERSIZE
766}
767
768ED4_returncode ED4_cursor::HideCursor() {
769    if (owner_of_cursor) {
770        if (is_partly_visible()) {
771            delete_cursor(cursor_abs_x, owner_of_cursor);
772        }
773        owner_of_cursor = NULp;
774    }
775
776    return ED4_R_OK;
777}
778
779void ED4_cursor::changeType(ED4_CursorType typ) {
780    if (owner_of_cursor) {
781        ED4_terminal *old_owner_of_cursor = owner_of_cursor;
782
783        HideCursor();
784        ctype = typ;
785        ED4_ROOT->aw_root->awar(ED4_AWAR_CURSOR_TYPE)->write_int(int(ctype));
786        owner_of_cursor = old_owner_of_cursor;
787        ShowCursor(0, ED4_C_NONE, 0);
788    }
789    else {
790        ctype = typ;
791    }
792}
793
794static void trace_termChange_in_global_awar(ED4_terminal *term, char*& last_value, bool& ignore_flag, const char *awar_name) {
795    char *species_name = term->get_name_of_species();
796
797    if (!last_value || strcmp(last_value, species_name) != 0) {
798        freeset(last_value, species_name);
799        LocallyModify<bool> raise(ignore_flag, true);
800#if defined(TRACE_JUMPS)
801        fprintf(stderr, "Writing '%s' to awar '%s'\n", species_name, awar_name);
802#endif
803        GBT_write_string(GLOBAL_gb_main, awar_name, species_name);
804    }
805    else {
806        free(species_name);
807    }
808}
809
810void ED4_cursor::updateAwars(bool new_term_selected) {
811    AW_root *aw_root = ED4_ROOT->aw_root;
812    int      seq_pos = get_sequence_pos();
813
814    if (allow_update_global_cursorpos && new_term_selected) {
815        // @@@ last_set_XXX has to be window-specific (or better cursor specific)
816        if (in_SAI_terminal()) {
817            static char *last_set_SAI = NULp;
818            trace_termChange_in_global_awar(owner_of_cursor, last_set_SAI, ignore_selected_SAI_changes_cb, AWAR_SAI_NAME);
819        }
820        else if (in_species_seq_terminal()) {
821            static char *last_set_species = NULp;
822            trace_termChange_in_global_awar(owner_of_cursor, last_set_species, ignore_selected_species_changes_cb, AWAR_SPECIES_NAME);
823        }
824    }
825    if (new_term_selected) ED4_viewDifferences_announceTerminalChange();
826
827    // update awars for cursor position:
828    aw_root->awar(win->awar_path_for_cursor)->write_int(info2bio(seq_pos));
829    if (allow_update_global_cursorpos) {
830        aw_root->awar(AWAR_CURSOR_POSITION)->write_int(info2bio(seq_pos)); // update ARB-global cursor position
831    }
832
833    // look if we have a commented search result under the cursor:
834
835    if (owner_of_cursor && owner_of_cursor->is_sequence_terminal()) {
836        ED4_sequence_terminal *seq_term = owner_of_cursor->to_sequence_terminal();
837        ED4_SearchResults     &results  = seq_term->results();
838        ED4_SearchPosition    *pos      = results.get_shown_at(seq_pos);
839
840        if (pos) {
841            GB_CSTR comment = pos->get_comment();
842
843            if (comment) {
844                char *buffer = GB_give_buffer(strlen(comment)+30);
845
846                sprintf(buffer, "%s: %s", ED4_SearchPositionTypeId[pos->get_whatsFound()], comment);
847                aw_message(buffer);
848            }
849        }
850    }
851
852    // update awar for ecoli position:
853    BI_ecoli_ref *ecoli = ED4_ROOT->ecoli_ref;
854    if (ecoli->gotData()) {
855        int ecoli_pos = ecoli->abs_2_rel(seq_pos+1); // inclusive position behind cursor
856        aw_root->awar(win->awar_path_for_Ecoli)->write_int(ecoli_pos);
857    }
858
859    // update awar for base position:
860    int base_pos = base_position.get_base_position(owner_of_cursor, seq_pos+1); // inclusive position behind cursor
861    aw_root->awar(win->awar_path_for_basePos)->write_int(base_pos);
862
863    // update awar for IUPAC:
864
865#define MAXIUPAC 6
866
867    char iupac[MAXIUPAC+1];
868    strcpy(iupac, ED4_IUPAC_EMPTY);
869
870    {
871        char at[2] = "\0";
872
873        if (in_consensus_terminal()) {
874            ED4_group_manager *group_manager = owner_of_cursor->get_parent(LEV_GROUP)->to_group_manager();
875            BaseFrequencies&   groupTab      = group_manager->table();
876            if (seq_pos<groupTab.size()) {
877                groupTab.build_consensus_string_to(at, ExplicitRange(seq_pos, seq_pos), ED4_ROOT->get_consensus_params());
878            }
879        }
880        else if (in_species_seq_terminal() || in_SAI_terminal()) {
881            int         len;
882            const char *seq = owner_of_cursor->resolve_pointer_to_char_pntr(&len);
883
884            if (seq_pos<len) at[0] = seq[seq_pos];
885        }
886
887        if (at[0]) {
888            char        base = at[0];
889            const char *i    = iupac::decode(base, ED4_ROOT->alignment_type, aw_root->awar(ED4_AWAR_CONSENSUS_GROUP)->read_int());
890
891            e4_assert(strlen(i)<=MAXIUPAC);
892            strcpy(iupac, i);
893        }
894    }
895
896#undef MAXIUPAC
897
898    aw_root->awar(win->awar_path_for_IUPAC)->write_string(iupac);
899
900    // update awar for helix#:
901    const char *helixNr = ED4_ROOT->helix->helixNr(seq_pos);
902    aw_root->awar(win->awar_path_for_helixNr)->write_string(helixNr ? helixNr : "");
903}
904
905int ED4_cursor::get_screen_relative_pos() const {
906    const ED4_coords& coords = window()->coords;
907    return cursor_abs_x - coords.window_left_clip_point;
908}
909void ED4_cursor::set_screen_relative_pos(int scroll_to_relpos) {
910    int curr_rel_pos  = get_screen_relative_pos();
911    int scroll_amount = curr_rel_pos-scroll_to_relpos;
912
913    int length_of_char = ED4_ROOT->font_group.get_width(ED4_G_SEQUENCES);
914    scroll_amount      = (scroll_amount/length_of_char)*length_of_char; // align to char-size
915
916    if (scroll_amount != 0) {
917        AW_window *aww = window()->aww;
918        aww->set_horizontal_scrollbar_position(aww->slider_pos_horizontal + scroll_amount);
919#if defined(TRACE_JUMPS)
920        printf("set_screen_relative_pos(%i) auto-scrolls %i\n", scroll_to_relpos, scroll_amount);
921#endif
922        ED4_horizontal_change_cb(aww);
923    }
924}
925
926
927void ED4_cursor::jump_screen_pos(int screen_pos, ED4_CursorJumpType jump_type) {
928    if (!owner_of_cursor) {
929        aw_message("First you have to place the cursor");
930        return;
931    }
932
933    if (owner_of_cursor->is_hidden()) return; // do not jump if cursor terminal is hidden
934
935    AW_pos terminal_x, terminal_y;
936    owner_of_cursor->calc_world_coords(&terminal_x, &terminal_y);
937
938#if defined(TRACE_JUMPS)
939    printf("jump_screen_pos(%i)\n", screen_pos);
940#endif
941
942    ED4_terminal *term = owner_of_cursor;
943    ED4_window   *ed4w = window();
944
945    term->scroll_into_view(ed4w); // correct y-position of terminal
946
947    int cursor_diff = screen_pos-screen_position;
948    if (cursor_diff == 0) { // cursor position did not change
949        if (jump_type == ED4_JUMP_KEEP_VISIBLE) return; // nothing special -> done
950    }
951
952    int terminal_pixel_length = ed4w->get_device()->get_string_size(ED4_G_SEQUENCES, owner_of_cursor->to_text_terminal()->get_length());
953    int length_of_char        = ED4_ROOT->font_group.get_width(ED4_G_SEQUENCES);
954    int abs_x_new             = cursor_abs_x+cursor_diff*length_of_char; // position in terminal
955
956    if (abs_x_new > terminal_x+terminal_pixel_length+CHARACTEROFFSET || abs_x_new < terminal_x+CHARACTEROFFSET) {
957        return; // don`t move out of terminal
958    }
959
960    ED4_coords *coords = &ed4w->coords;
961
962    int screen_width  = coords->window_right_clip_point-coords->window_left_clip_point;
963    int scroll_new_to = -1;     // if >0 -> scroll abs_x_new to this screen-relative position
964
965    if (jump_type != ED4_JUMP_KEEP_VISIBLE) {
966        int rel_x = cursor_abs_x-coords->window_left_clip_point;
967
968        if (jump_type == ED4_JUMP_KEEP_POSITION) {
969            bool was_in_screen = rel_x >= 0 && rel_x <= screen_width;
970            if (!was_in_screen) {
971                jump_type = ED4_JUMP_KEEP_VISIBLE; // // don't have useful relative position -> scroll
972            }
973        }
974
975        switch (jump_type) {
976            case ED4_JUMP_CENTERED:             scroll_new_to = screen_width/2;         break;
977            case ED4_JUMP_KEEP_POSITION:        scroll_new_to = rel_x;                  break;
978            case ED4_JUMP_KEEP_VISIBLE:         break; // handled below
979            default: e4_assert(0); break;
980        }
981    }
982
983    if (jump_type == ED4_JUMP_KEEP_VISIBLE) {
984        int margin = length_of_char * ED4_ROOT->aw_root->awar(ED4_AWAR_SCROLL_MARGIN)->read_int();
985
986        int right_margin = coords->window_right_clip_point - margin;
987        int left_margin  = coords->window_left_clip_point + margin;
988
989        if (left_margin >= right_margin)    scroll_new_to = screen_width/2; // margins too big -> center
990        else if (abs_x_new > right_margin)  scroll_new_to = screen_width-margin;
991        else if (abs_x_new < left_margin)   scroll_new_to = margin;
992    }
993
994    delete_cursor(cursor_abs_x, owner_of_cursor);
995
996    if (scroll_new_to >= 0) {   // scroll
997        int rel_x_new     = abs_x_new-coords->window_left_clip_point;
998        int scroll_amount = rel_x_new-scroll_new_to;
999
1000        if      (scroll_amount>0) scroll_amount += length_of_char/2;
1001        else if (scroll_amount<0) scroll_amount -= length_of_char/2;
1002
1003        scroll_amount = (scroll_amount/length_of_char)*length_of_char; // align to char-size
1004        if (scroll_amount != 0) {
1005            AW_window *aww  = ed4w->aww;
1006            aww->set_horizontal_scrollbar_position(aww->slider_pos_horizontal + scroll_amount);
1007#if defined(TRACE_JUMPS)
1008            printf("jump_screen_pos auto-scrolls %i\n", scroll_amount);
1009#endif
1010            LocallyModify<bool> flag(allowed_to_draw, false);
1011            ED4_horizontal_change_cb(aww);
1012        }
1013    }
1014
1015    LocallyModify<bool> flag(allowed_to_draw, true);
1016    if (cursor_diff >= 0) {
1017        ShowCursor(cursor_diff*length_of_char, ED4_C_RIGHT, abs(cursor_diff));
1018    }
1019    else {
1020        ShowCursor(cursor_diff*length_of_char, ED4_C_LEFT, abs(cursor_diff));
1021    }
1022#if defined(ASSERTION_USED)
1023    {
1024        int sp = get_screen_pos();
1025        e4_assert(sp == screen_pos);
1026    }
1027#endif
1028}
1029
1030void ED4_cursor::jump_sequence_pos(int seq_pos, ED4_CursorJumpType jump_type) {
1031    ED4_remap *remap = ED4_ROOT->root_group_man->remap();
1032
1033    if (remap->is_shown(seq_pos)) {
1034        int screen_pos = remap->sequence_to_screen(seq_pos);
1035        jump_screen_pos(screen_pos, jump_type);
1036#if defined(ASSERTION_USED)
1037        if (owner_of_cursor) {
1038            int res_seq_pos = get_sequence_pos();
1039            e4_assert(res_seq_pos == seq_pos);
1040        }
1041#endif
1042    }
1043    else {
1044        int scr_left, scr_right;
1045        remap->adjacent_screen_positions(seq_pos, scr_left, scr_right);
1046        jump_screen_pos(scr_right>=0 ? scr_right : scr_left, jump_type);
1047    }
1048}
1049
1050void ED4_cursor::jump_base_pos(int base_pos, ED4_CursorJumpType jump_type) {
1051    int seq_pos = base2sequence_position(base_pos);
1052    jump_sequence_pos(seq_pos, jump_type);
1053
1054#if defined(ASSERTION_USED)
1055    if (owner_of_cursor) {
1056        int bp = get_base_position();
1057        e4_assert(bp == base_pos);
1058    }
1059#endif
1060}
1061
1062class has_base_at : public ED4_TerminalPredicate {
1063    int  seq_pos;
1064    bool want_base;
1065public:
1066    has_base_at(int seq_pos_, bool want_base_) : seq_pos(seq_pos_), want_base(want_base_) {}
1067    bool fulfilled_by(const ED4_terminal *terminal) const OVERRIDE {
1068        bool test_succeeded = false;
1069
1070        if (terminal->is_sequence_terminal()) {
1071            const ED4_sequence_terminal *seqTerm = terminal->to_sequence_terminal();
1072            int len;
1073            char *seq = seqTerm->resolve_pointer_to_string_copy(&len);
1074            if (seq) {
1075                test_succeeded = len>seq_pos && bool(ED4_is_gap_character(seq[seq_pos]))!=want_base;
1076            }
1077            free(seq);
1078        }
1079
1080        return test_succeeded;
1081    }
1082};
1083
1084struct acceptAnyTerminal : public ED4_TerminalPredicate {
1085    bool fulfilled_by(const ED4_terminal *) const OVERRIDE { return true; }
1086};
1087
1088static ED4_terminal *get_upper_lower_cursor_pos(ED4_manager *starting_point, ED4_cursor_move cursor_move, AW_pos current_y, bool isScreen, const ED4_TerminalPredicate& predicate) {
1089    // current_y is y-position of terminal at which search starts.
1090    // It may be in world or screen coordinates (isScreen marks which is used)
1091    // This is needed to move the cursor from top- to middle-area w/o scrolling middle-area to top-position.
1092
1093    ED4_terminal *result = NULp;
1094
1095    int m      = 0;
1096    int last_m = starting_point->members()-1;
1097    int incr   = 1;
1098
1099    if (cursor_move == ED4_C_UP) {
1100        std::swap(m, last_m); incr = -1; // revert search direction
1101        e4_assert(!isScreen);            // use screen coordinates for ED4_C_DOWN only!
1102    }
1103
1104    while (!result) {
1105        ED4_base *member = starting_point->member(m);
1106
1107        if (member->is_manager()) {
1108            if (!member->flag.hidden) { // step over hidden managers (e.g. folded groups)
1109                result = get_upper_lower_cursor_pos(member->to_manager(), cursor_move, current_y, isScreen, predicate);
1110            }
1111        }
1112        else {
1113            if (member->has_property(PROP_CURSOR_ALLOWED)) {
1114                AW_pos x, y;
1115                member->calc_world_coords(&x, &y);
1116                if (isScreen) current_ed4w()->world_to_win_coords(&x, &y); // if current_y is screen, convert x/y to screen-coordinates as well
1117
1118                bool pos_beyond = (cursor_move == ED4_C_UP) ? y<current_y : y>current_y;
1119                if (pos_beyond) {
1120                    bool skip_top_scrolled = false;
1121                    if (isScreen) {
1122                        ED4_multi_species_manager *marea_man = NULp;
1123                        if (member->get_area_level(&marea_man) == ED4_A_MIDDLE_AREA) {
1124                            // previous position was in top-area -> avoid selecting scrolled-out terminals
1125                            AW_pos y_area     = marea_man->parent->extension.position[Y_POS];
1126                            skip_top_scrolled = y<y_area;
1127                        }
1128                    }
1129
1130                    if (!skip_top_scrolled) {
1131                        ED4_terminal *term = member->to_terminal();
1132                        if (predicate.fulfilled_by(term)) result = term;
1133                    }
1134                }
1135            }
1136        }
1137
1138        if (m == last_m) break;
1139        m += incr;
1140    }
1141
1142    return result;
1143}
1144
1145struct acceptConsensusTerminal : public ED4_TerminalPredicate {
1146    bool fulfilled_by(const ED4_terminal *term) const OVERRIDE { return term->is_consensus_terminal(); }
1147};
1148
1149ED4_returncode ED4_cursor::move_cursor(AW_event *event) {
1150    // move cursor up down
1151    ED4_cursor_move dir     = ED4_C_NONE;
1152    ED4_returncode  result  = ED4_R_OK;
1153    bool            endHome = false;
1154
1155    switch (event->keycode) {
1156        case AW_KEY_UP:   dir = ED4_C_UP;   break;
1157        case AW_KEY_DOWN: dir = ED4_C_DOWN; break;
1158        case AW_KEY_HOME: dir = ED4_C_UP;   endHome = true; break;
1159        case AW_KEY_END:  dir = ED4_C_DOWN; endHome = true; break;
1160        default: e4_assert(0); break; // illegal call of move_cursor()
1161    }
1162
1163    if (dir != ED4_C_NONE) {
1164        if (owner_of_cursor->is_hidden()) result = ED4_R_IMPOSSIBLE; // don't move cursor if terminal is hidden
1165
1166        if (result == ED4_R_OK) {
1167            AW_pos x_dummy, y_world;
1168
1169            owner_of_cursor->calc_world_coords(&x_dummy, &y_world);
1170
1171            int           seq_pos         = get_sequence_pos();
1172            ED4_terminal *target_terminal = NULp;
1173
1174            // stay in current area
1175            ED4_multi_species_manager *start_at_manager = NULp;
1176            ED4_AREA_LEVEL             area_level       = owner_of_cursor->get_area_level(&start_at_manager);
1177
1178            if (event->keymodifier & AW_KEYMODE_CONTROL) {
1179                bool has_base = has_base_at(seq_pos, true).fulfilled_by(owner_of_cursor);
1180
1181                if (!endHome) { // not End or Home
1182                    target_terminal = get_upper_lower_cursor_pos(start_at_manager, dir, y_world, false, has_base_at(seq_pos, !has_base));
1183                    if (target_terminal && !has_base && ED4_ROOT->aw_root->awar(ED4_AWAR_FAST_CURSOR_JUMP)->read_int()) {  // if jump_over group
1184                        target_terminal->calc_world_coords(&x_dummy, &y_world);
1185                        target_terminal = get_upper_lower_cursor_pos(start_at_manager, dir, y_world, false, has_base_at(seq_pos, false));
1186                    }
1187                }
1188
1189                if (!target_terminal) {
1190                    // either already in last group (or no space behind last group) -> jump to end (or start)
1191                    target_terminal = get_upper_lower_cursor_pos(start_at_manager,
1192                                                                 dir == ED4_C_UP ? ED4_C_DOWN : ED4_C_UP, // use opposite movement direction
1193                                                                 dir == ED4_C_UP ? 0 : INT_MAX, false, // search for top-/bottom-most terminal
1194                                                                 acceptAnyTerminal());
1195                }
1196            }
1197            else {
1198                e4_assert(!endHome); // END and HOME w/o Ctrl should not call move_cursor()
1199                if (event->keymodifier & AW_KEYMODE_ALT) {
1200                    target_terminal = get_upper_lower_cursor_pos(start_at_manager, dir, y_world, false, acceptConsensusTerminal());
1201                }
1202                else {
1203                    bool isScreen = false;
1204                    if (dir == ED4_C_DOWN) {
1205                        if (area_level == ED4_A_TOP_AREA) {
1206                            window()->world_to_win_coords(&x_dummy, &y_world); // special handling to move cursor from top to bottom area
1207                            isScreen = true;
1208                        }
1209                    }
1210                    target_terminal = get_upper_lower_cursor_pos(ED4_ROOT->main_manager, dir, y_world, isScreen, acceptAnyTerminal());
1211                }
1212            }
1213
1214            if (target_terminal) {
1215                set_to_terminal(target_terminal, seq_pos, ED4_JUMP_KEEP_VISIBLE);
1216            }
1217        }
1218    }
1219
1220    return result;
1221}
1222
1223void ED4_cursor::set_abs_x() {
1224    AW_pos x, y;
1225    owner_of_cursor->calc_world_coords(&x, &y);
1226    cursor_abs_x = int(get_sequence_pos()*ED4_ROOT->font_group.get_width(ED4_G_SEQUENCES) + CHARACTEROFFSET + x);
1227}
1228
1229
1230ED4_returncode ED4_cursor::ShowCursor(ED4_index offset_x, ED4_cursor_move move, int move_pos) {
1231    AW_pos x=0, y=0, x_help = 0, y_help;
1232
1233    owner_of_cursor->calc_world_coords(&x, &y);
1234
1235    switch (move) {
1236        case ED4_C_RIGHT: screen_position += move_pos; break;
1237        case ED4_C_LEFT:  screen_position -= move_pos; break;
1238        case ED4_C_NONE: break; // no move - only redisplay
1239        default: e4_assert(0); break;
1240    }
1241
1242    {
1243        LocallyModify<bool> flag(allow_update_global_cursorpos, allow_update_global_cursorpos && move != ED4_C_NONE);
1244        updateAwars(false);
1245    }
1246
1247    x_help = cursor_abs_x + offset_x;
1248    y_help = y;
1249
1250    window()->world_to_win_coords(&x_help, &y_help);
1251
1252    if (allowed_to_draw) draw_cursor(x_help, y_help);
1253#if defined(DEBUG) && 0
1254    else printf("Skip draw_cursor (allowed_to_draw=false)\n");
1255#endif // DEBUG
1256
1257    cursor_abs_x += offset_x;
1258
1259    return ED4_R_OK;
1260}
1261
1262bool ED4_cursor::is_hidden_inside_group() const {
1263    if (!owner_of_cursor) return false;
1264    if (!owner_of_cursor->is_in_folded_group()) return false;
1265    if (in_consensus_terminal()) {
1266        ED4_base *group_man = owner_of_cursor->get_parent(LEV_GROUP);
1267        e4_assert(group_man);
1268        return group_man->is_in_folded_group();
1269    }
1270    return true;
1271}
1272
1273bool ED4_cursor::is_partly_visible() const {
1274    e4_assert(owner_of_cursor);
1275    e4_assert(cursor_shape); // cursor is not drawn, cannot test visibility
1276
1277    if (is_hidden_inside_group()) {
1278        printf("is_hidden_inside_group=true\n");
1279        return false;
1280    }
1281
1282    AW_pos x, y;
1283    owner_of_cursor->calc_world_coords(&x, &y);
1284
1285    int x1, y1, x2, y2;
1286    cursor_shape->get_bounding_box(cursor_abs_x, int(y), x1, y1, x2, y2);
1287
1288    bool visible = false;
1289
1290    switch (owner_of_cursor->get_area_level(NULp)) {
1291        case ED4_A_TOP_AREA:    visible = win->shows_xpos(x1) || win->shows_xpos(x2); break;
1292        case ED4_A_MIDDLE_AREA: visible = win->partly_shows(x1, y1, x2, y2); break;
1293        default: break;
1294    }
1295
1296    return visible;
1297}
1298
1299bool ED4_cursor::is_completely_visible() const {
1300    e4_assert(owner_of_cursor);
1301    e4_assert(cursor_shape); // cursor is not drawn, cannot test visibility
1302
1303    if (is_hidden_inside_group()) return false;
1304
1305    AW_pos x, y;
1306    owner_of_cursor->calc_world_coords(&x, &y);
1307
1308    int x1, y1, x2, y2;
1309    cursor_shape->get_bounding_box(cursor_abs_x, int(y), x1, y1, x2, y2);
1310
1311    bool visible = false;
1312
1313    switch (owner_of_cursor->get_area_level(NULp)) {
1314        case ED4_A_TOP_AREA:    visible = win->shows_xpos(x1) && win->shows_xpos(x2); break;
1315        case ED4_A_MIDDLE_AREA: visible = win->completely_shows(x1, y1, x2, y2); break;
1316        default: break;
1317    }
1318
1319    return visible;
1320}
1321
1322#if defined(DEBUG) && 0
1323#define DUMP_SCROLL_INTO_VIEW
1324#endif
1325
1326void ED4_terminal::scroll_into_view(ED4_window *ed4w) { // scroll y-position only
1327    ED4_LocalWinContext uses(ed4w);
1328
1329    AW_pos termw_x, termw_y;
1330    calc_world_coords(&termw_x, &termw_y);
1331
1332    ED4_coords *coords  = &current_ed4w()->coords;
1333
1334    int term_height = int(extension.size[1]);
1335    int win_ysize   = coords->window_lower_clip_point - coords->window_upper_clip_point + 1;
1336
1337    bool scroll = false;
1338    int  slider_pos_y;
1339
1340    ED4_cursor_move direction = ED4_C_NONE;
1341
1342    AW_pos termw_y_upper = termw_y; // upper border of terminal
1343    AW_pos termw_y_lower = termw_y + term_height; // lower border of terminal
1344
1345    if (termw_y_upper > coords->top_area_height) { // don't scroll if terminal is in top area (always visible)
1346        if (termw_y_upper < coords->window_upper_clip_point) { // scroll up
1347#ifdef DUMP_SCROLL_INTO_VIEW
1348            printf("termw_y_upper(%i) < window_upper_clip_point(%i)\n",
1349                   int(termw_y_upper), int(coords->window_upper_clip_point));
1350#endif // DEBUG
1351            slider_pos_y = int(termw_y_upper - coords->top_area_height - term_height);
1352            scroll       = true;
1353            direction    = ED4_C_UP;
1354        }
1355        else if (termw_y_lower > coords->window_lower_clip_point) { // scroll down
1356#ifdef DUMP_SCROLL_INTO_VIEW
1357            printf("termw_y_lower(%i) > window_lower_clip_point(%i)\n",
1358                   int(termw_y_lower), int(coords->window_lower_clip_point));
1359#endif // DEBUG
1360            slider_pos_y = int(termw_y_upper - coords->top_area_height - win_ysize);
1361            scroll       = true;
1362            direction    = ED4_C_DOWN;
1363        }
1364    }
1365
1366#ifdef DUMP_SCROLL_INTO_VIEW
1367    if (!scroll) {
1368        printf("No scroll needed (termw_y_upper=%i termw_y_lower=%i term_height=%i window_upper_clip_point=%i window_lower_clip_point=%i)\n",
1369               int(termw_y_upper), int(termw_y_lower), term_height,
1370               int(coords->window_upper_clip_point), int(coords->window_lower_clip_point));
1371    }
1372#endif // DEBUG
1373
1374    if (scroll) {
1375        AW_window *aww = ed4w->aww;
1376
1377        int pic_ysize         = int(aww->get_scrolled_picture_height());
1378        int slider_pos_yrange = pic_ysize - win_ysize;
1379
1380        if (slider_pos_yrange<0) { // win_ysize > pic_ysize
1381            slider_pos_y = 0;
1382        }
1383        else {
1384            ED4_multi_species_manager *start_at_manager = NULp;
1385            get_area_level(&start_at_manager);
1386           
1387            ED4_terminal *nextTerm = get_upper_lower_cursor_pos(start_at_manager, direction, termw_y, false, acceptAnyTerminal());
1388            if (!nextTerm) { // no next term in this area
1389                slider_pos_y = direction == ED4_C_UP ? 0 : slider_pos_yrange; // scroll to limit
1390            }
1391        }
1392
1393        if (slider_pos_y>slider_pos_yrange) slider_pos_y = slider_pos_yrange;
1394        if (slider_pos_y<0) slider_pos_y                 = 0;
1395
1396        aww->set_vertical_scrollbar_position(slider_pos_y);
1397        ED4_scrollbar_change_cb(aww);
1398    }
1399}
1400
1401void ED4_cursor::set_to_terminal(ED4_terminal *terminal, int seq_pos, ED4_CursorJumpType jump_type) {
1402    if (seq_pos == -1) seq_pos = get_sequence_pos();
1403
1404    bool new_term_selected = owner_of_cursor != terminal;
1405    if (new_term_selected) {
1406        if (owner_of_cursor) {
1407            if (get_sequence_pos() != seq_pos) {
1408                jump_sequence_pos(seq_pos, jump_type); // position to wanted column -- scrolls horizontally
1409            }
1410        }
1411
1412        int scr_pos = ED4_ROOT->root_group_man->remap()->sequence_to_screen(seq_pos);
1413        show_cursor_at(terminal, scr_pos);
1414
1415        if (!is_completely_visible()) {
1416            jump_sequence_pos(seq_pos, jump_type);
1417        }
1418    }
1419    else {
1420        jump_sequence_pos(seq_pos, jump_type);
1421    }
1422
1423    GB_transaction ta(GLOBAL_gb_main);
1424    updateAwars(new_term_selected);
1425}
1426
1427ED4_returncode ED4_cursor::show_cursor_at(ED4_terminal *target_terminal, ED4_index scr_pos) {
1428    bool new_term_selected = owner_of_cursor != target_terminal;
1429   
1430    if (owner_of_cursor) {
1431        if (is_partly_visible()) {
1432            delete_cursor(cursor_abs_x, owner_of_cursor);
1433        }
1434        owner_of_cursor = NULp;
1435        DRAW = 1;
1436    }
1437
1438    target_terminal->scroll_into_view(window());
1439
1440    AW_pos termw_x, termw_y;
1441    target_terminal->calc_world_coords(&termw_x, &termw_y);
1442
1443    screen_position = scr_pos;
1444
1445    int length_of_char = ED4_ROOT->font_group.get_width(ED4_G_SEQUENCES);
1446
1447    AW_pos world_x = termw_x + length_of_char*screen_position + CHARACTEROFFSET;
1448    AW_pos world_y = termw_y;
1449
1450    AW_pos win_x = world_x;
1451    AW_pos win_y = world_y;
1452    window()->world_to_win_coords(&win_x, &win_y);
1453
1454    cursor_abs_x = (long int)world_x;
1455    owner_of_cursor = target_terminal;
1456
1457    draw_cursor(win_x, win_y);
1458
1459    GB_transaction ta(GLOBAL_gb_main);
1460    updateAwars(new_term_selected);
1461
1462    return ED4_R_OK;
1463}
1464
1465ED4_returncode ED4_cursor::show_clicked_cursor(AW_pos click_xpos, ED4_terminal *target_terminal) {
1466    AW_pos termw_x, termw_y;
1467    target_terminal->calc_world_coords(&termw_x, &termw_y);
1468
1469    ED4_index scr_pos = ED4_ROOT->pixel2pos(click_xpos - termw_x);
1470    return show_cursor_at(target_terminal, scr_pos);
1471}
1472
1473
1474/* --------------------------------------------------------------------------------
1475   ED4_base_position
1476   -------------------------------------------------------------------------------- */
1477
1478static void ed4_bp_sequence_changed_cb(ED4_species_manager*, ED4_base_position *base_pos) {
1479    base_pos->invalidate();
1480}
1481
1482void ED4_base_position::remove_changed_cb() {
1483    if (calced4term) {
1484        ED4_species_manager *species_manager = calced4term->get_parent(LEV_SPECIES)->to_species_manager();
1485        species_manager->remove_sequence_changed_cb(makeED4_species_managerCallback(ed4_bp_sequence_changed_cb, this));
1486
1487        calced4term = NULp;
1488    }
1489}
1490
1491static bool is_consensus_gap(char c) { return ED4_is_gap_character(c) || c == '='; }
1492
1493void ED4_base_position::calc4term(const ED4_terminal *base) {
1494    e4_assert(base);
1495
1496    ED4_species_manager *species_manager = base->get_parent(LEV_SPECIES)->to_species_manager();
1497
1498    int   len;
1499    char *seq;
1500
1501    if (base != calced4term) { // terminal changes => rebind callback to new manager
1502        remove_changed_cb();
1503        species_manager->add_sequence_changed_cb(makeED4_species_managerCallback(ed4_bp_sequence_changed_cb, this));
1504    }
1505
1506    bool (*isGap_fun)(char);
1507    if (species_manager->is_consensus_manager()) {
1508        ED4_group_manager *group_manager = base->get_parent(LEV_GROUP)->to_group_manager();
1509
1510        seq       = group_manager->build_consensus_string();
1511        len       = strlen(seq);
1512        isGap_fun = is_consensus_gap;
1513    }
1514    else {
1515        seq = base->resolve_pointer_to_string_copy(&len); 
1516        e4_assert((int)strlen(seq) == len);
1517        isGap_fun = ED4_is_gap_character;
1518    }
1519
1520    e4_assert(seq);
1521
1522    CharPredicate pred_is_gap(isGap_fun);
1523    initialize(seq, len, pred_is_gap);
1524    calced4term = base;
1525
1526    free(seq);
1527}
1528int ED4_base_position::get_base_position(const ED4_terminal *term, int sequence_position) {
1529    if (!term) return 0;
1530    set_term(term);
1531    return abs_2_rel(sequence_position);
1532}
1533int ED4_base_position::get_sequence_position(const ED4_terminal *term, int base_pos) {
1534    if (!term) return 0;
1535    set_term(term);
1536    return rel_2_abs(base_pos);
1537}
1538
1539/* --------------------------------------------------------------------------------
1540   Store/Restore Cursorpositions
1541   -------------------------------------------------------------------------------- */
1542
1543class CursorPos : virtual Noncopyable {
1544    ED4_terminal *terminal;
1545    int seq_pos;
1546
1547    CursorPos *next;
1548
1549    static CursorPos *head;
1550
1551public:
1552
1553    static void clear() {
1554        while (head) {
1555            CursorPos *p = head->next;
1556
1557            delete head;
1558            head = p;
1559        }
1560    }
1561    static CursorPos *get_head() { return head; }
1562
1563    CursorPos(ED4_terminal *t, int p) {
1564        terminal = t;
1565        seq_pos = p;
1566        next = head;
1567        head = this;
1568    }
1569    ~CursorPos() {}
1570
1571    ED4_terminal *get_terminal() const { return terminal; }
1572    int get_seq_pos() const { return seq_pos; }
1573
1574    void moveToEnd() {
1575        e4_assert(this==head);
1576
1577        if (next) {
1578            CursorPos *p = head = next;
1579
1580            while (p->next) {
1581                p = p->next;
1582            }
1583
1584            p->next = this;
1585            this->next = NULp;
1586        }
1587    }
1588};
1589
1590CursorPos *CursorPos::head = NULp;
1591
1592void ED4_store_curpos(AW_window *aww) {
1593    GB_transaction       ta(GLOBAL_gb_main);
1594    ED4_LocalWinContext  uses(aww);
1595    ED4_cursor          *cursor = &current_cursor();
1596   
1597    if (!cursor->owner_of_cursor) {
1598        aw_message("First you have to place the cursor.");
1599    }
1600    else {
1601        new CursorPos(cursor->owner_of_cursor, cursor->get_sequence_pos());
1602    }
1603}
1604
1605void ED4_restore_curpos(AW_window *aww) {
1606    GB_transaction       ta(GLOBAL_gb_main);
1607    ED4_LocalWinContext  uses(aww);
1608    ED4_cursor          *cursor = &current_cursor();
1609
1610    CursorPos *pos = CursorPos::get_head();
1611    if (!pos) {
1612        aw_message("No cursor position stored.");
1613        return;
1614    }
1615
1616    pos->get_terminal()->setCursorTo(cursor, pos->get_seq_pos(), true, ED4_JUMP_KEEP_VISIBLE);
1617    pos->moveToEnd();
1618}
1619
1620void ED4_clear_stored_curpos() {
1621    CursorPos::clear();
1622}
1623
1624/* --------------------------------------------------------------------------------
1625   Other stuff
1626   -------------------------------------------------------------------------------- */
1627
1628void ED4_helix_jump_opposite(AW_window *aww) {
1629    GB_transaction       ta(GLOBAL_gb_main);
1630    ED4_LocalWinContext  uses(aww);
1631    ED4_cursor          *cursor = &current_cursor();
1632
1633    if (!cursor->owner_of_cursor) {
1634        aw_message("First you have to place the cursor.");
1635        return;
1636    }
1637
1638    int           seq_pos  = cursor->get_sequence_pos();
1639    AW_helix     *helix    = ED4_ROOT->helix;
1640    BI_PAIR_TYPE  pairType = helix->pairtype(seq_pos);
1641
1642    if (pairType != HELIX_NONE) {
1643        int pairing_pos = helix->opposite_position(seq_pos);
1644        cursor->jump_sequence_pos(pairing_pos, ED4_JUMP_KEEP_POSITION);
1645    }
1646    else {
1647        aw_message("Not at helix position");
1648    }
1649}
1650
1651void ED4_change_cursor(AW_window *aww) {
1652    ED4_LocalWinContext uses(aww);
1653    ED4_cursor     *cursor = &current_cursor();
1654    ED4_CursorType  typ    = cursor->getType();
1655
1656    cursor->changeType((ED4_CursorType)((typ+1)%ED4_CURSOR_TYPES));
1657}
1658
1659// --------------------------------------------------------------------------------
1660
1661#ifdef UNIT_TESTS
1662#include <test_unit.h>
1663#include <test_helpers.h>
1664
1665struct test_absrel {
1666    bool torel;
1667    test_absrel(bool r) : torel(r) {}
1668    virtual ~test_absrel() {}
1669
1670    virtual int a2r(int a) const = 0;
1671    virtual int r2a(int r) const = 0;
1672   
1673    virtual int abs_size() const = 0;
1674    virtual int rel_size() const = 0;
1675
1676    int gen(int i) const { return torel ? a2r(i) : r2a(i); }
1677    int get_size() const { return torel ? abs_size()+1 : rel_size(); }
1678
1679    char *genResult() const;
1680};
1681
1682struct membind {
1683    const test_absrel& me;
1684    membind(const test_absrel& ta) : me(ta) {}
1685    int operator()(int i) const { return me.gen(i); }
1686};
1687
1688char *test_absrel::genResult() const {
1689    return collectIntFunResults(membind(*this), 0, get_size()-1, 3, 1, 1);
1690}
1691
1692struct test_ecoli : public test_absrel {
1693    BI_ecoli_ref& eref;
1694    test_ecoli(BI_ecoli_ref& b, bool to_rel) : test_absrel(to_rel), eref(b) {}
1695    int a2r(int a) const OVERRIDE { return eref.abs_2_rel(a); }
1696    int r2a(int r) const OVERRIDE { return eref.rel_2_abs(r); }
1697    int abs_size() const OVERRIDE { return eref.abs_count(); }
1698    int rel_size() const OVERRIDE { return eref.base_count(); }
1699};
1700
1701struct test_basepos : public test_absrel {
1702    BasePosition& bpos;
1703    test_basepos(BasePosition& bpos_, bool to_rel)
1704        : test_absrel(to_rel), bpos(bpos_) {}
1705    int a2r(int a) const OVERRIDE { return bpos.abs_2_rel(a); }
1706    int r2a(int r) const OVERRIDE { return bpos.rel_2_abs(r); }
1707    int abs_size() const OVERRIDE { return bpos.abs_count(); }
1708    int rel_size() const OVERRIDE { return bpos.base_count(); }
1709};
1710
1711#define TEST_ABSREL_EQUALS(tester,expected) do {        \
1712        char *res = tester.genResult();                 \
1713        TEST_EXPECT_EQUAL(res,expected);                \
1714        free(res);                                      \
1715    } while(0)
1716
1717#define TEST_ECOLIREF_EQUALS(data,alen,a2r,r2a) do {            \
1718        BI_ecoli_ref eref;                                      \
1719        eref.init(data,alen);                                   \
1720        TEST_ABSREL_EQUALS(test_ecoli(eref, true), a2r);        \
1721        TEST_ABSREL_EQUALS(test_ecoli(eref, false), r2a);       \
1722    } while(0)
1723
1724
1725#define TEST_BASE_POS_EQUALS(data,a2r,r2a) do {                                               \
1726        {                                                                                     \
1727            BasePosition bpos(data, strlen(data), CharPredicate(ED4_is_gap_character));       \
1728            TEST_ABSREL_EQUALS(test_basepos(bpos, true), a2r);                                \
1729            TEST_ABSREL_EQUALS(test_basepos(bpos, false), r2a);                               \
1730        }                                                                                     \
1731    } while(0)
1732
1733void TEST_BI_ecoli_ref() {
1734    TEST_ECOLIREF_EQUALS("-.AC-G-T-.", 10,
1735                         "  [0]  0  0  0  1  2  2  3  3  4  4  4  [4]", // abs -> rel
1736                         "  [0]  2  3  5  7  [7]");                     // rel -> abs
1737
1738    TEST_ECOLIREF_EQUALS("-",   1, "  [0]  0  0  [0]",       "  [0]  [0]");
1739    TEST_ECOLIREF_EQUALS("--A", 1, "  [0]  0  0  [0]",       "  [0]  [0]"); // part of sequence
1740    TEST_ECOLIREF_EQUALS("--",  2, "  [0]  0  0  0  [0]",    "  [0]  [0]");
1741    TEST_ECOLIREF_EQUALS("---", 3, "  [0]  0  0  0  0  [0]", "  [0]  [0]");
1742   
1743    TEST_ECOLIREF_EQUALS("A",   1, "  [0]  0  1  [1]",       "  [0]  0  [0]");
1744    TEST_ECOLIREF_EQUALS("A",   2, "  [0]  0  1  1  [1]",    "  [0]  0  [0]");
1745
1746    TEST_ECOLIREF_EQUALS("A-",  2, "  [0]  0  1  1  [1]",    "  [0]  0  [0]");
1747    TEST_ECOLIREF_EQUALS("-A",  2, "  [0]  0  0  1  [1]",    "  [0]  1  [1]");
1748
1749    TEST_ECOLIREF_EQUALS("A",   3, "  [0]  0  1  1  1  [1]", "  [0]  0  [0]"); // more than sequence
1750    TEST_ECOLIREF_EQUALS("A--", 3, "  [0]  0  1  1  1  [1]", "  [0]  0  [0]");
1751    TEST_ECOLIREF_EQUALS("-A-", 3, "  [0]  0  0  1  1  [1]", "  [0]  1  [1]");
1752    TEST_ECOLIREF_EQUALS("--A", 3, "  [0]  0  0  0  1  [1]", "  [0]  2  [2]");
1753}
1754
1755void TEST_base_position() {
1756    ED4_setup_gaps_and_alitype("-", GB_AT_RNA); // count '.' as base
1757
1758    TEST_BASE_POS_EQUALS("-.AC-G-T-.",
1759                         "  [0]  0  0  1  2  3  3  4  4  5  5  6  [6]", // abs -> rel
1760                         "  [0]  1  2  3  5  7  9  [9]");               // rel -> abs
1761
1762    // ------------------------------
1763    ED4_setup_gaps_and_alitype(".-", GB_AT_RNA); // count '.' as gap
1764
1765    TEST_BASE_POS_EQUALS("-.AC-G-T-.",
1766                         "  [0]  0  0  0  1  2  2  3  3  4  4  4  [4]", // abs -> rel
1767                         "  [0]  2  3  5  7  [7]");                     // rel -> abs
1768
1769    TEST_BASE_POS_EQUALS("-",   "  [0]  0  0  [0]",       "  [0]  [0]");
1770    TEST_BASE_POS_EQUALS("--",  "  [0]  0  0  0  [0]",    "  [0]  [0]");
1771    TEST_BASE_POS_EQUALS("---", "  [0]  0  0  0  0  [0]", "  [0]  [0]");
1772
1773    TEST_BASE_POS_EQUALS("A",   "  [0]  0  1  [1]",       "  [0]  0  [0]");
1774
1775    TEST_BASE_POS_EQUALS("A-",  "  [0]  0  1  1  [1]",    "  [0]  0  [0]");
1776    TEST_BASE_POS_EQUALS("-A",  "  [0]  0  0  1  [1]",    "  [0]  1  [1]");
1777   
1778    TEST_BASE_POS_EQUALS("A--", "  [0]  0  1  1  1  [1]", "  [0]  0  [0]");
1779    TEST_BASE_POS_EQUALS("-A-", "  [0]  0  0  1  1  [1]", "  [0]  1  [1]");
1780    TEST_BASE_POS_EQUALS("--A", "  [0]  0  0  0  1  [1]", "  [0]  2  [2]");
1781}
1782
1783#endif // UNIT_TESTS
1784
1785
Note: See TracBrowser for help on using the repository browser.