source: tags/arb_5.1/EDIT4/ED4_main.cxx

Last change on this file was 6169, checked in by westram, 15 years ago
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 23.9 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <string.h>
4#include <memory.h>
5// #include <malloc.h>
6
7#include <arbdb.h>
8#include <arbdbt.h>
9#include <ad_config.h>
10
11#include <aw_root.hxx>
12#include <aw_device.hxx>
13#include <aw_window.hxx>
14#include <aw_preset.hxx>
15#include <aw_awars.hxx>
16#include <awt_seq_colors.hxx>
17#include <awt_map_key.hxx>
18#include <awt.hxx>
19#include <AW_helix.hxx>
20#include <st_window.hxx>
21#include <gde.hxx>
22#include<awt_pro_a_nucs.hxx>
23
24#include <ed4_extern.hxx>
25
26#include "ed4_class.hxx"
27#include "ed4_awars.hxx"
28#include "ed4_edit_string.hxx"
29#include "ed4_nds.hxx"
30#include "ed4_visualizeSAI.hxx"
31#include "ed4_ProteinViewer.hxx"
32#include "ed4_protein_2nd_structure.hxx"
33#include "ed4_dots.hxx"
34
35#include "edit_naligner.hxx"
36#include "graph_aligner_gui.hxx"
37
38AW_HEADER_MAIN
39
40ED4_root     *ED4_ROOT;
41GBDATA       *GLOBAL_gb_main = NULL; // global gb_main for arb_edit4
42ED4_database *main_db;
43
44int  TERMINALHEIGHT;            // this variable replaces the define
45
46int INFO_TERM_TEXT_YOFFSET;
47int SEQ_TERM_TEXT_YOFFSET;
48
49int  MAXSEQUENCECHARACTERLENGTH; // greatest # of characters in a sequence string terminal
50int  MAXSPECIESWIDTH;
51int  MAXINFOWIDTH;              // # of pixels used to display sequence info ("CONS", "4data", etc.)
52
53long           ED4_counter = 0;
54long           all_found;       // nr of species which haven't been found
55long           species_read;    // nr of species read; important during loading
56GBS_strstruct *not_found_message;
57long           max_seq_terminal_length; // global maximum of sequence terminal length
58ED4_EDITMODI   awar_edit_modus;
59long           awar_edit_direction;
60bool           move_cursor;     // only needed for editing in consensus
61bool           DRAW;
62bool           last_window_reached; // needed for refreshing all windows (if TRUE refresh/...-flags will be cleared)
63
64size_t status_count_total;                          // used for consensus progress bar
65size_t status_count_curr;
66
67bool loading;
68
69void ED4_config_change_cb(AW_root *)
70{
71
72    // @@@ FIXME: ok to be empty ? check!
73}
74
75inline void replaceChars(char *s, char o, char n)
76{
77    while (1) {
78        char c = *s++;
79        if (!c) {
80            break;
81        }
82        if (c==o) {
83            s[-1] = n;
84        }
85    }
86}
87
88inline void set_and_realloc_gde_array(uchar **&the_names, uchar **&the_sequences, long &allocated, long &numberspecies, long &maxalign,
89                                      const char *name, int name_len, const char *seq, int seq_len)
90{
91    if (allocated==numberspecies)
92    {
93        long new_allocated = (allocated*3)/2;
94
95        the_names = (uchar**)GB_recalloc(the_names, allocated, new_allocated, sizeof(*the_names));
96        the_sequences = (uchar**)GB_recalloc(the_sequences, allocated, new_allocated, sizeof(*the_sequences));
97        allocated = new_allocated;
98    }
99
100    the_names[numberspecies] = (uchar*)GB_calloc(name_len+1, sizeof(char));
101    memcpy(the_names[numberspecies], name, name_len);
102    the_names[numberspecies][name_len] = 0;
103    replaceChars((char*)the_names[numberspecies], ' ', '_');
104
105    the_sequences[numberspecies] = (uchar*)GB_calloc(seq_len+1, sizeof(char));
106    memcpy(the_sequences[numberspecies], seq, seq_len);
107    the_sequences[numberspecies][seq_len] = 0;
108
109    if (seq_len>maxalign) {
110        maxalign = seq_len;
111    }
112
113    numberspecies++;
114}
115
116#ifndef NDEBUG
117
118inline const char *id(ED4_base *base)
119{
120    return base->id ? base->id : "???";
121}
122
123static void childs(ED4_manager *manager)
124{
125    int i;
126    int anz = manager->children->members();
127
128    if (anz) {
129        printf("(");
130        for (i=0; i<anz; i++) {
131            if (i) printf(", ");
132            printf("%s", id(manager->children->member(i)));
133        }
134        printf(")");
135    }
136}
137
138void baum(ED4_base *base)
139{
140    static int level;
141
142    level++;
143
144    if (base->parent) {
145        baum(base->parent);
146    }
147
148    printf("[%2i] %-30s", level, id(base));
149    if (base->is_manager()) {
150        childs(base->to_manager());
151    }
152    printf("\n");
153
154    level--;
155}
156
157void baum(const char *id)
158{
159    baum(ED4_ROOT->root_group_man->search_ID(id));
160}
161
162#endif
163
164static char *add_area_for_gde(ED4_area_manager *area_man, uchar **&the_names, uchar **&the_sequences,
165                              long &allocated, long &numberspecies, long &maxalign,
166                              int show_sequence, int show_SAI, int show_helix, int show_consensus, int show_remark)
167{
168    ED4_terminal *terminal = area_man->get_first_terminal(),
169        *last = area_man->get_last_terminal();
170    //    ED4_multi_species_manager *last_multi = 0;
171
172    for (;terminal;) {
173        if (terminal->is_species_name_terminal()) {
174            ED4_species_manager *species_manager = terminal->get_parent(ED4_L_SPECIES)->to_species_manager();
175            ED4_species_name_terminal *species_name = species_manager->search_spec_child_rek(ED4_L_SPECIES_NAME)->to_species_name_terminal();
176            int name_len;
177            char *name = species_name->resolve_pointer_to_string_copy(&name_len);
178            ED4_sequence_terminal *sequence_terminal;
179
180            {
181                ED4_base *sequence_term  = species_manager->search_spec_child_rek(ED4_L_SEQUENCE_STRING);
182                if (!sequence_term) goto end_of_loop;
183                sequence_terminal = sequence_term->to_sequence_terminal();
184            }
185
186            int show = -1;
187            int is_consensus = 0;
188            int is_SAI = 0;
189
190            if (sequence_terminal->parent) {
191                ED4_manager *cons_man = sequence_terminal->parent->parent;
192                if (cons_man && cons_man->flag.is_consensus) { // consensus
193                    show = show_consensus;
194                    is_consensus = 1;
195                }
196            }
197
198            if (show==-1) {
199                if (species_manager->flag.is_SAI) {
200                    show = show_SAI;
201                    is_SAI = 1;
202                }
203                else {
204                    show = show_sequence;
205                }
206            }
207
208            e4_assert(show!=-1);
209
210            if (show) {
211                int seq_len;
212                char *seq = 0;
213
214                if (is_consensus) {
215                    ED4_group_manager *group_manager = sequence_terminal->get_parent(ED4_L_GROUP)->to_group_manager();
216                    int size = group_manager->table().size();
217
218                    seq       = (char*)GB_calloc(size+1, sizeof(char)); // GB_give_buffer(size+1);
219                    seq[size] = 0;
220                    seq       = group_manager->table().build_consensus_string(0, size-1, seq);
221                    seq_len   = size;
222
223                    e4_assert(strlen(seq) == size_t(seq_len));
224
225                    ED4_group_manager *folded_group_man = sequence_terminal->is_in_folded_group();
226
227                    if (folded_group_man) { // we are in a folded group
228                        if (folded_group_man==group_manager) { // we are the consensus of the folded group
229                            if (folded_group_man->is_in_folded_group()) { // a folded group inside a folded group -> do not show
230                                freeset(seq, 0);
231                            }
232                            else { // group folded but consensus shown -> add '-' before name
233                                char *new_name = (char*)GB_calloc(name_len+2, sizeof(char));
234
235                                sprintf(new_name, "-%s", name);
236                                freeset(name, new_name);
237                                name_len++;
238                            }
239                        }
240                        else { // we are really inside a folded group -> don't show
241                            freeset(seq, 0);
242                        }
243                    }
244                }
245                else { // sequence
246                    if (!sequence_terminal->is_in_folded_group()) {
247                        seq = sequence_terminal->resolve_pointer_to_string_copy(&seq_len);
248                    }
249                }
250
251                if (seq) {
252                    set_and_realloc_gde_array(the_names, the_sequences, allocated, numberspecies, maxalign, name, name_len, seq, seq_len);
253                    if (show_helix && !is_SAI && ED4_ROOT->helix->size()) {
254                        char *helix = ED4_ROOT->helix->seq_2_helix(seq, '.');
255                        set_and_realloc_gde_array(the_names, the_sequences, allocated, numberspecies, maxalign, name, name_len, helix, seq_len);
256                    }
257                    if (show_remark && !is_consensus) {
258                        ED4_multi_sequence_manager *ms_man = sequence_terminal->get_parent(ED4_L_MULTI_SEQUENCE)->to_multi_sequence_manager();
259                        ED4_base *remark_name_term = ms_man->search_ID("remark");
260                        if (remark_name_term) {
261                            ED4_base *remark_term = remark_name_term->get_next_terminal();
262                            e4_assert(remark_term);
263
264                            int remark_len;
265                            char *remark = remark_term->resolve_pointer_to_string_copy(&remark_len);
266
267                            replaceChars(remark, ' ', '_');
268                            set_and_realloc_gde_array(the_names, the_sequences, allocated, numberspecies, maxalign, name, name_len, remark, remark_len);
269                            free(remark);
270                        }
271                    }
272                    free(seq);
273                }
274            }
275            free(name);
276        }
277    end_of_loop:
278        if (terminal==last) break;
279        terminal = terminal->get_next_terminal();
280    }
281
282    return 0;
283}
284
285char *ED4_create_sequences_for_gde(void*, GBDATA **&the_species, uchar **&the_names, uchar **&the_sequences, long &numberspecies, long &maxalign)
286{
287    int top = ED4_ROOT->aw_root->awar("gde/top_area")->read_int();
288    int tops = ED4_ROOT->aw_root->awar("gde/top_area_sai")->read_int();
289    int toph = ED4_ROOT->aw_root->awar("gde/top_area_helix")->read_int();
290    int topk = ED4_ROOT->aw_root->awar("gde/top_area_kons")->read_int();
291    int topr = ED4_ROOT->aw_root->awar("gde/top_area_remark")->read_int();
292    int middle = ED4_ROOT->aw_root->awar("gde/middle_area")->read_int();
293    int middles = ED4_ROOT->aw_root->awar("gde/middle_area_sai")->read_int();
294    int middleh = ED4_ROOT->aw_root->awar("gde/middle_area_helix")->read_int();
295    int middlek = ED4_ROOT->aw_root->awar("gde/middle_area_kons")->read_int();
296    int middler = ED4_ROOT->aw_root->awar("gde/middle_area_remark")->read_int();
297
298    numberspecies = 0;
299    maxalign = 0;
300
301    long allocated = 100;
302    the_species = 0;
303    the_names = (uchar**)GB_calloc(allocated, sizeof(*the_names));
304    the_sequences = (uchar**)GB_calloc(allocated, sizeof(*the_sequences));
305
306    char *err = add_area_for_gde(ED4_ROOT->top_area_man, the_names, the_sequences, allocated, numberspecies, maxalign, top, tops, toph, topk, topr);
307    if (!err) {
308        err = add_area_for_gde(ED4_ROOT->middle_area_man, the_names, the_sequences, allocated, numberspecies, maxalign, middle, middles, middleh, middlek, middler);
309    }
310
311    if (allocated!=(numberspecies+1)) {
312        the_names = (uchar**)GB_recalloc(the_names, allocated, numberspecies+1, sizeof(*the_names));
313        the_sequences = (uchar**)GB_recalloc(the_sequences, allocated, numberspecies+1, sizeof(*the_sequences));
314    }
315
316    return err;
317}
318
319static void ED4_gap_chars_changed(AW_root *root) {
320    char *gap_chars = root->awar_string(ED4_AWAR_GAP_CHARS)->read_string();
321
322    ED4_init_is_align_character(gap_chars);
323    free(gap_chars);
324}
325
326static void ED4_edit_direction_changed(AW_root */*awr*/) {
327    ED4_ROOT->get_ed4w()->cursor.redraw();
328}
329
330void ED4_expose_all_windows() {
331    for (ED4_window *ew = ED4_ROOT->first_window; ew; ew = ew->next) {
332        ED4_expose_cb(ew->aww, 0, 0);
333    }
334}
335
336static void ED4_do_expose(AW_root *) {
337    ED4_expose_all_windows();
338}
339
340static void ed4_bind_mainDB_awar_callbacks(AW_root *root) {
341    // callbacks to main DB awars are bound later
342    // (otherwise its easy to crash the editor by clicking around in ARB_NTREE during editor startup)
343
344    root->awar(AWAR_SET_CURSOR_POSITION)->add_callback(ED4_remote_set_cursor_cb, 0, 0);
345    root->awar(AWAR_SPECIES_NAME)->add_callback(ED4_selected_species_changed_cb);
346    root->awar(AWAR_SAI_NAME)->add_callback(ED4_selected_SAI_changed_cb);
347}
348
349static void ed4_create_mainDB_awars(AW_root *root, const char *config_name) {
350    // WARNING: do not bind callbacks here -> do it in ed4_bind_mainDB_awar_callbacks()
351
352    root->awar_string(AWAR_ITARGET_STRING, "", GLOBAL_gb_main);
353
354    root->awar_int(AWAR_CURSOR_POSITION,       1, GLOBAL_gb_main);
355    root->awar_int(AWAR_CURSOR_POSITION_LOCAL, 0, GLOBAL_gb_main);
356    root->awar_int(AWAR_SET_CURSOR_POSITION,   1, GLOBAL_gb_main);
357
358    root->awar_string(AWAR_FIELD_CHOSEN, "", GLOBAL_gb_main);
359
360    root->awar_string(AWAR_SPECIES_NAME, "", GLOBAL_gb_main);
361    root->awar_string(AWAR_SAI_NAME,     "", GLOBAL_gb_main);
362    root->awar_string(AWAR_SAI_GLOBAL,   "", GLOBAL_gb_main);
363    //    root->awar_string(AWAR_SAI_COLOR_STR, "", GLOBAL_gb_main); //sai visualization in probe match
364
365    root->awar_string(AWAR_EDIT_CONFIGURATION, config_name, GLOBAL_gb_main);
366
367    ED4_create_search_awars(root);
368}
369
370static void ed4_create_all_awars(AW_root *root, const char *config_name) {
371    // Note: cursor awars are created in window constructor
372
373    ed4_create_mainDB_awars(root, config_name);
374   
375#if defined(DEBUG)
376    AWT_create_db_browser_awars(root, AW_ROOT_DEFAULT);
377#endif // DEBUG
378
379    create_naligner_variables(root, AW_ROOT_DEFAULT);
380    create_sina_variables(root, AW_ROOT_DEFAULT);
381
382    awar_edit_modus = AD_ALIGN;
383
384    int def_sec_level = 0;
385#ifdef DEBUG
386    def_sec_level = 6; // don't nag developers
387#endif
388    root->awar_int( AWAR_EDIT_SECURITY_LEVEL, def_sec_level,AW_ROOT_DEFAULT);
389
390    root->awar_int( AWAR_EDIT_SECURITY_LEVEL_ALIGN, def_sec_level,AW_ROOT_DEFAULT)->add_callback(ed4_changesecurity,(AW_CL) def_sec_level);
391    root->awar_int( AWAR_EDIT_SECURITY_LEVEL_CHANGE, def_sec_level,AW_ROOT_DEFAULT)->add_callback(ed4_changesecurity,(AW_CL) def_sec_level);
392
393    //    root->awar_int( AWAR_EDIT_MODE, (long) awar_edit_modus )->add_target_var((long *) &awar_edit_modus)->add_callback(ed4_changesecurity,(AW_CL) 0);
394
395    root->awar_int( AWAR_EDIT_MODE,   0)->add_callback(ed4_change_edit_mode, (AW_CL)0);
396    root->awar_int( AWAR_INSERT_MODE, 1)->add_callback(ed4_change_edit_mode, (AW_CL)0);
397
398    root->awar_int( AWAR_EDIT_DIRECTION, 1)->add_target_var(&awar_edit_direction)->add_callback(ED4_edit_direction_changed);
399    root->awar_int( AWAR_EDIT_HELIX_SPACING, 0)->add_target_var(&ED4_ROOT->helix_add_spacing)->add_callback(ED4_do_expose);
400    root->awar_int( AWAR_EDIT_TERMINAL_SPACING, 0)->add_target_var(&ED4_ROOT->terminal_add_spacing)->add_callback(ED4_do_expose);
401    root->awar_int( AWAR_EDIT_TITLE_MODE, 0);
402
403    ed4_changesecurity(root,0);
404
405    root->awar_int(ED4_AWAR_COMPRESS_SEQUENCE_GAPS,0)->add_callback(ED4_compression_toggle_changed_cb, AW_CL(0), 0);
406    root->awar_int(ED4_AWAR_COMPRESS_SEQUENCE_HIDE,0)->add_callback(ED4_compression_toggle_changed_cb, AW_CL(1), 0);
407    root->awar_int(ED4_AWAR_COMPRESS_SEQUENCE_TYPE,0)->add_callback(ED4_compression_changed_cb);
408    root->awar_int(ED4_AWAR_COMPRESS_SEQUENCE_PERCENT,1)->add_callback(ED4_compression_changed_cb)->set_minmax(1,99);
409//     root->awar_int(ED4_AWAR_COMPRESS_LEFT_COLUMN,0);
410
411    root->awar_int(ED4_AWAR_DIGITS_AS_REPEAT, 0);
412    root->awar_int(ED4_AWAR_FAST_CURSOR_JUMP, 0);
413    root->awar_int(ED4_AWAR_CURSOR_TYPE, (int)ED4_RIGHT_ORIENTED_CURSOR);
414
415    ED4_create_consensus_awars(root);
416    ED4_create_NDS_awars(root);
417
418    root->awar_string(ED4_AWAR_REP_SEARCH_PATTERN, ".");
419    root->awar_string(ED4_AWAR_REP_REPLACE_PATTERN, "-");
420
421    root->awar_int(ED4_AWAR_SCROLL_SPEED_X, 40);
422    root->awar_int(ED4_AWAR_SCROLL_SPEED_Y, 20);
423    root->awar_int(ED4_AWAR_SCROLL_MARGIN, 5);
424
425    root->awar_string(ED4_AWAR_SPECIES_TO_CREATE, "");
426
427    root->awar_string(ED4_AWAR_GAP_CHARS, ".-~?")->add_callback(ED4_gap_chars_changed);
428    ED4_gap_chars_changed(root);
429    root->awar_int(ED4_AWAR_ANNOUNCE_CHECKSUM_CHANGES, 0);
430
431    create_gde_var(ED4_ROOT->aw_root, ED4_ROOT->db, ED4_create_sequences_for_gde, CGSS_WT_EDIT4, 0);
432
433    root->awar_string(ED4_AWAR_CREATE_FROM_CONS_REPL_EQUAL, "-");
434    root->awar_string(ED4_AWAR_CREATE_FROM_CONS_REPL_POINT, "?");
435    root->awar_int(ED4_AWAR_CREATE_FROM_CONS_CREATE_POINTS, 1);
436    root->awar_int(ED4_AWAR_CREATE_FROM_CONS_ALL_UPPER, 1);
437    root->awar_int(ED4_AWAR_CREATE_FROM_CONS_DATA_SOURCE, 0);
438
439    ED4_createVisualizeSAI_Awars(root,AW_ROOT_DEFAULT);
440    ED4_create_dot_missing_bases_awars(root,AW_ROOT_DEFAULT);
441
442    // Create Awars To Be Used In Protein Viewer
443    if(ED4_ROOT->alignment_type == GB_AT_DNA) {
444        PV_CreateAwars(root,AW_ROOT_DEFAULT);
445    }
446   
447    // create awars to be used for protein secondary structure match
448    if(ED4_ROOT->alignment_type == GB_AT_AA) {
449        root->awar_int(PFOLD_AWAR_ENABLE, 1);
450        root->awar_string(PFOLD_AWAR_SELECTED_SAI, "PFOLD");
451        root->awar_int(PFOLD_AWAR_MATCH_METHOD, SECSTRUCT_SEQUENCE);
452        int pt;
453        char awar[256];
454        for (int i = 0; pfold_match_type_awars[i].name; i++){
455            pt = pfold_match_type_awars[i].value;
456            sprintf(awar, PFOLD_AWAR_PAIR_TEMPLATE, pfold_match_type_awars[i].name);
457            root->awar_string(awar, pfold_pairs[pt])->add_target_var(&pfold_pairs[pt]);
458            sprintf(awar, PFOLD_AWAR_SYMBOL_TEMPLATE, pfold_match_type_awars[i].name);
459            root->awar_string(awar, pfold_pair_chars[pt])->add_target_var(&pfold_pair_chars[pt]);
460        }
461        root->awar_string(PFOLD_AWAR_SYMBOL_TEMPLATE_2, PFOLD_PAIR_CHARS_2);
462        root->awar_string(PFOLD_AWAR_SAI_FILTER, "pfold");
463    }
464
465    GB_ERROR error = ARB_init_global_awars(root, AW_ROOT_DEFAULT, GLOBAL_gb_main);
466    if (error) aw_message(error);
467}
468
469const char *ED4_propertyName(int mode) {
470    // mode == 0 -> alignment specific          (e.g. ".arb_prop/edit4_ali_16s.arb")
471    // mode == 1 -> alignment-type specific     (e.g. ".arb_prop/edit4_rna.arb")
472    // mode == 2 -> unspecific (normal)         (always ".arb_prop/edit4.arb")
473    //
474    // Note : result is only valid until next call
475
476    e4_assert(mode >= 0 && mode <= 2);
477
478    if (mode == 2) return ".arb_prop/edit4.arb";
479
480    static char *ali_name = 0;
481    static char *ali_type = 0;
482    static char *result = 0;
483
484    if (!ali_name) {
485        GB_transaction dummy(GLOBAL_gb_main);
486        ali_name = GBT_get_default_alignment(GLOBAL_gb_main);
487        ali_type = GBT_get_alignment_type_string(GLOBAL_gb_main, ali_name);
488        result   = new char[21+strlen(ali_name)];
489    }
490
491    sprintf(result, ".arb_prop/edit4_%s.arb", mode == 0 ? ali_name : ali_type);
492
493    return result;
494}
495
496
497static void openProperties() {
498    for (int mode = 0; mode <= 2; ++mode) { // search for defaults-database
499        const char *name  = ED4_propertyName(mode);
500        AW_default  found = ED4_ROOT->aw_root->open_default(name, mode == 2); // if mode == 2 -> create if missing
501
502        if (found) {
503            ED4_ROOT->db      = found;
504            ED4_ROOT->db_name = strdup(name);
505            break;
506        }
507    }
508
509    GB_informationf("Using properties from '%s'", ED4_ROOT->db_name);
510    ED4_ROOT->aw_root->init_variables( ED4_ROOT->db); // pass defaults
511}
512
513int main(int argc, char **argv)
514{
515    const char *data_path = ":";
516    const char *err = NULL;
517    char *config_name = NULL;
518
519    if (argc > 1 && ((strcmp(argv[1],"-h") == 0) || (strcmp(argv[1],"--help") == 0))) {
520        fprintf(stderr,
521                "\n"
522                "arb_edit4 commandline reference:\n"
523                "--------------------------------\n"
524                "\n"
525                "Usage: arb_edit4 [options] database\n"
526                "\n"
527                "database           name of database or ':' to connect to arb-database-server\n"
528                "\n"
529                "Options:\n"
530                "-c config          loads configuration 'config' (default: 'default_configuration')\n"
531                "\n"
532                );
533    }
534
535    if (argc > 1 && strcmp(argv[1],"-c") == 0) {
536        config_name = new char[strlen(argv[2])+1];
537        strcpy(config_name,argv[2]);
538        argc -= 2; argv += 2;
539    }
540    else { // load 'default_configuration' if no command line is given
541        config_name = strdup("default_configuration");
542        err = "Using 'default_configuration'";
543#ifndef NDEBUG
544        err = 0;
545#endif
546    }
547
548    if (argc>1) {
549        data_path = argv[1];
550        argc--; argv++;
551    }
552
553    GLOBAL_gb_main = GB_open(data_path, "rwt");
554    if (!GLOBAL_gb_main)
555    {
556        GB_print_error();
557        exit (-1);
558    }
559
560#if defined(DEBUG)
561    AWT_announce_db_to_browser(GLOBAL_gb_main, GBS_global_string("ARB database (%s)", data_path));
562#endif // DEBUG
563    ED4_ROOT = new ED4_root;
564
565    openProperties(); // open properties database
566
567    ED4_ROOT->aw_root->init_root("ARB_EDIT4", false); // initialize window-system
568
569    ED4_ROOT->database = new EDB_root_bact;
570    ED4_ROOT->init_alignment();
571    ed4_create_all_awars(ED4_ROOT->aw_root, config_name);
572
573    ED4_ROOT->st_ml = new_ST_ML(GLOBAL_gb_main);
574    ED4_ROOT->sequence_colors = new AWT_seq_colors((GBDATA *)ED4_ROOT->aw_root->application_database,(int)ED4_G_SEQUENCES, ED4_refresh_window, 0,0);
575
576    ED4_ROOT->edk = new ed_key;
577    ED4_ROOT->edk->create_awars(ED4_ROOT->aw_root);
578
579    ED4_ROOT->helix = new AW_helix(ED4_ROOT->aw_root);
580
581    if (err){
582        aw_message(err);
583        err = 0;
584    }
585
586    switch (ED4_ROOT->alignment_type) {
587        case GB_AT_RNA:
588        case GB_AT_DNA:
589            err = ED4_ROOT->helix->init(GLOBAL_gb_main);
590            break;
591
592        case GB_AT_AA:
593            err = ED4_pfold_set_SAI(&ED4_ROOT->protstruct, GLOBAL_gb_main, ED4_ROOT->alignment_name, &ED4_ROOT->protstruct_len);
594            break;
595
596        default :
597            e4_assert(0);
598            break;
599    }
600
601    if (err) aw_message(err); // write to console
602    ED4_ROOT->sequence_colors->aww = ED4_ROOT->create_new_window(); // create first editor window
603    if (err) aw_message(err); // write again to status window
604
605    {
606        int found_config = 0;
607
608        if (config_name)
609        {
610            GB_begin_transaction(GLOBAL_gb_main);
611            GBDATA *gb_configuration = GBT_find_configuration(GLOBAL_gb_main, config_name);
612
613            if (gb_configuration) {
614                GBDATA *gb_middle_area = GB_search(gb_configuration, "middle_area", GB_FIND);
615                GBDATA *gb_top_area = GB_search(gb_configuration, "top_area", GB_FIND);
616                char *config_data_middle = GB_read_as_string(gb_middle_area);
617                char *config_data_top   = GB_read_as_string(gb_top_area);
618
619                ED4_ROOT->create_hierarchy(config_data_middle, config_data_top); // create internal hierarchy
620                free(config_data_middle);
621                free(config_data_top);
622
623                found_config = 1;
624            }
625            else {
626                aw_message(GBS_global_string("Could not find configuration '%s'", config_name));
627            }
628
629            GB_commit_transaction(GLOBAL_gb_main);
630        }
631
632        if (!found_config) {
633            // create internal hierarchy
634
635            char *as_mid = ED4_ROOT->database->make_string();
636            char *as_top = ED4_ROOT->database->make_top_bot_string();
637
638            ED4_ROOT->create_hierarchy(as_mid, as_top);
639
640            delete as_mid;
641            delete as_top;
642        }
643    }
644
645    // now bind DB depending callbacks
646
647    ed4_bind_mainDB_awar_callbacks(ED4_ROOT->aw_root);
648    {
649        GB_transaction dummy(GLOBAL_gb_main);
650        GBDATA *species_container = GB_search(GLOBAL_gb_main, "species_data", GB_FIND);
651        GB_add_callback(species_container, (GB_CB_TYPE)GB_CB_CHANGED, (GB_CB)ED4_species_container_changed_cb, 0); // callback if species_data changes
652
653        ED4_elements_in_species_container = GB_number_of_subentries(species_container); // store # of species
654#if defined(DEBUG) && 0
655        printf("Species container contains %i species (at startup)\n", ED4_elements_in_species_container);
656#endif
657    }
658   
659    // Create Additional sequence (aminoacid) terminals to be used in Protein Viewer
660    if(ED4_ROOT->alignment_type == GB_AT_DNA) {
661        PV_CallBackFunction(ED4_ROOT->aw_root);
662    }
663
664    ED4_ROOT->aw_root->main_loop(); // enter main-loop
665}
666
667void AD_map_viewer(GBDATA *,AD_MAP_VIEWER_TYPE)
668{
669}
670
Note: See TracBrowser for help on using the repository browser.