ARB
ED4_ProteinViewer.cxx
Go to the documentation of this file.
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_edit_string.hxx"
15 #include "ed4_seq_colors.hxx"
16 #include "ed4_class.hxx"
17 
18 #include <AP_pro_a_nucs.hxx>
19 #include <AP_codon_table.hxx>
20 #include <Translate.hxx>
21 #include <aw_question.hxx>
22 #include <aw_preset.hxx>
23 #include <aw_awars.hxx>
24 #include <aw_msg.hxx>
25 #include <aw_root.hxx>
26 #include <arbdbt.h>
27 
28 #include <iostream>
29 
30 using namespace std;
31 
32 // Definitions used
33 #define FORWARD_STRAND 1
34 #define COMPLEMENTARY_STRAND 2
35 #define DB_FIELD_STRAND 3
36 
37 #define FORWARD_STRANDS 3
38 #define COMPLEMENTARY_STRANDS 3
39 #define DB_FIELD_STRANDS 1
40 
41 enum {
42  PV_MARKED = 0,
46 };
47 
48 // Global Variables
49 static bool gTerminalsCreated = false;
50 static int PV_AA_Terminals4Species = 0;
51 static int gMissingTransTable = 0;
52 static int gMissingCodonStart = 0;
53 static bool gbWritingData = false;
54 static int giNewAlignments = 0;
55 
56 static AW_repeated_question *ASKtoOverWriteData = NULp;
57 
58 static bool PV_LookForNewTerminals(AW_root *root) {
59  bool bTerminalsFound = true;
60 
61  int all = root->awar(AWAR_PV_DISPLAY_ALL)->read_int();
62  int all_f1 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_1)->read_int();
63  int all_f2 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_2)->read_int();
64  int all_f3 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_3)->read_int();
65  int all_c1 = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1)->read_int();
66  int all_c2 = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2)->read_int();
67  int all_c3 = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3)->read_int();
68  int all_db = root->awar(AWAR_PROTVIEW_DEFINED_FIELDS)->read_int();
69 
70  int sel = root->awar(AWAR_PV_SELECTED)->read_int();
71  int sel_db = root->awar(AWAR_PV_SELECTED_DB)->read_int();
72  int sel_f1 = root->awar(AWAR_PV_SELECTED_FS_1)->read_int();
73  int sel_f2 = root->awar(AWAR_PV_SELECTED_FS_2)->read_int();
74  int sel_f3 = root->awar(AWAR_PV_SELECTED_FS_3)->read_int();
75  int sel_c1 = root->awar(AWAR_PV_SELECTED_CS_1)->read_int();
76  int sel_c2 = root->awar(AWAR_PV_SELECTED_CS_2)->read_int();
77  int sel_c3 = root->awar(AWAR_PV_SELECTED_CS_3)->read_int();
78 
79  int mrk = root->awar(AWAR_PV_MARKED)->read_int();
80  int mrk_db = root->awar(AWAR_PV_MARKED_DB)->read_int();
81  int mrk_f1 = root->awar(AWAR_PV_MARKED_FS_1)->read_int();
82  int mrk_f2 = root->awar(AWAR_PV_MARKED_FS_2)->read_int();
83  int mrk_f3 = root->awar(AWAR_PV_MARKED_FS_3)->read_int();
84  int mrk_c1 = root->awar(AWAR_PV_MARKED_CS_1)->read_int();
85  int mrk_c2 = root->awar(AWAR_PV_MARKED_CS_2)->read_int();
86  int mrk_c3 = root->awar(AWAR_PV_MARKED_CS_3)->read_int();
87 
88  int cur = root->awar(AWAR_PV_CURSOR)->read_int();
89  int cur_db = root->awar(AWAR_PV_CURSOR_DB)->read_int();
90  int cur_f1 = root->awar(AWAR_PV_CURSOR_FS_1)->read_int();
91  int cur_f2 = root->awar(AWAR_PV_CURSOR_FS_2)->read_int();
92  int cur_f3 = root->awar(AWAR_PV_CURSOR_FS_3)->read_int();
93  int cur_c1 = root->awar(AWAR_PV_CURSOR_CS_1)->read_int();
94  int cur_c2 = root->awar(AWAR_PV_CURSOR_CS_2)->read_int();
95  int cur_c3 = root->awar(AWAR_PV_CURSOR_CS_3)->read_int();
96 
97  // Test whether any of the options are selected or not?
98  if ((all && (all_f1 || all_f2 || all_f3 || all_c1 || all_c2 || all_c3 || all_db)) ||
99  (sel && (sel_db || sel_f1 || sel_f2 || sel_f3 || sel_c1 || sel_c2 || sel_c3)) ||
100  (mrk && (mrk_db || mrk_f1 || mrk_f2 || mrk_f3 || mrk_c1 || mrk_c2 || mrk_c3)) ||
101  (cur && (cur_db || cur_f1 || cur_f2 || cur_f3 || cur_c1 || cur_c2 || cur_c3)))
102  {
103  // if so, then test whether the terminals are created already or not?
104  if (gTerminalsCreated) {
105  // if yes, then set the flag to true
106  bTerminalsFound = true;
107  }
108  else {
109  // if not, then new terminals has to be created
110  bTerminalsFound = false;
111  }
112  }
113  return bTerminalsFound;
114 }
115 
116 static void PV_HideTerminal(ED4_orf_terminal *orfTerm) {
117  ED4_sequence_manager *seqManager = orfTerm->get_parent(LEV_SEQUENCE)->to_sequence_manager();
118  seqManager->hide_children();
119 }
120 
121 static void PV_UnHideTerminal(ED4_orf_terminal *orfTerm) {
122  ED4_sequence_manager *seqManager = orfTerm->get_parent(LEV_SEQUENCE)->to_sequence_manager();
123  seqManager->unhide_children();
124 }
125 
126 static void PV_HideAllTerminals() {
127  ED4_terminal *terminal = NULp;
128  for (terminal = ED4_ROOT->root_group_man->get_first_terminal();
129  terminal;
130  terminal = terminal->get_next_terminal())
131  {
132  if (terminal->is_orf_terminal()) {
133  ED4_orf_terminal *orfTerm = terminal->to_orf_terminal();
134  PV_HideTerminal(orfTerm);
135  }
136  }
137 }
138 
139 
140 static void PV_ManageTerminalDisplay(AW_root *root, ED4_orf_terminal *orfTerm, long int DispMode) {
141  int all, af_1, af_2, af_3, ac_1, ac_2, ac_3, adb;
142  all = root->awar(AWAR_PV_DISPLAY_ALL)->read_int();
150 
151  int mrk, mf_1, mf_2, mf_3, mc_1, mc_2, mc_3, mdb;
152  mrk = root->awar(AWAR_PV_MARKED)->read_int();
153  mdb = root->awar(AWAR_PV_MARKED_DB)->read_int();
154  mf_1 = root->awar(AWAR_PV_MARKED_FS_1)->read_int();
155  mf_2 = root->awar(AWAR_PV_MARKED_FS_2)->read_int();
156  mf_3 = root->awar(AWAR_PV_MARKED_FS_3)->read_int();
157  mc_1 = root->awar(AWAR_PV_MARKED_CS_1)->read_int();
158  mc_2 = root->awar(AWAR_PV_MARKED_CS_2)->read_int();
159  mc_3 = root->awar(AWAR_PV_MARKED_CS_3)->read_int();
160 
161  int sel, sf_1, sf_2, sf_3, sc_1, sc_2, sc_3, sdb;
162  sel = root->awar(AWAR_PV_SELECTED)->read_int();
163  sdb = root->awar(AWAR_PV_SELECTED_DB)->read_int();
164  sf_1 = root->awar(AWAR_PV_SELECTED_FS_1)->read_int();
165  sf_2 = root->awar(AWAR_PV_SELECTED_FS_2)->read_int();
166  sf_3 = root->awar(AWAR_PV_SELECTED_FS_3)->read_int();
167  sc_1 = root->awar(AWAR_PV_SELECTED_CS_1)->read_int();
168  sc_2 = root->awar(AWAR_PV_SELECTED_CS_2)->read_int();
169  sc_3 = root->awar(AWAR_PV_SELECTED_CS_3)->read_int();
170 
171  int cur, cf_1, cf_2, cf_3, cc_1, cc_2, cc_3, cdb;
172  cur = root->awar(AWAR_PV_CURSOR)->read_int();
173  cdb = root->awar(AWAR_PV_CURSOR_DB)->read_int();
174  cf_1 = root->awar(AWAR_PV_CURSOR_FS_1)->read_int();
175  cf_2 = root->awar(AWAR_PV_CURSOR_FS_2)->read_int();
176  cf_3 = root->awar(AWAR_PV_CURSOR_FS_3)->read_int();
177  cc_1 = root->awar(AWAR_PV_CURSOR_CS_1)->read_int();
178  cc_2 = root->awar(AWAR_PV_CURSOR_CS_2)->read_int();
179  cc_3 = root->awar(AWAR_PV_CURSOR_CS_3)->read_int();
180 
181  // Get the AA sequence flag - says which strand we are in
182  int aaStrandType = int(orfTerm->GET_aaStrandType());
183  // Check the display options and make visible or hide the AA seq terminal
184  switch (aaStrandType) {
185  case FORWARD_STRAND: {
186  int aaStartPos = int(orfTerm->GET_aaStartPos());
187  switch (aaStartPos) {
188  case 1:
189  switch (DispMode) {
190  case PV_ALL: (all && af_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
191  case PV_MARKED: (mrk && mf_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
192  case PV_SELECTED: (sel && sf_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
193  case PV_CURSOR: (cur && cf_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
194  }
195  break;
196  case 2:
197  switch (DispMode) {
198  case PV_ALL: (all && af_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
199  case PV_MARKED: (mrk && mf_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
200  case PV_SELECTED: (sel && sf_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
201  case PV_CURSOR: (cur && cf_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
202  }
203  break;
204  case 3:
205  switch (DispMode) {
206  case PV_ALL: (all && af_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
207  case PV_MARKED: (mrk && mf_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
208  case PV_SELECTED: (sel && sf_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
209  case PV_CURSOR: (cur && cf_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
210  }
211  break;
212  }
213  break;
214  }
215  case COMPLEMENTARY_STRAND: {
216  int aaStartPos = int(orfTerm->GET_aaStartPos());
217  switch (aaStartPos) {
218  case 1:
219  switch (DispMode) {
220  case PV_ALL: (all && ac_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
221  case PV_MARKED: (mrk && mc_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
222  case PV_SELECTED: (sel && sc_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
223  case PV_CURSOR: (cur && cc_1) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
224  }
225  break;
226  case 2:
227  switch (DispMode) {
228  case PV_ALL: (all && ac_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
229  case PV_MARKED: (mrk && mc_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
230  case PV_SELECTED: (sel && sc_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
231  case PV_CURSOR: (cur && cc_2) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
232  }
233  break;
234  case 3:
235  switch (DispMode) {
236  case PV_ALL: (all && ac_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
237  case PV_MARKED: (mrk && mc_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
238  case PV_SELECTED: (sel && sc_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
239  case PV_CURSOR: (cur && cc_3) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
240  }
241  break;
242  }
243  break;
244  }
245  case DB_FIELD_STRAND:
246  switch (DispMode) {
247  case PV_ALL: (all && adb) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
248  case PV_MARKED: (mrk && mdb) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
249  case PV_SELECTED: (sel && sdb) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
250  case PV_CURSOR: (cur && cdb) ? PV_UnHideTerminal(orfTerm) : PV_HideTerminal(orfTerm); break;
251  }
252  break;
253  }
254 }
255 
256 static void PV_ManageTerminals(AW_root *root) {
257 
258  // First Hide all orf Terminals
260 
261  int dispAll = root->awar(AWAR_PV_DISPLAY_ALL)->read_int();
262  if (dispAll) {
264  terminal;
265  terminal = terminal->get_next_terminal())
266  {
267  if (terminal->is_orf_terminal()) {
268  ED4_orf_terminal *orfTerm = terminal->to_orf_terminal();
269  PV_ManageTerminalDisplay(root, orfTerm, PV_ALL);
270  }
271  }
272  }
273 
274  int dispMarked = root->awar(AWAR_PV_MARKED)->read_int();
275  if (dispMarked) {
277  GB_transaction ta(gb_main);
278  int marked = GBT_count_marked_species(gb_main);
279  if (marked) {
280  for (GBDATA *gbSpecies = GBT_first_marked_species(gb_main);
281  gbSpecies;
282  gbSpecies = GBT_next_marked_species(gbSpecies))
283  {
284  ED4_species_name_terminal *spNameTerm = ED4_find_species_name_terminal(GBT_get_name_or_description(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) {
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_highlighted()) {
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
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 
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 
367 static 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 
380 static void PV_WriteTranslatedSequenceToDB(ED4_orf_terminal *aaSeqTerm, const char *spName) {
383  GBDATA *gb_species = GBT_find_species(gb_main, spName);
384  if (!gb_species) error = GBS_global_string("Species '%s' does not exist", spName);
385  else {
386  const char *defaultAlignment = ED4_ROOT->get_alignment_name();
387  GBDATA *gb_SeqData = GBT_find_sequence(gb_species, defaultAlignment);
388  if (!gb_SeqData) {
389  error = GB_have_error()
390  ? GB_await_error()
391  : GBS_global_string("Species '%s' has no data in alignment '%s'", spName, defaultAlignment);
392  }
393  else {
394  char *str_SeqData = GB_read_string(gb_SeqData);
395  if (!str_SeqData) error = GB_await_error();
396  else {
397  int aaStrandType = int(aaSeqTerm->GET_aaStrandType());
398  if (aaStrandType == COMPLEMENTARY_STRAND) {
399  GB_ERROR compl_err = PV_ComplementarySequence(str_SeqData);
400  if (compl_err) error = GBS_global_string("Failed to calc complementary strand (Reason: %s)", compl_err);
401  }
402 
403  if (!error) {
404  char newAlignmentName[100];
405  int aaStartPos = int(aaSeqTerm->GET_aaStartPos());
406 
407  switch (aaStrandType) {
408  case FORWARD_STRAND: sprintf(newAlignmentName, "ali_pro_ProtView_forward_start_pos_%ld", (long)aaStartPos); break;
409  case COMPLEMENTARY_STRAND: sprintf(newAlignmentName, "ali_pro_ProtView_complementary_start_pos_%ld", (long)aaStartPos); break;
410  case DB_FIELD_STRAND: sprintf(newAlignmentName, "ali_pro_ProtView_database_field_start_pos_%ld", (long)aaStartPos); break;
411  }
412 
413  int len = GB_read_string_count(gb_SeqData);
414  translate_nuc2aa(AWT_default_protein_type(), str_SeqData, len, aaStartPos-1, false, true, false, NULp);
415 
416  // Create alignment data to store the translated sequence
417  GBDATA *gb_presets = GBT_get_presets(gb_main);
418  GBDATA *gb_alignment_exists = GB_find_string(gb_presets, "alignment_name", newAlignmentName, GB_IGNORE_CASE, SEARCH_GRANDCHILD);
419  GBDATA *gb_new_alignment = NULp;
420 
421  if (gb_alignment_exists) {
422  int skip_sp = 0;
423  char *question = NULp;
424  GBDATA *gb_seq_data = GBT_find_sequence(gb_species, newAlignmentName);
425  if (gb_seq_data) {
427  question = GBS_global_string_copy("\"%s\" contain data in the alignment \"%s\"!", spName, newAlignmentName);
428  skip_sp = ASKtoOverWriteData->get_answer("overwrite_translated", question, "Overwrite, Skip Species", "all", false);
429  }
430  if (skip_sp) {
431  error = GBS_global_string_copy("%s You chose to skip this Species!", question);
432  }
433  else {
434  gb_new_alignment = GBT_get_alignment(gb_main, newAlignmentName);
435  if (!gb_new_alignment) error = GB_await_error();
436  }
437  free(question);
438  }
439  else {
440  long aliLen = GBT_get_alignment_len(gb_main, defaultAlignment);
441  if (aliLen>0) {
442  gb_new_alignment = GBT_create_alignment(gb_main, newAlignmentName, aliLen/3+1, 0, 1, "ami", "by Protein Viewer");
443  }
444 
445  if (!gb_new_alignment) { // also handles aliLen<=0
446  error = GB_await_error();
447  }
448  else {
449  giNewAlignments++;
450  error = GBT_add_alignment_changekeys(gb_main, newAlignmentName);
451  }
452  }
453 
454  if (!error) {
455  GBDATA *gb_ProSeqData = GBT_add_data(gb_species, newAlignmentName, "data", GB_STRING);
456  if (!gb_ProSeqData) error = GB_await_error();
457  else error = GB_write_string(gb_ProSeqData, str_SeqData);
458  }
459 
460  if (!error) error = GBT_check_data(gb_main, NULp);
461  }
462 
463  free(str_SeqData);
464  }
465  }
466  }
467  GB_end_transaction_show_error(gb_main, error, aw_message);
468 }
469 
470 static 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 
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 
514 static 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 = NULp;
518  GBDATA *gb_species = GBT_find_species(gb_main, speciesName);
519  if (!gb_species) error = GBS_global_string("Species '%s' does not exist", speciesName);
520  else {
521  const char *defaultAlignment = ED4_ROOT->get_alignment_name();
522  GBDATA *gb_SeqData = GBT_find_sequence(gb_species, defaultAlignment);
523  if (!gb_SeqData) {
524  error = GB_have_error()
525  ? GB_await_error()
526  : 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(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 = TTIT_embl2arb(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  translate_nuc2aa(translationTable, str_SeqData, len, startPos4Translation, false, true, false, NULp); // translate
574 
575  char *s = new char[len+1];
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 = getAminoAcidAbbr(base);
591  if (!AAname) AAname = ED4_is_gap_character(base) ? "---" : "<?>";
592 
593  e4_assert(AAname && strlen(AAname) == 3);
594  for (int n = 0; n<3 && i<len; ++n,++i) {
595  s[i] = AAname[n];
596  gc[i] = base;
597  }
598  }
599 
600  gc[i] = '\0';
601  seqTerm->SET_aaColor(gc);
602  delete [] gc;
603  }
604  else {
605  int k = startPos4Translation+1;
606  for (i=0, j=0; i<len; i++) {
607  if ((k==i) && (j<len)) {
608  s[i] = str_SeqData[j++];
609  k += 3;
610  }
611  else s[i] = ' ';
612  }
613  seqTerm->SET_aaColor(NULp);
614  }
615  s[i] = '\0';
616 
617  seqTerm->SET_aaSequence(s);
618  delete [] s;
619  }
620  free(str_SeqData);
621  }
622  }
623  }
624 
625  if (error) aw_message(GBS_global_string("Error: %s", error));
626 }
627 
630  if (gMissingCodonStart>0) {
631  aw_message(GBS_global_string("WARNING: 'codon start' entry not found in %d of %d species! Using 1st base as codon start...",
632  gMissingCodonStart,
633  (int)GBT_count_marked_species(gb_main)));
634  gMissingCodonStart = 0;
635  }
636  if (gMissingTransTable>0) {
637  aw_message(GBS_global_string("WARNING: 'translation table' entry not found in %d of %d species! Using selected translation table as a default table...",
638  gMissingTransTable,
639  (int)GBT_count_marked_species(gb_main)));
640  gMissingTransTable = 0;
641  }
642 }
643 
644 static void PV_DisplayAminoAcidNames(AW_root *root) {
646 
648  terminal;
649  terminal = terminal->get_next_terminal())
650  {
651  if (terminal->is_species_seq_terminal()) {
652  const char *speciesName = terminal->to_sequence_terminal()->species_name;
653 
654  // we are in the sequence terminal section of a species
655  // walk through all the corresponding ORF terminals for the species and
656  // hide or unhide the terminals based on the display options set by the user
657  for (int i=0; i<PV_AA_Terminals4Species; i++) {
658  // get the corresponding orf_terminal skipping sequence_info terminal
659  terminal = terminal->get_next_terminal()->get_next_terminal();
660  // Make sure it is ORF terminal
661  if (terminal->is_orf_terminal()) {
662  ED4_orf_terminal *orfTerm = terminal->to_orf_terminal();
663  // we are in ORF terminal
664  int aaStartPos = int(orfTerm->GET_aaStartPos());
665  int aaStrandType = int(orfTerm->GET_aaStrandType());
666  // retranslate the genesequence and store it to the orf_terminal
667  TranslateGeneToAminoAcidSequence(root, orfTerm, speciesName, aaStartPos-1, aaStrandType);
668  }
669  }
670  }
671  }
672  // Print missing DB entries
674  PV_RefreshWindow(root);
675 }
676 
677 static void PV_RefreshDisplay(AW_root *root) {
679 }
680 
682  if (gTerminalsCreated) {
683  PV_RefreshDisplay(aww->get_root());
684  }
685 }
686 
688  if (gbtype==GB_CB_CHANGED &&
691  !gbWritingData)
692  {
694 
695  for (ED4_window *win = ED4_ROOT->first_window; win; win = win->next) {
696  ED4_cursor& cursor = win->cursor;
697  if (cursor.in_species_seq_terminal()) {
698  ED4_terminal *cursorTerminal = cursor.owner_of_cursor;
699  char *speciesName = cursorTerminal->to_sequence_terminal()->species_name;
700  for (int i=0; i<PV_AA_Terminals4Species; i++) {
701  // get the corresponding orf_terminal skipping sequence_info terminal
702  // $$$$$ sequence_terminal->sequence_info_terminal->aa_sequence_terminal $$$$$$
703  cursorTerminal = cursorTerminal->get_next_terminal()->get_next_terminal();
704  // Make sure it is ORF terminal
705  if (cursorTerminal->is_orf_terminal()) {
706  ED4_orf_terminal *orfTerm = cursorTerminal->to_orf_terminal();
707  // Get the AA sequence flag - says which strand we are in
708  int aaStartPos = int(orfTerm->GET_aaStartPos());
709  int aaStrandType = int(orfTerm->GET_aaStrandType());
710  // retranslate the genesequence and store it to the orf_terminal
711  TranslateGeneToAminoAcidSequence(ED4_ROOT->aw_root, orfTerm, speciesName, aaStartPos-1, aaStrandType);
712  }
713  }
714  // Print missing DB entries
717  }
718  }
719  }
720 }
721 
722 static void PV_AddNewAAseqTerminals(ED4_sequence_terminal *seqTerminal, ED4_species_manager *speciesManager) {
723  int translationMode = 0;
724  char namebuffer[NAME_BUFFERSIZE];
725 
726  for (int i = 0; i<PV_AA_Terminals4Species; i++) {
727  int count = 1;
728  int startPos = 0;
729 
730  sprintf(namebuffer, "Sequence_Manager.%ld.%d", ED4_counter, count++);
731  ED4_multi_sequence_manager *multiSeqManager = speciesManager->search_spec_child_rek(LEV_MULTI_SEQUENCE)->to_multi_sequence_manager();
732  ED4_sequence_manager *new_SeqManager = new ED4_sequence_manager(namebuffer, 0, 0, multiSeqManager);
733  new_SeqManager->set_property(PROP_MOVABLE);
734  multiSeqManager->append_member(new_SeqManager);
735 
736  if (i<FORWARD_STRANDS) sprintf(namebuffer, "F%d ProteinInfo_Term%ld.%d", i+1, ED4_counter, count++);
737  else if ((i-FORWARD_STRANDS)<COMPLEMENTARY_STRANDS) sprintf(namebuffer, "C%dProteinInfo_Term%ld.%d", (i-FORWARD_STRANDS)+1, ED4_counter, count++);
738  else sprintf(namebuffer, "DBProteinInfo_Term%ld.%d", ED4_counter, count++);
739 
740  {
741  ED4_sequence_info_terminal *new_SeqInfoTerminal = new ED4_sequence_info_terminal(namebuffer, SEQUENCE_INFO_WIDTH, TERMINAL_HEIGHT, new_SeqManager);
742  new_SeqInfoTerminal->set_property((ED4_properties) (PROP_SELECTABLE | PROP_DRAGABLE | PROP_IS_HANDLE));
743 
744  ED4_sequence_info_terminal *seqInfoTerminal = speciesManager->search_spec_child_rek(LEV_SEQUENCE_INFO)->to_sequence_info_terminal();
745  new_SeqInfoTerminal->set_both_links(seqInfoTerminal);
746  new_SeqManager->append_member(new_SeqInfoTerminal);
747  }
748 
749  {
750  sprintf(namebuffer, "AA_Sequence_Term%ld.%d", ED4_counter, count++);
751  ED4_orf_terminal *AA_SeqTerminal = new ED4_orf_terminal(namebuffer, 0, TERMINAL_HEIGHT, new_SeqManager);
752  AA_SeqTerminal->set_both_links(seqTerminal);
753 
754  char *speciesName = seqTerminal->species_name;
755  if (i<FORWARD_STRANDS) {
756  startPos = i;
757  translationMode = FORWARD_STRAND;
758  }
759  else if ((i-FORWARD_STRANDS)<COMPLEMENTARY_STRANDS) {
760  startPos = i-FORWARD_STRANDS;
761  translationMode = COMPLEMENTARY_STRAND;
762  }
763  else {
764  startPos = 0;
765  translationMode = DB_FIELD_STRAND;
766  }
767  TranslateGeneToAminoAcidSequence(ED4_ROOT->aw_root, AA_SeqTerminal, speciesName, startPos, translationMode);
768  AA_SeqTerminal->SET_aaSeqFlags(startPos+1, translationMode);
769  new_SeqManager->append_member(AA_SeqTerminal);
770  }
771 
772  ED4_counter++;
773 
774  new_SeqManager->request_resize();
775  }
776 }
777 
778 void PV_AddCorrespondingOrfTerminals(ED4_species_name_terminal *spNameTerm) {
779  if (gTerminalsCreated && spNameTerm) {
780  ED4_sequence_terminal *seqTerminal = spNameTerm->corresponding_sequence_terminal();
781  ED4_species_manager *speciesManager = spNameTerm->get_parent(LEV_SPECIES)->to_species_manager();
782  PV_AddNewAAseqTerminals(seqTerminal, speciesManager);
784  }
785 }
786 
788  if (gTerminalsCreated) {
790  GB_transaction ta(gb_main);
791  int marked = GBT_count_marked_species(gb_main);
792  if (marked) {
793  GBDATA *gbSpecies;
794  for (gbSpecies = GBT_first_marked_species(gb_main);
795  gbSpecies;
796  gbSpecies = GBT_next_marked_species(gbSpecies))
797  {
798  const char *spName = GBT_get_name_or_description(gbSpecies);
799  cout<<marked--<<". "<<spName<<endl;
800  ED4_species_name_terminal *spNameTerm = ED4_find_species_name_terminal(spName);
801  if (spNameTerm) {
802  ED4_terminal *terminal = spNameTerm->corresponding_sequence_terminal();
803  // $$$ If next terminal is species_name terminal => corresponding AA seq terminal doesn't exist ==> create one $$$
804  terminal = terminal->get_next_terminal();
805  if (terminal->is_species_name_terminal() || terminal->is_spacer_terminal()) {
806  ED4_sequence_terminal *seqTerminal = spNameTerm->corresponding_sequence_terminal();
807  ED4_species_manager *speciesManager = spNameTerm->get_parent(LEV_SPECIES)->to_species_manager();
808  PV_AddNewAAseqTerminals(seqTerminal, speciesManager);
809  }
810  }
811  }
813  }
814  }
815 }
816 
817 static void PV_CreateAllTerminals(AW_root *root) {
818  // 1. Get the species terminal pointer
819  // 2. Append the second terminal
820  // 3. resize the multi-species manager
821  // 4. refresh all the terminals including new appended terminals
822 
823  // Look for already created terminals, if found do nothing, otherwise, create
824  // new terminals and set gTerminalsCreated to true
825  bool bTerminalsFound = PV_LookForNewTerminals(root);
826  // if terminals are already created then do nothing exit the function
827  if (bTerminalsFound) return;
828 
830 
831  // Number of ORF terminals to be created = 3 forward strands + 3 complementary strands + 1 DB field strand
832  // totally 7 strands has to be created
833  int aaTerminalsToBeCreated = FORWARD_STRANDS + COMPLEMENTARY_STRANDS + DB_FIELD_STRANDS;
834  PV_AA_Terminals4Species = aaTerminalsToBeCreated;
835 
836  ED4_terminal *terminal = NULp;
837  for (terminal = ED4_ROOT->root_group_man->get_first_terminal();
838  terminal;
839  terminal = terminal->get_next_terminal())
840  {
841  if (terminal->is_sequence_terminal()) {
842  ED4_sequence_terminal *seqTerminal = terminal->to_sequence_terminal();
843  if (seqTerminal->species_name) {
844  ED4_species_manager *speciesManager = terminal->get_parent(LEV_SPECIES)->to_species_manager();
845  if (speciesManager->is_species_seq_manager()) {
846  PV_AddNewAAseqTerminals(seqTerminal, speciesManager);
847  }
848  }
849  }
850  }
851  ED4_ROOT->main_manager->request_resize(); // @@@ instead needs to be called whenever adding or deleting PV-terminals
852 
853  gTerminalsCreated = true;
854 
855  // Print missing DB entries
857 }
858 
860  // Create New Terminals If Aminoacid Sequence Terminals Are Not Created
861  if (!gTerminalsCreated) {
862  // AWAR_PROTEIN_TYPE is not initialized (if called from ED4_main before creating proteinViewer window)
863  // so, initialize it here
865  PV_CreateAllTerminals(root);
866  }
867 
868  PV_RefreshWindow(root);
869 }
870 
871 // --------------------------------------------------------------------------------
872 // Binding callback function to the AWARS
873 
874 static void PV_AddCallBacks(AW_root *awr) {
875 
884 
887 
896 
905 
914 }
915 
916 // --------------------------------------------------------------------------------
917 // Creating AWARS to be used by the PROTVIEW module
918 
919 void PV_CreateAwars(AW_root *root, AW_default aw_def) {
920 
921  root->awar_int(AWAR_PV_DISPLAY_ALL, 0, aw_def);
922 
923  root->awar_int(AWAR_PROTVIEW_FORWARD_STRAND_1, 0, aw_def);
924  root->awar_int(AWAR_PROTVIEW_FORWARD_STRAND_2, 0, aw_def);
925  root->awar_int(AWAR_PROTVIEW_FORWARD_STRAND_3, 0, aw_def);
926 
930 
931  root->awar_int(AWAR_PROTVIEW_DEFINED_FIELDS, 0, aw_def);
932  root->awar_int(AWAR_PROTVIEW_DISPLAY_OPTIONS, 0, aw_def);
933 
934  root->awar_int(AWAR_PV_SELECTED, 0, aw_def);
935  root->awar_int(AWAR_PV_SELECTED_DB, 0, aw_def);
936  root->awar_int(AWAR_PV_SELECTED_FS_1, 0, aw_def);
937  root->awar_int(AWAR_PV_SELECTED_FS_2, 0, aw_def);
938  root->awar_int(AWAR_PV_SELECTED_FS_3, 0, aw_def);
939  root->awar_int(AWAR_PV_SELECTED_CS_1, 0, aw_def);
940  root->awar_int(AWAR_PV_SELECTED_CS_2, 0, aw_def);
941  root->awar_int(AWAR_PV_SELECTED_CS_3, 0, aw_def);
942 
943  root->awar_int(AWAR_PV_MARKED, 0, aw_def);
944  root->awar_int(AWAR_PV_MARKED_DB, 0, aw_def);
945  root->awar_int(AWAR_PV_MARKED_FS_1, 0, aw_def);
946  root->awar_int(AWAR_PV_MARKED_FS_2, 0, aw_def);
947  root->awar_int(AWAR_PV_MARKED_FS_3, 0, aw_def);
948  root->awar_int(AWAR_PV_MARKED_CS_1, 0, aw_def);
949  root->awar_int(AWAR_PV_MARKED_CS_2, 0, aw_def);
950  root->awar_int(AWAR_PV_MARKED_CS_3, 0, aw_def);
951 
952  root->awar_int(AWAR_PV_CURSOR, 0, aw_def);
953  root->awar_int(AWAR_PV_CURSOR_DB, 0, aw_def);
954  root->awar_int(AWAR_PV_CURSOR_FS_1, 0, aw_def);
955  root->awar_int(AWAR_PV_CURSOR_FS_2, 0, aw_def);
956  root->awar_int(AWAR_PV_CURSOR_FS_3, 0, aw_def);
957  root->awar_int(AWAR_PV_CURSOR_CS_1, 0, aw_def);
958  root->awar_int(AWAR_PV_CURSOR_CS_2, 0, aw_def);
959  root->awar_int(AWAR_PV_CURSOR_CS_3, 0, aw_def);
960 }
961 
964  GB_transaction ta(gb_main);
965 
966  static AW_window_simple *aws = NULp;
967  if (aws) return aws;
968 
969  aws = new AW_window_simple;
970 
971  aws->init(aw_root, "PROTEIN_VIEWER", "Protein Viewer");
972  aws->load_xfig("proteinViewer.fig");
973 
974  aws->at("refresh");
975  aws->callback(PV_RefreshProtViewDisplay);
976  aws->button_length(0);
977  aws->create_button("REFRESH", "#refresh_text.xpm");
978 
979  aws->callback(makeHelpCallback("proteinViewer.hlp"));
980  aws->at("help");
981  aws->button_length(0);
982  aws->create_button("HELP", "#help_text.xpm");
983 
984  aws->at("close");
985  aws->callback(AW_POPDOWN);
986  aws->button_length(0);
987  aws->create_button("CLOSE", "#close_text.xpm");
988 
989  {
991  aws->at("table");
992  aws->create_option_menu(AWAR_PROTEIN_TYPE);
993  for (int code_nr=0; code_nr<AWT_CODON_TABLES; code_nr++) {
994  aws->insert_option(AWT_get_codon_code_name(code_nr), "", code_nr);
995  }
996  aws->update_option_menu();
997 
998  aws->at("all");
999  aws->create_toggle(AWAR_PV_DISPLAY_ALL);
1000 
1001  aws->at("f1");
1002  aws->create_toggle(AWAR_PROTVIEW_FORWARD_STRAND_1);
1003 
1004  aws->at("f2");
1005  aws->create_toggle(AWAR_PROTVIEW_FORWARD_STRAND_2);
1006 
1007  aws->at("f3");
1008  aws->create_toggle(AWAR_PROTVIEW_FORWARD_STRAND_3);
1009 
1010  aws->at("c1");
1011  aws->create_toggle(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1);
1012 
1013  aws->at("c2");
1014  aws->create_toggle(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2);
1015 
1016  aws->at("c3");
1017  aws->create_toggle(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3);
1018 
1019  aws->at("defined");
1020  aws->create_toggle(AWAR_PROTVIEW_DEFINED_FIELDS);
1021 
1022  aws->at("dispOption");
1023  aws->create_toggle_field(AWAR_PROTVIEW_DISPLAY_OPTIONS, AW_VERTICAL);
1024  aws->insert_toggle("Single Letter Code", "S", 0);
1025  aws->insert_toggle("Triple Letter Code", "T", 1);
1026  aws->insert_toggle("Colored Box", "B", 2);
1027  aws->update_toggle_field();
1028 
1029  aws->at("colMaps");
1030  aws->callback(makeCreateWindowCallback(ED4_create_seq_colors_window, ED4_ROOT->sequence_colors));
1031  aws->button_length(0);
1032  aws->create_button("COLORMAPS", "#colorMaps.xpm");
1033 
1034  aws->at("colors");
1035  aws->callback(makeWindowCallback(ED4_popup_gc_window, ED4_ROOT->gc_manager));
1036  aws->button_length(0);
1037  aws->create_button("COLORS", "#colors.xpm");
1038 
1039  {
1040  aws->at("sel"); aws->create_toggle(AWAR_PV_SELECTED);
1041  aws->at("sf1"); aws->create_toggle(AWAR_PV_SELECTED_FS_1);
1042  aws->at("sf2"); aws->create_toggle(AWAR_PV_SELECTED_FS_2);
1043  aws->at("sf3"); aws->create_toggle(AWAR_PV_SELECTED_FS_3);
1044  aws->at("sc1"); aws->create_toggle(AWAR_PV_SELECTED_CS_1);
1045  aws->at("sc2"); aws->create_toggle(AWAR_PV_SELECTED_CS_2);
1046  aws->at("sc3"); aws->create_toggle(AWAR_PV_SELECTED_CS_3);
1047  aws->at("sdb"); aws->create_toggle(AWAR_PV_SELECTED_DB);
1048 
1049  aws->at("mrk"); aws->create_toggle(AWAR_PV_MARKED);
1050  aws->at("mf1"); aws->create_toggle(AWAR_PV_MARKED_FS_1);
1051  aws->at("mf2"); aws->create_toggle(AWAR_PV_MARKED_FS_2);
1052  aws->at("mf3"); aws->create_toggle(AWAR_PV_MARKED_FS_3);
1053  aws->at("mc1"); aws->create_toggle(AWAR_PV_MARKED_CS_1);
1054  aws->at("mc2"); aws->create_toggle(AWAR_PV_MARKED_CS_2);
1055  aws->at("mc3"); aws->create_toggle(AWAR_PV_MARKED_CS_3);
1056  aws->at("mdb"); aws->create_toggle(AWAR_PV_MARKED_DB);
1057 
1058  aws->at("cur"); aws->create_toggle(AWAR_PV_CURSOR);
1059  aws->at("cf1"); aws->create_toggle(AWAR_PV_CURSOR_FS_1);
1060  aws->at("cf2"); aws->create_toggle(AWAR_PV_CURSOR_FS_2);
1061  aws->at("cf3"); aws->create_toggle(AWAR_PV_CURSOR_FS_3);
1062  aws->at("cc1"); aws->create_toggle(AWAR_PV_CURSOR_CS_1);
1063  aws->at("cc2"); aws->create_toggle(AWAR_PV_CURSOR_CS_2);
1064  aws->at("cc3"); aws->create_toggle(AWAR_PV_CURSOR_CS_3);
1065  aws->at("cdb"); aws->create_toggle(AWAR_PV_CURSOR_DB);
1066  }
1067 
1068  aws->at("save");
1069  aws->callback(PV_SaveData);
1070  aws->button_length(5);
1071  aws->create_button("SAVE", "#save.xpm");
1072  }
1073 
1074  // binding callback function to the AWARS
1075  PV_AddCallBacks(aw_root);
1076 
1077  // Create All Terminals
1078  PV_CreateAllTerminals(aw_root);
1079 
1080  aws->show();
1081 
1082  return aws;
1083 }
1084 
GB_ERROR GB_begin_transaction(GBDATA *gbd)
Definition: arbdb.cxx:2528
static void PV_PrintMissingDBentryInformation()
#define AWAR_PV_MARKED_DB
void set_both_links(ED4_base *ref)
Definition: ed4_class.hxx:972
void PV_SequenceUpdate_CB(GB_CB_TYPE gbtype)
void unhide_children()
Definition: ED4_base.cxx:830
const char * GB_ERROR
Definition: arb_core.h:25
#define AWAR_PV_MARKED_CS_3
#define AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1
#define COMPLEMENTARY_STRAND
bool is_species_seq_terminal() const
Definition: ed4_class.hxx:1850
#define AWAR_PROTVIEW_FORWARD_STRAND_2
group_matcher all()
Definition: test_unit.h:1011
GBDATA * GBT_first_marked_species(GBDATA *gb_main)
Definition: aditem.cxx:113
static void PV_RefreshDisplay(AW_root *root)
static bool PV_LookForNewTerminals(AW_root *root)
GB_ERROR GB_write_string(GBDATA *gbd, const char *s)
Definition: arbdb.cxx:1387
ED4_terminal * get_first_terminal(int start_index=0) const
static int gMissingTransTable
static void PV_HideTerminal(ED4_orf_terminal *orfTerm)
static void TranslateGeneToAminoAcidSequence(AW_root *, ED4_orf_terminal *seqTerm, const char *speciesName, int startPos4Translation, int translationMode)
#define FORWARD_STRANDS
char * GBT_complementNucSequence(const char *s, int len, char T_or_U)
Definition: adRevCompl.cxx:78
#define FORWARD_STRAND
bool in_species_seq_terminal() const
Definition: ed4_class.hxx:1852
#define AWAR_PV_SELECTED_FS_2
#define COMPLEMENTARY_STRANDS
#define AWAR_PV_MARKED_CS_1
GBDATA * GBT_get_alignment(GBDATA *gb_main, const char *aliname)
Definition: adali.cxx:808
#define AWAR_PV_SELECTED_FS_1
void request_resize()
Definition: ed4_class.hxx:2187
#define AWAR_PROTVIEW_FORWARD_STRAND_1
static AW_repeated_question * ASKtoOverWriteData
void GB_end_transaction_show_error(GBDATA *gbd, GB_ERROR error, void(*error_handler)(GB_ERROR))
Definition: arbdb.cxx:2584
long read_int() const
Definition: AW_awar.cxx:184
static void PV_ManageTerminalDisplay(AW_root *root, ED4_orf_terminal *orfTerm, long int DispMode)
const char * GBS_global_string(const char *templat,...)
Definition: arb_msg.cxx:203
void PV_CallBackFunction(AW_root *root)
static bool gbWritingData
ED4_root * ED4_ROOT
Definition: ED4_main.cxx:49
long GBT_get_alignment_len(GBDATA *gb_main, const char *aliname)
Definition: adali.cxx:833
static void PV_DisplayAminoAcidNames(AW_root *root)
bool GB_have_error()
Definition: arb_msg.cxx:338
STL namespace.
void AW_POPDOWN(AW_window *window)
Definition: AW_window.cxx:52
ED4_terminal * owner_of_cursor
Definition: ed4_class.hxx:644
void SET_aaSequence(const char *aaSeq)
Definition: ed4_class.hxx:1971
AW_gc_manager * gc_manager
Definition: ed4_class.hxx:1443
long ED4_counter
Definition: ED4_main.cxx:61
#define e4_assert(bed)
Definition: ed4_class.hxx:14
static GB_ERROR PV_ComplementarySequence(char *sequence)
AW_awar * add_callback(const RootCallback &cb)
Definition: AW_awar.cxx:231
GB_ERROR GBT_add_alignment_changekeys(GBDATA *gb_main, const char *ali)
#define AWAR_PV_CURSOR_CS_3
#define AWAR_PV_SELECTED_CS_1
int TTIT_embl2arb(int embl_code_nr)
NOT4PERL GBDATA * GBT_add_data(GBDATA *species, const char *ali_name, const char *key, GB_TYPES type) __ATTR__DEPRECATED_TODO("better use GBT_create_sequence_data()")
Definition: adali.cxx:597
static void PV_SaveData(AW_window *)
#define SEQUENCE_INFO_WIDTH
Definition: ed4_defs.hxx:80
size_t GB_read_string_count(GBDATA *gbd)
Definition: arbdb.cxx:916
GB_ERROR GB_await_error()
Definition: arb_msg.cxx:342
#define AWAR_PV_CURSOR_FS_2
WindowCallback makeHelpCallback(const char *helpfile)
Definition: aw_window.hxx:106
void append_member(ED4_base *new_member)
AW_window * ED4_CreateProteinViewer_window(AW_root *aw_root)
static void PV_HideAllTerminals()
static void PV_RefreshProtViewDisplay(AW_window *aww)
#define AWAR_PV_MARKED_FS_1
static void PV_WriteTranslatedSequenceToDB(ED4_orf_terminal *aaSeqTerm, const char *spName)
void hide_children()
Definition: ED4_base.cxx:819
#define DB_FIELD_STRAND
GBDATA * get_gb_main() const
Definition: ed4_class.hxx:1422
#define AWAR_PV_MARKED_FS_3
#define AWAR_PV_MARKED_CS_2
ED4_species_name_terminal * ED4_find_species_name_terminal(const char *species_name)
Definition: ED4_root.cxx:877
#define DB_FIELD_STRANDS
int translate_nuc2aa(int arb_code_nr, char *data, size_t size, size_t pos, bool translate_all, bool create_start_codon, bool append_stop_codon, int *translatedSize)
Definition: Translate.cxx:108
static void PV_CreateAllTerminals(AW_root *root)
ED4_window * first_window
Definition: ed4_class.hxx:1428
#define AWAR_PROTVIEW_DISPLAY_OPTIONS
ED4_terminal * get_next_terminal()
Definition: ED4_base.cxx:454
static void error(const char *msg)
Definition: mkptypes.cxx:96
#define AWAR_PV_SELECTED_FS_3
void PV_AddOrfTerminalsToLoadedSpecies()
#define AWAR_PV_SELECTED_CS_2
void PV_RefreshWindow(AW_root *root)
#define AWAR_PV_SELECTED_CS_3
AW_window * ED4_create_seq_colors_window(AW_root *awr, ED4_seq_colors *sc)
GBDATA * GBT_next_marked_species(GBDATA *gb_species)
Definition: aditem.cxx:116
#define AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2
#define AWAR_PV_CURSOR
ED4_root_group_manager * root_group_man
Definition: ed4_class.hxx:1432
static bool gTerminalsCreated
#define AWAR_SPECIES_NAME
ED4_main_manager * main_manager
Definition: ed4_class.hxx:1429
void PV_CreateAwars(AW_root *root, AW_default aw_def)
#define AWAR_PV_MARKED
#define AWAR_PV_DISPLAY_ALL
AW_awar * awar(const char *awar)
Definition: AW_root.cxx:554
#define AWAR_PV_CURSOR_DB
GBDATA * GBT_find_sequence(GBDATA *gb_species, const char *aliname)
Definition: adali.cxx:708
GB_alignment_type alignment_type
Definition: ed4_class.hxx:1440
static void PV_UnHideTerminal(ED4_orf_terminal *orfTerm)
long GBT_count_marked_species(GBDATA *gb_main)
Definition: aditem.cxx:372
static int PV_AA_Terminals4Species
const char * AWT_get_codon_code_name(int code)
int TERMINAL_HEIGHT
Definition: ED4_main.cxx:51
#define NAME_BUFFERSIZE
Definition: ed4_defs.hxx:111
#define AWAR_PV_SELECTED_DB
static void PV_ManageTerminals(AW_root *root)
void PV_AddCorrespondingOrfTerminals(ED4_species_name_terminal *spNameTerm)
static int gMissingCodonStart
int is_orf_terminal() const
Definition: ed4_class.hxx:1084
GB_ERROR GB_export_errorf(const char *templat,...)
Definition: arb_msg.cxx:262
ED4_base * search_spec_child_rek(ED4_level level)
Definition: ED4_base.cxx:434
ED4_cursor & current_cursor()
Definition: ed4_class.hxx:1400
AW_awar * awar_int(const char *var_name, long default_value=0, AW_default default_file=AW_ROOT_DEFAULT)
Definition: AW_root.cxx:580
#define AWAR_PV_SELECTED
#define AWAR_PROTVIEW_DEFINED_FIELDS
void set_property(ED4_properties prop)
Definition: ed4_class.hxx:975
void SET_aaSeqFlags(int startPos, int strandType)
Definition: ed4_class.hxx:1970
const char * get_alignment_name() const
Definition: ed4_class.hxx:1458
char * GB_read_string(GBDATA *gbd)
Definition: arbdb.cxx:909
const int AWAR_PROTEIN_TYPE_bacterial_code_index
ED4_seq_colors * sequence_colors
Definition: ed4_class.hxx:1442
AW_root * aw_root
Definition: ed4_class.hxx:1425
#define AWAR_PROTEIN_TYPE
static void PV_AddCallBacks(AW_root *awr)
#define AWT_CODON_TABLES
#define AWAR_PV_CURSOR_FS_1
ED4_properties
Definition: ed4_defs.hxx:174
unsigned int hidden
Definition: ed4_class.hxx:927
bool ED4_is_gap_character(char chr)
#define AWAR_PROTVIEW_FORWARD_STRAND_3
void aw_message(const char *msg)
Definition: AW_status.cxx:1142
int AWT_default_protein_type(GBDATA *gb_main)
void ED4_popup_gc_window(AW_window *awp, AW_gc_manager *gcman)
Definition: ED4_root.cxx:1285
GBDATA * GB_find_string(GBDATA *gbd, const char *key, const char *str, GB_CASE case_sens, GB_SEARCH_TYPE gbs)
Definition: adquery.cxx:302
AW_root * get_root()
Definition: aw_window.hxx:359
#define AWAR_PV_CURSOR_CS_2
GBDATA * GBT_create_alignment(GBDATA *gb_main, const char *name, long len, long aligned, long security, const char *type, const char *why_created)
Definition: adali.cxx:388
AW_window_simple * win
#define NULp
Definition: cxxforward.h:116
GBDATA * GBT_find_species(GBDATA *gb_main, const char *name)
Definition: aditem.cxx:139
static int giNewAlignments
#define AWAR_PV_MARKED_FS_2
void SET_aaColor(const char *aaSeq)
Definition: ed4_class.hxx:1972
int is_sequence_terminal() const
Definition: ed4_class.hxx:1083
#define AWAR_PV_CURSOR_FS_3
GB_transaction ta(gb_var)
static void PV_AddNewAAseqTerminals(ED4_sequence_terminal *seqTerminal, ED4_species_manager *speciesManager)
GB_CSTR GB_read_char_pntr(GBDATA *gbd)
Definition: arbdb.cxx:904
GBDATA * gb_main
Definition: adname.cxx:32
GB_ERROR GBT_check_data(GBDATA *Main, const char *alignment_name)
Definition: adali.cxx:218
GBDATA * GBT_get_presets(GBDATA *gb_main)
Definition: adali.cxx:30
GB_CSTR GBT_get_name_or_description(GBDATA *gb_item)
Definition: aditem.cxx:459
int is_spacer_terminal() const
Definition: ed4_class.hxx:1090
#define AWAR_PV_CURSOR_CS_1
GB_CB_TYPE
Definition: arbdb_base.h:46
ED4_manager * get_parent(ED4_level lev) const
Definition: ed4_class.hxx:1821
struct ED4_base::@7 flag
#define AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3
GBDATA * GB_entry(GBDATA *father, const char *key)
Definition: adquery.cxx:334
int is_species_name_terminal() const
Definition: ed4_class.hxx:1080
char * GBS_global_string_copy(const char *templat,...)
Definition: arb_msg.cxx:194
NOT4PERL GB_ERROR GBT_determine_T_or_U(GB_alignment_type alignment_type, char *T_or_U, const char *supposed_target)
Definition: adRevCompl.cxx:90
const char * getAminoAcidAbbr(char aa)
ED4_window * get_most_recently_used_window() const
Definition: ed4_class.hxx:1470
GB_write_int const char s
Definition: AW_awar.cxx:154