Context Navigation

source: tags/svn.1.5.4/EDIT4/ED4_ProteinViewer.cxx

Visit:

Last change on this file was 8359, checked in by westram, 14 years ago
added 'Never ask again' switch to most modal question dialogs. This is a workaround to make it possible to work with macros where modal questions are used. See also #179 added unique IDs to all calls to aw_question / AW_repeated_question::get_answer replaced most calls to aw_popup_ok with aw_message (most of them only worked-around the non-standard way of EDIT4 to show aw_message) added 'Reactivate questions' to all properties menus hardcoded unused default-params from aw_ask_sure, aw_popup_ok + aw_popup_exit
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 56.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_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_AA_sequence_terminal *aaSeqTerminal) {
120	ED4_sequence_manager *seqManager = aaSeqTerminal->get_parent(ED4_L_SEQUENCE)->to_sequence_manager();
121	seqManager->hide_children();
122	}
123
124	static void PV_UnHideTerminal(ED4_AA_sequence_terminal *aaSeqTerminal) {
125	ED4_sequence_manager *seqManager = aaSeqTerminal->get_parent(ED4_L_SEQUENCE)->to_sequence_manager();
126	seqManager->make_children_visible();
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_sequence_terminal()) {
136	ED4_species_manager *speciesManager = terminal->get_parent(ED4_L_SPECIES)->to_species_manager();
137	if (speciesManager && !speciesManager->flag.is_consensus && !speciesManager->flag.is_SAI) {
138	// hide all AA_Sequence terminals
139	for (int i=0; i<PV_AA_Terminals4Species; i++) {
140	// get the corresponding AA_sequence_terminal skipping sequence_info terminal
141	// $$$$$ sequence_terminal->sequence_info_terminal->aa_sequence_terminal $$$$$$
142	terminal = terminal->get_next_terminal()->get_next_terminal();
143	// Make sure it is AA sequence terminal
144	if (terminal->is_aa_sequence_terminal()) {
145	ED4_AA_sequence_terminal *aaSeqTerminal = terminal->to_aa_sequence_terminal();
146	PV_HideTerminal(aaSeqTerminal);
147	}
148	}
149	}
150	}
151	}
152	}
153
154
155	static void PV_ManageTerminalDisplay(AW_root root, ED4_AA_sequence_terminal aaSeqTerminal, long int DispMode) {
156
157	int all, af_1, af_2, af_3, ac_1, ac_2, ac_3, adb;
158	all = root->awar(AWAR_PV_DISPLAY_ALL)->read_int();
159	adb = root->awar(AWAR_PROTVIEW_DEFINED_FIELDS)->read_int();
160	af_1 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_1)->read_int();
161	af_2 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_2)->read_int();
162	af_3 = root->awar(AWAR_PROTVIEW_FORWARD_STRAND_3)->read_int();
163	ac_1 = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1)->read_int();
164	ac_2 = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2)->read_int();
165	ac_3 = root->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3)->read_int();
166
167	int mrk, mf_1, mf_2, mf_3, mc_1, mc_2, mc_3, mdb;
168	mrk = root->awar(AWAR_PV_MARKED)->read_int();
169	mdb = root->awar(AWAR_PV_MARKED_DB)->read_int();
170	mf_1 = root->awar(AWAR_PV_MARKED_FS_1)->read_int();
171	mf_2 = root->awar(AWAR_PV_MARKED_FS_2)->read_int();
172	mf_3 = root->awar(AWAR_PV_MARKED_FS_3)->read_int();
173	mc_1 = root->awar(AWAR_PV_MARKED_CS_1)->read_int();
174	mc_2 = root->awar(AWAR_PV_MARKED_CS_2)->read_int();
175	mc_3 = root->awar(AWAR_PV_MARKED_CS_3)->read_int();
176
177	int sel, sf_1, sf_2, sf_3, sc_1, sc_2, sc_3, sdb;
178	sel = root->awar(AWAR_PV_SELECTED)->read_int();
179	sdb = root->awar(AWAR_PV_SELECTED_DB)->read_int();
180	sf_1 = root->awar(AWAR_PV_SELECTED_FS_1)->read_int();
181	sf_2 = root->awar(AWAR_PV_SELECTED_FS_2)->read_int();
182	sf_3 = root->awar(AWAR_PV_SELECTED_FS_3)->read_int();
183	sc_1 = root->awar(AWAR_PV_SELECTED_CS_1)->read_int();
184	sc_2 = root->awar(AWAR_PV_SELECTED_CS_2)->read_int();
185	sc_3 = root->awar(AWAR_PV_SELECTED_CS_3)->read_int();
186
187	int cur, cf_1, cf_2, cf_3, cc_1, cc_2, cc_3, cdb;
188	cur = root->awar(AWAR_PV_CURSOR)->read_int();
189	cdb = root->awar(AWAR_PV_CURSOR_DB)->read_int();
190	cf_1 = root->awar(AWAR_PV_CURSOR_FS_1)->read_int();
191	cf_2 = root->awar(AWAR_PV_CURSOR_FS_2)->read_int();
192	cf_3 = root->awar(AWAR_PV_CURSOR_FS_3)->read_int();
193	cc_1 = root->awar(AWAR_PV_CURSOR_CS_1)->read_int();
194	cc_2 = root->awar(AWAR_PV_CURSOR_CS_2)->read_int();
195	cc_3 = root->awar(AWAR_PV_CURSOR_CS_3)->read_int();
196
197	// Get the AA sequence flag - says which strand we are in
198	int aaStrandType = int(aaSeqTerminal->GET_aaStrandType());
199	// Check the display options and make visible or hide the AA seq terminal
200	switch (aaStrandType)
201	{
202	case FORWARD_STRAND:
203	{
204	int aaStartPos = int(aaSeqTerminal->GET_aaStartPos());
205	switch (aaStartPos) {
206	case 1:
207	switch (DispMode) {
208	case PV_ALL: (all && af_1) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
209	case PV_MARKED: (mrk && mf_1) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
210	case PV_SELECTED: (sel && sf_1) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
211	case PV_CURSOR: (cur && cf_1) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
212	}
213	break;
214	case 2:
215	switch (DispMode) {
216	case PV_ALL: (all && af_2) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
217	case PV_MARKED: (mrk && mf_2) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
218	case PV_SELECTED: (sel && sf_2) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
219	case PV_CURSOR: (cur && cf_2) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
220	}
221	break;
222	case 3:
223	switch (DispMode) {
224	case PV_ALL: (all && af_3) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
225	case PV_MARKED: (mrk && mf_3) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
226	case PV_SELECTED: (sel && sf_3) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
227	case PV_CURSOR: (cur && cf_3) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
228	}
229	break;
230	}
231	}
232	break;
233	case COMPLEMENTARY_STRAND:
234	{
235	int aaStartPos = int(aaSeqTerminal->GET_aaStartPos());
236	switch (aaStartPos) {
237	case 1:
238	switch (DispMode) {
239	case PV_ALL: (all && ac_1) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
240	case PV_MARKED: (mrk && mc_1) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
241	case PV_SELECTED: (sel && sc_1) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
242	case PV_CURSOR: (cur && cc_1) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
243	}
244	break;
245	case 2:
246	switch (DispMode) {
247	case PV_ALL: (all && ac_2) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
248	case PV_MARKED: (mrk && mc_2) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
249	case PV_SELECTED: (sel && sc_2) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
250	case PV_CURSOR: (cur && cc_2) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
251	}
252	break;
253	case 3:
254	switch (DispMode) {
255	case PV_ALL: (all && ac_3) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
256	case PV_MARKED: (mrk && mc_3) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
257	case PV_SELECTED: (sel && sc_3) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
258	case PV_CURSOR: (cur && cc_3) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
259	}
260	break;
261	}
262	}
263	break;
264	case DB_FIELD_STRAND:
265	switch (DispMode) {
266	case PV_ALL: (all && adb) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
267	case PV_MARKED: (mrk && mdb) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
268	case PV_SELECTED: (sel && sdb) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
269	case PV_CURSOR: (cur && cdb) ? PV_UnHideTerminal(aaSeqTerminal) : PV_HideTerminal(aaSeqTerminal); break;
270	}
271	break;
272	}
273	}
274
275	static void PV_ManageTerminals(AW_root *root) {
276
277	// First Hide all AA_sequence Terminals
278	PV_HideAllTerminals();
279
280	int dispAll = root->awar(AWAR_PV_DISPLAY_ALL)->read_int();
281	if (dispAll)
282	{
283	ED4_terminal *terminal = 0;
284	for (terminal = ED4_ROOT->root_group_man->get_first_terminal();
285	terminal;
286	terminal = terminal->get_next_terminal())
287	{
288	if (terminal->is_sequence_terminal()) {
289	ED4_species_manager *speciesManager = terminal->get_parent(ED4_L_SPECIES)->to_species_manager();
290	if (speciesManager && !speciesManager->flag.is_consensus && !speciesManager->flag.is_SAI) {
291	// we are in the sequence terminal section of a species
292	// walk through all the corresponding AA sequence terminals for the species and
293	// hide or unhide the terminals based on the display options set by the user
294	for (int i=0; i<PV_AA_Terminals4Species; i++) {
295	// get the corresponding AA_sequence_terminal skipping sequence_info terminal
296	// $$$$$ sequence_terminal->sequence_info_terminal->aa_sequence_terminal $$$$$$
297	terminal = terminal->get_next_terminal()->get_next_terminal();
298	// Make sure it is AA sequence terminal
299	if (terminal->is_aa_sequence_terminal()) {
300	ED4_AA_sequence_terminal *aaSeqTerminal = terminal->to_aa_sequence_terminal();
301	PV_ManageTerminalDisplay(root, aaSeqTerminal, PV_ALL);
302	}
303	}
304	}
305	}
306	}
307	}
308
309	int dispMarked = root->awar(AWAR_PV_MARKED)->read_int();
310	if (dispMarked)
311	{
312	GB_transaction dummy(GLOBAL_gb_main);
313	int marked = GBT_count_marked_species(GLOBAL_gb_main);
314	if (marked) {
315	GBDATA *gbSpecies;
316	for (gbSpecies = GBT_first_marked_species(GLOBAL_gb_main);
317	gbSpecies;
318	gbSpecies = GBT_next_marked_species(gbSpecies))
319	{
320	ED4_species_name_terminal *spNameTerm = ED4_find_species_name_terminal(GBT_read_name(gbSpecies));
321	if (spNameTerm && spNameTerm->is_species_name_terminal())
322	{
323	ED4_terminal *terminal = spNameTerm->corresponding_sequence_terminal();
324	for (int i=0; i<PV_AA_Terminals4Species; i++) {
325	// get the corresponding AA_sequence_terminal skipping sequence_info terminal
326	// $$$$$ sequence_terminal->sequence_info_terminal->aa_sequence_terminal $$$$$$
327	terminal = terminal->get_next_terminal()->get_next_terminal();
328	// Make sure it is AA sequence terminal
329	if (terminal->is_aa_sequence_terminal()) {
330	ED4_AA_sequence_terminal *aaSeqTerminal = terminal->to_aa_sequence_terminal();
331	PV_ManageTerminalDisplay(root, aaSeqTerminal, PV_MARKED);
332	}
333	}
334	}
335	}
336	}
337	}
338
339	int dispSelected = root->awar(AWAR_PV_SELECTED)->read_int();
340	if (dispSelected)
341	{
342	ED4_terminal *terminal = 0;
343	for (terminal = ED4_ROOT->root_group_man->get_first_terminal();
344	terminal;
345	terminal = terminal->get_next_terminal())
346	{
347	if (terminal->is_sequence_terminal()) {
348	ED4_species_manager *speciesManager = terminal->get_parent(ED4_L_SPECIES)->to_species_manager();
349	if (speciesManager && !speciesManager->flag.is_consensus && !speciesManager->flag.is_SAI) {
350	// we are in the sequence terminal section of a species
351	// walk through all the corresponding AA sequence terminals for the species and
352	// hide or unhide the terminals based on the display options set by the user
353	ED4_species_name_terminal *speciesNameTerm = speciesManager->search_spec_child_rek(ED4_L_SPECIES_NAME)->to_species_name_terminal();
354	if (speciesNameTerm->flag.selected) {
355	for (int i=0; i<PV_AA_Terminals4Species; i++) {
356	// get the corresponding AA_sequence_terminal skipping sequence_info terminal
357	// $$$$$ sequence_terminal->sequence_info_terminal->aa_sequence_terminal $$$$$$
358	terminal = terminal->get_next_terminal()->get_next_terminal();
359	// Make sure it is AA sequence terminal
360	if (terminal->is_aa_sequence_terminal()) {
361	ED4_AA_sequence_terminal *aaSeqTerminal = terminal->to_aa_sequence_terminal();
362	PV_ManageTerminalDisplay(root, aaSeqTerminal, PV_SELECTED);
363	}
364	}
365	}
366	}
367	}
368	}
369	}
370
371	int dispAtCursor = root->awar(AWAR_PV_CURSOR)->read_int();
372	if (dispAtCursor)
373	{
374	// Display Only Terminals Corresponding To The Cursor Position in the multiple alignment
375	ED4_cursor *cursor = &ED4_ROOT->get_ed4w()->cursor;
376	if (cursor->owner_of_cursor) {
377	// Get The Cursor Terminal And The Corresponding Aa_Sequence Terminals And Set The Display Options
378	ED4_terminal *cursorTerminal = cursor->owner_of_cursor->to_terminal();
379	if (!cursorTerminal->parent->parent->flag.is_consensus) {
380	for (int i=0; i<PV_AA_Terminals4Species; i++) {
381	// get the corresponding AA_sequence_terminal skipping sequence_info terminal
382	// $$$$$ sequence_terminal->sequence_info_terminal->aa_sequence_terminal $$$$$$
383	cursorTerminal = cursorTerminal->get_next_terminal()->get_next_terminal();
384	// Make sure it is AA sequence terminal
385	if (cursorTerminal->is_aa_sequence_terminal()) {
386	ED4_AA_sequence_terminal *aaSeqTerminal = cursorTerminal->to_aa_sequence_terminal();
387	PV_ManageTerminalDisplay(root, aaSeqTerminal, PV_CURSOR);
388	}
389	}
390	}
391	}
392	}
393	}
394
395	void PV_RefreshWindow(AW_root *root) {
396	// Manage the terminals showing only those selected by the user
397	if (gTerminalsCreated) {
398	PV_ManageTerminals(root);
399	}
400	// Refresh all windows
401	ED4_refresh_window(0, 0, 0);
402	ED4_ROOT->refresh_all_windows(0);
403	}
404
405	static GB_ERROR PV_ComplementarySequence(char *sequence) {
406	char T_or_U;
407	GB_ERROR error = GBT_determine_T_or_U(ED4_ROOT->alignment_type, &T_or_U, "complement");
408	if (!error) {
409	int seqLen = strlen(sequence);
410	char complementarySeq = GBT_complementNucSequence((const char) sequence, seqLen, T_or_U);
411
412	strcpy(sequence, complementarySeq);
413	free(complementarySeq);
414	}
415	return error;
416	}
417
418	static void PV_WriteTranslatedSequenceToDB(ED4_AA_sequence_terminal aaSeqTerm, char spName) {
419	GB_ERROR error = GB_begin_transaction(GLOBAL_gb_main);
420	GBDATA *gb_species = GBT_find_species(GLOBAL_gb_main, spName);
421	if (!gb_species) error = GBS_global_string("Species '%s' does not exist", spName);
422	else {
423	char *defaultAlignment = GBT_get_default_alignment(GLOBAL_gb_main);
424	if (!defaultAlignment) error = GB_await_error();
425	else {
426	GBDATA *gb_SeqData = GBT_read_sequence(gb_species, defaultAlignment);
427	if (!gb_SeqData) {
428	error = GB_get_error();
429	if (!error) error = GBS_global_string("Species '%s' has no data in alignment '%s'", spName, defaultAlignment);
430	}
431	else {
432	char *str_SeqData = GB_read_string(gb_SeqData);
433	if (!str_SeqData) error = GB_await_error();
434	else {
435	int aaStrandType = int(aaSeqTerm->GET_aaStrandType());
436	if (aaStrandType == COMPLEMENTARY_STRAND) {
437	GB_ERROR compl_err = PV_ComplementarySequence(str_SeqData);
438	if (compl_err) error = GBS_global_string("Failed to calc complementary strand (Reason: %s)", compl_err);
439	}
440
441	if (!error) {
442	char newAlignmentName[100];
443	int aaStartPos = int(aaSeqTerm->GET_aaStartPos());
444
445	switch (aaStrandType) {
446	case FORWARD_STRAND: sprintf(newAlignmentName, "ali_pro_ProtView_forward_start_pos_%ld", (long)aaStartPos); break;
447	case COMPLEMENTARY_STRAND: sprintf(newAlignmentName, "ali_pro_ProtView_complementary_start_pos_%ld", (long)aaStartPos); break;
448	case DB_FIELD_STRAND: sprintf(newAlignmentName, "ali_pro_ProtView_database_field_start_pos_%ld", (long)aaStartPos); break;
449	}
450
451	int len = GB_read_string_count(gb_SeqData);
452	AWT_pro_a_nucs_convert(AWT_default_protein_type(), str_SeqData, len, aaStartPos-1, false, true, false, 0);
453
454	// Create alignment data to store the translated sequence
455	GBDATA *gb_presets = GB_search(GLOBAL_gb_main, "presets", GB_CREATE_CONTAINER);
456	GBDATA *gb_alignment_exists = GB_find_string(gb_presets, "alignment_name", newAlignmentName, GB_IGNORE_CASE, SEARCH_GRANDCHILD);
457	GBDATA *gb_new_alignment = 0;
458
459	if (gb_alignment_exists) {
460	int skip_sp = 0;
461	char *question = 0;
462	GBDATA *gb_seq_data = GBT_read_sequence(gb_species, newAlignmentName);
463	if (gb_seq_data) {
464	e4_assert(ASKtoOverWriteData);
465	question = GBS_global_string_copy("\"%s\" contain data in the alignment \"%s\"!", spName, newAlignmentName);
466	skip_sp = ASKtoOverWriteData->get_answer("overwrite_translated", question, "Overwrite, Skip Species", "all", false);
467	}
468	if (skip_sp) {
469	error = GBS_global_string_copy("%s You chose to skip this Species!", question);
470	}
471	else {
472	gb_new_alignment = GBT_get_alignment(GLOBAL_gb_main, newAlignmentName);
473	if (!gb_new_alignment) error = GB_await_error();
474	}
475	free(question);
476	}
477	else {
478	long aliLen = GBT_get_alignment_len(GLOBAL_gb_main, defaultAlignment);
479	gb_new_alignment = GBT_create_alignment(GLOBAL_gb_main, newAlignmentName, aliLen/3+1, 0, 1, "ami");
480
481	if (!gb_new_alignment) error = GB_await_error();
482	else giNewAlignments++;
483	}
484
485	if (!error) {
486	GBDATA *gb_ProSeqData = GBT_add_data(gb_species, newAlignmentName, "data", GB_STRING);
487	if (!gb_ProSeqData) error = GB_await_error();
488	else error = GB_write_string(gb_ProSeqData, str_SeqData);
489	}
490
491	if (!error) error = GBT_check_data(GLOBAL_gb_main, 0);
492	}
493
494	free(str_SeqData);
495	}
496	}
497	free(defaultAlignment);
498	}
499	}
500	GB_end_transaction_show_error(GLOBAL_gb_main, error, aw_message);
501	}
502
503	static void PV_SaveData(AW_window /aww*/) {
504	// IDEA:
505	// 1. walk thru the AA_sequence terminals
506	// 2. check the visibility status
507	// 3. select only the visible terminals
508	// 4. get the corresponding species name
509	// 5. translate the sequence
510	// 6. write to the database
511	gbWritingData = true;
512	if (gTerminalsCreated) {
513	ASKtoOverWriteData = new AW_repeated_question();
514
515	ED4_terminal *terminal = 0;
516	for (terminal = ED4_ROOT->root_group_man->get_first_terminal();
517	terminal;
518	terminal = terminal->get_next_terminal())
519	{
520	if (terminal->is_sequence_terminal()) {
521	char *speciesName = terminal->to_sequence_terminal()->species_name;
522	ED4_species_manager *speciesManager = terminal->get_parent(ED4_L_SPECIES)->to_species_manager();
523	if (speciesManager && !speciesManager->flag.is_consensus && !speciesManager->flag.is_SAI) {
524	for (int i=0; i<PV_AA_Terminals4Species; i++) {
525	// get the corresponding AA_sequence_terminal skipping sequence_info terminal
526	terminal = terminal->get_next_terminal()->get_next_terminal();
527	// Make sure it is AA sequence terminal
528	if (terminal->is_aa_sequence_terminal()) {
529	ED4_AA_sequence_terminal *aaSeqTerminal = terminal->to_aa_sequence_terminal();
530	ED4_base base = (ED4_base)aaSeqTerminal;
531	if (!base->flag.hidden) {
532	PV_WriteTranslatedSequenceToDB(aaSeqTerminal, speciesName);
533	}
534	}
535	}
536	}
537	}
538	}
539	if (giNewAlignments>0) {
540	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);
541	aw_message(msg);
542	free(msg);
543
544	giNewAlignments = 0;
545	}
546	}
547	gbWritingData = false;
548	}
549
550	static void TranslateGeneToAminoAcidSequence(AW_root * /* root /, ED4_AA_sequence_terminal seqTerm, char *speciesName, int startPos4Translation, int translationMode) {
551	// This function translates gene sequence to aminoacid sequence and stores translation into the respective AA_Sequence_terminal
552	GB_ERROR error = NULL;
553	GBDATA *gb_species = GBT_find_species(GLOBAL_gb_main, speciesName);
554	if (!gb_species) error = GBS_global_string("Species '%s' does not exist", speciesName);
555	else {
556	char *defaultAlignment = GBT_get_default_alignment(GLOBAL_gb_main);
557	if (!defaultAlignment) error = GB_await_error();
558	else {
559	GBDATA *gb_SeqData = GBT_read_sequence(gb_species, defaultAlignment);
560	if (!gb_SeqData) {
561	error = GB_get_error();
562	if (!error) error = GBS_global_string("Species '%s' has no data in alignment '%s'", speciesName, defaultAlignment);
563	}
564	else {
565	e4_assert(startPos4Translation>=0 && startPos4Translation<=2);
566
567	char *str_SeqData = GB_read_string(gb_SeqData);
568	if (!str_SeqData) error = GB_await_error();
569	else {
570	int len = GB_read_string_count(gb_SeqData);
571	int translationTable = AWT_default_protein_type(GLOBAL_gb_main);
572
573	switch (translationMode) {
574	case FORWARD_STRAND:
575	break;
576
577	case COMPLEMENTARY_STRAND: {
578	// convert sequence to the complementary sequence
579	GB_ERROR compl_err = PV_ComplementarySequence(str_SeqData);
580	if (compl_err) error = GBS_global_string("Failed to calc complementary strand for '%s' (Reason: %s)", speciesName, compl_err);
581	break;
582	}
583	case DB_FIELD_STRAND: {
584	// for use database field options - fetch codon start and translation table from the respective species data
585	GBDATA *gb_translTable = GB_entry(gb_species, "transl_table");
586	if (gb_translTable) {
587	int sp_embl_table = atoi(GB_read_char_pntr(gb_translTable));
588	translationTable = AWT_embl_transl_table_2_arb_code_nr(sp_embl_table);
589	}
590	else { // use selected translation table as default (if 'transl_table' field is missing)
591	gMissingTransTable++;
592	}
593	GBDATA *gb_codonStart = GB_entry(gb_species, "codon_start");
594	if (gb_codonStart) {
595	startPos4Translation = atoi(GB_read_char_pntr(gb_codonStart))-1;
596	if (startPos4Translation<0 \|\| startPos4Translation>2) {
597	error = GB_export_errorf("'%s' has invalid codon_start entry %i (allowed: 1..3)", speciesName, startPos4Translation+1);
598	}
599	}
600	else {
601	gMissingCodonStart++;
602	startPos4Translation = 0;
603	}
604	break;
605	}
606	}
607
608	if (!error) {
609	AWT_pro_a_nucs_convert(translationTable, str_SeqData, len, startPos4Translation, false, true, false, 0); // translate
610
611	char *s = new char[len+1];
612	int iDisplayMode = ED4_ROOT->aw_root->awar(AWAR_PROTVIEW_DISPLAY_OPTIONS)->read_int();
613	int i, j;
614
615	if (iDisplayMode == PV_AA_NAME) {
616	char *gc = new char[len+1];
617
618	for (i=0, j=0; i<len && j<len;) {
619	// start from the start pos of aa sequence
620	for (; i<startPos4Translation; ++i) {
621	s[i] = ' ';
622	gc[i] = ' ';
623	}
624
625	char base = str_SeqData[j++];
626	const char *AAname = 0;
627
628	if (base>='A' && base<='Z') AAname = AP_get_protein_name(base);
629	else if (base=='*') AAname = "End";
630	else {
631	for (int m = 0; m<3 && i<len; m++,i++) {
632	s[i] = base;
633	gc[i] = base;
634	}
635	}
636	if (AAname) {
637	unsigned nlen = strlen(AAname);
638	for (unsigned int n = 0; n<nlen && i<len; n++,i++) {
639	s[i] = AAname[n];
640	gc[i] = base;
641	}
642	}
643	}
644
645	gc[i] = '\0';
646	seqTerm->SET_aaColor(gc);
647	delete [] gc;
648	}
649	else {
650	int k = startPos4Translation+1;
651	for (i=0, j=0; i<len; i++) {
652	if ((k==i) && (j<len)) {
653	s[i] = str_SeqData[j++];
654	k += 3;
655	}
656	else s[i] = ' ';
657	}
658	seqTerm->SET_aaColor(NULL);
659	}
660	s[i] = '\0';
661
662	seqTerm->SET_aaSequence(s);
663	delete [] s;
664	}
665	free(str_SeqData);
666	}
667	}
668	}
669	free(defaultAlignment);
670	}
671
672	if (error) aw_message(GBS_global_string("Error: %s", error));
673	}
674
675	static void PV_PrintMissingDBentryInformation() {
676	if (gMissingCodonStart>0) {
677	aw_message(GBS_global_string("WARNING: 'codon start' entry not found in %d of %d species! Using 1st base as codon start...",
678	gMissingCodonStart,
679	(int)GBT_count_marked_species(GLOBAL_gb_main)));
680	gMissingCodonStart = 0;
681	}
682	if (gMissingTransTable>0) {
683	aw_message(GBS_global_string("WARNING: 'translation table' entry not found in %d of %d species! Using selected translation table as a default table...",
684	gMissingTransTable,
685	(int)GBT_count_marked_species(GLOBAL_gb_main)));
686	gMissingTransTable = 0;
687	}
688	}
689
690	static void PV_DisplayAminoAcidNames(AW_root *root) {
691	GB_transaction dummy(GLOBAL_gb_main);
692
693	ED4_terminal *terminal = 0;
694	for (terminal = ED4_ROOT->root_group_man->get_first_terminal();
695	terminal;
696	terminal = terminal->get_next_terminal())
697	{
698	if (terminal->is_sequence_terminal()) {
699	ED4_sequence_terminal *seqTerminal = terminal->to_sequence_terminal();
700	char *speciesName = seqTerminal->species_name;
701
702	ED4_species_manager *speciesManager = terminal->get_parent(ED4_L_SPECIES)->to_species_manager();
703	if (speciesManager && !speciesManager->flag.is_consensus && !speciesManager->flag.is_SAI)
704	{
705	// we are in the sequence terminal section of a species
706	// walk through all the corresponding AA sequence terminals for the species and
707	// hide or unhide the terminals based on the display options set by the user
708	for (int i=0; i<PV_AA_Terminals4Species; i++)
709	{
710	// get the corresponding AA_sequence_terminal skipping sequence_info terminal
711	terminal = terminal->get_next_terminal()->get_next_terminal();
712	// Make sure it is AA sequence terminal
713	if (terminal->is_aa_sequence_terminal()) {
714	ED4_AA_sequence_terminal *aaSeqTerminal = terminal->to_aa_sequence_terminal();
715	// we are in AA sequence terminal
716	int aaStartPos = int(aaSeqTerminal->GET_aaStartPos());
717	int aaStrandType = int(aaSeqTerminal->GET_aaStrandType());
718	// retranslate the genesequence and store it to the AA_sequence_terminal
719	TranslateGeneToAminoAcidSequence(root, aaSeqTerminal, speciesName, aaStartPos-1, aaStrandType);
720	}
721	}
722	}
723	}
724	}
725	// Print missing DB entries
726	PV_PrintMissingDBentryInformation();
727	PV_RefreshWindow(root);
728	}
729
730	static void PV_RefreshDisplay(AW_root *root) {
731	PV_DisplayAminoAcidNames(root);
732	}
733
734	static void PV_RefreshProtViewDisplay(AW_window *aww) {
735	if (gTerminalsCreated) {
736	PV_RefreshDisplay(aww->get_root());
737	}
738	}
739
740	void PV_AA_SequenceUpdate_CB(GB_CB_TYPE gbtype)
741	{
742	if (gbtype==GB_CB_CHANGED &&
743	gTerminalsCreated &&
744	(ED4_ROOT->alignment_type == GB_AT_DNA) &&
745	!gbWritingData)
746	{
747	GB_transaction dummy(GLOBAL_gb_main);
748
749	ED4_cursor *cursor = &ED4_ROOT->get_ed4w()->cursor;
750	if (cursor->owner_of_cursor) {
751	ED4_terminal *cursorTerminal = cursor->owner_of_cursor->to_terminal();
752
753	if (!cursorTerminal->parent->parent->flag.is_consensus)
754	{
755	ED4_sequence_terminal *seqTerminal = cursorTerminal->to_sequence_terminal();
756	char *speciesName = seqTerminal->species_name;
757
758	for (int i=0; i<PV_AA_Terminals4Species; i++)
759	{
760	// get the corresponding AA_sequence_terminal skipping sequence_info terminal
761	// $$$$$ sequence_terminal->sequence_info_terminal->aa_sequence_terminal $$$$$$
762	cursorTerminal = cursorTerminal->get_next_terminal()->get_next_terminal();
763	// Make sure it is AA sequence terminal
764	if (cursorTerminal->is_aa_sequence_terminal()) {
765	ED4_AA_sequence_terminal *aaSeqTerminal = cursorTerminal->to_aa_sequence_terminal();
766	// Get the AA sequence flag - says which strand we are in
767	int aaStartPos = int(aaSeqTerminal->GET_aaStartPos());
768	int aaStrandType = int(aaSeqTerminal->GET_aaStrandType());
769	// retranslate the genesequence and store it to the AA_sequence_terminal
770	TranslateGeneToAminoAcidSequence(ED4_ROOT->aw_root, aaSeqTerminal, speciesName, aaStartPos-1, aaStrandType);
771	}
772	}
773	// Print missing DB entries
774	PV_PrintMissingDBentryInformation();
775	PV_RefreshWindow(ED4_ROOT->aw_root);
776	}
777	}
778	}
779	}
780
781	static void PV_AddNewAAseqTerminals(ED4_sequence_terminal seqTerminal, ED4_species_manager speciesManager) {
782	int translationMode = 0;
783	char namebuffer[BUFFERSIZE];
784	for (int i = 0; i<PV_AA_Terminals4Species; i++)
785	{
786	int count = 1;
787	int startPos = 0;
788
789	sprintf(namebuffer, "Sequence_Manager.%ld.%d", ED4_counter, count++);
790	ED4_multi_sequence_manager *multiSeqManager = speciesManager->search_spec_child_rek(ED4_L_MULTI_SEQUENCE)->to_multi_sequence_manager();
791	ED4_sequence_manager *new_SeqManager = new ED4_sequence_manager(namebuffer, 0, 0, 0, 0, multiSeqManager);
792	new_SeqManager->set_properties(ED4_P_MOVABLE);
793	multiSeqManager->children->append_member(new_SeqManager);
794
795	ED4_sequence_info_terminal *new_SeqInfoTerminal = 0;
796	if (i<FORWARD_STRANDS)
797	sprintf(namebuffer, "F%d ProteinInfo_Term%ld.%d", i+1, ED4_counter, count++);
798	else if ((i-FORWARD_STRANDS)<COMPLEMENTARY_STRANDS)
799	sprintf(namebuffer, "C%dProteinInfo_Term%ld.%d", (i-FORWARD_STRANDS)+1, ED4_counter, count++);
800	else
801	sprintf(namebuffer, "DBProteinInfo_Term%ld.%d", ED4_counter, count++);
802	new_SeqInfoTerminal = new ED4_sequence_info_terminal(namebuffer, 0, 0, SEQUENCEINFOSIZE, TERMINALHEIGHT, new_SeqManager);
803	new_SeqInfoTerminal->set_properties((ED4_properties) (ED4_P_SELECTABLE \| ED4_P_DRAGABLE \| ED4_P_IS_HANDLE));
804	ED4_sequence_info_terminal *seqInfoTerminal = speciesManager->search_spec_child_rek(ED4_L_SEQUENCE_INFO)->to_sequence_info_terminal();
805	new_SeqInfoTerminal->set_links(seqInfoTerminal, seqInfoTerminal);
806	new_SeqManager->children->append_member(new_SeqInfoTerminal);
807
808	ED4_AA_sequence_terminal *AA_SeqTerminal = 0;
809	sprintf(namebuffer, "AA_Sequence_Term%ld.%d", ED4_counter, count++);
810	AA_SeqTerminal = new ED4_AA_sequence_terminal(namebuffer, SEQUENCEINFOSIZE, 0, 0, TERMINALHEIGHT, new_SeqManager);
811	AA_SeqTerminal->set_links(seqTerminal, seqTerminal);
812
813	char *speciesName = seqTerminal->species_name;
814	if (i<FORWARD_STRANDS) {
815	startPos = i;
816	translationMode = FORWARD_STRAND;
817	}
818	else if ((i-FORWARD_STRANDS)<COMPLEMENTARY_STRANDS) {
819	startPos = i-FORWARD_STRANDS;
820	translationMode = COMPLEMENTARY_STRAND;
821	}
822	else {
823	startPos = 0;
824	translationMode = DB_FIELD_STRAND;
825	}
826	TranslateGeneToAminoAcidSequence(ED4_ROOT->aw_root, AA_SeqTerminal, speciesName, startPos, translationMode);
827	AA_SeqTerminal->SET_aaSeqFlags(startPos+1, translationMode);
828	new_SeqManager->children->append_member(AA_SeqTerminal);
829
830	ED4_counter++;
831
832	new_SeqManager->resize_requested_by_child();
833	}
834	}
835
836	void PV_AddCorrespondingAAseqTerminals(ED4_species_name_terminal *spNameTerm) {
837	if (gTerminalsCreated) {
838	if (spNameTerm && spNameTerm->is_species_name_terminal())
839	{
840	ED4_sequence_terminal *seqTerminal = spNameTerm->corresponding_sequence_terminal()->to_sequence_terminal();
841	ED4_species_manager *speciesManager = spNameTerm->get_parent(ED4_L_SPECIES)->to_species_manager();
842	PV_AddNewAAseqTerminals(seqTerminal, speciesManager);
843	PV_RefreshWindow(ED4_ROOT->aw_root);
844	}
845	}
846	}
847
848	void PV_AddAAseqTerminalsToLoadedSpecies() {
849	if (gTerminalsCreated) {
850	GB_transaction dummy(GLOBAL_gb_main);
851	int marked = GBT_count_marked_species(GLOBAL_gb_main);
852	if (marked) {
853	GBDATA *gbSpecies;
854	for (gbSpecies = GBT_first_marked_species(GLOBAL_gb_main);
855	gbSpecies;
856	gbSpecies = GBT_next_marked_species(gbSpecies))
857	{
858	const char *spName = GBT_read_name(gbSpecies);
859	cout<<marked--<<". "<<spName<<endl;
860	ED4_species_name_terminal *spNameTerm = ED4_find_species_name_terminal(spName);
861	if (spNameTerm && spNameTerm->is_species_name_terminal())
862	{
863	ED4_terminal *terminal = spNameTerm->corresponding_sequence_terminal();
864	// $$$ If next terminal is species_name terminal => corresponding AA seq terminal doesn't exist ==> create one $$$
865	terminal = terminal->get_next_terminal();
866	if (terminal->is_species_name_terminal() \|\| terminal->is_spacer_terminal())
867	{
868	ED4_sequence_terminal *seqTerminal = spNameTerm->corresponding_sequence_terminal()->to_sequence_terminal();
869	ED4_species_manager *speciesManager = spNameTerm->get_parent(ED4_L_SPECIES)->to_species_manager();
870	PV_AddNewAAseqTerminals(seqTerminal, speciesManager);
871	}
872	}
873	}
874	PV_RefreshWindow(ED4_ROOT->aw_root);
875	}
876	}
877	}
878
879	static void PV_CreateAllTerminals(AW_root *root) {
880	// 1. Get the species terminal pointer
881	// 2. Append the second terminal
882	// 3. resize the multi-species manager
883	// 4. refresh all the terminals including new appended terminals
884
885	// Look for already created terminals, if found do nothing, otherwise, create
886	// new terminals and set gTerminalsCreated to true
887	bool bTerminalsFound = PV_LookForNewTerminals(root);
888	// if terminals are already created then do nothing exit the function
889	if (bTerminalsFound) return;
890
891	GB_transaction dummy(GLOBAL_gb_main);
892
893	// Number of AA sequence terminals to be created = 3 forward strands + 3 complementary strands + 1 DB field strand
894	// totally 7 strands has to be created
895	int aaTerminalsToBeCreated = FORWARD_STRANDS + COMPLEMENTARY_STRANDS + DB_FIELD_STRANDS;
896	PV_AA_Terminals4Species = aaTerminalsToBeCreated;
897
898	ED4_terminal *terminal = 0;
899	for (terminal = ED4_ROOT->root_group_man->get_first_terminal();
900	terminal;
901	terminal = terminal->get_next_terminal())
902	{
903	if (terminal->is_sequence_terminal()) {
904	ED4_sequence_terminal *seqTerminal = terminal->to_sequence_terminal();
905	if (seqTerminal->species_name)
906	{
907	ED4_species_manager *speciesManager = terminal->get_parent(ED4_L_SPECIES)->to_species_manager();
908	if (speciesManager && !speciesManager->flag.is_consensus && !speciesManager->flag.is_SAI)
909	{
910	PV_AddNewAAseqTerminals(seqTerminal, speciesManager);
911	}
912	}
913	}
914	}
915	ED4_ROOT->main_manager->update_info.set_resize(1);
916	ED4_ROOT->main_manager->resize_requested_by_parent();
917
918	gTerminalsCreated = true;
919
920	// Print missing DB entries
921	PV_PrintMissingDBentryInformation();
922	}
923
924	void PV_CallBackFunction(AW_root *root) {
925	// Create New Terminals If Aminoacid Sequence Terminals Are Not Created
926	if (!gTerminalsCreated) {
927	// AWAR_PROTEIN_TYPE is not initialized (if called from ED4_main before creating proteinViewer window)
928	// so, initialize it here
929	root->awar_int(AWAR_PROTEIN_TYPE, AWAR_PROTEIN_TYPE_bacterial_code_index, GLOBAL_gb_main);
930	PV_CreateAllTerminals(root);
931	}
932
933	PV_RefreshWindow(root);
934	}
935
936	// --------------------------------------------------------------------------------
937	// Binding callback function to the AWARS
938	// --------------------------------------------------------------------------------
939	static void PV_AddCallBacks(AW_root *awr) {
940
941	awr->awar(AWAR_PV_DISPLAY_ALL)->add_callback(PV_CallBackFunction);
942	awr->awar(AWAR_PROTVIEW_FORWARD_STRAND_1)->add_callback(PV_CallBackFunction);
943	awr->awar(AWAR_PROTVIEW_FORWARD_STRAND_2)->add_callback(PV_CallBackFunction);
944	awr->awar(AWAR_PROTVIEW_FORWARD_STRAND_3)->add_callback(PV_CallBackFunction);
945	awr->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1)->add_callback(PV_CallBackFunction);
946	awr->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2)->add_callback(PV_CallBackFunction);
947	awr->awar(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3)->add_callback(PV_CallBackFunction);
948	awr->awar(AWAR_PROTVIEW_DEFINED_FIELDS)->add_callback(PV_CallBackFunction);
949
950	awr->awar(AWAR_PROTVIEW_DISPLAY_OPTIONS)->add_callback(PV_RefreshDisplay);
951	awr->awar(AWAR_SPECIES_NAME)->add_callback(PV_CallBackFunction);
952
953	awr->awar(AWAR_PV_SELECTED)->add_callback(PV_CallBackFunction);
954	awr->awar(AWAR_PV_SELECTED_DB)->add_callback(PV_CallBackFunction);
955	awr->awar(AWAR_PV_SELECTED_FS_1)->add_callback(PV_CallBackFunction);
956	awr->awar(AWAR_PV_SELECTED_FS_2)->add_callback(PV_CallBackFunction);
957	awr->awar(AWAR_PV_SELECTED_FS_3)->add_callback(PV_CallBackFunction);
958	awr->awar(AWAR_PV_SELECTED_CS_1)->add_callback(PV_CallBackFunction);
959	awr->awar(AWAR_PV_SELECTED_CS_2)->add_callback(PV_CallBackFunction);
960	awr->awar(AWAR_PV_SELECTED_CS_3)->add_callback(PV_CallBackFunction);
961
962	awr->awar(AWAR_PV_MARKED)->add_callback(PV_CallBackFunction);
963	awr->awar(AWAR_PV_MARKED_DB)->add_callback(PV_CallBackFunction);
964	awr->awar(AWAR_PV_MARKED_FS_1)->add_callback(PV_CallBackFunction);
965	awr->awar(AWAR_PV_MARKED_FS_2)->add_callback(PV_CallBackFunction);
966	awr->awar(AWAR_PV_MARKED_FS_3)->add_callback(PV_CallBackFunction);
967	awr->awar(AWAR_PV_MARKED_CS_1)->add_callback(PV_CallBackFunction);
968	awr->awar(AWAR_PV_MARKED_CS_2)->add_callback(PV_CallBackFunction);
969	awr->awar(AWAR_PV_MARKED_CS_3)->add_callback(PV_CallBackFunction);
970
971	awr->awar(AWAR_PV_CURSOR)->add_callback(PV_CallBackFunction);
972	awr->awar(AWAR_PV_CURSOR_DB)->add_callback(PV_CallBackFunction);
973	awr->awar(AWAR_PV_CURSOR_FS_1)->add_callback(PV_CallBackFunction);
974	awr->awar(AWAR_PV_CURSOR_FS_2)->add_callback(PV_CallBackFunction);
975	awr->awar(AWAR_PV_CURSOR_FS_3)->add_callback(PV_CallBackFunction);
976	awr->awar(AWAR_PV_CURSOR_CS_1)->add_callback(PV_CallBackFunction);
977	awr->awar(AWAR_PV_CURSOR_CS_2)->add_callback(PV_CallBackFunction);
978	awr->awar(AWAR_PV_CURSOR_CS_3)->add_callback(PV_CallBackFunction);
979	}
980
981	// --------------------------------------------------------------------------------
982	// Creating AWARS to be used by the PROTVIEW module
983	// --------------------------------------------------------------------------------
984	void PV_CreateAwars(AW_root *root, AW_default aw_def) {
985
986	root->awar_int(AWAR_PV_DISPLAY_ALL, 0, aw_def);
987
988	root->awar_int(AWAR_PROTVIEW_FORWARD_STRAND_1, 0, aw_def);
989	root->awar_int(AWAR_PROTVIEW_FORWARD_STRAND_2, 0, aw_def);
990	root->awar_int(AWAR_PROTVIEW_FORWARD_STRAND_3, 0, aw_def);
991
992	root->awar_int(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1, 0, aw_def);
993	root->awar_int(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2, 0, aw_def);
994	root->awar_int(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3, 0, aw_def);
995
996	root->awar_int(AWAR_PROTVIEW_DEFINED_FIELDS, 0, aw_def);
997	root->awar_int(AWAR_PROTVIEW_DISPLAY_OPTIONS, 0, aw_def);
998
999	root->awar_int(AWAR_PV_SELECTED, 0, aw_def);
1000	root->awar_int(AWAR_PV_SELECTED_DB, 0, aw_def);
1001	root->awar_int(AWAR_PV_SELECTED_FS_1, 0, aw_def);
1002	root->awar_int(AWAR_PV_SELECTED_FS_2, 0, aw_def);
1003	root->awar_int(AWAR_PV_SELECTED_FS_3, 0, aw_def);
1004	root->awar_int(AWAR_PV_SELECTED_CS_1, 0, aw_def);
1005	root->awar_int(AWAR_PV_SELECTED_CS_2, 0, aw_def);
1006	root->awar_int(AWAR_PV_SELECTED_CS_3, 0, aw_def);
1007
1008	root->awar_int(AWAR_PV_MARKED, 0, aw_def);
1009	root->awar_int(AWAR_PV_MARKED_DB, 0, aw_def);
1010	root->awar_int(AWAR_PV_MARKED_FS_1, 0, aw_def);
1011	root->awar_int(AWAR_PV_MARKED_FS_2, 0, aw_def);
1012	root->awar_int(AWAR_PV_MARKED_FS_3, 0, aw_def);
1013	root->awar_int(AWAR_PV_MARKED_CS_1, 0, aw_def);
1014	root->awar_int(AWAR_PV_MARKED_CS_2, 0, aw_def);
1015	root->awar_int(AWAR_PV_MARKED_CS_3, 0, aw_def);
1016
1017	root->awar_int(AWAR_PV_CURSOR, 0, aw_def);
1018	root->awar_int(AWAR_PV_CURSOR_DB, 0, aw_def);
1019	root->awar_int(AWAR_PV_CURSOR_FS_1, 0, aw_def);
1020	root->awar_int(AWAR_PV_CURSOR_FS_2, 0, aw_def);
1021	root->awar_int(AWAR_PV_CURSOR_FS_3, 0, aw_def);
1022	root->awar_int(AWAR_PV_CURSOR_CS_1, 0, aw_def);
1023	root->awar_int(AWAR_PV_CURSOR_CS_2, 0, aw_def);
1024	root->awar_int(AWAR_PV_CURSOR_CS_3, 0, aw_def);
1025	}
1026
1027	AW_window ED4_CreateProteinViewer_window(AW_root aw_root) {
1028	GB_transaction dummy(GLOBAL_gb_main);
1029
1030	static AW_window_simple *aws = 0;
1031	if (aws) return aws;
1032
1033	aws = new AW_window_simple;
1034
1035	aws->init(aw_root, "PROTEIN_VIEWER", "Protein Viewer");
1036	aws->load_xfig("proteinViewer.fig");
1037
1038	aws->at("refresh");
1039	aws->callback(PV_RefreshProtViewDisplay);
1040	aws->button_length(0);
1041	aws->create_button("REFRESH", "#refresh_text.xpm");
1042
1043	aws->callback(AW_POPUP_HELP, (AW_CL)"proteinViewer.hlp");
1044	aws->at("help");
1045	aws->button_length(0);
1046	aws->create_button("HELP", "#help_text.xpm");
1047
1048	aws->at("close");
1049	aws->callback((AW_CB0)AW_POPDOWN);
1050	aws->button_length(0);
1051	aws->create_button("CLOSE", "#close_text.xpm");
1052
1053	{
1054	aw_root->awar_int(AWAR_PROTEIN_TYPE, AWAR_PROTEIN_TYPE_bacterial_code_index, GLOBAL_gb_main);
1055	aws->at("table");
1056	aws->create_option_menu(AWAR_PROTEIN_TYPE);
1057	for (int code_nr=0; code_nr<AWT_CODON_TABLES; code_nr++) {
1058	aws->insert_option(AWT_get_codon_code_name(code_nr), "", code_nr);
1059	}
1060	aws->update_option_menu();
1061
1062	aws->at("all");
1063	aws->create_toggle(AWAR_PV_DISPLAY_ALL);
1064
1065	aws->at("f1");
1066	aws->create_toggle(AWAR_PROTVIEW_FORWARD_STRAND_1);
1067
1068	aws->at("f2");
1069	aws->create_toggle(AWAR_PROTVIEW_FORWARD_STRAND_2);
1070
1071	aws->at("f3");
1072	aws->create_toggle(AWAR_PROTVIEW_FORWARD_STRAND_3);
1073
1074	aws->at("c1");
1075	aws->create_toggle(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_1);
1076
1077	aws->at("c2");
1078	aws->create_toggle(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_2);
1079
1080	aws->at("c3");
1081	aws->create_toggle(AWAR_PROTVIEW_COMPLEMENTARY_STRAND_3);
1082
1083	aws->at("defined");
1084	aws->create_toggle(AWAR_PROTVIEW_DEFINED_FIELDS);
1085
1086	aws->at("dispOption");
1087	aws->create_toggle_field(AWAR_PROTVIEW_DISPLAY_OPTIONS, 0);
1088	aws->insert_toggle("Single Letter Code", "S", 0);
1089	aws->insert_toggle("Triple Letter Code", "T", 1);
1090	aws->insert_toggle("Colored Box", "B", 2);
1091	aws->update_toggle_field();
1092
1093	aws->at("colMaps");
1094	aws->callback(AW_POPUP, (AW_CL)create_seq_colors_window, (AW_CL)ED4_ROOT->sequence_colors);
1095	aws->button_length(0);
1096	aws->create_button("COLORMAPS", "#colorMaps.xpm");
1097
1098	aws->at("colors");
1099	aws->callback(AW_POPUP, (AW_CL)AW_create_gc_window, (AW_CL)ED4_ROOT->aw_gc_manager);
1100	aws->button_length(0);
1101	aws->create_button("COLORS", "#colors.xpm");
1102
1103	{
1104	aws->at("sel"); aws->create_toggle(AWAR_PV_SELECTED);
1105	aws->at("sf1"); aws->create_toggle(AWAR_PV_SELECTED_FS_1);
1106	aws->at("sf2"); aws->create_toggle(AWAR_PV_SELECTED_FS_2);
1107	aws->at("sf3"); aws->create_toggle(AWAR_PV_SELECTED_FS_3);
1108	aws->at("sc1"); aws->create_toggle(AWAR_PV_SELECTED_CS_1);
1109	aws->at("sc2"); aws->create_toggle(AWAR_PV_SELECTED_CS_2);
1110	aws->at("sc3"); aws->create_toggle(AWAR_PV_SELECTED_CS_3);
1111	aws->at("sdb"); aws->create_toggle(AWAR_PV_SELECTED_DB);
1112
1113	aws->at("mrk"); aws->create_toggle(AWAR_PV_MARKED);
1114	aws->at("mf1"); aws->create_toggle(AWAR_PV_MARKED_FS_1);
1115	aws->at("mf2"); aws->create_toggle(AWAR_PV_MARKED_FS_2);
1116	aws->at("mf3"); aws->create_toggle(AWAR_PV_MARKED_FS_3);
1117	aws->at("mc1"); aws->create_toggle(AWAR_PV_MARKED_CS_1);
1118	aws->at("mc2"); aws->create_toggle(AWAR_PV_MARKED_CS_2);
1119	aws->at("mc3"); aws->create_toggle(AWAR_PV_MARKED_CS_3);
1120	aws->at("mdb"); aws->create_toggle(AWAR_PV_MARKED_DB);
1121
1122	aws->at("cur"); aws->create_toggle(AWAR_PV_CURSOR);
1123	aws->at("cf1"); aws->create_toggle(AWAR_PV_CURSOR_FS_1);
1124	aws->at("cf2"); aws->create_toggle(AWAR_PV_CURSOR_FS_2);
1125	aws->at("cf3"); aws->create_toggle(AWAR_PV_CURSOR_FS_3);
1126	aws->at("cc1"); aws->create_toggle(AWAR_PV_CURSOR_CS_1);
1127	aws->at("cc2"); aws->create_toggle(AWAR_PV_CURSOR_CS_2);
1128	aws->at("cc3"); aws->create_toggle(AWAR_PV_CURSOR_CS_3);
1129	aws->at("cdb"); aws->create_toggle(AWAR_PV_CURSOR_DB);
1130	}
1131
1132	aws->at("save");
1133	aws->callback(PV_SaveData);
1134	aws->button_length(5);
1135	aws->create_button("SAVE", "#save.xpm");
1136	}
1137
1138	// binding callback function to the AWARS
1139	PV_AddCallBacks(aw_root);
1140
1141	// Create All Terminals
1142	PV_CreateAllTerminals(aw_root);
1143
1144	aws->show();
1145
1146	return (AW_window *)aws;
1147	}
1148
1149	#undef BUFFERSIZE

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

Download in other formats: