source: tags/ms_r17q1/EDIT4/ED4_main.cxx

Last change on this file was 15288, checked in by westram, 8 years ago
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 22.1 KB
Line 
1// ============================================================= //
2//                                                               //
3//   File      : ED4_main.cxx                                    //
4//   Purpose   :                                                 //
5//                                                               //
6//   Institute of Microbiology (Technical University Munich)     //
7//   http://www.arb-home.de/                                     //
8//                                                               //
9// ============================================================= //
10
11
12#include "ed4_class.hxx"
13#include "ed4_awars.hxx"
14#include "ed4_edit_string.hxx"
15#include "ed4_nds.hxx"
16#include "ed4_visualizeSAI.hxx"
17#include "ed4_ProteinViewer.hxx"
18#include "ed4_protein_2nd_structure.hxx"
19#include "ed4_dots.hxx"
20#include "ed4_naligner.hxx"
21#include "ed4_seq_colors.hxx"
22#include "graph_aligner_gui.hxx"
23#include <ed4_extern.hxx>
24
25#include <st_window.hxx>
26#include <gde.hxx>
27#include <AW_helix.hxx>
28#include <AP_pro_a_nucs.hxx>
29#include <ad_config.h>
30#include <awt_map_key.hxx>
31#include <awt.hxx>
32
33#include <aw_preset.hxx>
34#include <aw_awars.hxx>
35#include <aw_msg.hxx>
36#include <aw_root.hxx>
37#include <aw_advice.hxx>
38
39#include <arbdbt.h>
40
41#include <arb_defs.h>
42#include <arb_global_defs.h>
43#include <macros.hxx>
44#include <aw_question.hxx>
45
46AW_HEADER_MAIN
47
48ED4_root *ED4_ROOT;
49GBDATA   *GLOBAL_gb_main = NULL; // global gb_main for arb_edit4
50
51int TERMINAL_HEIGHT;
52
53int INFO_TERM_TEXT_YOFFSET;
54int SEQ_TERM_TEXT_YOFFSET;
55
56int MAXSEQUENCECHARACTERLENGTH; // greatest # of characters in a sequence string terminal
57int MAXNAME_WIDTH;
58int MAXINFO_WIDTH;
59int FLAG_WIDTH;
60
61long ED4_counter = 0;
62
63size_t         not_found_counter; // nr of species which haven't been found
64GBS_strstruct *not_found_message;
65
66long         max_seq_terminal_length; // global maximum of sequence terminal length
67ED4_EDITMODE awar_edit_mode;
68long         awar_edit_rightward;
69bool         move_cursor;             // only needed for editing in consensus
70bool         DRAW;
71
72inline void replaceChars(char *s, char o, char n) {
73    while (1) {
74        char c = *s++;
75        if (!c) {
76            break;
77        }
78        if (c==o) {
79            s[-1] = n;
80        }
81    }
82}
83
84inline void set_and_realloc_gde_array(uchar **&the_names, uchar **&the_sequences, long &allocated, long &numberspecies, long &maxalign,
85                                      const char *name, int name_len, const char *seq, int seq_len)
86{
87    if (allocated==numberspecies) {
88        long new_allocated = (allocated*3)/2;
89
90        ARB_recalloc(the_names, allocated, new_allocated);
91        ARB_recalloc(the_sequences, allocated, new_allocated);
92        allocated = new_allocated;
93    }
94
95    the_names[numberspecies]     = (uchar*)ARB_strndup(name, name_len);
96    the_sequences[numberspecies] = (uchar*)ARB_strndup(seq, seq_len);
97
98    replaceChars((char*)the_names[numberspecies], ' ', '_');
99
100    if (seq_len>maxalign) {
101        maxalign = seq_len;
102    }
103
104    numberspecies++;
105}
106
107static char *add_area_for_gde(ED4_area_manager *area_man, uchar **&the_names, uchar **&the_sequences,
108                              long &allocated, long &numberspecies, long &maxalign,
109                              int show_sequence, int show_SAI, int show_helix, int show_consensus, int show_remark)
110{
111    ED4_terminal *terminal = area_man->get_first_terminal();
112    ED4_terminal *last     = area_man->get_last_terminal();
113
114    for (; terminal;) {
115        if (terminal->is_species_name_terminal()) {
116            ED4_species_manager *species_manager = terminal->get_parent(LEV_SPECIES)->to_species_manager();
117            ED4_species_name_terminal *species_name = species_manager->search_spec_child_rek(LEV_SPECIES_NAME)->to_species_name_terminal();
118            int name_len;
119            char *name = species_name->resolve_pointer_to_string_copy(&name_len);
120            ED4_sequence_terminal *sequence_terminal;
121
122            {
123                ED4_base *sequence_term  = species_manager->search_spec_child_rek(LEV_SEQUENCE_STRING);
124                if (!sequence_term) goto end_of_loop;
125                sequence_terminal = sequence_term->to_sequence_terminal();
126            }
127
128            int show = -1;
129
130            bool is_consensus = false;
131            bool is_SAI       = false;
132
133            if (terminal->is_consensus_terminal()) {
134                is_consensus = true;
135                show         = show_consensus;
136            }
137            else if (terminal->is_SAI_terminal()) {
138                is_SAI = true;
139                show   = show_SAI;
140            }
141            else {
142                show = show_sequence;
143            }
144
145            e4_assert(show!=-1);
146
147            if (show) {
148                int seq_len;
149                char *seq = 0;
150
151                if (is_consensus) {
152                    ED4_group_manager *group_manager = sequence_terminal->get_parent(LEV_GROUP)->to_group_manager();
153
154                    group_manager->build_consensus_string(&seq_len);
155                    e4_assert(strlen(seq) == size_t(seq_len));
156
157                    ED4_group_manager *folded_group_man = sequence_terminal->is_in_folded_group();
158
159                    if (folded_group_man) { // we are in a folded group
160                        if (folded_group_man==group_manager) { // we are the consensus of the folded group
161                            if (folded_group_man->is_in_folded_group()) { // a folded group inside a folded group -> do not show
162                                freenull(seq);
163                            }
164                            else { // group folded but consensus shown -> add '-' before name
165                                char *new_name = ARB_alloc<char>(name_len+2);
166
167                                sprintf(new_name, "-%s", name);
168                                freeset(name, new_name);
169                                name_len++;
170                            }
171                        }
172                        else { // we are really inside a folded group -> don't show
173                            freenull(seq);
174                        }
175                    }
176                }
177                else { // sequence
178                    if (!sequence_terminal->is_in_folded_group()) {
179                        seq = sequence_terminal->resolve_pointer_to_string_copy(&seq_len);
180                    }
181                }
182
183                if (seq) {
184                    set_and_realloc_gde_array(the_names, the_sequences, allocated, numberspecies, maxalign, name, name_len, seq, seq_len);
185                    if (show_helix && !is_SAI && ED4_ROOT->helix->size()) {
186                        char *helix = ED4_ROOT->helix->seq_2_helix(seq, '.');
187                        set_and_realloc_gde_array(the_names, the_sequences, allocated, numberspecies, maxalign, name, name_len, helix, seq_len);
188                        free(helix);
189                    }
190                    if (show_remark && !is_consensus) {
191                        ED4_multi_sequence_manager *ms_man = sequence_terminal->get_parent(LEV_MULTI_SEQUENCE)->to_multi_sequence_manager();
192                        ED4_base *remark_name_term = ms_man->search_ID("remark");
193                        if (remark_name_term) {
194                            ED4_base *remark_term = remark_name_term->get_next_terminal();
195                            e4_assert(remark_term);
196
197                            int remark_len;
198                            char *remark = remark_term->resolve_pointer_to_string_copy(&remark_len);
199
200                            replaceChars(remark, ' ', '_');
201                            set_and_realloc_gde_array(the_names, the_sequences, allocated, numberspecies, maxalign, name, name_len, remark, remark_len);
202                            free(remark);
203                        }
204                    }
205                    free(seq);
206                }
207            }
208            free(name);
209        }
210    end_of_loop :
211        if (terminal==last) break;
212        terminal = terminal->get_next_terminal();
213    }
214
215    return 0;
216}
217
218static char *ED4_create_sequences_for_gde(GBDATA **&the_species, uchar **&the_names, uchar **&the_sequences, long &numberspecies, long &maxalign) {
219    int top     = ED4_ROOT->aw_root->awar("gde/top_area")->read_int();
220    int tops    = ED4_ROOT->aw_root->awar("gde/top_area_sai")->read_int();
221    int toph    = ED4_ROOT->aw_root->awar("gde/top_area_helix")->read_int();
222    int topk    = ED4_ROOT->aw_root->awar("gde/top_area_kons")->read_int();
223    int topr    = ED4_ROOT->aw_root->awar("gde/top_area_remark")->read_int();
224    int middle  = ED4_ROOT->aw_root->awar("gde/middle_area")->read_int();
225    int middles = ED4_ROOT->aw_root->awar("gde/middle_area_sai")->read_int();
226    int middleh = ED4_ROOT->aw_root->awar("gde/middle_area_helix")->read_int();
227    int middlek = ED4_ROOT->aw_root->awar("gde/middle_area_kons")->read_int();
228    int middler = ED4_ROOT->aw_root->awar("gde/middle_area_remark")->read_int();
229
230    numberspecies = 0;
231    maxalign = 0;
232
233    long allocated = 100;
234    the_species    = 0;
235
236    ARB_calloc(the_names,     allocated);
237    ARB_calloc(the_sequences, allocated);
238
239    char *err = add_area_for_gde(ED4_ROOT->top_area_man, the_names, the_sequences, allocated, numberspecies, maxalign, top, tops, toph, topk, topr);
240    if (!err) {
241        err = add_area_for_gde(ED4_ROOT->middle_area_man, the_names, the_sequences, allocated, numberspecies, maxalign, middle, middles, middleh, middlek, middler);
242    }
243
244    if (allocated!=(numberspecies+1)) {
245        ARB_recalloc(the_names, allocated, numberspecies+1);
246        ARB_recalloc(the_sequences, allocated, numberspecies+1);
247    }
248
249    return err;
250}
251
252void ED4_setup_gaps_and_alitype(const char *gap_chars, GB_alignment_type alitype) {
253    BaseFrequencies::setup(gap_chars, alitype);
254}
255
256static void ED4_gap_chars_changed(AW_root *root) {
257    char *gap_chars = root->awar_string(ED4_AWAR_GAP_CHARS)->read_string();
258    ED4_setup_gaps_and_alitype(gap_chars, ED4_ROOT->alignment_type);
259    free(gap_chars);
260}
261
262void ED4_with_all_edit_windows(void (*cb)(ED4_window *)) {
263    for (ED4_window *win = ED4_ROOT->first_window; win; win = win->next) {
264        ED4_LocalWinContext uses(win);
265        cb(win);
266    }
267}
268
269static void redraw_cursor(ED4_window *win) { win->cursor.redraw(); }
270static void ED4_edit_direction_changed(AW_root * /* awr */) {
271    ED4_with_all_edit_windows(redraw_cursor);
272}
273
274static void ed4_bind_mainDB_awar_callbacks(AW_root *root) {
275    // callbacks to main DB awars are bound later
276    // (otherwise its easy to crash the editor by clicking around in ARB_NTREE during editor startup)
277
278    root->awar(AWAR_SET_CURSOR_POSITION)->add_callback(ED4_remote_set_cursor_cb);
279    root->awar(AWAR_SPECIES_NAME)->add_callback(ED4_selected_species_changed_cb);
280    root->awar(AWAR_SAI_NAME)->add_callback(ED4_selected_SAI_changed_cb);
281}
282
283static void ed4_create_mainDB_awars(AW_root *root) {
284    // WARNING: do not bind callbacks here -> do it in ed4_bind_mainDB_awar_callbacks()
285
286    root->awar_int(AWAR_CURSOR_POSITION,       info2bio(0), GLOBAL_gb_main);
287    root->awar_int(AWAR_CURSOR_POSITION_LOCAL, 0, GLOBAL_gb_main);
288    root->awar_int(AWAR_SET_CURSOR_POSITION,   1, GLOBAL_gb_main);
289
290    root->awar_string(AWAR_FIELD_CHOSEN, NO_FIELD_SELECTED, GLOBAL_gb_main);
291
292    root->awar_string(AWAR_SPECIES_NAME, "", GLOBAL_gb_main);
293    root->awar_string(AWAR_SAI_NAME,     "", GLOBAL_gb_main);
294    root->awar_string(AWAR_SAI_GLOBAL,   "", GLOBAL_gb_main);
295}
296
297static void ed4_create_all_awars(AW_root *root, const char *config_name) {
298    // Note: cursor awars are created in window constructor
299
300    root->awar_string(AWAR_EDIT_CONFIGURATION, config_name, AW_ROOT_DEFAULT);
301
302    ed4_create_mainDB_awars(root);
303    ED4_create_search_awars(root);
304
305#if defined(DEBUG)
306    AWT_create_db_browser_awars(root, AW_ROOT_DEFAULT);
307#endif // DEBUG
308
309    create_naligner_variables(root, AW_ROOT_DEFAULT);
310    create_sina_variables(root, AW_ROOT_DEFAULT);
311
312    awar_edit_mode = AD_ALIGN;
313
314    int def_sec_level = 0;
315#ifdef DEBUG
316    def_sec_level = 6; // don't nag developers
317#endif
318    root->awar_int(AWAR_EDIT_SECURITY_LEVEL, def_sec_level, AW_ROOT_DEFAULT);
319
320    root->awar_int(AWAR_EDIT_SECURITY_LEVEL_ALIGN,  def_sec_level, AW_ROOT_DEFAULT)->add_callback(ed4_changesecurity);
321    root->awar_int(AWAR_EDIT_SECURITY_LEVEL_CHANGE, def_sec_level, AW_ROOT_DEFAULT)->add_callback(ed4_changesecurity);
322
323    root->awar_int(AWAR_EDIT_MODE,   0)->add_callback(ed4_change_edit_mode);
324    root->awar_int(AWAR_INSERT_MODE, 1)->add_callback(ed4_change_edit_mode);
325
326    root->awar_int(AWAR_EDIT_RIGHTWARD, 1)->add_target_var(&awar_edit_rightward)->add_callback(ED4_edit_direction_changed);
327    root->awar_int(AWAR_EDIT_TITLE_MODE, 0);
328
329    root->awar_int(AWAR_EDIT_HELIX_SPACING,    0) ->set_minmax(-30, 30) ->add_target_var(&ED4_ROOT->helix_add_spacing)    ->add_callback(makeRootCallback(ED4_request_relayout));
330    root->awar_int(AWAR_EDIT_TERMINAL_SPACING, 0) ->set_minmax(-30, 30) ->add_target_var(&ED4_ROOT->terminal_add_spacing) ->add_callback(makeRootCallback(ED4_request_relayout));
331
332    ed4_changesecurity(root);
333
334    root->awar_int(ED4_AWAR_COMPRESS_SEQUENCE_GAPS,    0)->add_callback(makeRootCallback(ED4_compression_toggle_changed_cb, false));
335    root->awar_int(ED4_AWAR_COMPRESS_SEQUENCE_HIDE,    0)->add_callback(makeRootCallback(ED4_compression_toggle_changed_cb, true));
336    root->awar_int(ED4_AWAR_COMPRESS_SEQUENCE_TYPE,    0)->add_callback(ED4_compression_changed_cb);
337    root->awar_int(ED4_AWAR_COMPRESS_SEQUENCE_PERCENT, 1)->add_callback(ED4_compression_changed_cb)->set_minmax(1, 99);
338
339    root->awar_int(ED4_AWAR_DIGITS_AS_REPEAT, 0);
340    root->awar_int(ED4_AWAR_FAST_CURSOR_JUMP, 0);
341    root->awar_int(ED4_AWAR_CURSOR_TYPE, (int)ED4_RIGHT_ORIENTED_CURSOR);
342
343    ED4_create_consensus_awars(root);
344    ED4_create_NDS_awars(root);
345
346    root->awar_string(ED4_AWAR_REP_SEARCH_PATTERN, ".");
347    root->awar_string(ED4_AWAR_REP_REPLACE_PATTERN, "-");
348
349    root->awar_int(ED4_AWAR_SCROLL_SPEED_X, 40);
350    root->awar_int(ED4_AWAR_SCROLL_SPEED_Y, 20);
351    root->awar_int(ED4_AWAR_SCROLL_MARGIN, 5);
352
353    root->awar_string(ED4_AWAR_SPECIES_TO_CREATE, "");
354
355    root->awar_string(ED4_AWAR_GAP_CHARS, ".-~?")->add_callback(ED4_gap_chars_changed);
356    ED4_gap_chars_changed(root);
357    root->awar_int(ED4_AWAR_ANNOUNCE_CHECKSUM_CHANGES, 0);
358
359    {
360        GB_ERROR gde_err = GDE_init(ED4_ROOT->aw_root, ED4_ROOT->props_db, GLOBAL_gb_main, ED4_create_sequences_for_gde, 0, GDE_WINDOWTYPE_EDIT4);
361        if (gde_err) GBK_terminatef("Fatal error: %s", gde_err);
362    }
363
364    root->awar_string(ED4_AWAR_CREATE_FROM_CONS_REPL_EQUAL, "-");
365    root->awar_string(ED4_AWAR_CREATE_FROM_CONS_REPL_POINT, "?");
366    root->awar_int(ED4_AWAR_CREATE_FROM_CONS_CREATE_POINTS, 1);
367    root->awar_int(ED4_AWAR_CREATE_FROM_CONS_ALL_UPPER, 1);
368    root->awar_int(ED4_AWAR_CREATE_FROM_CONS_DATA_SOURCE, 0);
369
370    ED4_createVisualizeSAI_Awars(root, AW_ROOT_DEFAULT);
371    ED4_create_dot_missing_bases_awars(root, AW_ROOT_DEFAULT);
372
373    // Create Awars To Be Used In Protein Viewer
374    if (ED4_ROOT->alignment_type == GB_AT_DNA) {
375        PV_CreateAwars(root, AW_ROOT_DEFAULT);
376    }
377
378    // create awars to be used for protein secondary structure match
379    if (ED4_ROOT->alignment_type == GB_AT_AA) {
380        root->awar_int(PFOLD_AWAR_ENABLE, 1);
381        root->awar_string(PFOLD_AWAR_SELECTED_SAI, "PFOLD");
382        root->awar_int(PFOLD_AWAR_MATCH_METHOD, SECSTRUCT_SEQUENCE);
383        int pt;
384        char awar[256];
385        for (int i = 0; pfold_match_type_awars[i].name; i++) {
386            e4_assert(i<PFOLD_PAIRS);
387            pt = pfold_match_type_awars[i].value;
388            sprintf(awar, PFOLD_AWAR_PAIR_TEMPLATE, pfold_match_type_awars[i].name);
389            root->awar_string(awar, pfold_pairs[pt])->add_target_var(&pfold_pairs[pt]);
390            sprintf(awar, PFOLD_AWAR_SYMBOL_TEMPLATE, pfold_match_type_awars[i].name);
391            root->awar_string(awar, pfold_pair_chars[pt])->add_target_var(&pfold_pair_chars[pt]);
392        }
393        root->awar_string(PFOLD_AWAR_SYMBOL_TEMPLATE_2, PFOLD_PAIR_CHARS_2);
394        root->awar_string(PFOLD_AWAR_SAI_FILTER, "pfold");
395    }
396
397    GB_ERROR error = ARB_init_global_awars(root, AW_ROOT_DEFAULT, GLOBAL_gb_main);
398    if (error) aw_message(error);
399}
400
401const char *ED4_propertyName(int mode) {
402    // mode == 0 -> alignment specific          (e.g. "edit4_ali_16s.arb")
403    // mode == 1 -> alignment-type specific     (e.g. "edit4_rna.arb")
404    // mode == 2 -> unspecific (normal)         (always "edit4.arb")
405    //
406    // Note : result is only valid until next call
407
408    e4_assert(mode >= 0 && mode <= 2);
409
410    const char *result;
411    if (mode == 2) {
412        result = "edit4.arb";
413    }
414    else {
415        static char *ali_name = 0;
416        static char *ali_type = 0;
417        static char *result_copy = 0;
418
419        if (!ali_name) {
420            GB_transaction ta(GLOBAL_gb_main);
421            ali_name = GBT_get_default_alignment(GLOBAL_gb_main);
422            ali_type = GBT_get_alignment_type_string(GLOBAL_gb_main, ali_name);
423            result_copy   = new char[21+strlen(ali_name)];
424        }
425
426        sprintf(result_copy, "edit4_%s.arb", mode == 0 ? ali_name : ali_type);
427        result = result_copy;
428    }
429
430    return result;
431}
432
433static void ED4_postcbcb(AW_window *aww) {
434    ED4_ROOT->announce_useraction_in(aww);
435    ED4_trigger_instant_refresh();
436}
437static void seq_colors_changed_cb() {
438    ED4_ROOT->request_refresh_for_sequence_terminals();
439}
440
441int ARB_main(int argc, char *argv[]) {
442    const char *data_path = ":";
443    char *config_name = NULL;
444
445    if (argc > 1 && ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0))) {
446        fprintf(stderr,
447                "Usage: arb_edit4 [options] database\n"
448                "       database    name of database or ':' to connect to arb-database-server\n"
449                "\n"
450                "       options:\n"
451                "       -c config   loads configuration 'config' (default: '" DEFAULT_CONFIGURATION "')\n"
452            );
453        return EXIT_SUCCESS;
454    }
455
456    if (argc > 1 && strcmp(argv[1], "-c") == 0) {
457        config_name = new char[strlen(argv[2])+1];
458        strcpy(config_name, argv[2]);
459        argc -= 2; argv += 2;
460    }
461    else { // load default configuration if no command line is given
462        config_name = ARB_strdup(DEFAULT_CONFIGURATION);
463        printf("Using '%s'\n", DEFAULT_CONFIGURATION);
464    }
465
466    if (argc>1) {
467        data_path = argv[1];
468        argc--; argv++;
469    }
470
471    aw_initstatus();
472
473    GB_shell  shell;
474    ARB_ERROR error;
475    GLOBAL_gb_main = GB_open(data_path, "rwt");
476    if (!GLOBAL_gb_main) {
477        error = GB_await_error();
478    }
479    else {
480#if defined(DEBUG)
481        AWT_announce_db_to_browser(GLOBAL_gb_main, GBS_global_string("ARB database (%s)", data_path));
482#endif // DEBUG
483
484        ED4_ROOT = new ED4_root(&argc, &argv);
485
486        error = configure_macro_recording(ED4_ROOT->aw_root, "ARB_EDIT4", GLOBAL_gb_main);
487        if (!error) {
488            ED4_ROOT->database = new EDB_root_bact;
489            error              = ED4_ROOT->init_alignment();
490        }
491        if (!error) {
492            ed4_create_all_awars(ED4_ROOT->aw_root, config_name);
493
494            ED4_ROOT->st_ml           = STAT_create_ST_ML(GLOBAL_gb_main);
495            ED4_ROOT->sequence_colors = new ED4_seq_colors(ED4_G_SEQUENCES, seq_colors_changed_cb);
496
497            ED4_ROOT->edk = new ed_key;
498            ED4_ROOT->edk->create_awars(ED4_ROOT->aw_root);
499
500            ED4_ROOT->helix = new AW_helix(ED4_ROOT->aw_root);
501
502            {
503                GB_ERROR warning = NULL;
504                switch (ED4_ROOT->alignment_type) {
505                    case GB_AT_RNA:
506                    case GB_AT_DNA:
507                        warning = ED4_ROOT->helix->init(GLOBAL_gb_main);
508                        break;
509
510                    case GB_AT_AA:
511                        warning = ED4_pfold_set_SAI(&ED4_ROOT->protstruct, GLOBAL_gb_main, ED4_ROOT->alignment_name, &ED4_ROOT->protstruct_len);
512                        break;
513
514                    default:
515                        e4_assert(0);
516                        break;
517                }
518
519                if (warning) aw_message(warning); // write to console
520                ED4_ROOT->create_first_window();
521                if (warning) { aw_message(warning); warning = 0; } // write again to status window
522            }
523
524            ED4_objspec::init_object_specs();
525            {
526                int found_config = 0;
527                ED4_LocalWinContext uses(ED4_ROOT->first_window);
528
529                if (config_name)
530                {
531                    GB_transaction ta(GLOBAL_gb_main);
532                    GB_ERROR       cfg_error;
533                    GBT_config     cfg(GLOBAL_gb_main, config_name, cfg_error);
534
535                    if (cfg.exists()) {
536                        ED4_ROOT->create_hierarchy(cfg.get_definition(GBT_config::MIDDLE_AREA), cfg.get_definition(GBT_config::TOP_AREA)); // create internal hierarchy
537                        found_config = 1;
538                    }
539                    else {
540                        aw_message(GBS_global_string("Could not find configuration '%s'", config_name));
541                    }
542                }
543
544                if (!found_config) {
545                    // create internal hierarchy
546
547                    char *as_mid = ED4_ROOT->database->make_string();
548                    char *as_top = ED4_ROOT->database->make_top_bot_string();
549
550                    ED4_ROOT->create_hierarchy(as_mid, as_top);
551
552                    delete as_mid;
553                    delete as_top;
554                }
555            }
556
557            // now bind DB depending callbacks
558            ed4_bind_mainDB_awar_callbacks(ED4_ROOT->aw_root);
559
560            // Create Additional sequence (aminoacid) terminals to be used in Protein Viewer
561            if (ED4_ROOT->alignment_type == GB_AT_DNA) {
562                PV_CallBackFunction(ED4_ROOT->aw_root);
563            }
564
565            AWT_install_postcb_cb(ED4_postcbcb);
566            AWT_install_cb_guards();
567            e4_assert(!ED4_WinContext::have_context()); // no global context shall be active
568            ED4_ROOT->aw_root->main_loop(); // enter main-loop
569        }
570
571        shutdown_macro_recording(ED4_ROOT->aw_root);
572        GB_close(GLOBAL_gb_main);
573    }
574
575    bool have_aw_root = ED4_ROOT && ED4_ROOT->aw_root;
576    if (error) {
577        if (have_aw_root) aw_popup_ok(error.deliver());
578        else fprintf(stderr, "arb_edit4: Error: %s\n", error.deliver());
579    }
580    if (have_aw_root) delete ED4_ROOT->aw_root;
581
582    return EXIT_SUCCESS;
583}
584
Note: See TracBrowser for help on using the repository browser.