ARB
primer_design.cxx
Go to the documentation of this file.
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 = NULp;
38 
39 static double get_estimated_memory(AW_root *root) {
42  double mem = bases*length*0.9*(sizeof(Node)+16);
43  return mem;
44 }
45 
47  double mem = get_estimated_memory(root);
48  const char *display = NULp;
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  }
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 
95  aw_root->awar_int(AWAR_PRIMER_DESIGN_LEFT_POS, 0, aw_def);
97  aw_root->awar_int(AWAR_PRIMER_DESIGN_RIGHT_POS, 1000, aw_def);
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);
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  aw_root->awar_string(AWAR_PRIMER_TARGET_STRING, NULp, global);
115 
117 }
118 
120  if (!pdrw) {
121  pdrw = new AW_window_simple;
122  pdrw->init(aww->get_root(), "PRD_RESULT", "Primer Design RESULT");
123  pdrw->load_xfig("pd_reslt.fig");
124 
125  pdrw->button_length(6);
126  pdrw->auto_space(10, 10);
127 
128  pdrw->at("help");
129  pdrw->callback(makeHelpCallback("primer_result.hlp"));
130  pdrw->create_button("HELP", "HELP", "H");
131 
132  pdrw->at("result");
133  resultList = pdrw->create_selection_list(AWAR_PRIMER_TARGET_STRING, 40, 5, true);
134 
135  const StorableSelectionList *storable_primer_list = new StorableSelectionList(TypedSelectionList("prim", resultList, "primers", "primer")); // never freed
136 
137  pdrw->at("buttons");
138 
139  pdrw->callback(AW_POPDOWN);
140  pdrw->create_button("CLOSE", "CLOSE", "C");
141 
142  pdrw->callback(makeWindowCallback(awt_clear_selection_list_cb, resultList));
143  pdrw->create_button("CLEAR", "CLEAR", "R");
144 
145  pdrw->callback(makeCreateWindowCallback(create_load_box_for_selection_lists, storable_primer_list));
146  pdrw->create_button("LOAD", "LOAD", "L");
147 
148  pdrw->callback(makeCreateWindowCallback(create_save_box_for_selection_lists, storable_primer_list));
149  pdrw->create_button("SAVE", "SAVE", "S");
150 
151  pdrw->callback(makeWindowCallback(create_print_box_for_selection_lists, &storable_primer_list->get_typedsellist()));
152  pdrw->create_button("PRINT", "PRINT", "P");
153  }
154 
155  pdrw->show();
156 }
157 
159  AW_root *root = aww->get_root();
160  GB_ERROR error = NULp;
161  char *sequence = NULp;
162  long int length = 0;
163 
164  if ((get_estimated_memory(root)/1024.0) > GB_get_usable_memory()) {
165  if (aw_question(NULp, "ARB may crash due to memory problems.", "Continue, Abort") == 1) {
166  return;
167  }
168  }
169 
170  {
171  GB_transaction ta(gb_main);
172  char *selected_species = root->awar(AWAR_SPECIES_NAME)->read_string();
173  GBDATA *gb_species = GBT_find_species(gb_main, selected_species);
174 
175  if (!gb_species) {
176  error = "you have to select a species!";
177  }
178  else {
179  const char *alignment = GBT_get_default_alignment(gb_main);
180  GBDATA *gb_seq = GBT_find_sequence(gb_species, alignment);
181 
182  if (!gb_seq) {
183  error = GBS_global_string("Selected species has no sequence data in alignment '%s'", alignment);
184  }
185  else {
186  sequence = GB_read_string(gb_seq);
187  length = GB_read_count(gb_seq);
188  }
189  }
190  }
191 
192  if (!error) {
193  arb_progress progress("Searching PCR primer pairs");
194  PrimerDesign *PD =
195  new PrimerDesign(sequence, length,
205  (float)root->awar(AWAR_PRIMER_DESIGN_GC_FACTOR)->read_int()/100,
206  (float)root->awar(AWAR_PRIMER_DESIGN_TEMP_FACTOR)->read_int()/100
207  );
208 
209  try {
210  PD->run();
211  }
212 
213  catch (string& s) {
214  error = GBS_static_string(s.c_str());
215  }
216  catch (...) {
217  error = "Unknown error (maybe out of memory ? )";
218  }
219  if (!error) error = PD->get_error();
220 
221  if (!error) {
222  if (!resultList) create_primer_design_result_window(aww);
223  prd_assert(resultList);
224 
225  // create result-list:
226  resultList->clear();
227  int max_primer_length = PD->get_max_primer_length();
228  int max_position_length = int(std::log10(double (PD->get_max_primer_pos())))+1;
229  int max_length_length = int(std::log10(double(PD->get_max_primer_length())))+1;
230 
231  if (max_position_length < 3) max_position_length = 3;
232  if (max_length_length < 3) max_length_length = 3;
233 
234  resultList->insert(GBS_global_string(" Rating | %-*s %-*s %-*s G/C Tmp | %-*s %-*s %-*s G/C Tmp",
235  max_primer_length, "Left primer",
236  max_position_length, "Pos",
237  max_length_length, "Len",
238  max_primer_length, "Right primer",
239  max_position_length, "Pos",
240  max_length_length, "Len"),
241  "");
242 
243  int r;
244 
245  for (r = 0; ; ++r) {
246  const char *primers = NULp;
247  const char *result = PD->get_result(r, primers, max_primer_length, max_position_length, max_length_length);
248  if (!result) break;
249  resultList->insert(result, primers);
250  }
251 
252  resultList->insert_default(r ? "**** End of list" : "**** There are no results", "");
253  resultList->update();
254 
255  pdrw->show();
256  }
257  }
258  if (sequence) free(sequence);
259  if (error) aw_message(error);
260 }
261 
262 
264  AW_root *root = aww->get_root();
265 
266  int temp = root->awar(AWAR_PRIMER_DESIGN_TEMP_FACTOR)->read_int();
267  if (temp > 100) temp = 100;
268  if (temp < 0) temp = 0;
270  root->awar(AWAR_PRIMER_DESIGN_GC_FACTOR)->write_int(100-temp);
271 }
272 
274  AW_root *root = aww->get_root();
275 
276  int gc = root->awar(AWAR_PRIMER_DESIGN_GC_FACTOR)->read_int();
277  if (gc > 100) gc = 100;
278  if (gc < 0) gc = 0;
281 }
282 
283 static void primer_design_event_init(AW_window *aww, GBDATA *gb_main, bool from_gene) {
284  GB_transaction ta(gb_main);
285 
286  AW_root *root = aww->get_root();
287  GB_ERROR error = NULp;
288  char *selected_species = NULp;
289  char *selected_gene = NULp;
290  GBDATA *gb_species = NULp;
291  GBDATA *gb_gene = NULp;
292  GEN_position *genPos = NULp;
293  GBDATA *gb_seq = NULp;
294  bool is_genom_db = GEN_is_genome_db(gb_main, -1);
295 
296  if (is_genom_db && from_gene) {
297  selected_species = root->awar(AWAR_ORGANISM_NAME)->read_string();
298  selected_gene = root->awar(AWAR_GENE_NAME)->read_string();
299 
300  root->awar(AWAR_SPECIES_NAME)->write_string(selected_species);
301  }
302  else {
303  selected_species = root->awar(AWAR_SPECIES_NAME)->read_string();
304  }
305 
306  gb_species = GBT_find_species(gb_main, selected_species);
307 
308  if (!gb_species) {
309  error = "You have to select a species!";
310  }
311  else {
312  const char *alignment = GBT_get_default_alignment(gb_main);
313  gb_seq = GBT_find_sequence(gb_species, alignment);
314  if (!gb_seq) {
315  error = GB_export_errorf("Species '%s' has no data in alignment '%s'", selected_species, alignment);
316  }
317  }
318 
319  if (!error && from_gene) {
320  prd_assert(is_genom_db); // otherwise button should not exist
321 
322  gb_gene = GEN_find_gene(gb_species, selected_gene);
323  if (!gb_gene) {
324  error = GB_export_errorf("Species '%s' has no gene named '%s'", selected_species, selected_gene);
325  }
326  else {
327  genPos = GEN_read_position(gb_gene);
328  if (!genPos) {
329  error = GB_await_error();
330  }
331  else if (!genPos->joinable) {
332  error = GBS_global_string("Gene '%s' is not joinable", selected_gene);
333  }
334  }
335  }
336 
337  if (!error && gb_seq) {
338  SequenceIterator *i = NULp;
340  PRD_Sequence_Pos add_offset = 0; // offset to add to positions (used for genes)
341  char *sequence = NULp;
342 
343  if (gb_gene) {
344  size_t gene_length;
345  sequence = GBT_read_gene_sequence_and_length(gb_gene, false, 0, &gene_length);
346  if (!sequence) {
347  error = GB_await_error();
348  }
349  else {
350  length = gene_length;
351  add_offset = genPos->start_pos[0];
352 #if defined(WARN_TODO)
353 #warning does this work with split genes ?
354 #warning warn about uncertainties ?
355 #endif
356  }
357  }
358  else {
359  sequence = GB_read_string(gb_seq);
360  length = strlen(sequence);
361  }
362 
363  if (!error) {
364  long int dist_min;
365  long int dist_max;
366 
367  // find reasonable parameters
368  // left pos (first base from start)
369 
370  long int left_len = root->awar(AWAR_PRIMER_DESIGN_LEFT_LENGTH)->read_int();
371  if (left_len == 0 || left_len<0) left_len = 100;
372 
374 
375  i->nextBase(); // find first base from start
376  PRD_Sequence_Pos left_min = i->pos; // store pos. of first base
377  while (i->nextBase() != SequenceIterator::EOS) ; // step to 'left_len'th base from start
378  PRD_Sequence_Pos left_max = i->pos; // store pos. of 'left_len'th base
379 
380  root->awar(AWAR_PRIMER_DESIGN_LEFT_POS)->write_int(left_min+add_offset);
382 
383  long int right_len = root->awar(AWAR_PRIMER_DESIGN_RIGHT_LENGTH)->read_int();
384  if (right_len == 0 || right_len<0) right_len = 100;
385 
386  // right pos ('right_len'th base from end)
387  i->restart(length, 0, right_len, SequenceIterator::BACKWARD);
388 
389  i->nextBase(); // find last base
390  PRD_Sequence_Pos right_max = i->pos; // store pos. of last base
391  while (i->nextBase() != SequenceIterator::EOS) ; // step to 'right_len'th base from end
392  PRD_Sequence_Pos right_min = i->pos; // store pos of 'right_len'th base from end
393 
394  root->awar(AWAR_PRIMER_DESIGN_RIGHT_POS)->write_int(right_min+add_offset);
396 
397  // primer distance
398  if (right_min >= left_max) { // non-overlapping ranges
400  long int bases_between = 0; // count bases from right_min to left_max
401  while (i->nextBase() != SequenceIterator::EOS) ++bases_between;
402  dist_min = bases_between; // take bases between as min distance
403  }
404  else { // overlapping ranges
405  dist_min = right_min - left_min + 1;
406  }
407  dist_max = right_max - left_min;
408  root->awar(AWAR_PRIMER_DESIGN_DIST_MIN)->write_int(dist_min);
409  root->awar(AWAR_PRIMER_DESIGN_DIST_MAX)->write_int(dist_max);
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 
434  { AWAR_PRIMER_DESIGN_LEFT_POS, "lpos" },
435  { AWAR_PRIMER_DESIGN_LEFT_LENGTH, "llen" },
436  { AWAR_PRIMER_DESIGN_RIGHT_POS, "rpos" },
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  { NULp, NULp }
452 };
453 
455  bool is_genome_db;
456  {
457  GB_transaction ta(gb_main);
458  char *selected_species = root->awar(AWAR_SPECIES_NAME)->read_string();
459  GBDATA *gb_species = GBT_find_species(gb_main, selected_species);
460 
461  if (!gb_species) {
462  aw_message("You have to select a species!");
463  }
464 
465  is_genome_db = GEN_is_genome_db(gb_main, -1);
466  }
467 
468  AW_window_simple *aws = new AW_window_simple;
469  aws->init(root, "PRIMER_DESIGN", "PRIMER DESIGN");
470 
471  aws->load_xfig("prd_main.fig");
472 
473  aws->at("close");
474  aws->callback(AW_POPDOWN);
475  aws->create_button("CLOSE", "CLOSE", "C");
476 
477  aws->at("help");
478  aws->callback(makeHelpCallback("primer_new.hlp"));
479  aws->create_button("HELP", "HELP", "H");
480 
481  aws->at("init1");
482  aws->callback(makeWindowCallback(primer_design_event_init, gb_main, false));
483  aws->create_button("INIT_FROM_SPECIES", "Species", "I");
484 
485  if (is_genome_db) {
486  aws->at("init2");
487  aws->callback(makeWindowCallback(primer_design_event_init, gb_main, true));
488  aws->create_button("INIT_FROM_GENE", "Gene", "I");
489  }
490 
491  aws->at("design");
492  aws->callback(makeWindowCallback(primer_design_event_go, gb_main));
493  aws->create_button("GO", "GO", "G");
494  aws->highlight();
495 
496  aws->at("minleft");
497  aws->create_input_field(AWAR_PRIMER_DESIGN_LEFT_POS, 7);
498 
499  aws->at("maxleft");
500  aws->create_input_field(AWAR_PRIMER_DESIGN_LEFT_LENGTH, 9);
501 
502  aws->at("minright");
503  aws->create_input_field(AWAR_PRIMER_DESIGN_RIGHT_POS, 7);
504 
505  aws->at("maxright");
506  aws->create_input_field(AWAR_PRIMER_DESIGN_RIGHT_LENGTH, 9);
507 
508  aws->at("minlen");
509  aws->create_input_field(AWAR_PRIMER_DESIGN_LENGTH_MIN, 7);
510 
511  aws->at("maxlen");
512  aws->create_input_field(AWAR_PRIMER_DESIGN_LENGTH_MAX, 7);
513 
514  aws->at("mindist"); aws->create_input_field(AWAR_PRIMER_DESIGN_DIST_MIN, 7);
515  aws->at("maxdist"); aws->create_input_field(AWAR_PRIMER_DESIGN_DIST_MAX, 7);
516  aws->at("mingc"); aws->create_input_field(AWAR_PRIMER_DESIGN_GCRATIO_MIN, 7);
517  aws->at("maxgc"); aws->create_input_field(AWAR_PRIMER_DESIGN_GCRATIO_MAX, 7);
518  aws->at("mintemp"); aws->create_input_field(AWAR_PRIMER_DESIGN_TEMPERATURE_MIN, 7);
519  aws->at("maxtemp"); aws->create_input_field(AWAR_PRIMER_DESIGN_TEMPERATURE_MAX, 7);
520  aws->at("allowed_match"); aws->create_input_field(AWAR_PRIMER_DESIGN_ALLOWED_MATCH_MIN_DIST, 7);
521  aws->at("max_pairs"); aws->create_input_field(AWAR_PRIMER_DESIGN_MAX_PAIRS, 7);
522 
523  aws->at("expand_IUPAC");
524  aws->create_toggle(AWAR_PRIMER_DESIGN_EXPAND_IUPAC);
525 
526  aws->at("GC_factor");
527  aws->callback(primer_design_event_check_gc_factor); // @@@ used as INPUTFIELD_CB (see #559)
528  aws->create_input_field(AWAR_PRIMER_DESIGN_GC_FACTOR, 7);
529 
530  aws->at("temp_factor");
531  aws->callback(primer_design_event_check_temp_factor); // @@@ used as INPUTFIELD_CB (see #559)
532  aws->create_input_field(AWAR_PRIMER_DESIGN_TEMP_FACTOR, 7);
533 
534  aws->at("config");
535  AWT_insert_config_manager(aws, AW_ROOT_DEFAULT, "pcr_primer_design", primer_design_config_mapping);
536 
537  aws->at("aprox_mem");
538  aws->button_length(11);
539  aws->create_button(NULp, AWAR_PRIMER_DESIGN_APROX_MEM, NULp, "+");
540 
541  return aws;
542 }
const char * get_result(int num, const char *&primers, int max_primer_length, int max_position_length, int max_length_length) const
Definition: PRD_Design.cxx:953
string result
#define AWAR_PRIMER_DESIGN_GC_FACTOR
static void create_primer_design_result_window(AW_window *aww)
#define AWAR_PRIMER_DESIGN_ALLOWED_MATCH_MIN_DIST
return string(buffer, length)
Definition: PRD_Node.hxx:9
void GEN_free_position(GEN_position *pos)
Definition: adGene.cxx:195
static void primer_design_event_init(AW_window *aww, GBDATA *gb_main, bool from_gene)
const TypedSelectionList & get_typedsellist() const
void insert_default(const char *displayed, const AW_scalar &value)
Definition: AW_select.cxx:385
GBDATA * GEN_find_gene(GBDATA *gb_species, const char *name)
Definition: adGene.cxx:64
unsigned char nextBase()
static void primer_design_event_check_primer_length(AW_root *root, bool max_changed)
#define AWAR_ORGANISM_NAME
void awt_clear_selection_list_cb(AW_window *, AW_selection_list *sellist)
static void primer_design_event_check_gc_factor(AW_window *aww)
void create_primer_design_variables(AW_root *aw_root, AW_default aw_def, AW_default global)
void AWT_insert_config_manager(AW_window *aww, AW_default default_file_, const char *id, const StoreConfigCallback &store_cb, const RestoreConfigCallback &load_or_reset_cb, const char *macro_id, const AWT_predefined_config *predef)
#define AWAR_PRIMER_DESIGN_GCRATIO_MIN
long read_int() const
Definition: AW_awar.cxx:187
#define AWAR_PRIMER_DESIGN_LEFT_POS
const char * GBS_global_string(const char *templat,...)
Definition: arb_msg.cxx:204
void AW_POPDOWN(AW_window *window)
Definition: AW_window.cxx:52
static AW_window_simple * pdrw
#define prd_assert(cond)
Definition: PRD_Globals.hxx:14
AW_window * create_primer_design_window(AW_root *root, GBDATA *gb_main)
#define AWAR_PRIMER_DESIGN_MAX_PAIRS
#define AWAR_PRIMER_DESIGN_RIGHT_POS
#define AWAR_PRIMER_DESIGN_EXPAND_IUPAC
PRD_Sequence_Pos pos
AW_awar * add_callback(const RootCallback &cb)
Definition: AW_awar.cxx:234
void insert(const char *displayed, const AW_scalar &value)
Definition: AW_select.cxx:380
#define AWAR_PRIMER_DESIGN_LEFT_LENGTH
GB_ERROR GB_await_error()
Definition: arb_msg.cxx:353
void restart(PRD_Sequence_Pos start_pos_, PRD_Sequence_Pos stop_pos_, int max_length_, int direction_)
WindowCallback makeHelpCallback(const char *helpfile)
Definition: aw_window.hxx:106
long GB_read_count(GBDATA *gbd)
Definition: arbdb.cxx:752
static const int FORWARD
static AW_selection_list * resultList
#define AWAR_PRIMER_DESIGN_APROX_MEM
#define AWAR_PRIMER_DESIGN_TEMPERATURE_MAX
static void error(const char *msg)
Definition: mkptypes.cxx:96
static double get_estimated_memory(AW_root *root)
#define AWAR_PRIMER_TARGET_STRING
void create_print_box_for_selection_lists(AW_window *aw_window, const TypedSelectionList *typedsellist)
static void primer_design_event_go(AW_window *aww, GBDATA *gb_main)
#define AWAR_SPECIES_NAME
char * read_string() const
Definition: AW_awar.cxx:201
AW_awar * awar(const char *awar)
Definition: AW_root.cxx:554
GBDATA * GBT_find_sequence(GBDATA *gb_species, const char *aliname)
Definition: adali.cxx:670
AW_window * create_load_box_for_selection_lists(AW_root *aw_root, const StorableSelectionList *storabsellist)
int aw_question(const char *unique_id, const char *question, const char *buttons, bool sameSizeButtons, const char *helpfile)
Definition: AW_question.cxx:26
PRD_Sequence_Pos get_max_primer_pos() const
Definition: PRD_Design.hxx:148
GB_ULONG GB_get_usable_memory(void)
Definition: adsocket.cxx:812
GB_ERROR GB_export_errorf(const char *templat,...)
Definition: arb_msg.cxx:264
#define AWAR_PRIMER_DESIGN_TEMPERATURE_MIN
AW_awar * awar_int(const char *var_name, long default_value=0, AW_default default_file=AW_ROOT_DEFAULT)
Definition: AW_root.cxx:580
GB_ERROR get_error() const
Definition: PRD_Design.hxx:145
static const int BACKWARD
#define AWAR_PRIMER_DESIGN_LENGTH_MAX
#define AWAR_PRIMER_DESIGN_DIST_MIN
char * GB_read_string(GBDATA *gbd)
Definition: arbdb.cxx:903
AW_window * create_save_box_for_selection_lists(AW_root *aw_root, const StorableSelectionList *storabsellist)
const char * GBS_static_string(const char *str)
Definition: arb_msg.cxx:213
#define AWAR_GENE_NAME
Definition: GEN.hxx:33
void aw_message(const char *msg)
Definition: AW_status.cxx:932
size_t * start_pos
Definition: adGene.h:39
#define AWAR_PRIMER_DESIGN_TEMP_FACTOR
#define AWAR_PRIMER_DESIGN_LENGTH_MIN
AW_root * get_root()
Definition: aw_window.hxx:348
#define NULp
Definition: cxxforward.h:97
GBDATA * GBT_find_species(GBDATA *gb_main, const char *name)
Definition: aditem.cxx:139
#define AWAR_PRIMER_DESIGN_RIGHT_LENGTH
GB_ERROR write_string(const char *aw_string)
char * GBT_get_default_alignment(GBDATA *gb_main)
Definition: adali.cxx:675
PrimerDesign * PD
Definition: PRD_main.cxx:22
static void primer_design_event_update_memory(AW_root *root)
GB_transaction ta(gb_var)
bool joinable
Definition: adGene.h:38
static void primer_design_event_check_temp_factor(AW_window *aww)
GBDATA * gb_main
Definition: adname.cxx:33
long int PRD_Sequence_Pos
Definition: PRD_Globals.hxx:21
PRD_Sequence_Pos get_max_primer_length() const
Definition: PRD_Design.hxx:147
static const char EOS
AW_awar * awar_string(const char *var_name, const char *default_value="", AW_default default_file=AW_ROOT_DEFAULT)
Definition: AW_root.cxx:570
NOT4PERL char * GBT_read_gene_sequence_and_length(GBDATA *gb_gene, bool use_revComplement, char partSeparator, size_t *gene_length)
Definition: adali.cxx:817
bool GEN_is_genome_db(GBDATA *gb_main, int default_value)
Definition: adGene.cxx:20
GEN_position * GEN_read_position(GBDATA *gb_gene)
Definition: adGene.cxx:250
size_t length
static AWT_config_mapping_def primer_design_config_mapping[]
static const int IGNORE
#define AW_ROOT_DEFAULT
Definition: aw_base.hxx:106
#define AWAR_PRIMER_DESIGN_DIST_MAX
GB_ERROR write_int(long aw_int)
#define AWAR_PRIMER_DESIGN_GCRATIO_MAX
GB_write_int const char s
Definition: AW_awar.cxx:156