Context Navigation

source: tags/ms_r16q2/EDIT4/ED4_ProteinViewer.cxx

Visit:

Last change on this file was 14453, checked in by westram, 8 years ago
do not cast AW_POPDOWN
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 50.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_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	#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_have_error()
396	? GB_await_error()
397	: GBS_global_string("Species '%s' has no data in alignment '%s'", spName, defaultAlignment);
398	}
399	else {
400	char *str_SeqData = GB_read_string(gb_SeqData);
401	if (!str_SeqData) error = GB_await_error();
402	else {
403	int aaStrandType = int(aaSeqTerm->GET_aaStrandType());
404	if (aaStrandType == COMPLEMENTARY_STRAND) {
405	GB_ERROR compl_err = PV_ComplementarySequence(str_SeqData);
406	if (compl_err) error = GBS_global_string("Failed to calc complementary strand (Reason: %s)", compl_err);
407	}
408
409	if (!error) {
410	char newAlignmentName[100];
411	int aaStartPos = int(aaSeqTerm->GET_aaStartPos());
412
413	switch (aaStrandType) {
414	case FORWARD_STRAND: sprintf(newAlignmentName, "ali_pro_ProtView_forward_start_pos_%ld", (long)aaStartPos); break;
415	case COMPLEMENTARY_STRAND: sprintf(newAlignmentName, "ali_pro_ProtView_complementary_start_pos_%ld", (long)aaStartPos); break;
416	case DB_FIELD_STRAND: sprintf(newAlignmentName, "ali_pro_ProtView_database_field_start_pos_%ld", (long)aaStartPos); break;
417	}
418
419	int len = GB_read_string_count(gb_SeqData);
420	AWT_pro_a_nucs_convert(AWT_default_protein_type(), str_SeqData, len, aaStartPos-1, false, true, false, 0);
421
422	// Create alignment data to store the translated sequence
423	GBDATA *gb_presets = GBT_get_presets(GLOBAL_gb_main);
424	GBDATA *gb_alignment_exists = GB_find_string(gb_presets, "alignment_name", newAlignmentName, GB_IGNORE_CASE, SEARCH_GRANDCHILD);
425	GBDATA *gb_new_alignment = 0;
426
427	if (gb_alignment_exists) {
428	int skip_sp = 0;
429	char *question = 0;
430	GBDATA *gb_seq_data = GBT_find_sequence(gb_species, newAlignmentName);
431	if (gb_seq_data) {
432	e4_assert(ASKtoOverWriteData);
433	question = GBS_global_string_copy("\"%s\" contain data in the alignment \"%s\"!", spName, newAlignmentName);
434	skip_sp = ASKtoOverWriteData->get_answer("overwrite_translated", question, "Overwrite, Skip Species", "all", false);
435	}
436	if (skip_sp) {
437	error = GBS_global_string_copy("%s You chose to skip this Species!", question);
438	}
439	else {
440	gb_new_alignment = GBT_get_alignment(GLOBAL_gb_main, newAlignmentName);
441	if (!gb_new_alignment) error = GB_await_error();
442	}
443	free(question);
444	}
445	else {
446	long aliLen = GBT_get_alignment_len(GLOBAL_gb_main, defaultAlignment);
447	gb_new_alignment = GBT_create_alignment(GLOBAL_gb_main, newAlignmentName, aliLen/3+1, 0, 1, "ami");
448
449	if (!gb_new_alignment) error = GB_await_error();
450	else giNewAlignments++;
451	}
452
453	if (!error) {
454	GBDATA *gb_ProSeqData = GBT_add_data(gb_species, newAlignmentName, "data", GB_STRING);
455	if (!gb_ProSeqData) error = GB_await_error();
456	else error = GB_write_string(gb_ProSeqData, str_SeqData);
457	}
458
459	if (!error) error = GBT_check_data(GLOBAL_gb_main, 0);
460	}
461
462	free(str_SeqData);
463	}
464	}
465	free(defaultAlignment);
466	}
467	}
468	GB_end_transaction_show_error(GLOBAL_gb_main, error, aw_message);
469	}
470
471	static void PV_SaveData(AW_window /aww*/) {
472	// IDEA:
473	// 1. walk thru the orf terminals
474	// 2. check the visibility status
475	// 3. select only the visible terminals
476	// 4. get the corresponding species name
477	// 5. translate the sequence
478	// 6. write to the database
479	gbWritingData = true;
480	if (gTerminalsCreated) {
481	ASKtoOverWriteData = new AW_repeated_question;
482
483	for (ED4_terminal *terminal = ED4_ROOT->root_group_man->get_first_terminal();
484	terminal;
485	terminal = terminal->get_next_terminal())
486	{
487	if (terminal->is_species_seq_terminal()) {
488	const char *speciesName = terminal->to_sequence_terminal()->species_name;
489
490	for (int i=0; i<PV_AA_Terminals4Species; i++) {
491	// get the corresponding orf_terminal skipping sequence_info terminal
492	terminal = terminal->get_next_terminal()->get_next_terminal();
493	// Make sure it is ORF terminal
494	if (terminal->is_orf_terminal()) {
495	ED4_orf_terminal *orfTerm = terminal->to_orf_terminal();
496	ED4_base base = (ED4_base)orfTerm;
497	if (!base->flag.hidden) {
498	PV_WriteTranslatedSequenceToDB(orfTerm, speciesName);
499	}
500	}
501	}
502	}
503	}
504	if (giNewAlignments>0) {
505	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);
506	aw_message(msg);
507	free(msg);
508
509	giNewAlignments = 0;
510	}
511	}
512	gbWritingData = false;
513	}
514
515	static void TranslateGeneToAminoAcidSequence(AW_root * /* root /, ED4_orf_terminal seqTerm, const char *speciesName, int startPos4Translation, int translationMode) {
516	// This function translates gene sequence to aminoacid sequence and stores translation into the respective AA_Sequence_terminal
517	GB_ERROR error = NULL;
518	GBDATA *gb_species = GBT_find_species(GLOBAL_gb_main, speciesName);
519	if (!gb_species) error = GBS_global_string("Species '%s' does not exist", speciesName);
520	else {
521	char *defaultAlignment = GBT_get_default_alignment(GLOBAL_gb_main);
522	if (!defaultAlignment) error = GB_await_error();
523	else {
524	GBDATA *gb_SeqData = GBT_find_sequence(gb_species, defaultAlignment);
525	if (!gb_SeqData) {
526	error = GB_have_error()
527	? GB_await_error()
528	: GBS_global_string("Species '%s' has no data in alignment '%s'", speciesName, defaultAlignment);
529	}
530	else {
531	e4_assert(startPos4Translation>=0 && startPos4Translation<=2);
532
533	char *str_SeqData = GB_read_string(gb_SeqData);
534	if (!str_SeqData) error = GB_await_error();
535	else {
536	int len = GB_read_string_count(gb_SeqData);
537	int translationTable = AWT_default_protein_type(GLOBAL_gb_main);
538
539	switch (translationMode) {
540	case FORWARD_STRAND:
541	break;
542
543	case COMPLEMENTARY_STRAND: {
544	// convert sequence to the complementary sequence
545	GB_ERROR compl_err = PV_ComplementarySequence(str_SeqData);
546	if (compl_err) error = GBS_global_string("Failed to calc complementary strand for '%s' (Reason: %s)", speciesName, compl_err);
547	break;
548	}
549	case DB_FIELD_STRAND: {
550	// for use database field options - fetch codon start and translation table from the respective species data
551	GBDATA *gb_translTable = GB_entry(gb_species, "transl_table");
552	if (gb_translTable) {
553	int sp_embl_table = atoi(GB_read_char_pntr(gb_translTable));
554	translationTable = AWT_embl_transl_table_2_arb_code_nr(sp_embl_table);
555	}
556	else { // use selected translation table as default (if 'transl_table' field is missing)
557	gMissingTransTable++;
558	}
559	GBDATA *gb_codonStart = GB_entry(gb_species, "codon_start");
560	if (gb_codonStart) {
561	startPos4Translation = atoi(GB_read_char_pntr(gb_codonStart))-1;
562	if (startPos4Translation<0 \|\| startPos4Translation>2) {
563	error = GB_export_errorf("'%s' has invalid codon_start entry %i (allowed: 1..3)", speciesName, startPos4Translation+1);
564	}
565	}
566	else {
567	gMissingCodonStart++;
568	startPos4Translation = 0;
569	}
570	break;
571	}
572	}
573
574	if (!error) {
575	AWT_pro_a_nucs_convert(translationTable, str_SeqData, len, startPos4Translation, false, true, false, 0); // translate
576
577	char *s = new char[len+1];
578	int iDisplayMode = ED4_ROOT->aw_root->awar(AWAR_PROTVIEW_DISPLAY_OPTIONS)->read_int();
579	int i, j;
580
581	if (iDisplayMode == PV_AA_NAME) {
582	char *gc = new char[len+1];
583
584	for (i=0, j=0; i<len && j<len;) {
585	// start from the start pos of aa sequence
586	for (; i<startPos4Translation; ++i) {
587	s[i] = ' ';
588	gc[i] = ' ';
589	}
590
591	char base = str_SeqData[j++];
592	const char *AAname = 0;
593
594	if (base>='A' && base<='Z') AAname = AP_get_protein_name(base);
595	else if (base=='*') AAname = "End";
596	else {
597	for (int m = 0; m<3 && i<len; m++,i++) {
598	s[i] = base;
599	gc[i] = base;
600	}
601	}
602	if (AAname) {
603	unsigned nlen = strlen(AAname);
604	for (unsigned int n = 0; n<nlen && i<len; n++,i++) {
605	s[i] = AAname[n];
606	gc[i] = base;
607	}
608	}
609	}
610
611	gc[i] = '\0';
612	seqTerm->SET_aaColor(gc);
613	delete [] gc;
614	}
615	else {
616	int k = startPos4Translation+1;
617	for (i=0, j=0; i<len; i++) {
618	if ((k==i) && (j<len)) {
619	s[i] = str_SeqData[j++];
620	k += 3;
621	}
622	else s[i] = ' ';
623	}
624	seqTerm->SET_aaColor(NULL);
625	}
626	s[i] = '\0';
627
628	seqTerm->SET_aaSequence(s);
629	delete [] s;
630	}
631	free(str_SeqData);
632	}
633	}
634	}
635	free(defaultAlignment);
636	}
637
638	if (error) aw_message(GBS_global_string("Error: %s", error));
639	}
640
641	static void PV_PrintMissingDBentryInformation() {
642	if (gMissingCodonStart>0) {
643	aw_message(GBS_global_string("WARNING: 'codon start' entry not found in %d of %d species! Using 1st base as codon start...",
644	gMissingCodonStart,
645	(int)GBT_count_marked_species(GLOBAL_gb_main)));
646	gMissingCodonStart = 0;
647	}
648	if (gMissingTransTable>0) {
649	aw_message(GBS_global_string("WARNING: 'translation table' entry not found in %d of %d species! Using selected translation table as a default table...",
650	gMissingTransTable,
651	(int)GBT_count_marked_species(GLOBAL_gb_main)));
652	gMissingTransTable = 0;
653	}
654	}
655
656	static void PV_DisplayAminoAcidNames(AW_root *root) {
657	GB_transaction ta(GLOBAL_gb_main);
658
659	for (ED4_terminal *terminal = ED4_ROOT->root_group_man->get_first_terminal();
660	terminal;
661	terminal = terminal->get_next_terminal())
662	{
663	if (terminal->is_species_seq_terminal()) {
664	const char *speciesName = terminal->to_sequence_terminal()->species_name;
665
666	// we are in the sequence terminal section of a species
667	// walk through all the corresponding ORF terminals for the species and
668	// hide or unhide the terminals based on the display options set by the user
669	for (int i=0; i<PV_AA_Terminals4Species; i++) {
670	// get the corresponding orf_terminal skipping sequence_info terminal
671	terminal = terminal->get_next_terminal()->get_next_terminal();
672	// Make sure it is ORF terminal
673	if (terminal->is_orf_terminal()) {
674	ED4_orf_terminal *orfTerm = terminal->to_orf_terminal();
675	// we are in ORF terminal
676	int aaStartPos = int(orfTerm->GET_aaStartPos());
677	int aaStrandType = int(orfTerm->GET_aaStrandType());
678	// retranslate the genesequence and store it to the orf_terminal
679	TranslateGeneToAminoAcidSequence(root, orfTerm, speciesName, aaStartPos-1, aaStrandType);
680	}
681	}
682	}
683	}
684	// Print missing DB entries
685	PV_PrintMissingDBentryInformation();
686	PV_RefreshWindow(root);
687	}
688
689	static void PV_RefreshDisplay(AW_root *root) {
690	PV_DisplayAminoAcidNames(root);
691	}
692
693	static void PV_RefreshProtViewDisplay(AW_window *aww) {
694	if (gTerminalsCreated) {
695	PV_RefreshDisplay(aww->get_root());
696	}
697	}
698
699	void PV_SequenceUpdate_CB(GB_CB_TYPE gbtype) {
700	if (gbtype==GB_CB_CHANGED &&
701	gTerminalsCreated &&
702	(ED4_ROOT->alignment_type == GB_AT_DNA) &&
703	!gbWritingData)
704	{
705	GB_transaction ta(GLOBAL_gb_main);
706
707	for (ED4_window *win = ED4_ROOT->first_window; win; win = win->next) {
708	ED4_cursor& cursor = win->cursor;
709	if (cursor.in_species_seq_terminal()) {
710	ED4_terminal *cursorTerminal = cursor.owner_of_cursor;
711	char *speciesName = cursorTerminal->to_sequence_terminal()->species_name;
712	for (int i=0; i<PV_AA_Terminals4Species; i++) {
713	// get the corresponding orf_terminal skipping sequence_info terminal
714	// $$$$$ sequence_terminal->sequence_info_terminal->aa_sequence_terminal $$$$$$
715	cursorTerminal = cursorTerminal->get_next_terminal()->get_next_terminal();
716	// Make sure it is ORF terminal
717	if (cursorTerminal->is_orf_terminal()) {
718	ED4_orf_terminal *orfTerm = cursorTerminal->to_orf_terminal();
719	// Get the AA sequence flag - says which strand we are in
720	int aaStartPos = int(orfTerm->GET_aaStartPos());
721	int aaStrandType = int(orfTerm->GET_aaStrandType());
722	// retranslate the genesequence and store it to the orf_terminal
723	TranslateGeneToAminoAcidSequence(ED4_ROOT->aw_root, orfTerm, speciesName, aaStartPos-1, aaStrandType);
724	}
725	}
726	// Print missing DB entries
727	PV_PrintMissingDBentryInformation();
728	PV_RefreshWindow(ED4_ROOT->aw_root);
729	}
730	}
731	}
732	}
733
734	static void PV_AddNewAAseqTerminals(ED4_sequence_terminal seqTerminal, ED4_species_manager speciesManager) {
735	int translationMode = 0;
736	char namebuffer[BUFFERSIZE];
737	for (int i = 0; i<PV_AA_Terminals4Species; i++)
738	{
739	int count = 1;
740	int startPos = 0;
741
742	sprintf(namebuffer, "Sequence_Manager.%ld.%d", ED4_counter, count++);
743	ED4_multi_sequence_manager *multiSeqManager = speciesManager->search_spec_child_rek(ED4_L_MULTI_SEQUENCE)->to_multi_sequence_manager();
744	ED4_sequence_manager *new_SeqManager = new ED4_sequence_manager(namebuffer, 0, 0, 0, 0, multiSeqManager);
745	new_SeqManager->set_property(ED4_P_MOVABLE);
746	multiSeqManager->children->append_member(new_SeqManager);
747
748	ED4_sequence_info_terminal *new_SeqInfoTerminal = 0;
749	if (i<FORWARD_STRANDS)
750	sprintf(namebuffer, "F%d ProteinInfo_Term%ld.%d", i+1, ED4_counter, count++);
751	else if ((i-FORWARD_STRANDS)<COMPLEMENTARY_STRANDS)
752	sprintf(namebuffer, "C%dProteinInfo_Term%ld.%d", (i-FORWARD_STRANDS)+1, ED4_counter, count++);
753	else
754	sprintf(namebuffer, "DBProteinInfo_Term%ld.%d", ED4_counter, count++);
755	new_SeqInfoTerminal = new ED4_sequence_info_terminal(namebuffer, 0, 0, SEQUENCEINFOSIZE, TERMINALHEIGHT, new_SeqManager);
756	new_SeqInfoTerminal->set_property((ED4_properties) (ED4_P_SELECTABLE \| ED4_P_DRAGABLE \| ED4_P_IS_HANDLE));
757	ED4_sequence_info_terminal *seqInfoTerminal = speciesManager->search_spec_child_rek(ED4_L_SEQUENCE_INFO)->to_sequence_info_terminal();
758	new_SeqInfoTerminal->set_links(seqInfoTerminal, seqInfoTerminal);
759	new_SeqManager->children->append_member(new_SeqInfoTerminal);
760
761	sprintf(namebuffer, "AA_Sequence_Term%ld.%d", ED4_counter, count++);
762	ED4_orf_terminal *AA_SeqTerminal = new ED4_orf_terminal(namebuffer, SEQUENCEINFOSIZE, 0, 0, TERMINALHEIGHT, new_SeqManager);
763	AA_SeqTerminal->set_links(seqTerminal, seqTerminal);
764
765	char *speciesName = seqTerminal->species_name;
766	if (i<FORWARD_STRANDS) {
767	startPos = i;
768	translationMode = FORWARD_STRAND;
769	}
770	else if ((i-FORWARD_STRANDS)<COMPLEMENTARY_STRANDS) {
771	startPos = i-FORWARD_STRANDS;
772	translationMode = COMPLEMENTARY_STRAND;
773	}
774	else {
775	startPos = 0;
776	translationMode = DB_FIELD_STRAND;
777	}
778	TranslateGeneToAminoAcidSequence(ED4_ROOT->aw_root, AA_SeqTerminal, speciesName, startPos, translationMode);
779	AA_SeqTerminal->SET_aaSeqFlags(startPos+1, translationMode);
780	new_SeqManager->children->append_member(AA_SeqTerminal);
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(ED4_L_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(ED4_L_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(ED4_L_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
1095	#undef BUFFERSIZE

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

Download in other formats: