Context Navigation

source: branches/profile/EDIT4/ED4_ProteinViewer.cxx

Visit:

Last change on this file was 12803, checked in by westram, 10 years ago
merge from 'alilink' into 'trunk' adds: log:branches/alilink@12801:12802
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 50.4 KB

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

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

Download in other formats: