source: tags/arb-6.0/PRIMER_DESIGN/primer_design.cxx

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