Changeset 8303 for branches

Show
Ignore:
Timestamp:
14/12/11 08:29:43 (5 months ago)
Author:
westram
Message:
  • moved variables handling selected block into new class ED4_block
Files:
1 modified

Legend:

Unmodified
Added
Removed

  • branches/e4fix/EDIT4/ED4_block.cxx

    r8293 r8303  
    1919// -------------------------------------------------------------------------------- 
    2020 
    21 static ED4_blocktype blocktype = ED4_BT_NOBLOCK; 
    22  
    23 // linerange for COLUMNBLOCK is stored in EDIT4 marks, 
    24 // columnrange for COLUMNBLOCK is stored here: 
    25  
    26 static PosRange blockrange; 
    27 static int columnBlockUsed = 0; 
     21class ED4_block : virtual Noncopyable { 
     22    // stores columnrange of selected region 
     23    // (linerange is stored in EDIT4 marks) 
     24    ED4_blocktype type; 
     25    bool          columnBlockUsed; 
     26    PosRange      range; 
     27 
     28public: 
     29    ED4_block() 
     30        : type(ED4_BT_NOBLOCK), 
     31          columnBlockUsed(false) 
     32    {} 
     33 
     34    ED4_blocktype get_type() const { return type; } 
     35    void set_type(ED4_blocktype bt); 
     36    void toggle_type(); 
     37    void autocorrect_type(); 
     38 
     39    const PosRange& get_range() const { return range; } 
     40    void set_range(const PosRange& new_range) { range = new_range; } 
     41}; 
     42 
     43static ED4_block block; 
    2844 
    2945// -------------------------------------------------------------------------------- 
    … …  
    3349    seq_term->parent->refresh_requested_by_child(); 
    3450 
     51    // @@@ code below is more than weird. why do sth with column-stat here ? why write probe match awars here ?  
    3552    ED4_columnStat_terminal *colStatTerm = seq_term->corresponding_columnStat_terminal(); 
    3653    if (colStatTerm) { 
    37         const char *probe_match_pattern = colStatTerm->build_probe_match_string(blockrange); 
     54        const char *probe_match_pattern = colStatTerm->build_probe_match_string(block.get_range()); 
    3855        int len = strlen(probe_match_pattern); 
    3956 
    … …  
    5168    } 
    5269} 
     70 
     71static void refresh_selected(bool refresh_name_terminals) { 
     72    ED4_list_elem *listElem = ED4_ROOT->selected_objects.first(); 
     73    while (listElem) { 
     74        ED4_selection_entry       *selected  = (ED4_selection_entry*)listElem->elem(); 
     75        ED4_species_name_terminal *name_term = selected->object->to_species_name_terminal(); 
     76        ED4_sequence_terminal     *seq_term  = name_term->corresponding_sequence_terminal(); 
     77 
     78        if (refresh_name_terminals) { 
     79            name_term->set_refresh(1); 
     80            name_term->parent->refresh_requested_by_child(); 
     81        } 
     82        if (seq_term) col_block_refresh_on_seq_term(seq_term); 
     83 
     84        listElem = listElem->next(); 
     85    } 
     86} 
     87 
     88// -------------------------------------------------------------------------------- 
     89 
     90void ED4_block::set_type(ED4_blocktype bt) { 
     91    if (type != bt) { 
     92        type = bt; 
     93        refresh_selected(true); 
     94        if (type==ED4_BT_COLUMNBLOCK || type==ED4_BT_MODIFIED_COLUMNBLOCK) { 
     95            columnBlockUsed = true; 
     96        } 
     97    } 
     98} 
     99 
     100void ED4_block::toggle_type() { 
     101    switch (type) { 
     102        case ED4_BT_NOBLOCK: { 
     103            aw_message("No block selected."); 
     104            break; 
     105        } 
     106        case ED4_BT_LINEBLOCK: { 
     107            if (columnBlockUsed) { 
     108                set_type(ED4_BT_MODIFIED_COLUMNBLOCK); 
     109            } 
     110            else { 
     111                aw_message("No columnblock marked so far  - I can't guess the column range"); 
     112            } 
     113            break; 
     114        } 
     115        case ED4_BT_MODIFIED_COLUMNBLOCK: 
     116        case ED4_BT_COLUMNBLOCK: { 
     117            set_type(ED4_BT_LINEBLOCK); 
     118            break; 
     119        } 
     120    } 
     121} 
     122 
     123void ED4_block::autocorrect_type() { 
     124    // this has to be called every time the selection has changed 
     125 
     126    if (ED4_ROOT->selected_objects.first()==0) { // no objects are selected 
     127        set_type(ED4_BT_NOBLOCK); 
     128    } 
     129    else { 
     130        switch (type) { 
     131            case ED4_BT_NOBLOCK: { 
     132                set_type(ED4_BT_LINEBLOCK); 
     133                break; 
     134            } 
     135            case ED4_BT_COLUMNBLOCK: { 
     136                set_type(ED4_BT_MODIFIED_COLUMNBLOCK); 
     137                break; 
     138            } 
     139            case ED4_BT_LINEBLOCK: 
     140            case ED4_BT_MODIFIED_COLUMNBLOCK: { 
     141                break; 
     142            } 
     143        } 
     144    } 
     145} 
     146 
    53147// -------------------------------------------------------------------------------- 
    54148 
    … …  
    117211        int   len = GB_read_string_count(gbd); 
    118212 
    119         ExplicitRange range(blockrange, len); 
     213        ExplicitRange range(block.get_range(), len); 
    120214 
    121215        int   len_part     = range.size(); 
    … …  
    178272 
    179273 
    180     switch (blocktype) { 
     274    switch (block.get_type()) { 
    181275        case ED4_BT_NOBLOCK: { 
    182276            aw_message("No block marked -- use right mouse button"); 
    … …  
    191285                ED4_sequence_terminal *seqTerm        = selectionEntry->object->get_parent(ED4_L_SPECIES)->search_spec_child_rek(ED4_L_SEQUENCE_STRING)->to_sequence_terminal(); 
    192286 
    193                 error = blocktype == ED4_BT_LINEBLOCK 
     287                error = block.get_type() == ED4_BT_LINEBLOCK 
    194288                    ? perform_block_operation_on_whole_sequence(block_operation, seqTerm, repeat) 
    195289                    : perform_block_operation_on_part_of_sequence(block_operation, seqTerm, repeat); 
    … …  
    224318} 
    225319 
    226 bool ED4_get_selected_range(ED4_terminal *term, PosRange& range) { 
    227     if (blocktype==ED4_BT_NOBLOCK) return false; 
     320bool ED4_get_selected_range(ED4_terminal *term, PosRange& range) { // @@@ function will get useless, when multi-column-blocks are possible 
     321    if (block.get_type()==ED4_BT_NOBLOCK) return false; 
    228322 
    229323    ED4_species_name_terminal *name_term = term->to_sequence_terminal()->corresponding_species_name_terminal(); 
    230324    if (!name_term->tflag.selected) return false; 
    231325 
    232     if (blocktype==ED4_BT_COLUMNBLOCK || blocktype==ED4_BT_MODIFIED_COLUMNBLOCK) { 
    233         range = blockrange; 
     326    if (block.get_type()==ED4_BT_COLUMNBLOCK || block.get_type()==ED4_BT_MODIFIED_COLUMNBLOCK) { 
     327        range = block.get_range(); 
    234328    } 
    235329    else { 
    236         e4_assert(blocktype==ED4_BT_LINEBLOCK); 
     330        e4_assert(block.get_type()==ED4_BT_LINEBLOCK); 
    237331        range = PosRange::whole(); 
    238332    } 
    … …  
    241335} 
    242336 
    243 ED4_blocktype ED4_getBlocktype() { 
    244     return blocktype; 
    245 } 
    246 void ED4_setBlocktype(ED4_blocktype bt) { 
    247     if (blocktype!=bt) { 
    248         blocktype = bt; 
    249  
    250         ED4_list_elem *listElem = ED4_ROOT->selected_objects.first(); 
    251         while (listElem) { 
    252             ED4_selection_entry *selected = (ED4_selection_entry*)listElem->elem(); 
    253             ED4_species_name_terminal *name_term = selected->object->to_species_name_terminal(); 
    254             ED4_sequence_terminal *seq_term = name_term->corresponding_sequence_terminal(); 
    255  
    256             name_term->set_refresh(1); 
    257             name_term->parent->refresh_requested_by_child(); 
    258             if (seq_term) col_block_refresh_on_seq_term(seq_term); 
    259  
    260             listElem = listElem->next(); 
    261         } 
    262  
    263         if (blocktype==ED4_BT_COLUMNBLOCK || blocktype==ED4_BT_MODIFIED_COLUMNBLOCK) { 
    264             columnBlockUsed = 1; 
    265         } 
    266     } 
    267 } 
    268  
    269 void ED4_toggle_block_type() { 
    270     switch (blocktype) { 
    271         case ED4_BT_NOBLOCK: { 
    272             aw_message("No block selected."); 
    273             break; 
    274         } 
    275         case ED4_BT_LINEBLOCK: { 
    276             if (columnBlockUsed) { 
    277                 ED4_setBlocktype(ED4_BT_MODIFIED_COLUMNBLOCK); 
    278             } 
    279             else { 
    280                 aw_message("No columnblock marked so far  - I can't guess the column range"); 
    281             } 
    282             break; 
    283         } 
    284         case ED4_BT_MODIFIED_COLUMNBLOCK: 
    285         case ED4_BT_COLUMNBLOCK: { 
    286             ED4_setBlocktype(ED4_BT_LINEBLOCK); 
    287             break; 
    288         } 
    289         default: { 
    290             e4_assert(0); 
    291             break; 
    292         } 
    293     } 
    294 } 
    295  
    296 void ED4_correctBlocktypeAfterSelection() { // this has to be called every time the selection has changed 
    297  
    298     if (ED4_ROOT->selected_objects.first()==0) { // no objects are selected 
    299         ED4_setBlocktype(ED4_BT_NOBLOCK); 
    300     } 
    301     else { 
    302         switch (ED4_getBlocktype()) { 
    303             case ED4_BT_NOBLOCK: { 
    304                 ED4_setBlocktype(ED4_BT_LINEBLOCK); 
    305                 break; 
    306             } 
    307             case ED4_BT_COLUMNBLOCK: { 
    308                 ED4_setBlocktype(ED4_BT_MODIFIED_COLUMNBLOCK); 
    309                 break; 
    310             } 
    311             case ED4_BT_LINEBLOCK: 
    312             case ED4_BT_MODIFIED_COLUMNBLOCK: { 
    313                 break; 
    314             } 
    315             default: { 
    316                 e4_assert(0); 
    317                 break; 
    318             } 
    319         } 
    320     } 
    321 } 
     337ED4_blocktype ED4_getBlocktype() { return block.get_type(); } 
     338void ED4_setBlocktype(ED4_blocktype bt) { block.set_type(bt); } 
     339void ED4_toggle_block_type() { block.toggle_type(); } 
     340void ED4_correctBlocktypeAfterSelection() { block.autocorrect_type(); } 
    322341 
    323342static void select_and_update(ED4_sequence_terminal *term1, ED4_sequence_terminal *term2, ED4_index pos1, ED4_index pos2, int initial_call) { 
    … …  
    326345 
    327346    if (pos1>pos2) { 
    328         blockrange = PosRange(pos2, pos1); 
     347        block.set_range(PosRange(pos2, pos1)); 
    329348    } 
    330349    else { 
    331         blockrange = PosRange(pos1, pos2); 
    332     } 
    333  
    334     if (blocktype==ED4_BT_MODIFIED_COLUMNBLOCK) { 
    335         ED4_list_elem *listElem = ED4_ROOT->selected_objects.first(); 
    336         while (listElem) { 
    337             ED4_selection_entry *selectionEntry = (ED4_selection_entry*)listElem->elem(); 
    338             ED4_species_name_terminal *name_term = selectionEntry->object->to_species_name_terminal(); 
    339             ED4_sequence_terminal *seq_term = name_term->corresponding_sequence_terminal(); 
    340  
    341             if (seq_term) col_block_refresh_on_seq_term(seq_term); 
    342  
    343             listElem = listElem->next(); 
    344         } 
     350        block.set_range(PosRange(pos1, pos2)); 
     351    } 
     352 
     353    if (block.get_type()==ED4_BT_MODIFIED_COLUMNBLOCK) { 
     354        refresh_selected(false); 
    345355    } 
    346356    else { 
    … …  
    361371 
    362372        ED4_terminal *term          = term1; 
    363         int           xRangeChanged = blockrange != last_range; 
     373        int           xRangeChanged = block.get_range() != last_range; 
    364374 
    365375        while (term) { 
    … …  
    427437    last_term1 = term1; 
    428438    last_term2 = term2; 
    429     last_range = blockrange; 
     439    last_range = block.get_range(); 
    430440} 
    431441 
    … …  
    446456    switch (event->type) { 
    447457        case AW_Mouse_Press: { 
    448             if (blocktype==ED4_BT_NOBLOCK) { // initial columnblock 
    449                 ED4_setBlocktype(ED4_BT_COLUMNBLOCK); 
     458            if (block.get_type()==ED4_BT_NOBLOCK) { // initial columnblock 
     459                block.set_type(ED4_BT_COLUMNBLOCK); 
    450460 
    451461                fix_term = seq_term; 
    … …  
    454464                select_and_update(fix_term, seq_term, fix_pos, seq_pos, 1); 
    455465            } 
    456             else if (blocktype==ED4_BT_LINEBLOCK) { // change lineblock to columnblock 
    457                 ED4_setBlocktype(ED4_BT_MODIFIED_COLUMNBLOCK); 
     466            else if (block.get_type()==ED4_BT_LINEBLOCK) { // change lineblock to columnblock 
     467                block.set_type(ED4_BT_MODIFIED_COLUMNBLOCK); 
    458468 
    459469                fix_term = seq_term; 
    … …  
    468478            } 
    469479            else { // expand columnblock (search nearest corner/border -> fix opposite corner/border) 
    470                 e4_assert(blocktype==ED4_BT_COLUMNBLOCK || blocktype==ED4_BT_MODIFIED_COLUMNBLOCK); 
     480                e4_assert(block.get_type()==ED4_BT_COLUMNBLOCK || block.get_type()==ED4_BT_MODIFIED_COLUMNBLOCK); 
    471481 
    472482                ED4_list_elem *listElem = ED4_ROOT->selected_objects.first(); 
    473483                e4_assert(listElem); 
    474484 
    475                 if (blocktype==ED4_BT_COLUMNBLOCK) { 
     485                if (block.get_type()==ED4_BT_COLUMNBLOCK) { 
    476486                    AW_pos min_term_y = LONG_MAX; 
    477487                    AW_pos max_term_y = LONG_MIN; 
    … …  
    528538                int      scr_pos      = rm->sequence_to_screen(seq_pos); 
    529539 
    530                 PosRange block_visible_part = intersection(screen_range, rm->sequence_to_screen(blockrange)); 
     540                PosRange block_visible_part = intersection(screen_range, rm->sequence_to_screen(block.get_range())); 
     541 
     542                // @@@ block_visible_part might be empty (if completely outside screen) -> code below fails 
    531543 
    532544                int dist_left  = abs(scr_pos-block_visible_part.start()); 
    … …  
    534546 
    535547                if (dist_left < dist_right) {   // click nearer to left border of visible part of block 
    536                     fix_pos = blockrange.end(); // keep right block-border 
     548                    fix_pos = block.get_range().end(); // keep right block-border 
    537549                } 
    538550                else { 
    539                     fix_pos = blockrange.start(); 
     551                    fix_pos = block.get_range().start(); 
    540552                } 
    541553 
    … …  
    884896    } 
    885897} 
     898