Context Navigation

source: tags/ms_r17q1/PRIMER_DESIGN/primer_design.cxx

Visit:

Last change on this file was 14731, checked in by westram, 10 years ago
mark code binding callbacks to non-button-widgets (probably incomplete; see #559 for details)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 22.3 KB

Line
1	// =============================================================== //
2	// //
3	// File : primer_design.cxx //
4	// Purpose : //
5	// //
6	// Coded by Wolfram Foerster in February 2001 //
7	// Institute of Microbiology (Technical University Munich) //
8	// http://www.arb-home.de/ //
9	// //
10	// =============================================================== //
11
12	#include "primer_design.hxx"
13	#include "PRD_Design.hxx"
14	#include "PRD_SequenceIterator.hxx"
15
16	#include <GEN.hxx>
17
18	#include <awt_sel_boxes.hxx>
19	#include <awt_config_manager.hxx>
20
21	#include <aw_awars.hxx>
22	#include <aw_msg.hxx>
23	#include <arb_progress.h>
24	#include <aw_root.hxx>
25	#include <aw_question.hxx>
26	#include <aw_select.hxx>
27
28	#include <arbdbt.h>
29	#include <adGene.h>
30
31	#include <string>
32	#include <cmath>
33
34	using std::string;
35
36	static AW_window_simple *pdrw = 0;
37	static AW_selection_list *resultList = 0;
38
39	static double get_estimated_memory(AW_root *root) {
40	int bases = root->awar(AWAR_PRIMER_DESIGN_LEFT_LENGTH)->read_int() + root->awar(AWAR_PRIMER_DESIGN_RIGHT_LENGTH)->read_int();
41	int length = root->awar(AWAR_PRIMER_DESIGN_LENGTH_MAX)->read_int();
42	double mem = baseslength0.9*(sizeof(Node)+16);
43	return mem;
44	}
45
46	static void primer_design_event_update_memory(AW_root *root) {
47	double mem = get_estimated_memory(root);
48	const char *display = NULL;
49
50	if (mem > 1073741824) {
51	mem = mem / 1073741824;
52	display = GBS_global_string("%.1f TB", mem);
53	}
54	else if (mem > 1048576) {
55	mem = mem / 1048576;
56	display = GBS_global_string("%.1f MB", mem);
57	}
58	else if (mem > 1024) {
59	mem = mem / 1024;
60	display = GBS_global_string("%.1f KB", mem);
61	}
62	else {
63	display = GBS_global_string("%.0f bytes", mem);
64	}
65	root->awar(AWAR_PRIMER_DESIGN_APROX_MEM)->write_string(display);
66	}
67
68	static void primer_design_event_check_primer_length(AW_root *root, bool max_changed) {
69	static bool avoid_recursion = false;
70
71	if (!avoid_recursion) {
72	avoid_recursion = true;
73
74	int min_length = root->awar(AWAR_PRIMER_DESIGN_LENGTH_MIN)->read_int();
75	int max_length = root->awar(AWAR_PRIMER_DESIGN_LENGTH_MAX)->read_int();
76
77	if (max_length<1) max_length = 1;
78	if (min_length<1) min_length = 1;
79
80	if (min_length > max_length) {
81	if (max_changed) min_length = max_length;
82	else max_length = min_length;
83	}
84
85	prd_assert(min_length>0);
86
87	root->awar(AWAR_PRIMER_DESIGN_LENGTH_MIN)->write_int(min_length);
88	root->awar(AWAR_PRIMER_DESIGN_LENGTH_MAX)->write_int(max_length);
89
90	avoid_recursion = false;
91	}
92	}
93
94	void create_primer_design_variables(AW_root *aw_root, AW_default aw_def, AW_default global) {
95	aw_root->awar_int(AWAR_PRIMER_DESIGN_LEFT_POS, 0, aw_def);
96	aw_root->awar_int(AWAR_PRIMER_DESIGN_LEFT_LENGTH, 100, aw_def)->add_callback(primer_design_event_update_memory);
97	aw_root->awar_int(AWAR_PRIMER_DESIGN_RIGHT_POS, 1000, aw_def);
98	aw_root->awar_int(AWAR_PRIMER_DESIGN_RIGHT_LENGTH, 100, aw_def)->add_callback(primer_design_event_update_memory);
99	aw_root->awar_int(AWAR_PRIMER_DESIGN_LENGTH_MIN, 10, aw_def)->add_callback(makeRootCallback(primer_design_event_check_primer_length, false));
100	aw_root->awar_int(AWAR_PRIMER_DESIGN_LENGTH_MAX, 20, aw_def)->add_callback(makeRootCallback(primer_design_event_check_primer_length, true));
101	aw_root->awar_int(AWAR_PRIMER_DESIGN_DIST_MIN, 1050, aw_def);
102	aw_root->awar_int(AWAR_PRIMER_DESIGN_DIST_MAX, 1200, aw_def);
103	aw_root->awar_int(AWAR_PRIMER_DESIGN_GCRATIO_MIN, 10, aw_def);
104	aw_root->awar_int(AWAR_PRIMER_DESIGN_GCRATIO_MAX, 50, aw_def);
105	aw_root->awar_int(AWAR_PRIMER_DESIGN_TEMPERATURE_MIN, 30, aw_def);
106	aw_root->awar_int(AWAR_PRIMER_DESIGN_TEMPERATURE_MAX, 80, aw_def);
107	aw_root->awar_int(AWAR_PRIMER_DESIGN_ALLOWED_MATCH_MIN_DIST, 0, aw_def);
108	aw_root->awar_int(AWAR_PRIMER_DESIGN_EXPAND_IUPAC, 1, aw_def);
109	aw_root->awar_int(AWAR_PRIMER_DESIGN_MAX_PAIRS, 25, aw_def);
110	aw_root->awar_int(AWAR_PRIMER_DESIGN_GC_FACTOR, 50, aw_def);
111	aw_root->awar_int(AWAR_PRIMER_DESIGN_TEMP_FACTOR, 50, aw_def);
112
113	aw_root->awar_string(AWAR_PRIMER_DESIGN_APROX_MEM, "", aw_def);
114
115	aw_root->awar_string(AWAR_PRIMER_TARGET_STRING, 0, global);
116
117	primer_design_event_update_memory(aw_root);
118	}
119
120	static void create_primer_design_result_window(AW_window *aww) {
121	if (!pdrw) {
122	pdrw = new AW_window_simple;
123	pdrw->init(aww->get_root(), "PRD_RESULT", "Primer Design RESULT");
124	pdrw->load_xfig("pd_reslt.fig");
125
126	pdrw->button_length(6);
127	pdrw->auto_space(10, 10);
128
129	pdrw->at("help");
130	pdrw->callback(makeHelpCallback("primer_result.hlp"));
131	pdrw->create_button("HELP", "HELP", "H");
132
133	pdrw->at("result");
134	resultList = pdrw->create_selection_list(AWAR_PRIMER_TARGET_STRING, 40, 5, true);
135
136	const StorableSelectionList *storable_primer_list = new StorableSelectionList(TypedSelectionList("prim", resultList, "primers", "primer")); // never freed
137
138	pdrw->at("buttons");
139
140	pdrw->callback(AW_POPDOWN);
141	pdrw->create_button("CLOSE", "CLOSE", "C");
142
143	pdrw->callback(makeWindowCallback(awt_clear_selection_list_cb, resultList));
144	pdrw->create_button("CLEAR", "CLEAR", "R");
145
146	pdrw->callback(makeCreateWindowCallback(create_load_box_for_selection_lists, storable_primer_list));
147	pdrw->create_button("LOAD", "LOAD", "L");
148
149	pdrw->callback(makeCreateWindowCallback(create_save_box_for_selection_lists, storable_primer_list));
150	pdrw->create_button("SAVE", "SAVE", "S");
151
152	pdrw->callback(makeWindowCallback(create_print_box_for_selection_lists, &storable_primer_list->get_typedsellist()));
153	pdrw->create_button("PRINT", "PRINT", "P");
154	}
155
156	pdrw->show();
157	}
158
159	static void primer_design_event_go(AW_window aww, GBDATA gb_main) {
160	AW_root *root = aww->get_root();
161	GB_ERROR error = 0;
162	char *sequence = 0;
163	long int length = 0;
164
165	if ((get_estimated_memory(root)/1024.0) > GB_get_usable_memory()) {
166	if (aw_question(NULL, "ARB may crash due to memory problems.", "Continue, Abort") == 1) {
167	return;
168	}
169	}
170
171	{
172
173	GB_transaction ta(gb_main);
174	char *selected_species = root->awar(AWAR_SPECIES_NAME)->read_string();
175	GBDATA *gb_species = GBT_find_species(gb_main, selected_species);
176
177	if (!gb_species) {
178	error = "you have to select a species!";
179	}
180	else {
181	const char *alignment = GBT_get_default_alignment(gb_main);
182	GBDATA *gb_seq = GBT_find_sequence(gb_species, alignment);
183
184	if (!gb_seq) {
185	error = GBS_global_string("Selected species has no sequence data in alignment '%s'", alignment);
186	}
187	else {
188	sequence = GB_read_string(gb_seq);
189	length = GB_read_count(gb_seq);
190	}
191	}
192	}
193
194	if (!error) {
195	arb_progress progress("Searching PCR primer pairs");
196	PrimerDesign *PD =
197	new PrimerDesign(sequence, length,
198	Range(root->awar(AWAR_PRIMER_DESIGN_LEFT_POS)->read_int(), root->awar(AWAR_PRIMER_DESIGN_LEFT_LENGTH)->read_int()),
199	Range(root->awar(AWAR_PRIMER_DESIGN_RIGHT_POS)->read_int(), root->awar(AWAR_PRIMER_DESIGN_RIGHT_LENGTH)->read_int()),
200	Range(root->awar(AWAR_PRIMER_DESIGN_LENGTH_MIN)->read_int(), root->awar(AWAR_PRIMER_DESIGN_LENGTH_MAX)->read_int()),
201	Range(root->awar(AWAR_PRIMER_DESIGN_DIST_MIN)->read_int(), root->awar(AWAR_PRIMER_DESIGN_DIST_MAX)->read_int()),
202	Range(root->awar(AWAR_PRIMER_DESIGN_GCRATIO_MIN)->read_int(), root->awar(AWAR_PRIMER_DESIGN_GCRATIO_MAX)->read_int()),
203	Range(root->awar(AWAR_PRIMER_DESIGN_TEMPERATURE_MIN)->read_int(), root->awar(AWAR_PRIMER_DESIGN_TEMPERATURE_MAX)->read_int()),
204	root->awar(AWAR_PRIMER_DESIGN_ALLOWED_MATCH_MIN_DIST)->read_int(),
205	(bool)root->awar(AWAR_PRIMER_DESIGN_EXPAND_IUPAC)->read_int(),
206	root->awar(AWAR_PRIMER_DESIGN_MAX_PAIRS)->read_int(),
207	(float)root->awar(AWAR_PRIMER_DESIGN_GC_FACTOR)->read_int()/100,
208	(float)root->awar(AWAR_PRIMER_DESIGN_TEMP_FACTOR)->read_int()/100
209	);
210
211	try {
212	PD->run();
213	}
214
215	catch (string& s) {
216	error = GBS_static_string(s.c_str());
217	}
218	catch (...) {
219	error = "Unknown error (maybe out of memory ? )";
220	}
221	if (!error) error = PD->get_error();
222
223	if (!error) {
224	if (!resultList) create_primer_design_result_window(aww);
225	prd_assert(resultList);
226
227	// create result-list:
228	resultList->clear();
229	int max_primer_length = PD->get_max_primer_length();
230	int max_position_length = int(std::log10(double (PD->get_max_primer_pos())))+1;
231	int max_length_length = int(std::log10(double(PD->get_max_primer_length())))+1;
232
233	if (max_position_length < 3) max_position_length = 3;
234	if (max_length_length < 3) max_length_length = 3;
235
236	resultList->insert(GBS_global_string(" Rating \| %-s %-s %-s G/C Tmp \| %-s %-s %-s G/C Tmp",
237	max_primer_length, "Left primer",
238	max_position_length, "Pos",
239	max_length_length, "Len",
240	max_primer_length, "Right primer",
241	max_position_length, "Pos",
242	max_length_length, "Len"),
243	"");
244
245	int r;
246
247	for (r = 0; ; ++r) {
248	const char *primers = 0;
249	const char *result = PD->get_result(r, primers, max_primer_length, max_position_length, max_length_length);
250	if (!result) break;
251	resultList->insert(result, primers);
252	}
253
254	resultList->insert_default(r ? "** End of list" : "** There are no results", "");
255	resultList->update();
256
257	pdrw->show();
258	}
259	}
260	if (sequence) free(sequence);
261	if (error) aw_message(error);
262	}
263
264
265	static void primer_design_event_check_temp_factor(AW_window *aww) {
266	AW_root *root = aww->get_root();
267
268	int temp = root->awar(AWAR_PRIMER_DESIGN_TEMP_FACTOR)->read_int();
269	if (temp > 100) temp = 100;
270	if (temp < 0) temp = 0;
271	root->awar(AWAR_PRIMER_DESIGN_TEMP_FACTOR)->write_int(temp);
272	root->awar(AWAR_PRIMER_DESIGN_GC_FACTOR)->write_int(100-temp);
273	}
274
275	static void primer_design_event_check_gc_factor(AW_window *aww) {
276	AW_root *root = aww->get_root();
277
278	int gc = root->awar(AWAR_PRIMER_DESIGN_GC_FACTOR)->read_int();
279	if (gc > 100) gc = 100;
280	if (gc < 0) gc = 0;
281	root->awar(AWAR_PRIMER_DESIGN_GC_FACTOR)->write_int(gc);
282	root->awar(AWAR_PRIMER_DESIGN_TEMP_FACTOR)->write_int(100-gc);
283	}
284
285	static void primer_design_event_init(AW_window aww, GBDATA gb_main, bool from_gene) {
286	GB_transaction ta(gb_main);
287
288	AW_root *root = aww->get_root();
289	GB_ERROR error = 0;
290	char *selected_species = 0;
291	char *selected_gene = 0;
292	GBDATA *gb_species = 0;
293	GBDATA *gb_gene = 0;
294	GEN_position *genPos = 0;
295	GBDATA *gb_seq = 0;
296	bool is_genom_db = GEN_is_genome_db(gb_main, -1);
297
298	if (is_genom_db && from_gene) {
299	selected_species = root->awar(AWAR_ORGANISM_NAME)->read_string();
300	selected_gene = root->awar(AWAR_GENE_NAME)->read_string();
301
302	root->awar(AWAR_SPECIES_NAME)->write_string(selected_species);
303	}
304	else {
305	selected_species = root->awar(AWAR_SPECIES_NAME)->read_string();
306	}
307
308	gb_species = GBT_find_species(gb_main, selected_species);
309
310	if (!gb_species) {
311	error = "You have to select a species!";
312	}
313	else {
314	const char *alignment = GBT_get_default_alignment(gb_main);
315	gb_seq = GBT_find_sequence(gb_species, alignment);
316	if (!gb_seq) {
317	error = GB_export_errorf("Species '%s' has no data in alignment '%s'", selected_species, alignment);
318	}
319	}
320
321	if (!error && from_gene) {
322	prd_assert(is_genom_db); // otherwise button should not exist
323
324	gb_gene = GEN_find_gene(gb_species, selected_gene);
325	if (!gb_gene) {
326	error = GB_export_errorf("Species '%s' has no gene named '%s'", selected_species, selected_gene);
327	}
328	else {
329	genPos = GEN_read_position(gb_gene);
330	if (!genPos) {
331	error = GB_await_error();
332	}
333	else if (!genPos->joinable) {
334	error = GBS_global_string("Gene '%s' is not joinable", selected_gene);
335	}
336	}
337	}
338
339	if (!error && gb_seq) {
340	SequenceIterator *i = 0;
341	PRD_Sequence_Pos length = 0;
342	PRD_Sequence_Pos add_offset = 0; // offset to add to positions (used for genes)
343	char *sequence = 0;
344
345	if (gb_gene) {
346	size_t gene_length;
347	sequence = GBT_read_gene_sequence_and_length(gb_gene, false, 0, &gene_length);
348	if (!sequence) {
349	error = GB_await_error();
350	}
351	else {
352	length = gene_length;
353	add_offset = genPos->start_pos[0];
354	#if defined(WARN_TODO)
355	#warning does this work with split genes ?
356	#warning warn about uncertainties ?
357	#endif
358	}
359	}
360	else {
361	sequence = GB_read_string(gb_seq);
362	length = strlen(sequence);
363	}
364
365	if (!error) {
366	long int dist_min;
367	long int dist_max;
368
369	// find reasonable parameters
370	// left pos (first base from start)
371
372	long int left_len = root->awar(AWAR_PRIMER_DESIGN_LEFT_LENGTH)->read_int();
373	if (left_len == 0 \|\| left_len<0) left_len = 100;
374
375	i = new SequenceIterator(sequence, 0, SequenceIterator::IGNORE, left_len, SequenceIterator::FORWARD);
376
377	i->nextBase(); // find first base from start
378	PRD_Sequence_Pos left_min = i->pos; // store pos. of first base
379	while (i->nextBase() != SequenceIterator::EOS) ; // step to 'left_len'th base from start
380	PRD_Sequence_Pos left_max = i->pos; // store pos. of 'left_len'th base
381
382	root->awar(AWAR_PRIMER_DESIGN_LEFT_POS)->write_int(left_min+add_offset);
383	root->awar(AWAR_PRIMER_DESIGN_LEFT_LENGTH)->write_int(left_len);
384
385	long int right_len = root->awar(AWAR_PRIMER_DESIGN_RIGHT_LENGTH)->read_int();
386	if (right_len == 0 \|\| right_len<0) right_len = 100;
387
388	// right pos ('right_len'th base from end)
389	i->restart(length, 0, right_len, SequenceIterator::BACKWARD);
390
391	i->nextBase(); // find last base
392	PRD_Sequence_Pos right_max = i->pos; // store pos. of last base
393	while (i->nextBase() != SequenceIterator::EOS) ; // step to 'right_len'th base from end
394	PRD_Sequence_Pos right_min = i->pos; // store pos of 'right_len'th base from end
395
396	root->awar(AWAR_PRIMER_DESIGN_RIGHT_POS)->write_int(right_min+add_offset);
397	root->awar(AWAR_PRIMER_DESIGN_RIGHT_LENGTH)->write_int(right_len);
398
399	// primer distance
400	if (right_min >= left_max) { // non-overlapping ranges
401	i->restart(left_max, right_min, SequenceIterator::IGNORE, SequenceIterator::FORWARD);
402	long int bases_between = 0; // count bases from right_min to left_max
403	while (i->nextBase() != SequenceIterator::EOS) ++bases_between;
404	dist_min = bases_between; // take bases between as min distance
405	}
406	else { // overlapping ranges
407	dist_min = right_min - left_min + 1;
408	}
409	dist_max = right_max - left_min;
410	root->awar(AWAR_PRIMER_DESIGN_DIST_MIN)->write_int(dist_min);
411	root->awar(AWAR_PRIMER_DESIGN_DIST_MAX)->write_int(dist_max);
412
413	#if defined(DUMP_PRIMER)
414	printf ("primer_design_event_init : left_min %7li\n", left_min);
415	printf ("primer_design_event_init : left_max %7li\n", left_max);
416	printf ("primer_design_event_init : right_min %7li\n", right_min);
417	printf ("primer_design_event_init : right_max %7li\n", right_max);
418	printf ("primer_design_event_init : dist_min %7li\n", dist_min);
419	printf ("primer_design_event_init : dist_max %7li\n\n", dist_max);
420	#endif
421	}
422	delete i;
423	free(sequence);
424	}
425
426	if (error) {
427	aw_message(error);
428	}
429
430	GEN_free_position(genPos);
431	free(selected_gene);
432	free(selected_species);
433	}
434
435	static AWT_config_mapping_def primer_design_config_mapping[] = {
436	{ AWAR_PRIMER_DESIGN_LEFT_POS, "lpos" },
437	{ AWAR_PRIMER_DESIGN_LEFT_LENGTH, "llen" },
438	{ AWAR_PRIMER_DESIGN_RIGHT_POS, "rpos" },
439	{ AWAR_PRIMER_DESIGN_RIGHT_LENGTH, "rlen" },
440	{ AWAR_PRIMER_DESIGN_LENGTH_MIN, "lenmin" },
441	{ AWAR_PRIMER_DESIGN_LENGTH_MAX, "lenmax" },
442	{ AWAR_PRIMER_DESIGN_DIST_MIN, "distmin" },
443	{ AWAR_PRIMER_DESIGN_DIST_MAX, "distmax" },
444	{ AWAR_PRIMER_DESIGN_GCRATIO_MIN, "gcmin" },
445	{ AWAR_PRIMER_DESIGN_GCRATIO_MAX, "gcmax" },
446	{ AWAR_PRIMER_DESIGN_TEMPERATURE_MIN, "tempmin" },
447	{ AWAR_PRIMER_DESIGN_TEMPERATURE_MAX, "tempmax" },
448	{ AWAR_PRIMER_DESIGN_ALLOWED_MATCH_MIN_DIST, "minmatchdist" },
449	{ AWAR_PRIMER_DESIGN_EXPAND_IUPAC, "iupac" },
450	{ AWAR_PRIMER_DESIGN_MAX_PAIRS, "maxpairs" },
451	{ AWAR_PRIMER_DESIGN_GC_FACTOR, "gcfactor" },
452	{ AWAR_PRIMER_DESIGN_TEMP_FACTOR, "temp_factor" },
453	{ 0, 0 }
454	};
455
456	AW_window create_primer_design_window(AW_root root, GBDATA *gb_main) {
457	bool is_genome_db;
458	{
459	GB_transaction ta(gb_main);
460	char *selected_species = root->awar(AWAR_SPECIES_NAME)->read_string();
461	GBDATA *gb_species = GBT_find_species(gb_main, selected_species);
462
463	if (!gb_species) {
464	aw_message("You have to select a species!");
465	}
466
467	is_genome_db = GEN_is_genome_db(gb_main, -1);
468	}
469
470	AW_window_simple *aws = new AW_window_simple;
471	aws->init(root, "PRIMER_DESIGN", "PRIMER DESIGN");
472
473	aws->load_xfig("prd_main.fig");
474
475	aws->at("close");
476	aws->callback(AW_POPDOWN);
477	aws->create_button("CLOSE", "CLOSE", "C");
478
479	aws->at("help");
480	aws->callback(makeHelpCallback("primer_new.hlp"));
481	aws->create_button("HELP", "HELP", "H");
482
483	aws->at("init1");
484	aws->callback(makeWindowCallback(primer_design_event_init, gb_main, false));
485	aws->create_button("INIT_FROM_SPECIES", "Species", "I");
486
487	if (is_genome_db) {
488	aws->at("init2");
489	aws->callback(makeWindowCallback(primer_design_event_init, gb_main, true));
490	aws->create_button("INIT_FROM_GENE", "Gene", "I");
491	}
492
493	aws->at("design");
494	aws->callback(makeWindowCallback(primer_design_event_go, gb_main));
495	aws->create_button("GO", "GO", "G");
496	aws->highlight();
497
498	aws->at("minleft");
499	aws->create_input_field(AWAR_PRIMER_DESIGN_LEFT_POS, 7);
500
501	aws->at("maxleft");
502	aws->create_input_field(AWAR_PRIMER_DESIGN_LEFT_LENGTH, 9);
503
504	aws->at("minright");
505	aws->create_input_field(AWAR_PRIMER_DESIGN_RIGHT_POS, 7);
506
507	aws->at("maxright");
508	aws->create_input_field(AWAR_PRIMER_DESIGN_RIGHT_LENGTH, 9);
509
510	aws->at("minlen");
511	aws->create_input_field(AWAR_PRIMER_DESIGN_LENGTH_MIN, 7);
512
513	aws->at("maxlen");
514	aws->create_input_field(AWAR_PRIMER_DESIGN_LENGTH_MAX, 7);
515
516	aws->at("mindist"); aws->create_input_field(AWAR_PRIMER_DESIGN_DIST_MIN, 7);
517	aws->at("maxdist"); aws->create_input_field(AWAR_PRIMER_DESIGN_DIST_MAX, 7);
518	aws->at("mingc"); aws->create_input_field(AWAR_PRIMER_DESIGN_GCRATIO_MIN, 7);
519	aws->at("maxgc"); aws->create_input_field(AWAR_PRIMER_DESIGN_GCRATIO_MAX, 7);
520	aws->at("mintemp"); aws->create_input_field(AWAR_PRIMER_DESIGN_TEMPERATURE_MIN, 7);
521	aws->at("maxtemp"); aws->create_input_field(AWAR_PRIMER_DESIGN_TEMPERATURE_MAX, 7);
522	aws->at("allowed_match"); aws->create_input_field(AWAR_PRIMER_DESIGN_ALLOWED_MATCH_MIN_DIST, 7);
523	aws->at("max_pairs"); aws->create_input_field(AWAR_PRIMER_DESIGN_MAX_PAIRS, 7);
524
525	aws->at("expand_IUPAC");
526	aws->create_toggle(AWAR_PRIMER_DESIGN_EXPAND_IUPAC);
527
528	aws->at("GC_factor");
529	aws->callback(primer_design_event_check_gc_factor); // @@@ used as INPUTFIELD_CB (see #559)
530	aws->create_input_field(AWAR_PRIMER_DESIGN_GC_FACTOR, 7);
531
532	aws->at("temp_factor");
533	aws->callback(primer_design_event_check_temp_factor); // @@@ used as INPUTFIELD_CB (see #559)
534	aws->create_input_field(AWAR_PRIMER_DESIGN_TEMP_FACTOR, 7);
535
536	aws->at("config");
537	AWT_insert_config_manager(aws, AW_ROOT_DEFAULT, "pcr_primer_design", primer_design_config_mapping);
538
539	aws->at("aprox_mem");
540	aws->button_length(11);
541	aws->create_button(NULL, AWAR_PRIMER_DESIGN_APROX_MEM, 0, "+");
542
543	return aws;
544	}

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

Download in other formats: