Context Navigation

source: tags/ms_r16q4/EDIT4/ED4_ProteinViewer.cxx

Visit:

Last change on this file was 15223, checked in by westram, 8 years ago
reintegrates 'flags' into 'trunk' DRYed group generation code ref-terminal access layout done by managers (removed manual coordinate calculation) dynamic size calculated by terminals themselves fix design issues brackets were used where groups should have been used. fixed fix many bad/spammy names fix broken member-code (only worked with a NULL sentinel present) dynamic indentation (according to visible group-nesting) adds: log:branches/flags@15098:15222
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 50.3 KB

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

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

Download in other formats: