Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

ED4_ProteinViewer.cxx

Visit:

Last change on this file was 19432, checked in by westram, 14 months ago
`GBT_get_alignment_len` now also reports error if alignment length is zero this case often was unhandled and did easily lead to allocation problems. catch error in case of zero alignment length ⇒ fixes alloc-size-larger-than-warning (in `NT_count_different_chars`). check + fix callers.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 49.5 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_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,
43	PV_SELECTED,
44	PV_CURSOR,
45	PV_ALL
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();
143	adb = root->awar(AWAR_PROTVIEW_DEFINED_FIELDS)->read_int();
144	af_1 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_1)->read_int();
145	af_2 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_2)->read_int();
146	af_3 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_3)->read_int();
147	ac_1 = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1)->read_int();
148	ac_2 = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2)->read_int();
149	ac_3 = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3)->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
259	PV_HideAllTerminals();
260
261	int dispAll = root->awar(AWAR_PV_DISPLAY_ALL)->read_int();
262	if (dispAll) {
263	for (ED4_terminal *terminal = ED4_ROOT->root_group_man->get_first_terminal();
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) {
276	GBDATA *gb_main = ED4_ROOT->get_gb_main();
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) {
304	for (ED4_terminal *terminal = ED4_ROOT->root_group_man->get_first_terminal();
305	terminal;
306	terminal = terminal->get_next_terminal())
307	{
308	if (terminal->is_sequence_terminal()) {
309	ED4_species_manager *speciesManager = terminal->get_parent(LEV_SPECIES)->to_species_manager();
310	if (speciesManager->is_species_seq_terminal()) {
311	// we are in the sequence terminal section of a species
312	// walk through all the corresponding ORF terminals for the species and
313	// hide or unhide the terminals based on the display options set by the user
314	if (speciesManager->is_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
334	if (ED4_ROOT->get_most_recently_used_window()) {
335	ED4_MostRecentWinContext context;
336	ED4_cursor& cursor = current_cursor();
337
338	if (cursor.owner_of_cursor) {
339	// Get The Cursor Terminal And The Corresponding Aa_Sequence Terminals And Set The Display Options
340	ED4_terminal *cursorTerminal = cursor.owner_of_cursor;
341	if (cursorTerminal->is_species_seq_terminal()) {
342	for (int i=0; i<PV_AA_Terminals4Species; i++) {
343	// get the corresponding orf_terminal skipping sequence_info terminal
344	// $$$$$ sequence_terminal->sequence_info_terminal->aa_sequence_terminal $$$$$$
345	cursorTerminal = cursorTerminal->get_next_terminal()->get_next_terminal();
346	// Make sure it is ORF terminal
347	if (cursorTerminal->is_orf_terminal()) {
348	ED4_orf_terminal *orfTerm = cursorTerminal->to_orf_terminal();
349	PV_ManageTerminalDisplay(root, orfTerm, PV_CURSOR);
350	}
351	}
352	}
353	}
354	}
355	}
356	}
357
358	void PV_RefreshWindow(AW_root *root) {
359	// Manage the terminals showing only those selected by the user
360	if (gTerminalsCreated) {
361	PV_ManageTerminals(root);
362	}
363	// Refresh all windows
364	// ED4_ROOT->refresh_all_windows(0);
365	}
366
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) {
381	GBDATA *gb_main = ED4_ROOT->get_gb_main();
382	GB_ERROR error = GB_begin_transaction(gb_main);
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) {
426	e4_assert(ASKtoOverWriteData);
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
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
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;
517	GBDATA *gb_main = ED4_ROOT->get_gb_main();
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];
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 = 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
628	static void PV_PrintMissingDBentryInformation() {
629	GBDATA *gb_main = ED4_ROOT->get_gb_main();
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) {
645	GB_transaction ta(ED4_ROOT->get_gb_main());
646
647	for (ED4_terminal *terminal = ED4_ROOT->root_group_man->get_first_terminal();
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
673	PV_PrintMissingDBentryInformation();
674	PV_RefreshWindow(root);
675	}
676
677	static void PV_RefreshDisplay(AW_root *root) {
678	PV_DisplayAminoAcidNames(root);
679	}
680
681	static void PV_RefreshProtViewDisplay(AW_window *aww) {
682	if (gTerminalsCreated) {
683	PV_RefreshDisplay(aww->get_root());
684	}
685	}
686
687	void PV_SequenceUpdate_CB(GB_CB_TYPE gbtype) {
688	if (gbtype==GB_CB_CHANGED &&
689	gTerminalsCreated &&
690	(ED4_ROOT->alignment_type == GB_AT_DNA) &&
691	!gbWritingData)
692	{
693	GB_transaction ta(ED4_ROOT->get_gb_main());
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
715	PV_PrintMissingDBentryInformation();
716	PV_RefreshWindow(ED4_ROOT->aw_root);
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);
783	PV_RefreshWindow(ED4_ROOT->aw_root);
784	}
785	}
786
787	void PV_AddOrfTerminalsToLoadedSpecies() {
788	if (gTerminalsCreated) {
789	GBDATA *gb_main = ED4_ROOT->get_gb_main();
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	}
812	PV_RefreshWindow(ED4_ROOT->aw_root);
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
829	GB_transaction ta(ED4_ROOT->get_gb_main());
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
856	PV_PrintMissingDBentryInformation();
857	}
858
859	void PV_CallBackFunction(AW_root *root) {
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
864	root->awar_int(AWAR_PROTEIN_TYPE, AWAR_PROTEIN_TYPE_bacterial_code_index, ED4_ROOT->get_gb_main());
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
876	awr->awar(AWAR_PV_DISPLAY_ALL)->add_callback(PV_CallBackFunction);
877	awr->awar(AWAR_PROTVIEW_FORWARD_STRAND_1)->add_callback(PV_CallBackFunction);
878	awr->awar(AWAR_PROTVIEW_FORWARD_STRAND_2)->add_callback(PV_CallBackFunction);
879	awr->awar(AWAR_PROTVIEW_FORWARD_STRAND_3)->add_callback(PV_CallBackFunction);
880	awr->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1)->add_callback(PV_CallBackFunction);
881	awr->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2)->add_callback(PV_CallBackFunction);
882	awr->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3)->add_callback(PV_CallBackFunction);
883	awr->awar(AWAR_PROTVIEW_DEFINED_FIELDS)->add_callback(PV_CallBackFunction);
884
885	awr->awar(AWAR_PROTVIEW_DISPLAY_OPTIONS)->add_callback(PV_RefreshDisplay);
886	awr->awar(AWAR_SPECIES_NAME)->add_callback(PV_CallBackFunction);
887
888	awr->awar(AWAR_PV_SELECTED)->add_callback(PV_CallBackFunction);
889	awr->awar(AWAR_PV_SELECTED_DB)->add_callback(PV_CallBackFunction);
890	awr->awar(AWAR_PV_SELECTED_FS_1)->add_callback(PV_CallBackFunction);
891	awr->awar(AWAR_PV_SELECTED_FS_2)->add_callback(PV_CallBackFunction);
892	awr->awar(AWAR_PV_SELECTED_FS_3)->add_callback(PV_CallBackFunction);
893	awr->awar(AWAR_PV_SELECTED_CS_1)->add_callback(PV_CallBackFunction);
894	awr->awar(AWAR_PV_SELECTED_CS_2)->add_callback(PV_CallBackFunction);
895	awr->awar(AWAR_PV_SELECTED_CS_3)->add_callback(PV_CallBackFunction);
896
897	awr->awar(AWAR_PV_MARKED)->add_callback(PV_CallBackFunction);
898	awr->awar(AWAR_PV_MARKED_DB)->add_callback(PV_CallBackFunction);
899	awr->awar(AWAR_PV_MARKED_FS_1)->add_callback(PV_CallBackFunction);
900	awr->awar(AWAR_PV_MARKED_FS_2)->add_callback(PV_CallBackFunction);
901	awr->awar(AWAR_PV_MARKED_FS_3)->add_callback(PV_CallBackFunction);
902	awr->awar(AWAR_PV_MARKED_CS_1)->add_callback(PV_CallBackFunction);
903	awr->awar(AWAR_PV_MARKED_CS_2)->add_callback(PV_CallBackFunction);
904	awr->awar(AWAR_PV_MARKED_CS_3)->add_callback(PV_CallBackFunction);
905
906	awr->awar(AWAR_PV_CURSOR)->add_callback(PV_CallBackFunction);
907	awr->awar(AWAR_PV_CURSOR_DB)->add_callback(PV_CallBackFunction);
908	awr->awar(AWAR_PV_CURSOR_FS_1)->add_callback(PV_CallBackFunction);
909	awr->awar(AWAR_PV_CURSOR_FS_2)->add_callback(PV_CallBackFunction);
910	awr->awar(AWAR_PV_CURSOR_FS_3)->add_callback(PV_CallBackFunction);
911	awr->awar(AWAR_PV_CURSOR_CS_1)->add_callback(PV_CallBackFunction);
912	awr->awar(AWAR_PV_CURSOR_CS_2)->add_callback(PV_CallBackFunction);
913	awr->awar(AWAR_PV_CURSOR_CS_3)->add_callback(PV_CallBackFunction);
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
927	root->awar_int(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1, 0, aw_def);
928	root->awar_int(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2, 0, aw_def);
929	root->awar_int(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3, 0, aw_def);
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
962	AW_window ED4_CreateProteinViewer_window(AW_root aw_root) {
963	GBDATA *gb_main = ED4_ROOT->get_gb_main();
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	{
990	aw_root->awar_int(AWAR_PROTEIN_TYPE, AWAR_PROTEIN_TYPE_bacterial_code_index, gb_main);
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

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/EDIT4/ED4_ProteinViewer.cxx

Download in other formats: