source: branches/nameserver/EDIT4/ED4_ProteinViewer.cxx @ 17124

Last change on this file since 17124 was 16766, 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: 50.3 KB
Line 
1// =======================================================================================
2//
3//    File       : ED4_ProteinViewer.cxx
4//    Purpose    : Protein Viewer: Dynamical translation and display of
5//                 aminoacid sequences in the dna alignment.
6//    Author     : Yadhu Kumar (yadhu@arb-home.de)
7//    web site   : http://www.arb-home.de/
8//
9//    Copyright Department of Microbiology (Technical University Munich)
10//
11// =======================================================================================
12
13#include "ed4_ProteinViewer.hxx"
14#include "ed4_seq_colors.hxx"
15#include "ed4_class.hxx"
16
17#include <AP_pro_a_nucs.hxx>
18#include <AP_codon_table.hxx>
19#include <Translate.hxx>
20#include <aw_question.hxx>
21#include <aw_preset.hxx>
22#include <aw_awars.hxx>
23#include <aw_msg.hxx>
24#include <aw_root.hxx>
25#include <arbdbt.h>
26
27#include <iostream>
28
29using namespace std;
30
31// Definitions used
32#define FORWARD_STRAND         1
33#define COMPLEMENTARY_STRAND   2
34#define DB_FIELD_STRAND        3
35
36#define FORWARD_STRANDS        3
37#define COMPLEMENTARY_STRANDS  3
38#define DB_FIELD_STRANDS       1
39
40enum {
41    PV_MARKED = 0,
42    PV_SELECTED,
43    PV_CURSOR,
44    PV_ALL
45};
46
47// Global Variables
48extern GBDATA *GLOBAL_gb_main;
49
50static bool gTerminalsCreated       = false;
51static int  PV_AA_Terminals4Species = 0;
52static int  gMissingTransTable      = 0;
53static int  gMissingCodonStart      = 0;
54static bool gbWritingData           = false;
55static int  giNewAlignments         = 0;
56
57static AW_repeated_question *ASKtoOverWriteData = NULp;
58
59static bool PV_LookForNewTerminals(AW_root *root) {
60    bool bTerminalsFound = true;
61
62    int all = root->awar(AWAR_PV_DISPLAY_ALL)->read_int();
63    int all_f1 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_1)->read_int();
64    int all_f2 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_2)->read_int();
65    int all_f3 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_3)->read_int();
66    int all_c1  = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1)->read_int();
67    int all_c2  = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2)->read_int();
68    int all_c3  = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3)->read_int();
69    int all_db     = root->awar(AWAR_PROTVIEW_DEFINED_FIELDS)->read_int();
70
71    int sel = root->awar(AWAR_PV_SELECTED)->read_int();
72    int sel_db = root->awar(AWAR_PV_SELECTED_DB)->read_int();
73    int sel_f1 = root->awar(AWAR_PV_SELECTED_FS_1)->read_int();
74    int sel_f2 = root->awar(AWAR_PV_SELECTED_FS_2)->read_int();
75    int sel_f3 = root->awar(AWAR_PV_SELECTED_FS_3)->read_int();
76    int sel_c1 = root->awar(AWAR_PV_SELECTED_CS_1)->read_int();
77    int sel_c2 = root->awar(AWAR_PV_SELECTED_CS_2)->read_int();
78    int sel_c3 = root->awar(AWAR_PV_SELECTED_CS_3)->read_int();
79
80    int mrk = root->awar(AWAR_PV_MARKED)->read_int();
81    int mrk_db = root->awar(AWAR_PV_MARKED_DB)->read_int();
82    int mrk_f1 = root->awar(AWAR_PV_MARKED_FS_1)->read_int();
83    int mrk_f2 = root->awar(AWAR_PV_MARKED_FS_2)->read_int();
84    int mrk_f3 = root->awar(AWAR_PV_MARKED_FS_3)->read_int();
85    int mrk_c1 = root->awar(AWAR_PV_MARKED_CS_1)->read_int();
86    int mrk_c2 = root->awar(AWAR_PV_MARKED_CS_2)->read_int();
87    int mrk_c3 = root->awar(AWAR_PV_MARKED_CS_3)->read_int();
88
89    int cur = root->awar(AWAR_PV_CURSOR)->read_int();
90    int cur_db = root->awar(AWAR_PV_CURSOR_DB)->read_int();
91    int cur_f1 = root->awar(AWAR_PV_CURSOR_FS_1)->read_int();
92    int cur_f2 = root->awar(AWAR_PV_CURSOR_FS_2)->read_int();
93    int cur_f3 = root->awar(AWAR_PV_CURSOR_FS_3)->read_int();
94    int cur_c1 = root->awar(AWAR_PV_CURSOR_CS_1)->read_int();
95    int cur_c2 = root->awar(AWAR_PV_CURSOR_CS_2)->read_int();
96    int cur_c3 = root->awar(AWAR_PV_CURSOR_CS_3)->read_int();
97
98    // Test whether any of the options are selected or not?
99    if ((all && (all_f1 || all_f2 || all_f3 || all_c1 || all_c2 || all_c3 || all_db)) ||
100        (sel && (sel_db || sel_f1 || sel_f2 || sel_f3 || sel_c1 || sel_c2 || sel_c3)) ||
101        (mrk && (mrk_db || mrk_f1 || mrk_f2 || mrk_f3 || mrk_c1 || mrk_c2 || mrk_c3)) ||
102        (cur && (cur_db || cur_f1 || cur_f2 || cur_f3 || cur_c1 || cur_c2 || cur_c3)))
103        {
104            // if so, then test whether the terminals are created already or not?
105            if (gTerminalsCreated) {
106                // if yes, then set the flag to true
107                bTerminalsFound = true;
108            }
109            else {
110                // if not, then new terminals has to be created
111                bTerminalsFound = false;
112            }
113        }
114    return bTerminalsFound;
115}
116
117static void PV_HideTerminal(ED4_orf_terminal *orfTerm) {
118    ED4_sequence_manager *seqManager = orfTerm->get_parent(LEV_SEQUENCE)->to_sequence_manager();
119    seqManager->hide_children();
120}
121
122static void PV_UnHideTerminal(ED4_orf_terminal *orfTerm) {
123    ED4_sequence_manager *seqManager = orfTerm->get_parent(LEV_SEQUENCE)->to_sequence_manager();
124    seqManager->unhide_children();
125}
126
127static void PV_HideAllTerminals() {
128    ED4_terminal *terminal = NULp;
129    for (terminal = ED4_ROOT->root_group_man->get_first_terminal();
130         terminal;
131         terminal = terminal->get_next_terminal())
132    {
133        if (terminal->is_orf_terminal()) { 
134            ED4_orf_terminal *orfTerm = terminal->to_orf_terminal();
135            PV_HideTerminal(orfTerm);
136        }
137    }
138}
139
140
141static void PV_ManageTerminalDisplay(AW_root *root, ED4_orf_terminal *orfTerm, long int DispMode) {
142    int all, af_1, af_2, af_3, ac_1, ac_2, ac_3, adb;
143    all =  root->awar(AWAR_PV_DISPLAY_ALL)->read_int();
144    adb = root->awar(AWAR_PROTVIEW_DEFINED_FIELDS)->read_int();
145    af_1 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_1)->read_int();
146    af_2 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_2)->read_int();
147    af_3 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_3)->read_int();
148    ac_1 = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1)->read_int();
149    ac_2 = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2)->read_int();
150    ac_3 = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3)->read_int();
151
152    int mrk, mf_1, mf_2, mf_3, mc_1, mc_2, mc_3, mdb;
153    mrk = root->awar(AWAR_PV_MARKED)->read_int();
154    mdb = root->awar(AWAR_PV_MARKED_DB)->read_int();
155    mf_1 = root->awar(AWAR_PV_MARKED_FS_1)->read_int();
156    mf_2 = root->awar(AWAR_PV_MARKED_FS_2)->read_int();
157    mf_3 = root->awar(AWAR_PV_MARKED_FS_3)->read_int();
158    mc_1 = root->awar(AWAR_PV_MARKED_CS_1)->read_int();
159    mc_2 = root->awar(AWAR_PV_MARKED_CS_2)->read_int();
160    mc_3 = root->awar(AWAR_PV_MARKED_CS_3)->read_int();
161
162    int sel, sf_1, sf_2, sf_3, sc_1, sc_2, sc_3, sdb;
163    sel = root->awar(AWAR_PV_SELECTED)->read_int();
164    sdb = root->awar(AWAR_PV_SELECTED_DB)->read_int();
165    sf_1 = root->awar(AWAR_PV_SELECTED_FS_1)->read_int();
166    sf_2 = root->awar(AWAR_PV_SELECTED_FS_2)->read_int();
167    sf_3 = root->awar(AWAR_PV_SELECTED_FS_3)->read_int();
168    sc_1 = root->awar(AWAR_PV_SELECTED_CS_1)->read_int();
169    sc_2 = root->awar(AWAR_PV_SELECTED_CS_2)->read_int();
170    sc_3 = root->awar(AWAR_PV_SELECTED_CS_3)->read_int();
171
172    int cur, cf_1, cf_2, cf_3, cc_1, cc_2, cc_3, cdb;
173    cur = root->awar(AWAR_PV_CURSOR)->read_int();
174    cdb = root->awar(AWAR_PV_CURSOR_DB)->read_int();
175    cf_1 = root->awar(AWAR_PV_CURSOR_FS_1)->read_int();
176    cf_2 = root->awar(AWAR_PV_CURSOR_FS_2)->read_int();
177    cf_3 = root->awar(AWAR_PV_CURSOR_FS_3)->read_int();
178    cc_1 = root->awar(AWAR_PV_CURSOR_CS_1)->read_int();
179    cc_2 = root->awar(AWAR_PV_CURSOR_CS_2)->read_int();
180    cc_3 = root->awar(AWAR_PV_CURSOR_CS_3)->read_int();
181
182    // Get the AA sequence flag - says which strand we are in
183    int aaStrandType = int(orfTerm->GET_aaStrandType());
184    // Check the display options and make visible or hide the AA seq terminal
185    switch (aaStrandType) {
186        case FORWARD_STRAND: {
187            int aaStartPos = int(orfTerm->GET_aaStartPos());
188            switch (aaStartPos) {
189                case 1:
190                    switch (DispMode) {
191                        case PV_ALL:      (all && af_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
192                        case PV_MARKED:   (mrk && mf_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
193                        case PV_SELECTED: (sel && sf_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
194                        case PV_CURSOR:   (cur && cf_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
195                    }
196                    break;
197                case 2:
198                    switch (DispMode) {
199                        case PV_ALL:      (all && af_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
200                        case PV_MARKED:   (mrk && mf_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
201                        case PV_SELECTED: (sel && sf_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
202                        case PV_CURSOR:   (cur && cf_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
203                    }
204                    break;
205                case 3:
206                    switch (DispMode) {
207                        case PV_ALL:      (all && af_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
208                        case PV_MARKED:   (mrk && mf_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
209                        case PV_SELECTED: (sel && sf_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
210                        case PV_CURSOR:   (cur && cf_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
211                    }
212                    break;
213            }
214            break;
215        }
216        case COMPLEMENTARY_STRAND: {
217            int aaStartPos = int(orfTerm->GET_aaStartPos());
218            switch (aaStartPos) {
219                case 1:
220                    switch (DispMode) {
221                        case PV_ALL:      (all && ac_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
222                        case PV_MARKED:   (mrk && mc_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
223                        case PV_SELECTED: (sel && sc_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
224                        case PV_CURSOR:   (cur && cc_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
225                    }
226                    break;
227                case 2:
228                    switch (DispMode) {
229                        case PV_ALL:      (all && ac_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
230                        case PV_MARKED:   (mrk && mc_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
231                        case PV_SELECTED: (sel && sc_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
232                        case PV_CURSOR:   (cur && cc_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
233                    }
234                    break;
235                case 3:
236                    switch (DispMode) {
237                        case PV_ALL:      (all && ac_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
238                        case PV_MARKED:   (mrk && mc_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
239                        case PV_SELECTED: (sel && sc_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
240                        case PV_CURSOR:   (cur && cc_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
241                    }
242                    break;
243            }
244            break;
245        }
246        case DB_FIELD_STRAND:
247            switch (DispMode) {
248                case PV_ALL:      (all && adb) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
249                case PV_MARKED:   (mrk && mdb) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
250                case PV_SELECTED: (sel && sdb) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
251                case PV_CURSOR:   (cur && cdb) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
252            }
253            break;
254        }
255}
256
257static void PV_ManageTerminals(AW_root *root) {
258
259    // First Hide all orf Terminals
260    PV_HideAllTerminals();
261
262    int dispAll = root->awar(AWAR_PV_DISPLAY_ALL)->read_int();
263    if (dispAll) {
264        for (ED4_terminal *terminal = ED4_ROOT->root_group_man->get_first_terminal();
265             terminal;
266             terminal = terminal->get_next_terminal())
267        {
268            if (terminal->is_orf_terminal()) {
269                ED4_orf_terminal *orfTerm = terminal->to_orf_terminal();
270                PV_ManageTerminalDisplay(root, orfTerm, PV_ALL);
271            }
272        }
273    }
274
275    int dispMarked = root->awar(AWAR_PV_MARKED)->read_int();
276    if (dispMarked) {
277        GB_transaction ta(GLOBAL_gb_main);
278        int marked = GBT_count_marked_species(GLOBAL_gb_main);
279        if (marked) {
280            for (GBDATA *gbSpecies = GBT_first_marked_species(GLOBAL_gb_main);
281                 gbSpecies;
282                 gbSpecies = GBT_next_marked_species(gbSpecies))
283            {
284                ED4_species_name_terminal *spNameTerm = ED4_find_species_name_terminal(GBT_read_name(gbSpecies));
285                if (spNameTerm) {
286                    ED4_terminal *terminal = spNameTerm->corresponding_sequence_terminal();
287                    for (int i=0; i<PV_AA_Terminals4Species; i++) {
288                        // get the corresponding orf_terminal skipping sequence_info terminal
289                        // $$$$$ sequence_terminal->sequence_info_terminal->aa_sequence_terminal $$$$$$
290                        terminal = terminal->get_next_terminal()->get_next_terminal();
291                        // Make sure it is ORF terminal
292                        if (terminal->is_orf_terminal()) {
293                            ED4_orf_terminal *orfTerm = terminal->to_orf_terminal();
294                            PV_ManageTerminalDisplay(root, orfTerm, PV_MARKED);
295                        }
296                    }
297                }
298            }
299        }
300    }
301
302    int dispSelected = root->awar(AWAR_PV_SELECTED)->read_int();
303    if (dispSelected) {
304        for (ED4_terminal *terminal = ED4_ROOT->root_group_man->get_first_terminal();
305             terminal;
306             terminal = terminal->get_next_terminal())
307        {
308            if (terminal->is_sequence_terminal()) {
309                ED4_species_manager *speciesManager = terminal->get_parent(LEV_SPECIES)->to_species_manager();
310                if (speciesManager->is_species_seq_terminal()) {
311                    // we are in the sequence terminal section of a species
312                    // walk through all the corresponding ORF terminals for the species and
313                    // hide or unhide the terminals based on the display options set by the user
314                    if (speciesManager->is_selected()) {
315                        for (int i=0; i<PV_AA_Terminals4Species; i++) {
316                            // get the corresponding orf_terminal skipping sequence_info terminal
317                            // $$$$$ sequence_terminal->sequence_info_terminal->aa_sequence_terminal $$$$$$
318                            terminal = terminal->get_next_terminal()->get_next_terminal();
319                            // Make sure it is ORF terminal
320                            if (terminal->is_orf_terminal()) {
321                                ED4_orf_terminal *orfTerm = terminal->to_orf_terminal();
322                                PV_ManageTerminalDisplay(root, orfTerm, PV_SELECTED);
323                            }
324                        }
325                    }
326                }
327            }
328        }
329    }
330
331    int dispAtCursor = root->awar(AWAR_PV_CURSOR)->read_int();
332    if (dispAtCursor) {
333        // only display terminals for species at cursor
334        if (ED4_ROOT->get_most_recently_used_window()) {
335            ED4_MostRecentWinContext context;
336            ED4_cursor&              cursor = current_cursor();
337
338            if (cursor.owner_of_cursor) {
339                // Get The Cursor Terminal And The Corresponding Aa_Sequence Terminals And Set The Display Options
340                ED4_terminal *cursorTerminal = cursor.owner_of_cursor;
341                if (cursorTerminal->is_species_seq_terminal()) {
342                    for (int i=0; i<PV_AA_Terminals4Species; i++) {
343                        // get the corresponding orf_terminal skipping sequence_info terminal
344                        // $$$$$ sequence_terminal->sequence_info_terminal->aa_sequence_terminal $$$$$$
345                        cursorTerminal = cursorTerminal->get_next_terminal()->get_next_terminal();
346                        // Make sure it is ORF terminal
347                        if (cursorTerminal->is_orf_terminal()) {
348                            ED4_orf_terminal *orfTerm = cursorTerminal->to_orf_terminal();
349                            PV_ManageTerminalDisplay(root, orfTerm, PV_CURSOR);
350                        }
351                    }
352                }
353            }
354        }
355    }
356}
357
358void PV_RefreshWindow(AW_root *root) {
359    // Manage the terminals showing only those selected by the user
360    if (gTerminalsCreated) {
361        PV_ManageTerminals(root);
362    }
363    // Refresh all windows
364    // ED4_ROOT->refresh_all_windows(0);
365}
366
367static GB_ERROR PV_ComplementarySequence(char *sequence) {
368    char     T_or_U;
369    GB_ERROR error = GBT_determine_T_or_U(ED4_ROOT->alignment_type, &T_or_U, "complement");
370    if (!error) {
371        int   seqLen           = strlen(sequence);
372        char *complementarySeq = GBT_complementNucSequence((const char*) sequence, seqLen, T_or_U);
373
374        strcpy(sequence, complementarySeq);
375        free(complementarySeq);
376    }
377    return error;
378}
379
380static void PV_WriteTranslatedSequenceToDB(ED4_orf_terminal *aaSeqTerm, const char *spName) {
381    GB_ERROR  error      = GB_begin_transaction(GLOBAL_gb_main);
382    GBDATA   *gb_species = GBT_find_species(GLOBAL_gb_main, spName);
383    if (!gb_species) error = GBS_global_string("Species '%s' does not exist", spName);
384    else {
385        char *defaultAlignment = GBT_get_default_alignment(GLOBAL_gb_main);
386        if (!defaultAlignment) error = GB_await_error();
387        else {
388            GBDATA *gb_SeqData = GBT_find_sequence(gb_species, defaultAlignment);
389            if (!gb_SeqData) {
390                error = GB_have_error()
391                    ? GB_await_error()
392                    : GBS_global_string("Species '%s' has no data in alignment '%s'", spName, defaultAlignment);
393            }
394            else {
395                char *str_SeqData       = GB_read_string(gb_SeqData);
396                if (!str_SeqData) error = GB_await_error();
397                else {
398                    int aaStrandType = int(aaSeqTerm->GET_aaStrandType());
399                    if (aaStrandType == COMPLEMENTARY_STRAND) {
400                        GB_ERROR compl_err =  PV_ComplementarySequence(str_SeqData);
401                        if (compl_err) error = GBS_global_string("Failed to calc complementary strand (Reason: %s)", compl_err);
402                    }
403
404                    if (!error) {
405                        char newAlignmentName[100];
406                        int  aaStartPos = int(aaSeqTerm->GET_aaStartPos());
407
408                        switch (aaStrandType) {
409                            case FORWARD_STRAND:       sprintf(newAlignmentName, "ali_pro_ProtView_forward_start_pos_%ld",        (long)aaStartPos); break;
410                            case COMPLEMENTARY_STRAND: sprintf(newAlignmentName, "ali_pro_ProtView_complementary_start_pos_%ld",  (long)aaStartPos); break;
411                            case DB_FIELD_STRAND:      sprintf(newAlignmentName, "ali_pro_ProtView_database_field_start_pos_%ld", (long)aaStartPos); break;
412                        }
413
414                        int len = GB_read_string_count(gb_SeqData);
415                        AWT_pro_a_nucs_convert(AWT_default_protein_type(), str_SeqData, len, aaStartPos-1, false, true, false, NULp);
416
417                        // Create alignment data to store the translated sequence
418                        GBDATA *gb_presets          = GBT_get_presets(GLOBAL_gb_main);
419                        GBDATA *gb_alignment_exists = GB_find_string(gb_presets, "alignment_name", newAlignmentName, GB_IGNORE_CASE, SEARCH_GRANDCHILD);
420                        GBDATA *gb_new_alignment    = NULp;
421
422                        if (gb_alignment_exists) {
423                            int     skip_sp     = 0;
424                            char   *question    = NULp;
425                            GBDATA *gb_seq_data = GBT_find_sequence(gb_species, newAlignmentName);
426                            if (gb_seq_data) {
427                                e4_assert(ASKtoOverWriteData);
428                                question = GBS_global_string_copy("\"%s\" contain data in the alignment \"%s\"!", spName, newAlignmentName);
429                                skip_sp  = ASKtoOverWriteData->get_answer("overwrite_translated", question, "Overwrite, Skip Species", "all", false);
430                            }
431                            if (skip_sp) {
432                                error = GBS_global_string_copy("%s You chose to skip this Species!", question);
433                            }
434                            else {
435                                gb_new_alignment             = GBT_get_alignment(GLOBAL_gb_main, newAlignmentName);
436                                if (!gb_new_alignment) error = GB_await_error();
437                            }
438                            free(question);
439                        }
440                        else {
441                            long aliLen      = GBT_get_alignment_len(GLOBAL_gb_main, defaultAlignment);
442                            gb_new_alignment = GBT_create_alignment(GLOBAL_gb_main, newAlignmentName, aliLen/3+1, 0, 1, "ami");
443
444                            if (!gb_new_alignment) error = GB_await_error();
445                            else giNewAlignments++;
446                        }
447
448                        if (!error) {
449                            GBDATA *gb_ProSeqData     = GBT_add_data(gb_species, newAlignmentName, "data", GB_STRING);
450                            if (!gb_ProSeqData) error = GB_await_error();
451                            else    error             = GB_write_string(gb_ProSeqData, str_SeqData);
452                        }
453
454                        if (!error) error = GBT_check_data(GLOBAL_gb_main, NULp);
455                    }
456
457                    free(str_SeqData);
458                }
459            }
460            free(defaultAlignment);
461        }
462    }
463    GB_end_transaction_show_error(GLOBAL_gb_main, error, aw_message);
464}
465
466static void PV_SaveData(AW_window */*aww*/) {
467    // IDEA:
468    // 1. walk thru the orf terminals
469    // 2. check the visibility status
470    // 3. select only the visible terminals
471    // 4. get the corresponding species name
472    // 5. translate the sequence
473    // 6. write to the database
474    gbWritingData = true;
475    if (gTerminalsCreated) {
476        ASKtoOverWriteData = new AW_repeated_question;
477
478        for (ED4_terminal *terminal = ED4_ROOT->root_group_man->get_first_terminal();
479             terminal;
480             terminal = terminal->get_next_terminal())
481        {
482            if (terminal->is_species_seq_terminal()) {
483                const char *speciesName = terminal->to_sequence_terminal()->species_name;
484               
485                for (int i=0; i<PV_AA_Terminals4Species; i++) {
486                    // get the corresponding orf_terminal skipping sequence_info terminal
487                    terminal = terminal->get_next_terminal()->get_next_terminal();
488                    // Make sure it is ORF terminal
489                    if (terminal->is_orf_terminal()) {
490                        ED4_orf_terminal *orfTerm = terminal->to_orf_terminal();
491                        ED4_base *base = (ED4_base*)orfTerm;
492                        if (!base->flag.hidden) {
493                            PV_WriteTranslatedSequenceToDB(orfTerm, speciesName);
494                        }
495                    }
496                }
497            }
498        }
499        if (giNewAlignments>0) {
500            char *msg = GBS_global_string_copy("Protein data saved to NEW alignments.\n%d new alignments were created and named ali_prot_ProtView_XXXX", giNewAlignments);
501            aw_message(msg);
502            free(msg);
503
504            giNewAlignments = 0;
505        }
506    }
507    gbWritingData = false;
508}
509
510static void TranslateGeneToAminoAcidSequence(AW_root * /* root */, ED4_orf_terminal *seqTerm, const char *speciesName, int startPos4Translation, int translationMode) {
511    // This function translates gene sequence to aminoacid sequence and stores translation into the respective AA_Sequence_terminal
512    GB_ERROR  error        = NULp;
513    GBDATA   *gb_species   = GBT_find_species(GLOBAL_gb_main, speciesName);
514    if (!gb_species) error = GBS_global_string("Species '%s' does not exist", speciesName);
515    else {
516        char *defaultAlignment = GBT_get_default_alignment(GLOBAL_gb_main);
517        if (!defaultAlignment) error = GB_await_error();
518        else {
519            GBDATA *gb_SeqData = GBT_find_sequence(gb_species, defaultAlignment);
520            if (!gb_SeqData) {
521                error = GB_have_error()
522                    ? GB_await_error()
523                    : GBS_global_string("Species '%s' has no data in alignment '%s'", speciesName, defaultAlignment);
524            }
525            else {
526                e4_assert(startPos4Translation>=0 && startPos4Translation<=2);
527
528                char *str_SeqData = GB_read_string(gb_SeqData);
529                if (!str_SeqData) error = GB_await_error();
530                else {
531                    int len              = GB_read_string_count(gb_SeqData);
532                    int translationTable = AWT_default_protein_type(GLOBAL_gb_main);
533
534                    switch (translationMode) {
535                        case FORWARD_STRAND:
536                            break;
537                           
538                        case COMPLEMENTARY_STRAND: {
539                            // convert sequence to the complementary sequence
540                            GB_ERROR compl_err =  PV_ComplementarySequence(str_SeqData);
541                            if (compl_err) error = GBS_global_string("Failed to calc complementary strand for '%s' (Reason: %s)", speciesName, compl_err);
542                            break;
543                        }
544                        case DB_FIELD_STRAND: {
545                            // for use database field options - fetch codon start and translation table from the respective species data
546                            GBDATA *gb_translTable = GB_entry(gb_species, "transl_table");
547                            if (gb_translTable) {
548                                int sp_embl_table = atoi(GB_read_char_pntr(gb_translTable));
549                                translationTable  = AWT_embl_transl_table_2_arb_code_nr(sp_embl_table);
550                            }
551                            else {   // use selected translation table as default (if 'transl_table' field is missing)
552                                gMissingTransTable++;
553                            }
554                            GBDATA *gb_codonStart = GB_entry(gb_species, "codon_start");
555                            if (gb_codonStart) {
556                                startPos4Translation = atoi(GB_read_char_pntr(gb_codonStart))-1;
557                                if (startPos4Translation<0 || startPos4Translation>2) {
558                                    error = GB_export_errorf("'%s' has invalid codon_start entry %i (allowed: 1..3)", speciesName, startPos4Translation+1);
559                                }
560                            }
561                            else {
562                                gMissingCodonStart++;
563                                startPos4Translation = 0;
564                            }
565                            break;
566                        }
567                    }
568
569                    if (!error) {
570                        AWT_pro_a_nucs_convert(translationTable, str_SeqData, len, startPos4Translation, false, true, false, NULp); // translate
571
572                        char *s = new char[len+1];
573                        int iDisplayMode = ED4_ROOT->aw_root->awar(AWAR_PROTVIEW_DISPLAY_OPTIONS)->read_int();
574                        int i, j;
575
576                        if (iDisplayMode == PV_AA_NAME) {
577                            char *gc = new char[len+1];
578
579                            for (i=0, j=0; i<len && j<len;) {
580                                // start from the start pos of aa sequence
581                                for (; i<startPos4Translation; ++i) {
582                                    s[i]  = ' ';
583                                    gc[i] = ' ';
584                                }
585
586                                char        base   = str_SeqData[j++];
587                                const char *AAname = NULp;
588                               
589                                if (base>='A' && base<='Z') AAname = AP_get_protein_name(base);
590                                else if (base=='*')         AAname = "End";
591                                else {
592                                    for (int m = 0; m<3 && i<len; m++,i++) {
593                                        s[i] = base;
594                                        gc[i] = base;
595                                    }
596                                }
597                                if (AAname) {
598                                    unsigned nlen = strlen(AAname);
599                                    for (unsigned int n = 0; n<nlen && i<len; n++,i++) {
600                                        s[i]  = AAname[n];
601                                        gc[i] = base;
602                                    }
603                                }
604                            }
605
606                            gc[i] = '\0';
607                            seqTerm->SET_aaColor(gc);
608                            delete [] gc;
609                        }
610                        else {
611                            int k = startPos4Translation+1;
612                            for (i=0, j=0; i<len; i++) {
613                                if ((k==i) && (j<len)) {
614                                    s[i]  = str_SeqData[j++];
615                                    k    += 3;
616                                }
617                                else s[i] = ' ';
618                            }
619                            seqTerm->SET_aaColor(NULp);
620                        }
621                        s[i] = '\0';
622                       
623                        seqTerm->SET_aaSequence(s);
624                        delete [] s;
625                    }
626                    free(str_SeqData);
627                }
628            }
629        }
630        free(defaultAlignment);
631    }
632
633    if (error) aw_message(GBS_global_string("Error: %s", error));
634}
635
636static void PV_PrintMissingDBentryInformation() {
637    if (gMissingCodonStart>0) {
638        aw_message(GBS_global_string("WARNING:  'codon start' entry not found in %d of %d species! Using 1st base as codon start...",
639                                     gMissingCodonStart,
640                                     (int)GBT_count_marked_species(GLOBAL_gb_main)));
641        gMissingCodonStart = 0;
642    }
643    if (gMissingTransTable>0) {
644        aw_message(GBS_global_string("WARNING:  'translation table' entry not found in %d of %d species! Using selected translation table  as a default table...",
645                                     gMissingTransTable,
646                                     (int)GBT_count_marked_species(GLOBAL_gb_main)));
647        gMissingTransTable = 0;
648    }
649}
650
651static void PV_DisplayAminoAcidNames(AW_root *root) {
652    GB_transaction ta(GLOBAL_gb_main);
653
654    for (ED4_terminal *terminal = ED4_ROOT->root_group_man->get_first_terminal();
655         terminal;
656         terminal = terminal->get_next_terminal())
657    {
658        if (terminal->is_species_seq_terminal()) {
659            const char *speciesName = terminal->to_sequence_terminal()->species_name;
660
661            // we are in the sequence terminal section of a species
662            // walk through all the corresponding ORF terminals for the species and
663            // hide or unhide the terminals based on the display options set by the user
664            for (int i=0; i<PV_AA_Terminals4Species; i++) {
665                // get the corresponding orf_terminal skipping sequence_info terminal
666                terminal = terminal->get_next_terminal()->get_next_terminal();
667                // Make sure it is ORF terminal
668                if (terminal->is_orf_terminal()) {
669                    ED4_orf_terminal *orfTerm = terminal->to_orf_terminal();
670                    // we are in ORF terminal
671                    int   aaStartPos = int(orfTerm->GET_aaStartPos());
672                    int aaStrandType = int(orfTerm->GET_aaStrandType());
673                    // retranslate the genesequence and store it to the orf_terminal
674                    TranslateGeneToAminoAcidSequence(root, orfTerm, speciesName, aaStartPos-1, aaStrandType);
675                }
676            }
677        }
678    }
679    // Print missing DB entries
680    PV_PrintMissingDBentryInformation();
681    PV_RefreshWindow(root);
682}
683
684static void PV_RefreshDisplay(AW_root *root) {
685    PV_DisplayAminoAcidNames(root);
686}
687
688static void PV_RefreshProtViewDisplay(AW_window *aww) {
689    if (gTerminalsCreated) {
690        PV_RefreshDisplay(aww->get_root());
691    }
692}
693
694void PV_SequenceUpdate_CB(GB_CB_TYPE gbtype) {
695    if (gbtype==GB_CB_CHANGED &&
696        gTerminalsCreated &&
697        (ED4_ROOT->alignment_type == GB_AT_DNA) &&
698        !gbWritingData)
699    {
700        GB_transaction ta(GLOBAL_gb_main);
701
702        for (ED4_window *win = ED4_ROOT->first_window; win; win = win->next) {
703            ED4_cursor& cursor = win->cursor;
704            if (cursor.in_species_seq_terminal()) {
705                ED4_terminal *cursorTerminal = cursor.owner_of_cursor;
706                char         *speciesName    = cursorTerminal->to_sequence_terminal()->species_name;
707                for (int i=0; i<PV_AA_Terminals4Species; i++) {
708                    // get the corresponding orf_terminal skipping sequence_info terminal
709                    // $$$$$ sequence_terminal->sequence_info_terminal->aa_sequence_terminal $$$$$$
710                    cursorTerminal = cursorTerminal->get_next_terminal()->get_next_terminal();
711                    // Make sure it is ORF terminal
712                    if (cursorTerminal->is_orf_terminal()) {
713                        ED4_orf_terminal *orfTerm = cursorTerminal->to_orf_terminal();
714                        // Get the AA sequence flag - says which strand we are in
715                        int   aaStartPos = int(orfTerm->GET_aaStartPos());
716                        int aaStrandType = int(orfTerm->GET_aaStrandType());
717                        // retranslate the genesequence and store it to the orf_terminal
718                        TranslateGeneToAminoAcidSequence(ED4_ROOT->aw_root, orfTerm, speciesName, aaStartPos-1, aaStrandType);
719                    }
720                }
721                // Print missing DB entries
722                PV_PrintMissingDBentryInformation();
723                PV_RefreshWindow(ED4_ROOT->aw_root);
724            }
725        }
726    }
727}
728
729static void PV_AddNewAAseqTerminals(ED4_sequence_terminal *seqTerminal, ED4_species_manager *speciesManager) {
730    int  translationMode = 0;
731    char namebuffer[NAME_BUFFERSIZE];
732
733    for (int i = 0; i<PV_AA_Terminals4Species; i++) {
734        int count = 1;
735        int startPos = 0;
736
737        sprintf(namebuffer, "Sequence_Manager.%ld.%d", ED4_counter, count++);
738        ED4_multi_sequence_manager *multiSeqManager = speciesManager->search_spec_child_rek(LEV_MULTI_SEQUENCE)->to_multi_sequence_manager();
739        ED4_sequence_manager *new_SeqManager = new ED4_sequence_manager(namebuffer, 0, 0, multiSeqManager);
740        new_SeqManager->set_property(PROP_MOVABLE);
741        multiSeqManager->append_member(new_SeqManager);
742
743        if (i<FORWARD_STRANDS)                              sprintf(namebuffer, "F%d ProteinInfo_Term%ld.%d", i+1, ED4_counter, count++);
744        else if ((i-FORWARD_STRANDS)<COMPLEMENTARY_STRANDS) sprintf(namebuffer, "C%dProteinInfo_Term%ld.%d", (i-FORWARD_STRANDS)+1, ED4_counter, count++);
745        else                                                sprintf(namebuffer, "DBProteinInfo_Term%ld.%d", ED4_counter, count++);
746
747        {
748            ED4_sequence_info_terminal *new_SeqInfoTerminal = new ED4_sequence_info_terminal(namebuffer, SEQUENCE_INFO_WIDTH, TERMINAL_HEIGHT, new_SeqManager);
749            new_SeqInfoTerminal->set_property((ED4_properties) (PROP_SELECTABLE | PROP_DRAGABLE | PROP_IS_HANDLE));
750
751            ED4_sequence_info_terminal *seqInfoTerminal = speciesManager->search_spec_child_rek(LEV_SEQUENCE_INFO)->to_sequence_info_terminal();
752            new_SeqInfoTerminal->set_both_links(seqInfoTerminal);
753            new_SeqManager->append_member(new_SeqInfoTerminal);
754        }
755
756        {
757            sprintf(namebuffer, "AA_Sequence_Term%ld.%d", ED4_counter, count++);
758            ED4_orf_terminal *AA_SeqTerminal = new ED4_orf_terminal(namebuffer, 0, TERMINAL_HEIGHT, new_SeqManager);
759            AA_SeqTerminal->set_both_links(seqTerminal);
760
761            char *speciesName = seqTerminal->species_name;
762            if (i<FORWARD_STRANDS) {
763                startPos = i;
764                translationMode = FORWARD_STRAND;
765            }
766            else if ((i-FORWARD_STRANDS)<COMPLEMENTARY_STRANDS) {
767                startPos = i-FORWARD_STRANDS;
768                translationMode = COMPLEMENTARY_STRAND;
769            }
770            else {
771                startPos = 0;
772                translationMode = DB_FIELD_STRAND;
773            }
774            TranslateGeneToAminoAcidSequence(ED4_ROOT->aw_root, AA_SeqTerminal, speciesName, startPos, translationMode);
775            AA_SeqTerminal->SET_aaSeqFlags(startPos+1, translationMode);
776            new_SeqManager->append_member(AA_SeqTerminal);
777        }
778
779        ED4_counter++;
780
781        new_SeqManager->request_resize();
782    }
783}
784
785void PV_AddCorrespondingOrfTerminals(ED4_species_name_terminal *spNameTerm) {
786    if (gTerminalsCreated && spNameTerm) {
787        ED4_sequence_terminal *seqTerminal    = spNameTerm->corresponding_sequence_terminal();
788        ED4_species_manager *speciesManager = spNameTerm->get_parent(LEV_SPECIES)->to_species_manager();
789        PV_AddNewAAseqTerminals(seqTerminal, speciesManager);
790        PV_RefreshWindow(ED4_ROOT->aw_root);
791    }
792}
793
794void PV_AddOrfTerminalsToLoadedSpecies() {
795    if (gTerminalsCreated) {
796        GB_transaction ta(GLOBAL_gb_main);
797        int marked = GBT_count_marked_species(GLOBAL_gb_main);
798        if (marked) {
799            GBDATA *gbSpecies;
800            for (gbSpecies = GBT_first_marked_species(GLOBAL_gb_main);
801                 gbSpecies;
802                 gbSpecies = GBT_next_marked_species(gbSpecies))
803            {
804                const char *spName = GBT_read_name(gbSpecies);
805                cout<<marked--<<". "<<spName<<endl;
806                ED4_species_name_terminal *spNameTerm = ED4_find_species_name_terminal(spName);
807                if (spNameTerm) {
808                    ED4_terminal *terminal = spNameTerm->corresponding_sequence_terminal();
809                    // $$$ If next terminal is species_name terminal => corresponding AA seq terminal doesn't exist ==> create one $$$
810                    terminal = terminal->get_next_terminal();
811                    if (terminal->is_species_name_terminal() || terminal->is_spacer_terminal()) {
812                        ED4_sequence_terminal *seqTerminal    = spNameTerm->corresponding_sequence_terminal();
813                        ED4_species_manager *speciesManager = spNameTerm->get_parent(LEV_SPECIES)->to_species_manager();
814                        PV_AddNewAAseqTerminals(seqTerminal, speciesManager);
815                    }
816                }
817            }
818            PV_RefreshWindow(ED4_ROOT->aw_root);
819        }
820    }
821}
822
823static void PV_CreateAllTerminals(AW_root *root) {
824    // 1. Get the species terminal pointer
825    // 2. Append the second terminal
826    // 3. resize the multi-species manager
827    // 4. refresh all the terminals including new appended terminals
828
829    // Look for already created terminals, if found do nothing, otherwise, create
830    // new terminals and set gTerminalsCreated to true
831    bool bTerminalsFound = PV_LookForNewTerminals(root);
832    // if terminals are already created then do nothing exit the function
833    if (bTerminalsFound) return;
834
835    GB_transaction ta(GLOBAL_gb_main);
836
837    // Number of ORF terminals to be created = 3 forward strands + 3 complementary strands + 1 DB field strand
838    // totally 7 strands has to be created
839    int aaTerminalsToBeCreated = FORWARD_STRANDS + COMPLEMENTARY_STRANDS + DB_FIELD_STRANDS;
840    PV_AA_Terminals4Species = aaTerminalsToBeCreated;
841
842    ED4_terminal *terminal = NULp;
843    for (terminal = ED4_ROOT->root_group_man->get_first_terminal();
844         terminal;
845         terminal = terminal->get_next_terminal())
846    {
847        if (terminal->is_sequence_terminal()) {
848            ED4_sequence_terminal *seqTerminal = terminal->to_sequence_terminal();
849            if (seqTerminal->species_name) {
850                ED4_species_manager *speciesManager = terminal->get_parent(LEV_SPECIES)->to_species_manager();
851                if (speciesManager->is_species_seq_manager()) {
852                    PV_AddNewAAseqTerminals(seqTerminal, speciesManager);
853                }
854            }
855        }
856    }
857    ED4_ROOT->main_manager->request_resize(); // @@@ instead needs to be called whenever adding or deleting PV-terminals
858
859    gTerminalsCreated = true;
860
861    // Print missing DB entries
862    PV_PrintMissingDBentryInformation();
863}
864
865void PV_CallBackFunction(AW_root *root) {
866    // Create New Terminals If Aminoacid Sequence Terminals Are Not Created
867    if (!gTerminalsCreated) {
868        // AWAR_PROTEIN_TYPE is not initialized (if called from ED4_main before creating proteinViewer window)
869        // so, initialize it here
870        root->awar_int(AWAR_PROTEIN_TYPE, AWAR_PROTEIN_TYPE_bacterial_code_index, GLOBAL_gb_main);
871        PV_CreateAllTerminals(root);
872    }
873
874    PV_RefreshWindow(root);
875}
876
877// --------------------------------------------------------------------------------
878//        Binding callback function to the AWARS
879
880static void PV_AddCallBacks(AW_root *awr) {
881
882    awr->awar(AWAR_PV_DISPLAY_ALL)->add_callback(PV_CallBackFunction);
883    awr->awar(AWAR_PROTVIEW_FORWARD_STRAND_1)->add_callback(PV_CallBackFunction);
884    awr->awar(AWAR_PROTVIEW_FORWARD_STRAND_2)->add_callback(PV_CallBackFunction);
885    awr->awar(AWAR_PROTVIEW_FORWARD_STRAND_3)->add_callback(PV_CallBackFunction);
886    awr->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1)->add_callback(PV_CallBackFunction);
887    awr->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2)->add_callback(PV_CallBackFunction);
888    awr->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3)->add_callback(PV_CallBackFunction);
889    awr->awar(AWAR_PROTVIEW_DEFINED_FIELDS)->add_callback(PV_CallBackFunction);
890
891    awr->awar(AWAR_PROTVIEW_DISPLAY_OPTIONS)->add_callback(PV_RefreshDisplay);
892    awr->awar(AWAR_SPECIES_NAME)->add_callback(PV_CallBackFunction);
893
894    awr->awar(AWAR_PV_SELECTED)->add_callback(PV_CallBackFunction);
895    awr->awar(AWAR_PV_SELECTED_DB)->add_callback(PV_CallBackFunction);
896    awr->awar(AWAR_PV_SELECTED_FS_1)->add_callback(PV_CallBackFunction);
897    awr->awar(AWAR_PV_SELECTED_FS_2)->add_callback(PV_CallBackFunction);
898    awr->awar(AWAR_PV_SELECTED_FS_3)->add_callback(PV_CallBackFunction);
899    awr->awar(AWAR_PV_SELECTED_CS_1)->add_callback(PV_CallBackFunction);
900    awr->awar(AWAR_PV_SELECTED_CS_2)->add_callback(PV_CallBackFunction);
901    awr->awar(AWAR_PV_SELECTED_CS_3)->add_callback(PV_CallBackFunction);
902
903    awr->awar(AWAR_PV_MARKED)->add_callback(PV_CallBackFunction);
904    awr->awar(AWAR_PV_MARKED_DB)->add_callback(PV_CallBackFunction);
905    awr->awar(AWAR_PV_MARKED_FS_1)->add_callback(PV_CallBackFunction);
906    awr->awar(AWAR_PV_MARKED_FS_2)->add_callback(PV_CallBackFunction);
907    awr->awar(AWAR_PV_MARKED_FS_3)->add_callback(PV_CallBackFunction);
908    awr->awar(AWAR_PV_MARKED_CS_1)->add_callback(PV_CallBackFunction);
909    awr->awar(AWAR_PV_MARKED_CS_2)->add_callback(PV_CallBackFunction);
910    awr->awar(AWAR_PV_MARKED_CS_3)->add_callback(PV_CallBackFunction);
911
912    awr->awar(AWAR_PV_CURSOR)->add_callback(PV_CallBackFunction);
913    awr->awar(AWAR_PV_CURSOR_DB)->add_callback(PV_CallBackFunction);
914    awr->awar(AWAR_PV_CURSOR_FS_1)->add_callback(PV_CallBackFunction);
915    awr->awar(AWAR_PV_CURSOR_FS_2)->add_callback(PV_CallBackFunction);
916    awr->awar(AWAR_PV_CURSOR_FS_3)->add_callback(PV_CallBackFunction);
917    awr->awar(AWAR_PV_CURSOR_CS_1)->add_callback(PV_CallBackFunction);
918    awr->awar(AWAR_PV_CURSOR_CS_2)->add_callback(PV_CallBackFunction);
919    awr->awar(AWAR_PV_CURSOR_CS_3)->add_callback(PV_CallBackFunction);
920}
921
922// --------------------------------------------------------------------------------
923//        Creating AWARS to be used by the PROTVIEW module
924
925void PV_CreateAwars(AW_root *root, AW_default aw_def) {
926
927    root->awar_int(AWAR_PV_DISPLAY_ALL, 0, aw_def);
928
929    root->awar_int(AWAR_PROTVIEW_FORWARD_STRAND_1, 0, aw_def);
930    root->awar_int(AWAR_PROTVIEW_FORWARD_STRAND_2, 0, aw_def);
931    root->awar_int(AWAR_PROTVIEW_FORWARD_STRAND_3, 0, aw_def);
932
933    root->awar_int(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1, 0, aw_def);
934    root->awar_int(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2, 0, aw_def);
935    root->awar_int(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3, 0, aw_def);
936
937    root->awar_int(AWAR_PROTVIEW_DEFINED_FIELDS, 0, aw_def);
938    root->awar_int(AWAR_PROTVIEW_DISPLAY_OPTIONS, 0, aw_def);
939
940    root->awar_int(AWAR_PV_SELECTED, 0, aw_def);
941    root->awar_int(AWAR_PV_SELECTED_DB, 0, aw_def);
942    root->awar_int(AWAR_PV_SELECTED_FS_1, 0, aw_def);
943    root->awar_int(AWAR_PV_SELECTED_FS_2, 0, aw_def);
944    root->awar_int(AWAR_PV_SELECTED_FS_3, 0, aw_def);
945    root->awar_int(AWAR_PV_SELECTED_CS_1, 0, aw_def);
946    root->awar_int(AWAR_PV_SELECTED_CS_2, 0, aw_def);
947    root->awar_int(AWAR_PV_SELECTED_CS_3, 0, aw_def);
948
949    root->awar_int(AWAR_PV_MARKED, 0, aw_def);
950    root->awar_int(AWAR_PV_MARKED_DB, 0, aw_def);
951    root->awar_int(AWAR_PV_MARKED_FS_1, 0, aw_def);
952    root->awar_int(AWAR_PV_MARKED_FS_2, 0, aw_def);
953    root->awar_int(AWAR_PV_MARKED_FS_3, 0, aw_def);
954    root->awar_int(AWAR_PV_MARKED_CS_1, 0, aw_def);
955    root->awar_int(AWAR_PV_MARKED_CS_2, 0, aw_def);
956    root->awar_int(AWAR_PV_MARKED_CS_3, 0, aw_def);
957
958    root->awar_int(AWAR_PV_CURSOR, 0, aw_def);
959    root->awar_int(AWAR_PV_CURSOR_DB, 0, aw_def);
960    root->awar_int(AWAR_PV_CURSOR_FS_1, 0, aw_def);
961    root->awar_int(AWAR_PV_CURSOR_FS_2, 0, aw_def);
962    root->awar_int(AWAR_PV_CURSOR_FS_3, 0, aw_def);
963    root->awar_int(AWAR_PV_CURSOR_CS_1, 0, aw_def);
964    root->awar_int(AWAR_PV_CURSOR_CS_2, 0, aw_def);
965    root->awar_int(AWAR_PV_CURSOR_CS_3, 0, aw_def);
966}
967
968AW_window *ED4_CreateProteinViewer_window(AW_root *aw_root) {
969    GB_transaction ta(GLOBAL_gb_main);
970
971    static AW_window_simple *aws = NULp;
972    if (aws) return aws;
973
974    aws = new AW_window_simple;
975
976    aws->init(aw_root, "PROTEIN_VIEWER", "Protein Viewer");
977    aws->load_xfig("proteinViewer.fig");
978
979    aws->at("refresh");
980    aws->callback(PV_RefreshProtViewDisplay);
981    aws->button_length(0);
982    aws->create_button("REFRESH", "#refresh_text.xpm");
983
984    aws->callback(makeHelpCallback("proteinViewer.hlp"));
985    aws->at("help");
986    aws->button_length(0);
987    aws->create_button("HELP", "#help_text.xpm");
988
989    aws->at("close");
990    aws->callback(AW_POPDOWN);
991    aws->button_length(0);
992    aws->create_button("CLOSE", "#close_text.xpm");
993
994    {
995        aw_root->awar_int(AWAR_PROTEIN_TYPE, AWAR_PROTEIN_TYPE_bacterial_code_index, GLOBAL_gb_main);
996        aws->at("table");
997        aws->create_option_menu(AWAR_PROTEIN_TYPE, true);
998        for (int code_nr=0; code_nr<AWT_CODON_TABLES; code_nr++) {
999            aws->insert_option(AWT_get_codon_code_name(code_nr), "", code_nr);
1000        }
1001        aws->update_option_menu();
1002
1003        aws->at("all");
1004        aws->create_toggle(AWAR_PV_DISPLAY_ALL);
1005
1006        aws->at("f1");
1007        aws->create_toggle(AWAR_PROTVIEW_FORWARD_STRAND_1);
1008
1009        aws->at("f2");
1010        aws->create_toggle(AWAR_PROTVIEW_FORWARD_STRAND_2);
1011
1012        aws->at("f3");
1013        aws->create_toggle(AWAR_PROTVIEW_FORWARD_STRAND_3);
1014
1015        aws->at("c1");
1016        aws->create_toggle(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1);
1017
1018        aws->at("c2");
1019        aws->create_toggle(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2);
1020
1021        aws->at("c3");
1022        aws->create_toggle(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3);
1023
1024        aws->at("defined");
1025        aws->create_toggle(AWAR_PROTVIEW_DEFINED_FIELDS);
1026
1027        aws->at("dispOption");
1028        aws->create_toggle_field(AWAR_PROTVIEW_DISPLAY_OPTIONS, 0);
1029        aws->insert_toggle("Single Letter Code", "S", 0);
1030        aws->insert_toggle("Triple Letter Code", "T", 1);
1031        aws->insert_toggle("Colored Box", "B", 2);
1032        aws->update_toggle_field();
1033
1034        aws->at("colMaps");
1035        aws->callback(makeCreateWindowCallback(ED4_create_seq_colors_window, ED4_ROOT->sequence_colors));
1036        aws->button_length(0);
1037        aws->create_button("COLORMAPS", "#colorMaps.xpm");
1038
1039        aws->at("colors");
1040        aws->callback(makeWindowCallback(ED4_popup_gc_window, ED4_ROOT->gc_manager));
1041        aws->button_length(0);
1042        aws->create_button("COLORS", "#colors.xpm");
1043
1044        {
1045            aws->at("sel"); aws->create_toggle(AWAR_PV_SELECTED);
1046            aws->at("sf1"); aws->create_toggle(AWAR_PV_SELECTED_FS_1);
1047            aws->at("sf2"); aws->create_toggle(AWAR_PV_SELECTED_FS_2);
1048            aws->at("sf3"); aws->create_toggle(AWAR_PV_SELECTED_FS_3);
1049            aws->at("sc1"); aws->create_toggle(AWAR_PV_SELECTED_CS_1);
1050            aws->at("sc2"); aws->create_toggle(AWAR_PV_SELECTED_CS_2);
1051            aws->at("sc3"); aws->create_toggle(AWAR_PV_SELECTED_CS_3);
1052            aws->at("sdb"); aws->create_toggle(AWAR_PV_SELECTED_DB);
1053
1054            aws->at("mrk"); aws->create_toggle(AWAR_PV_MARKED);
1055            aws->at("mf1"); aws->create_toggle(AWAR_PV_MARKED_FS_1);
1056            aws->at("mf2"); aws->create_toggle(AWAR_PV_MARKED_FS_2);
1057            aws->at("mf3"); aws->create_toggle(AWAR_PV_MARKED_FS_3);
1058            aws->at("mc1"); aws->create_toggle(AWAR_PV_MARKED_CS_1);
1059            aws->at("mc2"); aws->create_toggle(AWAR_PV_MARKED_CS_2);
1060            aws->at("mc3"); aws->create_toggle(AWAR_PV_MARKED_CS_3);
1061            aws->at("mdb"); aws->create_toggle(AWAR_PV_MARKED_DB);
1062
1063            aws->at("cur"); aws->create_toggle(AWAR_PV_CURSOR);
1064            aws->at("cf1"); aws->create_toggle(AWAR_PV_CURSOR_FS_1);
1065            aws->at("cf2"); aws->create_toggle(AWAR_PV_CURSOR_FS_2);
1066            aws->at("cf3"); aws->create_toggle(AWAR_PV_CURSOR_FS_3);
1067            aws->at("cc1"); aws->create_toggle(AWAR_PV_CURSOR_CS_1);
1068            aws->at("cc2"); aws->create_toggle(AWAR_PV_CURSOR_CS_2);
1069            aws->at("cc3"); aws->create_toggle(AWAR_PV_CURSOR_CS_3);
1070            aws->at("cdb"); aws->create_toggle(AWAR_PV_CURSOR_DB);
1071        }
1072
1073        aws->at("save");
1074        aws->callback(PV_SaveData);
1075        aws->button_length(5);
1076        aws->create_button("SAVE", "#save.xpm");
1077    }
1078
1079    // binding callback function to the AWARS
1080    PV_AddCallBacks(aw_root);
1081
1082    // Create All Terminals
1083    PV_CreateAllTerminals(aw_root);
1084
1085    aws->show();
1086
1087    return aws;
1088}
1089
Note: See TracBrowser for help on using the repository browser.