source: tags/svn.1.5.4/PRIMER_DESIGN/primer_design.cxx

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