source: branches/profile/EDIT4/ED4_ProteinViewer.cxx

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