Context Navigation

source: tags/arb-6.0.5/EDIT4/graph_aligner_gui.cxx

Visit:

Last change on this file was 12267, checked in by westram, 10 years ago
full update from 'trunk' into 'rc' because i was (nearly) only fixing bugs in the last 5 weeks adds: log:branches/fix@11985,11990:11997,12008:12013,12023:12042,12049:12053,12058:12137,12147:12156 log:branches/gcc@12076:12079 log:branches/tree@12004:12019,12116:12120 log:trunk@11971:11972,11974:11980,11982:11989,11991:12260
File size: 22.2 KB

Line
1	// =============================================================== //
2	// //
3	// File : graph_aligner_gui.cxx //
4	// Purpose : //
5	// //
6	// Coded by Elmar Pruesse in October 2008 //
7	// Institute of Microbiology (Technical University Munich) //
8	// http://www.arb-home.de/ //
9	// //
10	// =============================================================== //
11
12	#include "graph_aligner_gui.hxx"
13
14	#include "ed4_defs.hxx"
15
16	// need to use AlignDataAccess defined here to get selected species
17	#include <fast_aligner.hxx>
18
19	#include <aw_awars.hxx>
20	#include <aw_msg.hxx>
21	#include <aw_root.hxx>
22	#include <awt_sel_boxes.hxx>
23	#include <servercntrl.h>
24	#include <PT_com.h>
25	#include <client.h>
26	#include <arbdbt.h>
27	#include <arb_strbuf.h>
28
29	#include <sys/types.h>
30	#include <sys/wait.h>
31
32	#include <unistd.h>
33
34	#include <string>
35	#include <sstream>
36	#include <iostream>
37	#include <vector>
38
39
40	using std::cerr;
41	using std::cout;
42	using std::endl;
43
44	#define GA_AWAR_ROOT "sina/"
45	#define GA_AWAR_CMD GA_AWAR_ROOT "command"
46	#define GA_AWAR_TGT GA_AWAR_ROOT "target"
47	#define GA_AWAR_SAI GA_AWAR_ROOT "sai"
48	#define GA_AWAR_ALIGNMENT GA_AWAR_ROOT "alignment"
49	#define GA_AWAR_PROTECTION GA_AWAR_ROOT "protection"
50	#define GA_AWAR_TURN_CHECK GA_AWAR_ROOT "turncheck"
51	#define GA_AWAR_LOGLEVEL GA_AWAR_ROOT "loglevel"
52	#define GA_AWAR_REALIGN GA_AWAR_ROOT "realign"
53	#define GA_AWAR_COPYMARKREF GA_AWAR_ROOT "copymarkref"
54	#define GA_AWAR_MATCH_SCORE GA_AWAR_ROOT "match_score"
55	#define GA_AWAR_MISMATCH_SCORE GA_AWAR_ROOT "mismatch_score"
56	#define GA_AWAR_GAP_PEN GA_AWAR_ROOT "gap_pen"
57	#define GA_AWAR_GAP_EXT GA_AWAR_ROOT "gap_ext"
58	#define GA_AWAR_ADVANCED GA_AWAR_ROOT "advanced"
59	#define GA_AWAR_FS_MIN GA_AWAR_ROOT "fs_min"
60	#define GA_AWAR_FS_MAX GA_AWAR_ROOT "fs_max"
61	#define GA_AWAR_FS_MSC GA_AWAR_ROOT "fs_msc"
62	#define GA_AWAR_MIN_FULL GA_AWAR_ROOT "min_full"
63	#define GA_AWAR_FULL_MINLEN GA_AWAR_ROOT "full_minlen"
64	#define GA_AWAR_OVERHANG GA_AWAR_ROOT "overhang"
65	#define GA_AWAR_THREADS GA_AWAR_ROOT "threads"
66	#define GA_AWAR_QSIZE GA_AWAR_ROOT "qsize"
67	#define GA_AWAR_KMER_LEN GA_AWAR_ROOT "kmer_len"
68	#define GA_AWAR_KMER_MM GA_AWAR_ROOT "kmer_mm"
69	#define GA_AWAR_MIN_LEN GA_AWAR_ROOT "min_len"
70	#define GA_AWAR_WEIGHT GA_AWAR_ROOT "weight"
71	#define GA_AWAR_INSERT GA_AWAR_ROOT "insert"
72	#define GA_AWAR_LOWERCASE GA_AWAR_ROOT "lowercase"
73	#define GA_AWAR_AUTOFILTER GA_AWAR_ROOT "autofilter"
74	#define GA_AWAR_KMER_NOREL GA_AWAR_ROOT "kmer_norel"
75	#define GA_AWAR_KMER_NOFAST GA_AWAR_ROOT "kmer_nofast"
76	#define GA_AWAR_SHOW_DIST GA_AWAR_ROOT "show_dist"
77	#define GA_AWAR_SHOW_DIFF GA_AWAR_ROOT "show_diff"
78	#define GA_AWAR_COLOR GA_AWAR_ROOT "color"
79	#define GA_AWAR_GENE_START GA_AWAR_ROOT "gene_start"
80	#define GA_AWAR_GENE_END GA_AWAR_ROOT "gene_end"
81	#define GA_AWAR_FS_COVER_GENE GA_AWAR_ROOT "fs_cover_gene"
82
83	void create_sina_variables(AW_root *root, AW_default db1) {
84	root->awar_string(GA_AWAR_CMD, "sina", db1);
85	root->awar_int(GA_AWAR_TGT, 2, db1);
86	root->awar_int(AWAR_PT_SERVER, 0, db1);
87	root->awar_string(GA_AWAR_SAI, "", db1);
88	root->awar_int(GA_AWAR_PROTECTION, 0, db1);
89	root->awar_string(GA_AWAR_LOGLEVEL, "3", db1); // @@@ change to int?
90	root->awar_int(GA_AWAR_TURN_CHECK, 1, db1);
91	root->awar_int(GA_AWAR_REALIGN, 1, db1);
92	root->awar_int(GA_AWAR_COPYMARKREF, 0, db1);
93	root->awar_float(GA_AWAR_GAP_PEN, 5.0, db1);
94	root->awar_float(GA_AWAR_GAP_EXT, 2.0, db1);
95	root->awar_float(GA_AWAR_MATCH_SCORE, 2.0, db1);
96	root->awar_float(GA_AWAR_MISMATCH_SCORE, -1.0, db1);
97	root->awar_int(GA_AWAR_ADVANCED, 0, db1);
98	root->awar_int(GA_AWAR_FS_MIN, 40, db1);
99	root->awar_int(GA_AWAR_FS_MAX, 40, db1);
100	root->awar_float(GA_AWAR_FS_MSC, .7, db1);
101	root->awar_int(GA_AWAR_MIN_FULL, 1, db1);
102	root->awar_int(GA_AWAR_FULL_MINLEN, 1400, db1);
103	root->awar_string(GA_AWAR_OVERHANG, "attach", db1);
104	root->awar_int(GA_AWAR_THREADS, 1, db1);
105	root->awar_int(GA_AWAR_QSIZE, 1, db1);
106	root->awar_int(GA_AWAR_KMER_LEN, 10, db1);
107	root->awar_int(GA_AWAR_KMER_MM, 0, db1);
108	root->awar_int(GA_AWAR_MIN_LEN, 150, db1);
109	root->awar_float(GA_AWAR_WEIGHT, 1, db1);
110	root->awar_string(GA_AWAR_INSERT, "shift", db1);
111	root->awar_string(GA_AWAR_LOWERCASE, "none", db1);
112	root->awar_string(GA_AWAR_AUTOFILTER, "none", db1);
113	root->awar_int(GA_AWAR_KMER_NOREL, 0, db1);
114	root->awar_int(GA_AWAR_KMER_NOFAST, 0, db1);
115	root->awar_int(GA_AWAR_SHOW_DIST, 0, db1);
116	root->awar_int(GA_AWAR_SHOW_DIFF, 0, db1);
117	root->awar_int(GA_AWAR_COLOR, 1, db1);
118	root->awar_int(GA_AWAR_GENE_START, 0, db1);
119	root->awar_int(GA_AWAR_GENE_END, 0, db1);
120	root->awar_int(GA_AWAR_FS_COVER_GENE, 1, db1);
121	}
122
123	AW_active sina_mask(AW_root *root) {
124	const char *sinaName = root->awar(GA_AWAR_CMD)->read_char_pntr();
125	char *sina = GB_executable(sinaName);
126	const char *fail_reason = 0;
127
128	if (sina) {
129	int exitstatus = system(GBS_global_string("%s --has-cli-vers ARB5.99", sina));
130	exitstatus = WEXITSTATUS(exitstatus);
131
132	switch (exitstatus) {
133	case EXIT_SUCCESS:
134	break;
135
136	case EXIT_FAILURE:
137	fail_reason = "Incompatible SINA and ARB versions";
138	break;
139
140	case 127: // libs missing
141	default: // unexpected
142	fail_reason = GBS_global_string("Could execute SINA binary '%s' (exitstatus was %i)",
143	sinaName, exitstatus);
144	break;
145	}
146	free(sina);
147	}
148	else {
149	fail_reason = GBS_global_string("%s not found", sinaName);
150	}
151
152	if (fail_reason) {
153	fprintf(stderr,
154	"Note: SINA (SILVA Aligner) disabled (Reason: %s)\n"
155	" Visit http://www.ribocon.com/sina/ for more information.\n",
156	fail_reason);
157	}
158
159	return fail_reason ? AWM_DISABLED : AWM_ALL;
160	}
161
162	inline const char *stream2static(const std::stringstream& str) {
163	return GBS_static_string(str.str().c_str());
164	}
165
166	inline const char empty_as_none(const char sainame) {
167	// see http://bugs.arb-home.de/ticket/519
168	if (sainame && !sainame[0]) sainame = "none";
169	return sainame;
170	}
171
172	static void sina_start(AW_window *window, AW_CL cl_AlignDataAccess) {
173	cerr << "Starting SINA..." << endl;
174
175	// make string from pt server selection
176	AW_root *root = window->get_root();
177	int pt = root->awar(AWAR_PT_SERVER)->read_int();
178
179	std::stringstream ptnam;
180	ptnam << "ARB_PT_SERVER" << pt;
181
182	const char *pt_server = GBS_read_arb_tcp(ptnam.str().c_str());
183	GB_ERROR gb_error = NULL;
184
185	if (!pt_server) gb_error = "Unable to find definition for chosen PT-server";
186	else {
187	const char *pt_db = pt_server + strlen(pt_server) + 1;
188	pt_db += strlen(pt_db)+3;
189
190	// start pt server if necessary
191	gb_error = arb_look_and_start_server(AISC_MAGIC_NUMBER, ptnam.str().c_str());
192	if (gb_error) {
193	std::stringstream tmp;
194	tmp << "Cannot contact PT server. Aborting" << endl
195	<< " ID: \"" << tmp.str().c_str()
196	<< "\" PORT: \"" << pt_server
197	<< "\" DB: \"" << pt_db << endl
198	<< "\" GBERROR: \"" << gb_error << "\"" << endl;
199	gb_error = stream2static(tmp);
200	}
201	else {
202	// create temporary file
203	char* tmpfile;
204	FILE* tmpfile_F;
205	{
206	char* tmpfile_tpl = GB_unique_filename("sina_select", "tmp");
207	tmpfile_F = GB_fopen_tempfile(tmpfile_tpl, "w", &tmpfile);
208	free(tmpfile_tpl);
209	}
210
211	if (!tmpfile_F) {
212	std::stringstream tmp;
213	tmp << "Error: Unable to create temporary file \"" << tmpfile << "\"!";
214	gb_error = stream2static(tmp);
215	}
216	else {
217	GB_remove_on_exit(tmpfile);
218
219	std::vector<std::string> spec_names;
220	switch (root->awar(GA_AWAR_TGT)->read_int()) {
221	case 0: { // current
222	char *spec_name = root->awar(AWAR_SPECIES_NAME)->read_string();
223	if (spec_name) {
224	fwrite(spec_name, strlen(spec_name), 1, tmpfile_F);
225	fwrite("\n", 1, 1, tmpfile_F);
226	}
227	else {
228	gb_error = "Unable to get name of currently active species";
229	}
230	free(spec_name);
231	break;
232	}
233	case 1: { // selected
234	const AlignDataAccess data_access = (const AlignDataAccess )cl_AlignDataAccess;
235	GB_begin_transaction(GLOBAL_gb_main);
236	int num_selected = 0;
237	for (GBDATA *gb_spec = data_access->get_first_selected_species(&num_selected);
238	gb_spec;
239	gb_spec = data_access->get_next_selected_species())
240	{
241	GBDATA *gbd_name = GB_find(gb_spec, "name", SEARCH_CHILD);
242	if (gbd_name) {
243	const char *str = GB_read_char_pntr(gbd_name);
244	fwrite(str, strlen(str), 1, tmpfile_F);
245	fwrite("\n", 1, 1, tmpfile_F);
246	}
247	}
248	GB_commit_transaction(GLOBAL_gb_main);
249	break;
250	}
251	case 2: { // marked
252	GB_begin_transaction(GLOBAL_gb_main);
253	for (GBDATA *gb_spec = GBT_first_marked_species(GLOBAL_gb_main);
254	gb_spec; gb_spec = GBT_next_marked_species(gb_spec)) {
255	GBDATA *gbd_name = GB_find(gb_spec, "name", SEARCH_CHILD);
256	if (gbd_name) {
257	const char *str = GB_read_char_pntr(gbd_name);
258	fwrite(str, strlen(str), 1, tmpfile_F);
259	fwrite("\n", 1, 1, tmpfile_F);
260	}
261	}
262	GB_commit_transaction(GLOBAL_gb_main);
263	break;
264	}
265	}
266	fclose(tmpfile_F);
267
268	if (!gb_error) {
269	// build command line
270	GBS_strstruct *cl = GBS_stropen(2000);
271
272	GBS_strcat(cl, root->awar(GA_AWAR_CMD)->read_char_pntr());
273	GBS_strcat(cl, " -i :");
274	GBS_strcat(cl, " --ptdb :");
275	GBS_strcat(cl, " --ptport "); GBS_strcat(cl, pt_server);
276	GBS_strcat(cl, " --turn "); GBS_strcat(cl, root->awar(GA_AWAR_TURN_CHECK)->read_int() ? "all" : "none");
277	GBS_strcat(cl, " --overhang "); GBS_strcat(cl, root->awar(GA_AWAR_OVERHANG)->read_char_pntr());
278	GBS_strcat(cl, " --filter "); GBS_strcat(cl, empty_as_none(root->awar(GA_AWAR_SAI)->read_char_pntr()));
279	GBS_strcat(cl, " --fs-min "); GBS_intcat(cl, root->awar(GA_AWAR_FS_MIN)->read_int());
280	GBS_strcat(cl, " --fs-msc "); GBS_floatcat(cl, root->awar(GA_AWAR_FS_MSC)->read_float());
281	GBS_strcat(cl, " --fs-max "); GBS_intcat(cl, root->awar(GA_AWAR_FS_MAX)->read_int());
282	GBS_strcat(cl, " --fs-req 1");
283	GBS_strcat(cl, " --fs-req-full "); GBS_intcat(cl, root->awar(GA_AWAR_MIN_FULL)->read_int());
284	GBS_strcat(cl, " --fs-full-len "); GBS_intcat(cl, root->awar(GA_AWAR_FULL_MINLEN)->read_int());
285	GBS_strcat(cl, " --fs-kmer-len "); GBS_intcat(cl, root->awar(GA_AWAR_KMER_LEN)->read_int());
286	GBS_strcat(cl, " --fs-kmer-mm "); GBS_intcat(cl, root->awar(GA_AWAR_KMER_MM)->read_int());
287	GBS_strcat(cl, " --fs-min-len "); GBS_intcat(cl, root->awar(GA_AWAR_MIN_LEN)->read_int());
288	GBS_strcat(cl, " --fs-weight "); GBS_intcat(cl, root->awar(GA_AWAR_WEIGHT)->read_float());
289	GBS_strcat(cl, " --pen-gap "); GBS_floatcat(cl, root->awar(GA_AWAR_GAP_PEN)->read_float());
290	GBS_strcat(cl, " --pen-gapext "); GBS_floatcat(cl, root->awar(GA_AWAR_GAP_EXT)->read_float());
291	GBS_strcat(cl, " --match-score "); GBS_floatcat(cl, root->awar(GA_AWAR_MATCH_SCORE)->read_float());
292	GBS_strcat(cl, " --mismatch-score "); GBS_floatcat(cl, root->awar(GA_AWAR_MISMATCH_SCORE)->read_float());
293	GBS_strcat(cl, " --prot-level "); GBS_intcat(cl, root->awar(GA_AWAR_PROTECTION)->read_int());
294	GBS_strcat(cl, " --select-file "); GBS_strcat(cl, tmpfile);
295	GBS_strcat(cl, " --insertion "); GBS_strcat(cl, root->awar(GA_AWAR_INSERT)->read_char_pntr());
296	GBS_strcat(cl, " --lowercase "); GBS_strcat(cl, root->awar(GA_AWAR_LOWERCASE)->read_char_pntr());
297	GBS_strcat(cl, " --auto-filter-field "); GBS_strcat(cl, root->awar(GA_AWAR_AUTOFILTER)->read_char_pntr());
298	GBS_strcat(cl, " --gene-start "); GBS_intcat(cl, root->awar(GA_AWAR_GENE_START)->read_int());
299	GBS_strcat(cl, " --gene-end "); GBS_intcat(cl, root->awar(GA_AWAR_GENE_END)->read_int());
300	GBS_strcat(cl, " --fs-cover-gene ");GBS_intcat(cl, root->awar(GA_AWAR_FS_COVER_GENE)->read_int());
301
302
303	if (root->awar(GA_AWAR_KMER_NOREL)->read_int()) GBS_strcat(cl, " --fs-kmer-norel ");
304	if (root->awar(GA_AWAR_KMER_NOFAST)->read_int()) GBS_strcat(cl, " --fs-kmer-no-fast ");
305	if (root->awar(GA_AWAR_SHOW_DIST)->read_int()) GBS_strcat(cl, " --show-dist ");
306	if (root->awar(GA_AWAR_SHOW_DIFF)->read_int()) GBS_strcat(cl, " --show-diff ");
307	if (root->awar(GA_AWAR_COLOR)->read_int()) GBS_strcat(cl, " --color");
308	if (root->awar(GA_AWAR_REALIGN)->read_int()) GBS_strcat(cl, " --realign");
309
310	gb_error = GB_xcmd(GBS_mempntr(cl), true, false);
311	GBS_strforget(cl);
312	}
313
314	if (!gb_error) aw_message("SINA finished aligning.");
315	}
316	free(tmpfile);
317	}
318	}
319
320	aw_message_if(gb_error);
321	}
322
323
324
325	static char* filter_sai(GBDATA *gb_extended, AW_CL) {
326	char *result = 0;
327	GBDATA *gbd = GB_search(gb_extended, "ali_16s/_TYPE", GB_FIND);
328	if (gbd) {
329	const char* type = GB_read_char_pntr(gbd);
330	if (type && strncmp("PV", type, 2) == 0) {
331	gbd = GB_find(gb_extended, "name", SEARCH_CHILD);
332	result = GB_read_string(gbd);
333	}
334	}
335	return result;
336	}
337
338	static AW_window_simple* new_sina_simple(AW_root *root, AW_CL cl_AlignDataAccess, bool adv) {
339	int closex, closey, startx, starty, winx, winy;
340	const int hgap = 10;
341	AW_window_simple *aws = new AW_window_simple;
342
343	aws->init(root, "SINA", "SINA (SILVA Incremental Aligner)");
344
345	aws->button_length(12);
346	aws->at(10, 10);
347	aws->auto_space(5, 5);
348
349	aws->callback(AW_POPDOWN);
350	aws->create_button("CLOSE", "CLOSE", "O");
351	aws->get_at_position(&closex, &closey);
352
353	aws->at_shift(10, 0);
354	aws->callback(show_sina_window, cl_AlignDataAccess, 0);
355	aws->label_length(0);
356	aws->label("Show advanced options");
357	aws->create_toggle(GA_AWAR_ADVANCED);
358
359	aws->at_newline();
360	aws->at_shift(0, hgap);
361	aws->label_length(15);
362	aws->create_toggle_field(GA_AWAR_TGT, "Align what?", "A");
363	aws->insert_toggle("Current Species:", "C", 0);
364	aws->insert_toggle("Selected Species", "S", 1);
365	aws->insert_default_toggle("Marked Species", "M", 2);
366	aws->update_toggle_field();
367
368	aws->at_shift(0, 3);
369	aws->create_input_field(AWAR_SPECIES_NAME, 20);
370
371	aws->at_newline();
372	aws->at_shift(0, hgap);
373	aws->button_length(24);
374	aws->label("PT Server:");
375	awt_create_selection_list_on_pt_servers(aws, AWAR_PT_SERVER, true);
376
377	aws->at_newline();
378	aws->label_length(0);
379	aws->label("Overhang placement");
380	aws->create_option_menu(GA_AWAR_OVERHANG, true);
381	aws->insert_option("keep attached", 0, "attach");
382	aws->insert_option("move to edge", 0, "edge");
383	aws->insert_option("remove", 0, "remove");
384	aws->update_option_menu();
385
386	aws->at_newline();
387	aws->label("Handling of unmappable insertions");
388	aws->create_option_menu(GA_AWAR_INSERT, true);
389	aws->insert_option("Shift surrounding bases", 0, "shift");
390	aws->insert_option("Forbid during DP alignment", 0, "forbid");
391	aws->insert_option("Delete bases", 0, "remove");
392	aws->update_option_menu();
393
394	aws->at_newline();
395	aws->label("Character Case");
396	aws->create_option_menu(GA_AWAR_LOWERCASE, true);
397	aws->insert_option("Do not modify", 0, "original");
398	aws->insert_option("Show unaligned bases as lower case", 0, "unaligned");
399	aws->insert_option("Uppercase all", 0, "none");
400	aws->update_option_menu();
401
402	aws->at_newline();
403	aws->label("Family conservation weight (0-1)");
404	aws->create_input_field(GA_AWAR_WEIGHT, 3);
405
406	aws->at_newline();
407	aws->label("Size of full-length sequences");
408	aws->create_input_field(GA_AWAR_FULL_MINLEN, 5);
409
410	if (adv) {
411	aws->at_newline();
412	aws->at_shift(0, hgap);
413
414	aws->at_newline();
415
416	aws->label("Pos. Var.:");
417	awt_create_SAI_selection_button(GLOBAL_gb_main, aws, GA_AWAR_SAI, filter_sai, 0);
418
419	aws->at_newline();
420	aws->label("Field used for automatic filter selection");
421	aws->create_input_field(GA_AWAR_AUTOFILTER, 20);
422
423	aws->label("Turn check");
424	aws->create_toggle(GA_AWAR_TURN_CHECK);
425
426	aws->at_newline();
427	aws->label("Realign");
428	aws->create_toggle(GA_AWAR_REALIGN);
429
430	/*
431	aws->at_newline();
432	aws->label("(Copy and) mark sequences used as reference");
433	aws->create_toggle(GA_AWAR_COPYMARKREF);
434	*/
435
436	aws->at_newline();
437	aws->at_shift(0, hgap);
438	aws->label_length(0);
439
440	aws->label("Gap insertion/extension penalties");
441	aws->create_input_field(GA_AWAR_GAP_PEN, 5);
442	aws->create_input_field(GA_AWAR_GAP_EXT, 5);
443
444	aws->at_newline();
445	aws->label("Match score");
446	aws->create_input_field(GA_AWAR_MATCH_SCORE, 3);
447	aws->label("Mismatch score");
448	aws->create_input_field(GA_AWAR_MISMATCH_SCORE, 3);
449
450	aws->at_newline();
451	aws->label("Family search min/min_score/max");
452	aws->create_input_field(GA_AWAR_FS_MIN, 3);
453	aws->create_input_field(GA_AWAR_FS_MSC, 3);
454	aws->create_input_field(GA_AWAR_FS_MAX, 3);
455
456	aws->at_newline();
457	aws->label("Minimal number of full length sequences");
458	aws->create_input_field(GA_AWAR_MIN_FULL, 3);
459
460	aws->at_newline();
461	aws->label("Family search oligo length / mismatches");
462	aws->create_input_field(GA_AWAR_KMER_LEN, 3);
463	aws->create_input_field(GA_AWAR_KMER_MM, 3);
464
465	aws->at_newline();
466	aws->label("Minimal reference sequence length");
467	aws->create_input_field(GA_AWAR_MIN_LEN, 5);
468
469	aws->at_newline();
470	aws->label("Alignment bounds: start");
471	aws->create_input_field(GA_AWAR_GENE_START, 6);
472	aws->label("end");
473	aws->create_input_field(GA_AWAR_GENE_END, 6);
474
475	aws->at_newline();
476	aws->label("Number of references required to touch bounds");
477	aws->create_input_field(GA_AWAR_FS_COVER_GENE, 3);
478
479	aws->at_newline();
480	aws->label("Disable fast search");
481	aws->create_toggle(GA_AWAR_KMER_NOFAST);
482
483	aws->at_newline();
484	aws->label("Score search results by absolute oligo match count");
485	aws->create_toggle(GA_AWAR_KMER_NOREL);
486
487	aws->at_newline();
488	aws->label("SINA command");
489	aws->create_input_field(GA_AWAR_CMD, 20);
490
491	aws->at_shift(0, hgap);
492	}
493
494	aws->at_newline();
495	aws->at_shift(0, hgap);
496
497	aws->label_length(17);
498	aws->label("Protection Level");
499	aws->create_option_menu(GA_AWAR_PROTECTION, true);
500	aws->insert_option("0", 0, 0);
501	aws->insert_option("1", 0, 1);
502	aws->insert_option("2", 0, 2);
503	aws->insert_option("3", 0, 3);
504	aws->insert_option("4", 0, 4);
505	aws->insert_option("5", 0, 5);
506	aws->insert_option("6", 0, 6);
507	aws->update_option_menu();
508
509	/*
510	aws->at_newline();
511	aws->create_option_menu(GA_AWAR_LOGLEVEL, "Logging level", "L");
512	aws->insert_option("silent", 0, "1");
513	aws->insert_option("quiet", 0, "2");
514	aws->insert_default_option("normal", 0, "3");
515	aws->insert_option("verbose", 0, "4");
516	aws->insert_option("debug", 0, "5");
517	aws->insert_option("debug more", 0, "6");
518	aws->update_option_menu();
519	*/
520
521	aws->at_newline();
522	aws->label("Show changed sections of alignment");
523	aws->create_toggle(GA_AWAR_SHOW_DIFF);
524	aws->label("color bases");
525	aws->create_toggle(GA_AWAR_COLOR);
526
527	aws->at_newline();
528	aws->label("Show statistics");
529	aws->create_toggle(GA_AWAR_SHOW_DIST);
530
531	aws->get_window_size(winx, winy);
532	aws->get_at_position(&startx, &starty);
533
534	aws->button_length(12);
535
536	aws->at(winx-closex+5, closey);
537	aws->callback(makeHelpCallback("sina_main.hlp"));
538	aws->create_button("HELP", "HELP");
539
540	aws->at(winx-closex+5, starty);
541	aws->callback(sina_start, cl_AlignDataAccess);
542	aws->highlight();
543	aws->create_button("Start", "Start", "S");
544
545	return aws;
546	}
547
548	void show_sina_window(AW_window *aw, AW_CL cl_AlignDataAccess, AW_CL) {
549	static AW_window_simple *ga_aws = 0;
550	static AW_window_simple *ga_aws_adv = 0;
551
552	AW_root *root = aw->get_root();
553	if (root->awar(GA_AWAR_ADVANCED)->read_int()) {
554	if (!ga_aws_adv) ga_aws_adv = new_sina_simple(root, cl_AlignDataAccess, true);
555	ga_aws_adv->show();
556	if (ga_aws) ga_aws->hide();
557	}
558	else {
559	if (!ga_aws) ga_aws = new_sina_simple(root, cl_AlignDataAccess, false);
560	ga_aws->show();
561	if (ga_aws_adv) ga_aws_adv->hide();
562	}
563	}
564

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

Download in other formats: