ARB
probe_design.cxx
Go to the documentation of this file.
1 // =============================================================== //
2 // //
3 // File : probe_design.cxx //
4 // Purpose : //
5 // //
6 // Institute of Microbiology (Technical University Munich) //
7 // http://www.arb-home.de/ //
8 // //
9 // =============================================================== //
10 
12 #include "probe_match_parser.hxx"
13 
14 #include <PT_com.h>
15 #include <PT_server.h> // needed for DOMAIN_MIN_LENGTH
16 #include <client.h>
17 #include <servercntrl.h>
18 #include <probe_gui.hxx>
19 #include <probe_local.hxx>
20 
21 #include <GEN.hxx>
22 #include <TreeCallbacks.hxx>
23 
24 #include <iupac.h>
25 #include <awt_config_manager.hxx>
26 #include <awt_sel_boxes.hxx>
27 #include <awt_misc.hxx>
28 
29 #include <aw_awars.hxx>
30 #include <aw_preset.hxx>
31 #include <aw_select.hxx>
32 #include <aw_msg.hxx>
33 #include <aw_root.hxx>
34 #include <aw_question.hxx>
35 #include <aw_edit.hxx>
36 #include <aw_global_awars.hxx>
37 #include <rootAsWin.h>
38 
39 #include <adGene.h>
40 
41 #include <arb_progress.h>
42 #include <arb_strbuf.h>
43 #include <arb_file.h>
44 #include <arb_misc.h>
45 
46 #include "probe_collection.hxx"
47 
48 // general awars
49 
50 #define AWAR_PROBE_CREATE_GENE_SERVER "tmp/probe_admin/gene_server" // whether to create a gene pt server
51 
52 #define AWAR_ITARGET_STRING "nt/itarget_string"
53 
54 // probe match awars
55 
56 // #define AWAR_PD_MATCH_ITEM AWAR_SPECIES_NAME
57 #define AWAR_PD_SELECTED_MATCH "tmp/probe_design/match"
58 #define AWAR_PD_MATCH_RESOLVE "tmp/probe_design/match_resolve" // for IUPAC resolution
59 
60 #define AWAR_PD_MATCH_SORTBY "probe_match/sort_by" // weighted mismatches
61 #define AWAR_PD_MATCH_ALSO_REVCOMP "probe_match/complement" // check reverse complement too
62 #define AWAR_PD_MATCH_MARKHITS "probe_match/mark_hits" // mark hitten species in database
63 #define AWAR_PD_MATCH_WRITE2TMP "probe_match/write_2_tmp" // write result to field tmp
64 #define AWAR_PD_MATCH_AUTOMATCH "probe_match/auto_match" // auto match probes when target string changes
65 
66 #define AWAR_PD_MATCH_NHITS "tmp/probe_match/nhits" // display the 'number of hits'
67 
68 // probe design awars
69 
70 #define AWAR_PD_DESIGN_CLIPRESULT "probe_design/CLIPRESULT" // 'length of output' (how many probes will get designed)
71 #define AWAR_PD_DESIGN_MISHIT "probe_design/MISHIT" // 'non group hits'
72 #define AWAR_PD_DESIGN_MAXBOND "probe_design/MAXBOND" // max hairpinbonds ?
73 #define AWAR_PD_DESIGN_MINTARGETS "probe_design/MINTARGETS" // 'min. group hits (%)'
74 
75 #define AWAR_PD_DESIGN_MIN_LENGTH "probe_design/PROBELENGTH" // min. length of probe
76 #define AWAR_PD_DESIGN_MAX_LENGTH "probe_design/PROBEMAXLENGTH" // max. length of probe (or empty)
77 
78 #define AWAR_PD_DESIGN_MIN_TEMP "probe_design/MINTEMP" // temperature (min)
79 #define AWAR_PD_DESIGN_MAX_TEMP "probe_design/MAXTEMP" // temperature (max)
80 #define AWAR_PD_DESIGN_MIN_GC "probe_design/MINGC" // GC content (min)
81 #define AWAR_PD_DESIGN_MAX_GC "probe_design/MAXGC" // GC content (max)
82 #define AWAR_PD_DESIGN_MIN_ECOLIPOS "probe_design/MINECOLI" // ecolipos (min)
83 #define AWAR_PD_DESIGN_MAX_ECOLIPOS "probe_design/MAXECOLI" // ecolipos (max)
84 
85 #define AWAR_PD_DESIGN_GENE "probe_design/gene" // generate probes for genes ?
86 
87 // probe design/match (expert window)
88 #define AWAR_PD_COMMON_EXP_BONDS_FORMAT "probe_design/bonds/pos%i" // format to generate bond awar names
89 #define AWAR_PD_COMMON_EXP_SPLIT "probe_design/SPLIT"
90 
91 #define AWAR_PD_DESIGN_EXP_DTEDGE "probe_design/DTEDGE"
92 #define AWAR_PD_DESIGN_EXP_DT "probe_design/DT"
93 
94 #define AWAR_PD_MATCH_NMATCHES "probe_match/nmatches"
95 #define AWAR_PD_MATCH_LIM_NMATCH "probe_match/lim_nmatch"
96 #define AWAR_PD_MATCH_MAX_RES "probe_match/maxres"
97 
98 // --------------------------------
99 // probe collection awars
100 
101 // probe collection window
102 #define AWAR_PC_TARGET_STRING "probe_collection/target_string"
103 #define AWAR_PC_TARGET_NAME "probe_collection/target_name"
104 #define AWAR_PC_MATCH_WEIGHTS "probe_collection/match_weights/pos"
105 #define AWAR_PC_MATCH_WIDTH "probe_collection/match_weights/width"
106 #define AWAR_PC_MATCH_BIAS "probe_collection/match_weights/bias"
107 #define AWAR_PC_AUTO_MATCH "probe_collection/auto"
108 #define AWAR_PC_CURRENT_COLLECTION "probe_collection/current"
109 
110 #define AWAR_PC_SELECTED_PROBE "tmp/probe_collection/probe"
111 #define AWAR_PC_MATCH_NHITS "tmp/probe_collection/nhits"
112 
113 // probe collection matching control parameters
114 #define AWAR_PC_MISMATCH_THRESHOLD "probe_collection/mismatch_threshold"
115 
116 #define REPLACE_TARGET_CONTROL_CHARS ":#=_:\\:=_"
117 
118 // ----------------------------------------
119 
121 
122 static struct {
124  T_PT_LOCS locs;
125  T_PT_MAIN com;
126  AW_window_simple *win;
127  AW_selection_list *resultList; // @@@ replace by TypedSelectionList?
128 } PD;
129 
133  int *counter; // may be NULp (if specified -> afterwards contains number of hits)
134 
135  // results set by probe_match_event:
136  std::string hits_summary; // shown in probe match window
138 
139  void init_results() {
140  refresh_sai_display = false;
141  }
142 
143  ProbeMatchEventParam(GBDATA *gb_main_, int *counter_) : gb_main(gb_main_), selection_id(NULp), counter(counter_) { init_results(); }
144  ProbeMatchEventParam(GBDATA *gb_main_, AW_selection_list *id) : gb_main(gb_main_), selection_id(id), counter(NULp) { init_results(); }
145 };
146 
149  bool disable;
150 
151  AutoMatchSettings(ProbeMatchEventParam *event_param_, bool disable_)
152  : event_param(event_param_), disable(disable_)
153  {}
155  event_param(NULp),
156  disable(true)
157  {}
158 
159  bool initialized() const { return event_param; }
160 };
161 
163 
164 // prototypes:
165 static void probe_match_event_using_awars(AW_root *root, ProbeMatchEventParam *event_param);
166 
167 static void auto_match_cb(AW_root *root) {
168  if (!auto_match_cb_settings.disable) {
169  char *ts = root->awar(AWAR_TARGET_STRING)->read_string();
170  if (strlen(ts) > 0) {
171  probe_match_event_using_awars(root, auto_match_cb_settings.event_param);
172  }
173  free(ts);
174  }
175 }
176 
177 static const char *auto_match_sensitive_awars[] = {
183  NULp
184 };
185 
186 static void auto_match_changed(AW_root *root) {
187  static bool callback_active = false;
188  int autoMatch = root->awar(AWAR_PD_MATCH_AUTOMATCH)->read_int();
189 
190  if (autoMatch) {
191  if (!callback_active) {
192  for (int i = 0; auto_match_sensitive_awars[i]; ++i) {
193  root->awar(auto_match_sensitive_awars[i])->add_callback(auto_match_cb);
194  }
195  }
196  }
197  else {
198  if (callback_active) {
199  for (int i = 0; auto_match_sensitive_awars[i]; ++i) {
200  root->awar(auto_match_sensitive_awars[i])->remove_callback(auto_match_cb);
201  }
202  }
203  }
204  callback_active = bool(autoMatch);
205 }
206 
207 static void enable_auto_match_cb(AW_root *root, ProbeMatchEventParam *event_param) {
208  if (!event_param && auto_match_cb_settings.initialized()) {
209  // "partially" enable (w/o ProbeMatchEventParam) is only done
210  // if not already "fully enabled"
211  return;
212  }
213 
214  auto_match_cb_settings = AutoMatchSettings(event_param, false);
215  auto_match_changed(root);
216 }
217 
218 static void popup_match_window_cb(AW_window *aww, GBDATA *gb_main) { // @@@ shall be called by auto_match_cb (if never opened b4)
219  AW_root *root = aww->get_root();
220  AW_window *match_window = create_probe_match_window(root, gb_main);
221  match_window->activate();
222  root->awar(AWAR_TARGET_STRING)->touch(); // force re-match
223 }
224 
225 // --------------------------------------------------------------------------------
226 
228  if (!PD.win) {
229  AW_root *root = aww->get_root();
230 
231  PD.win = new AW_window_simple;
232  PD.win->init(root, "PD_RESULT", "PD RESULT");
233  PD.win->load_xfig("pd_reslt.fig");
234 
235  PD.win->button_length(6);
236  PD.win->auto_space(10, 10);
237 
238  PD.win->at("help");
239  PD.win->callback(makeHelpCallback("probedesignresult.hlp"));
240  PD.win->create_button("HELP", "HELP", "H");
241 
242  PD.win->at("result");
243  PD.resultList = PD.win->create_selection_list(AWAR_TARGET_STRING, 40, 5);
244  const StorableSelectionList *storable_result_list = new StorableSelectionList(TypedSelectionList("prb", PD.resultList, "designed probes", "designed")); // @@@ make member of PD ?
245 
246  PD.resultList->clear();
247  PD.resultList->insert_default("No probes designed yet", "");
248 
249  PD.win->at("buttons");
250 
251  PD.win->callback(AW_POPDOWN);
252  PD.win->create_button("CLOSE", "CLOSE", "C");
253 
254  PD.win->callback(makeWindowCallback(awt_clear_selection_list_cb, PD.resultList));
255  PD.win->create_button("CLEAR", "CLEAR", "R");
256 
257  PD.win->callback(makeCreateWindowCallback(create_load_box_for_selection_lists, storable_result_list));
258  PD.win->create_button("LOAD", "LOAD", "L");
259 
260  PD.win->callback(makeCreateWindowCallback(create_save_box_for_selection_lists, storable_result_list));
261  PD.win->create_button("SAVE", "SAVE", "S");
262 
263  PD.win->callback(makeWindowCallback(create_print_box_for_selection_lists, &storable_result_list->get_typedsellist()));
264  PD.win->create_button("PRINT", "PRINT", "P");
265 
266  PD.win->callback(makeWindowCallback(popup_match_window_cb, gb_main));
267  PD.win->create_button("MATCH", "MATCH", "M");
268 
269  PD.win->label("Auto match");
270  PD.win->create_toggle(AWAR_PD_MATCH_AUTOMATCH);
271 
272  enable_auto_match_cb(root, NULp);
273  }
274  PD.win->activate();
275 }
276 
277 static int init_local_com_struct() {
278  const char *user = GB_getenvUSER();
279 
280  if (aisc_create(PD.link, PT_MAIN, PD.com,
281  MAIN_LOCS, PT_LOCS, PD.locs,
282  LOCS_USER, user,
283  NULp)) {
284  return 1;
285  }
286  return 0;
287 }
288 
289 static GB_ERROR species_requires(GBDATA *gb_species, const char *whats_required) {
290  return GBS_global_string("Species '%s' needs %s", GBT_get_name_or_description(gb_species), whats_required);
291 }
292 
293 static GB_ERROR gene_requires(GBDATA *gb_gene, const char *whats_required) {
294  GBDATA *gb_species = GB_get_grandfather(gb_gene);
295  pd_assert(gb_species);
296  return GBS_global_string("Gene '%s' of organism '%s' needs %s", GBT_get_name_or_description(gb_gene), GBT_get_name_or_description(gb_species), whats_required);
297 }
298 
300  GBS_strstruct names(1024);
301  GBS_strstruct checksums(1024);
302 
304  if (!error) {
305  char *use = GBT_get_default_alignment(gb_main);
306  if (!use) {
307  error = GB_await_error();
308  }
309  else {
310  for (GBDATA *gb_species = GBT_first_marked_species(gb_main); gb_species; gb_species = GBT_next_marked_species(gb_species)) {
311  GBDATA *gb_name = GB_entry(gb_species, "name");
312  if (!gb_name) { error = species_requires(gb_species, "name"); break; }
313 
314  GBDATA *gb_data = GBT_find_sequence(gb_species, use);
315  if (!gb_data) { error = species_requires(gb_species, GBS_global_string("data in '%s'", use)); break; }
316 
317  checksums.putlong(GBS_checksum(GB_read_char_pntr(gb_data), 1, ".-"));
318  names.cat(GB_read_char_pntr(gb_name));
319  checksums.put('#');
320  names.put('#');
321  }
322 
323  if (!error) {
324  names.cut_tail(1); // remove trailing '#'
325  checksums.cut_tail(1); // remove trailing '#'
326  }
327  free(use);
328  }
329  }
330 
331  bs.size = names.get_position()+1;
332  bs.data = names.release();
333 
334  checksum.size = checksums.get_position()+1;
335  checksum.data = checksums.release();
336 
337  error = GB_end_transaction(gb_main, error);
338 
339  return error;
340 }
341 
343  GBS_strstruct names(1024);
344  GBS_strstruct checksums(1024);
345  GB_ERROR error = NULp;
346 
347  GB_begin_transaction(gb_main);
348  const char *use = GENOM_ALIGNMENT; // gene pt server is always build on 'ali_genom'
349 
350  for (GBDATA *gb_species = GEN_first_organism(gb_main); gb_species && !error; gb_species = GEN_next_organism(gb_species)) {
351  const char *species_name = NULp;
352  {
353  GBDATA *gb_data = GBT_find_sequence(gb_species, use);
354  if (!gb_data) { error = species_requires(gb_species, GBS_global_string("data in '%s'", use)); break; }
355 
356  GBDATA *gb_name = GB_search(gb_species, "name", GB_FIND);
357  if (!gb_name) { error = species_requires(gb_species, "name"); break; }
358  species_name = GB_read_char_pntr(gb_name);
359  }
360 
361  for (GBDATA *gb_gene = GEN_first_marked_gene(gb_species); gb_gene && !error; gb_gene = GEN_next_marked_gene(gb_gene)) {
362  const char *gene_name = NULp;
363  {
364  GBDATA *gb_gene_name = GB_entry(gb_gene, "name");
365  if (!gb_gene_name) { error = gene_requires(gb_gene, "name"); break; }
366  gene_name = GB_read_char_pntr(gb_gene_name);
367  }
368 
369  {
370  char *gene_seq = GBT_read_gene_sequence(gb_gene, false, 0);
371  if (!gene_seq) error = GB_await_error();
372  else {
373  long CheckSum = GBS_checksum(gene_seq, 1, ".-");
374  const char *id = GBS_global_string("%s/%s", species_name, gene_name);
375 
376  checksums.putlong(CheckSum);
377  names.cat(id);
378  checksums.put('#');
379  names.put('#');
380 
381  free(gene_seq);
382  }
383  }
384  }
385  }
386 
387  if (!error) {
388  names.cut_tail(1); // remove trailing '#'
389  checksums.cut_tail(1); // remove trailing '#'
390 
391  bs.size = names.get_position()+1;
392  bs.data = names.release();
393 
394  checksum.size = checksums.get_position()+1;
395  checksum.data = checksums.release();
396  }
397 
398  error = GB_end_transaction(gb_main, error);
399  return error;
400 }
401 
402 inline const char *bond_awar_name(int i) {
404 }
405 
407  float split;
408  float bonds[16];
409 
410  explicit ProbeCommonSettings(AW_root *root)
411  : split(root->awar(AWAR_PD_COMMON_EXP_SPLIT)->read_float())
412  {
413  for (int i=0; i<16; i++) {
414  bonds[i] = root->awar(bond_awar_name(i))->read_float();
415  }
416  }
417 };
418 
419 static int probe_common_send_data(const ProbeCommonSettings& commonSettings) {
420  // send data common to probe-design AND -match
421  if (aisc_put(PD.link, PT_LOCS, PD.locs,
422  LOCS_SPLIT, (double)commonSettings.split,
423  NULp))
424  return 1;
425 
426  for (int i=0; i<16; i++) {
427  if (aisc_put(PD.link, PT_LOCS, PD.locs,
428  PT_INDEX, (long)i,
429  LOCS_BONDVAL, (double)commonSettings.bonds[i],
430  NULp))
431  return 1;
432  }
433  return 0;
434 }
435 static int probe_design_send_data(AW_root *root, const T_PT_PDC& pdc) {
436  if (aisc_put(PD.link, PT_PDC, pdc,
437  PDC_DTEDGE, (double)root->awar(AWAR_PD_DESIGN_EXP_DTEDGE)->read_float()*100.0,
438  PDC_DT, (double)root->awar(AWAR_PD_DESIGN_EXP_DT)->read_float()*100.0,
439  PDC_CLIPRESULT, (long)root->awar(AWAR_PD_DESIGN_CLIPRESULT)->read_int(),
440  NULp))
441  return 1;
442 
444 }
445 
448  int nmatches;
449  int nlimit;
450  int maxhits;
452  int sortBy;
454  int markHits;
456 
458 
459  explicit ProbeMatchSettings(AW_root *root)
460  : ProbeCommonSettings(root),
461  serverNumber(root->awar(AWAR_PT_SERVER)->read_int()),
462  nmatches(root->awar(AWAR_PD_MATCH_NMATCHES)->read_int()),
463  nlimit(root->awar(AWAR_PD_MATCH_LIM_NMATCH)->read_int()),
464  maxhits(root->awar(AWAR_PD_MATCH_MAX_RES)->read_int()),
465  alsoRevcompl(root->awar(AWAR_PD_MATCH_ALSO_REVCOMP)->read_int()),
466  sortBy(root->awar(AWAR_PD_MATCH_SORTBY)->read_int()),
467  maxMismatches(root->awar(AWAR_MAX_MISMATCHES)->read_int()),
468  markHits(root->awar(AWAR_PD_MATCH_MARKHITS)->read_int()),
469  write2tmp(root->awar(AWAR_PD_MATCH_WRITE2TMP)->read_int()),
470  targetString(root->awar(AWAR_TARGET_STRING)->read_char_pntr())
471  {}
472 };
473 
474 static int probe_match_send_data(const ProbeMatchSettings& matchSettings) {
475  if (aisc_put(PD.link, PT_LOCS, PD.locs,
476  LOCS_MATCH_N_ACCEPT, (long)matchSettings.nmatches,
477  LOCS_MATCH_N_LIMIT, (long)matchSettings.nlimit,
478  LOCS_MATCH_MAX_HITS, (long)matchSettings.maxhits,
479  NULp))
480  return 1;
481 
482  return probe_common_send_data(matchSettings);
483 }
484 
485 static int ecolipos2int(const char *awar_val) {
486  int i = atoi(awar_val);
487  return i>0 ? i : -1;
488 }
489 
490 static char *readableUnknownNames(const ConstStrArray& unames) {
491  GBS_strstruct readable(100);
492 
493  int ulast = unames.size()-1;
494  int umax = ulast <= 10 ? ulast : 10;
495  for (int u = 0; u <= umax; ++u) {
496  if (u) readable.cat(u == ulast ? " and " : ", ");
497  readable.cat(unames[u]);
498  }
499 
500  if (umax<ulast) readable.nprintf(30, " (and %i other)", ulast-umax);
501 
502  return readable.release();
503 }
504 
506  AW_root *root = aww->get_root();
507  T_PT_PDC pdc;
508  T_PT_TPROBE tprobe;
509  bytestring bs;
510  bytestring check;
511  GB_ERROR error = NULp;
512 
513  arb_progress progress("Probe design");
514  progress.subtitle("Connecting PT-server");
515 
516  {
517  const char *servername = arb_look_and_start_ptserver(AISC_MAGIC_NUMBER, root->awar(AWAR_PT_SERVER)->read_int(), error);
518  if (servername) {
519  PD.link = aisc_open(servername, PD.com, AISC_MAGIC_NUMBER, &error);
520  if (!PD.link) error = "can't contact PT server";
521  PD.locs.clear();
522  }
523  }
524 
525  if (!error && init_local_com_struct()) {
526  error = "Cannot contact to probe server: Connection Refused";
527  }
528 
529  bool design_gene_probes = root->awar(AWAR_PD_DESIGN_GENE)->read_int();
530  if (design_gene_probes) {
531  GB_transaction ta(gb_main);
532  if (!GEN_is_genome_db(gb_main, -1)) design_gene_probes = false;
533  }
534 
535  if (!error) {
536  if (design_gene_probes) { // design probes for genes
537  error = pd_get_the_gene_names(gb_main, bs, check);
538  }
539  else {
540  error = pd_get_the_names(gb_main, bs, check);
541  }
542  }
543 
544  if (error) {
545  aw_message(error);
546  return;
547  }
548 
549  progress.subtitle("probe design running");
550 
551  if (aisc_create(PD.link, PT_LOCS, PD.locs,
552  LOCS_PROBE_DESIGN_CONFIG, PT_PDC, pdc,
553  PDC_MIN_PROBELEN, (long)root->awar(AWAR_PD_DESIGN_MIN_LENGTH)->read_int(),
554  PDC_MAX_PROBELEN, (long)root->awar(AWAR_PD_DESIGN_MAX_LENGTH)->read_int(),
555  PDC_MINTEMP, (double)root->awar(AWAR_PD_DESIGN_MIN_TEMP)->read_float(),
556  PDC_MAXTEMP, (double)root->awar(AWAR_PD_DESIGN_MAX_TEMP)->read_float(),
557  PDC_MINGC, (double)root->awar(AWAR_PD_DESIGN_MIN_GC)->read_float()/100.0,
558  PDC_MAXGC, (double)root->awar(AWAR_PD_DESIGN_MAX_GC)->read_float()/100.0,
559  PDC_MAXBOND, (double)root->awar(AWAR_PD_DESIGN_MAXBOND)->read_int(),
560  PDC_MIN_ECOLIPOS, (long)ecolipos2int(root->awar(AWAR_PD_DESIGN_MIN_ECOLIPOS)->read_char_pntr()),
561  PDC_MAX_ECOLIPOS, (long)ecolipos2int(root->awar(AWAR_PD_DESIGN_MAX_ECOLIPOS)->read_char_pntr()),
562  PDC_MISHIT, (long)root->awar(AWAR_PD_DESIGN_MISHIT)->read_int(),
563  PDC_MINTARGETS, (double)root->awar(AWAR_PD_DESIGN_MINTARGETS)->read_float()/100.0,
564  NULp))
565  {
566  aw_message("Connection to PT_SERVER lost (1)");
567  return;
568  }
569 
570  if (probe_design_send_data(root, pdc)) {
571  aw_message("Connection to PT_SERVER lost (1)");
572  return;
573  }
574 
575  aisc_put(PD.link, PT_PDC, pdc,
576  PDC_NAMES, &bs,
577  PDC_CHECKSUMS, &check,
578  NULp);
579 
580 
581  // Get the unknown names
582  bytestring unknown_names;
583  if (aisc_get(PD.link, PT_PDC, pdc,
584  PDC_UNKNOWN_NAMES, &unknown_names,
585  NULp))
586  {
587  aw_message("Connection to PT_SERVER lost (1)");
588  return;
589  }
590 
591  bool abort = false;
592 
593  if (unknown_names.size>1) {
594  ConstStrArray unames_array;
595  GBT_split_string(unames_array, unknown_names.data, "#", true);
596 
597  char *readable_unames = readableUnknownNames(unames_array);
598 
599  if (design_gene_probes) { // updating sequences of missing genes is not possible with gene PT server
600  aw_message(GBS_global_string("Your PT server is not up to date or wrongly chosen!\n"
601  "It knows nothing about the following genes:\n"
602  "\n"
603  " %s\n"
604  "\n"
605  "You have to rebuild the PT server.",
606  readable_unames));
607  abort = true;
608  }
609  else if (aw_question("ptserver_add_unknown",
610  GBS_global_string("Your PT server is not up to date or wrongly chosen!\n"
611  "It knows nothing about the following species:\n"
612  "\n"
613  " %s\n"
614  "\n"
615  "You may now temporarily add these sequences for probe design.\n",
616  readable_unames),
617  "Add and continue,Abort"))
618  {
619  abort = true;
620  }
621  else {
622  GB_transaction ta(gb_main);
623 
624  char *ali_name = GBT_get_default_alignment(gb_main);
625  if (!ali_name) {
627  abort = true;
628  }
629 
630  for (size_t u = 0; !abort && u<unames_array.size(); ++u) {
631  const char *uname = unames_array[u];
632  GBDATA *gb_species = GBT_find_species(gb_main, uname);
633  if (!gb_species) {
634  aw_message(GBS_global_string("Species '%s' not found", uname));
635  abort = true;
636  }
637  else {
638  GBDATA *data = GBT_find_sequence(gb_species, ali_name);
639  if (!data) {
640  aw_message(GB_export_errorf("Species '%s' has no sequence belonging to alignment '%s'", uname, ali_name));
641  abort = true;
642  }
643  else {
644  T_PT_SEQUENCE pts;
645 
646  bytestring bs_seq;
647  bs_seq.data = (char*)GB_read_char_pntr(data);
648  bs_seq.size = GB_read_string_count(data)+1;
649 
650  aisc_create(PD.link, PT_PDC, pdc,
651  PDC_SEQUENCE, PT_SEQUENCE, pts,
652  SEQUENCE_SEQUENCE, &bs_seq,
653  NULp);
654  }
655  }
656  }
657  free(ali_name);
658  }
659  free(readable_unames);
660  free(unknown_names.data);
661  }
662 
663  if (!abort) {
664  aisc_put(PD.link, PT_PDC, pdc,
665  PDC_GO, (long)0,
666  NULp);
667 
668  progress.subtitle("Reading results from server");
669  {
670  char *locs_error = NULp;
671  if (aisc_get(PD.link, PT_LOCS, PD.locs,
672  LOCS_ERROR, &locs_error,
673  NULp))
674  {
675  aw_message("Connection to PT_SERVER lost (1)");
676  abort = true;
677  }
678  else if (*locs_error) {
679  aw_message(locs_error);
680  abort = true;
681  }
682  else {
683  free(locs_error);
684  }
685  }
686  }
687 
688  if (!abort) {
689  aisc_get(PD.link, PT_PDC, pdc,
690  PDC_TPROBE, tprobe.as_result_param(),
691  NULp);
692 
693  popup_probe_design_result_window(aww, gb_main);
694  PD.resultList->clear();
695 
696  {
697  char *match_info = NULp;
698  aisc_get(PD.link, PT_PDC, pdc,
699  PDC_INFO_HEADER, &match_info,
700  NULp);
701 
702  char *s = strtok(match_info, "\n");
703  while (s) {
704  PD.resultList->insert(s, "");
705  s = strtok(NULp, "\n");
706  }
707  free(match_info);
708  }
709 
710  while (tprobe.exists()) {
711  T_PT_TPROBE tprobe_next;
712  char *match_info = NULp;
713 
714  if (aisc_get(PD.link, PT_TPROBE, tprobe,
715  TPROBE_NEXT, tprobe_next.as_result_param(),
716  TPROBE_INFO, &match_info,
717  NULp)) break;
718 
719  tprobe.assign(tprobe_next);
720 
721  char *probe, *space;
722  probe = strpbrk(match_info, "acgtuACGTU");
723  if (probe) space = strchr(probe, ' ');
724  if (probe && space) {
725  *space = 0; probe = ARB_strdup(probe); *space=' ';
726  }
727  else {
728  probe = ARB_strdup("");
729  }
730  PD.resultList->insert(match_info, probe);
731  free(probe);
732  free(match_info);
733  }
734  PD.resultList->insert_default("", "");
735  PD.resultList->update();
736  }
737 
738  aisc_close(PD.link, PD.com); PD.link = NULp;
739  return;
740 }
741 
742 static bool allow_probe_match_event = true;
743 
745  GB_ERROR error = NULp;
747 #if defined(ASSERTION_USED)
748  // runtime check against awar usage when NOT called from probe match window!
749  typedef SmartPtr< LocallyModify<bool> > Maybe;
750 
751  Maybe dontReadAwars;
752  Maybe dontWriteAwars;
753 
754  if (!event_param || !event_param->selection_id) {
755  dontReadAwars = new LocallyModify<bool>(AW_awar::deny_read, true);
756  dontWriteAwars = new LocallyModify<bool>(AW_awar::deny_write, true);
757  }
758 #endif
759 
760  AW_selection_list *selection_id = event_param ? event_param->selection_id : NULp;
761  int *counter = event_param ? event_param->counter : NULp;
762  GBDATA *gb_main = event_param ? event_param->gb_main : NULp;
763  int show_status = 0;
764  int extras = 1; // mark species and write to temp fields
765 
766  if (!gb_main) { error = "Please open probe match window once to enable auto-match"; }
767 
768  SmartPtr<arb_progress> progress;
769 
770  if (!error) {
771  const char *servername = arb_look_and_start_ptserver(AISC_MAGIC_NUMBER, matchSettings.serverNumber, error);
772 
773  if (!error) {
774  if (selection_id) {
775  selection_id->clear();
776  pd_assert(!counter);
777  show_status = 1;
778  }
779  else if (counter) {
780  extras = 0;
781  }
782 
783  if (show_status) {
784  progress = new arb_progress("Probe match");
785  progress->subtitle("Connecting PT-server");
786  }
787 
788  PD.link = aisc_open(servername, PD.com, AISC_MAGIC_NUMBER, &error);
789  if (!error && !PD.link) error = "Cannot contact PT-server";
790  PD.locs.clear();
791  }
792  }
793 
794  if (!error && init_local_com_struct()) error = "Cannot contact PT-server (2)";
795  if (!error && probe_match_send_data(matchSettings)) error = "Connection to PT_SERVER lost (2)";
796 
797  const char *probe = matchSettings.targetString.c_str();
798  if (!error) {
799  if (show_status) progress->subtitle("Probe match running");
800 
801  if (aisc_nput(PD.link, PT_LOCS, PD.locs,
802  LOCS_MATCH_ALSO_REVCOMP, (long)matchSettings.alsoRevcompl,
803  LOCS_COMPLEMENT_FIRST, (long)0, // (use sequence passed below as is. do not complement it.)
804  LOCS_MATCH_SORT_BY, (long)matchSettings.sortBy,
805  LOCS_MATCH_MAX_MISMATCHES, (long)matchSettings.maxMismatches,
806  LOCS_SEARCHMATCH, probe,
807  NULp))
808  {
809  error = "Connection to PT_SERVER lost (2)";
810  }
811  else {
812  delete(g_spd); // delete previous probe data
813  g_spd = new saiProbeData;
814  transferProbeData(g_spd);
815 
816  g_spd->setProbeTarget(probe);
817  }
818  }
819 
820  bytestring bs;
821  bs.data = NULp;
822 
823  long matches_truncated = 0;
824  if (!error) {
825  if (show_status) progress->subtitle("Reading results");
826 
827  T_PT_MATCHLIST match_list;
828  long match_list_cnt = 0;
829  char *locs_error = NULp;
830 
831  if (aisc_get(PD.link, PT_LOCS, PD.locs,
832  LOCS_MATCH_LIST, match_list.as_result_param(),
833  LOCS_MATCH_LIST_CNT, &match_list_cnt,
834  LOCS_MATCH_STRING, &bs,
835  LOCS_MATCHES_TRUNCATED, &matches_truncated,
836  LOCS_ERROR, &locs_error,
837  NULp))
838  {
839  error = "Connection to PT_SERVER lost (3)";
840  }
841  else {
842  if (locs_error) {
843  if (*locs_error) error = GBS_static_string(locs_error);
844  free(locs_error);
845  }
846  else {
847  error = "Missing status from server (connection aborted?)";
848  }
849  }
850 
851  event_param->hits_summary = GBS_global_string(matches_truncated ? "[more than %li]" : "%li", match_list_cnt);
852  if (matches_truncated) {
853  aw_message("Too many matches, displaying a random digest.\n" // @@@ should better be handled by caller
854  "Increase the limit in the expert window.");
855  }
856  }
857 
858  long mcount = 0;
859  long unknown_species_count = 0;
860  long unknown_gene_count = 0;
861 
862  if (!error) {
863  char toksep[2] = { 1, 0 };
864  char *strtok_ptr = NULp; // stores strtok position
865  const char *hinfo = strtok_r(bs.data, toksep, &strtok_ptr);
866 
867  bool gene_flag = false;
868  ProbeMatchParser *parser = NULp;
869  char *result = ARB_alloc<char>(1024);
870 
871 
872  if (hinfo) {
873  g_spd->setHeadline(hinfo);
874  parser = new ProbeMatchParser(probe, hinfo);
875  error = parser->get_error();
876  if (!error) gene_flag = parser->is_gene_result();
877  }
878 
879  if (selection_id) {
880  int width = 0;
881  if (parser && !error) width = parser->get_probe_region_offset()+2+10; // 2 cause headline is shorter and 10 for match prefix region
882 
883  const char *searched = GBS_global_string("%-*s%s", width, "Searched for ", probe);
884  selection_id->insert(searched, probe);
885  if (hinfo) selection_id->insert(hinfo, "");
886  }
887 
888 
889  // clear all marks and delete all 'tmp' entries
890 
891  int mark = extras && matchSettings.markHits;
892  int write_2_tmp = extras && matchSettings.write2tmp;
893 
894  GB_push_transaction(gb_main);
895 
897  if (mark && !error) {
898  if (show_status) progress->subtitle(gene_flag ? "Unmarking all species and genes" : "Unmarking all species");
899  for (GBDATA *gb_species = GBT_first_marked_species_rel_species_data(gb_species_data);
900  gb_species;
901  gb_species = GBT_next_marked_species(gb_species))
902  {
903  GB_write_flag(gb_species, 0);
904  }
905 
906  if (gene_flag) {
907  // unmark genes of ALL species
908  for (GBDATA *gb_species = GBT_first_species_rel_species_data(gb_species_data);
909  gb_species;
910  gb_species = GBT_next_species(gb_species))
911  {
912  GBDATA *genData = GEN_find_gene_data(gb_species);
913  if (genData) {
914  for (GBDATA *gb_gene = GEN_first_marked_gene(gb_species);
915  gb_gene;
916  gb_gene = GEN_next_marked_gene(gb_gene))
917  {
918  GB_write_flag(gb_gene, 0);
919  }
920  }
921  }
922  }
923  }
924  if (write_2_tmp && !error) {
925  if (show_status) progress->subtitle("Deleting old 'tmp' fields");
926  for (GBDATA *gb_species = GBT_first_species_rel_species_data(gb_species_data);
927  gb_species;
928  gb_species = GBT_next_species(gb_species))
929  {
930  GBDATA *gb_tmp = GB_entry(gb_species, "tmp");
931  if (gb_tmp) GB_delete(gb_tmp);
932  if (gene_flag) {
933  for (GBDATA *gb_gene = GEN_first_gene(gb_species);
934  gb_gene;
935  gb_gene = GEN_next_gene(gb_species))
936  {
937  gb_tmp = GB_entry(gb_gene, "tmp");
938  if (gb_tmp) GB_delete(gb_tmp);
939  }
940  }
941  }
942  }
943 
944  // read results from pt-server :
945 
946  if (!error) {
947  if (show_status) progress->subtitle("Parsing results");
948 
949  g_spd->probeSpecies.clear();
950  g_spd->probeSeq.clear();
951 
952  if (gene_flag) {
953  if (!GEN_is_genome_db(gb_main, -1)) {
954  error = "Wrong PT-Server chosen (selected one is built for genes)";
955  }
956  }
957  }
958 
959  const char *match_name = NULp;
960  while (hinfo && !error && (match_name = strtok_r(NULp, toksep, &strtok_ptr))) {
961  const char *match_info = strtok_r(NULp, toksep, &strtok_ptr);
962  if (!match_info) break;
963 
964  pd_assert(parser);
965  ParsedProbeMatch ppm(match_info, *parser);
966  char *gene_str = NULp;
967 
968  if (gene_flag) {
969  gene_str = ppm.get_column_content("genename", true);
970  }
971 
972  if (!error) {
973  char flags[] = "xx";
974  GBDATA *gb_species = GBT_find_species_rel_species_data(gb_species_data, match_name);
975 
976  if (gb_species) {
977  GBDATA *gb_gene = NULp;
978  if (gene_flag && strncmp(gene_str, "intergene_", 10) != 0) { // real gene
979  gb_gene = GEN_find_gene(gb_species, gene_str);
980  if (!gb_gene) {
981  aw_message(GBS_global_string("Gene '%s' not found in organism '%s'", gene_str, match_name));
982  }
983  }
984 
985  if (mark) {
986  GB_write_flag(gb_species, 1);
987  flags[0] = '*';
988  if (gb_gene) {
989  GB_write_flag(gb_gene, 1);
990  flags[1] = '*';
991  }
992  else {
993  flags[1] = '?'; // no gene
994  }
995  }
996  else {
997  flags[0] = " *"[GB_read_flag(gb_species)];
998  flags[1] = " *?"[gb_gene ? GB_read_flag(gb_gene) : 2];
999  }
1000 
1001  if (write_2_tmp) {
1002  // write or append to field 'tmp'
1003 
1004  GBDATA *gb_tmp = NULp;
1005  GB_ERROR error2 = NULp;
1006  bool append = true;
1007  {
1008  GBDATA *gb_parent = gene_flag ? gb_gene : gb_species;
1009  gb_tmp = GB_search(gb_parent, "tmp", GB_FIND);
1010  if (!gb_tmp) {
1011  append = false;
1012  gb_tmp = GB_search(gb_parent, "tmp", GB_STRING);
1013  if (!gb_tmp) error2 = GB_await_error();
1014  }
1015  }
1016 
1017  if (!error2) {
1018  pd_assert(gb_tmp);
1019  if (append) {
1020  char *prevContent = GB_read_string(gb_tmp);
1021  if (!prevContent) {
1022  error2 = GB_await_error();
1023  }
1024  else {
1025  char *concatenatedContent = ARB_alloc<char>(strlen(prevContent)+1+strlen(match_info)+1);
1026  sprintf(concatenatedContent, "%s\n%s", prevContent, match_info);
1027  error2 = GB_write_string(gb_tmp, concatenatedContent);
1028  free(concatenatedContent);
1029  free(prevContent);
1030  }
1031  }
1032  else {
1033  error2 = GB_write_string(gb_tmp, match_info);
1034  }
1035  }
1036 
1037  if (error2) aw_message(error2);
1038  }
1039  }
1040  else {
1041  flags[0] = flags[1] = '?'; // species does not exist
1042  unknown_species_count++;
1043  }
1044 
1045 
1046  if (gene_flag) {
1047  sprintf(result, "%s %s", flags, match_info+1); // both flags (skip 1 space from match info to keep alignment)
1048  char *gene_match_name = new char[strlen(match_name) + strlen(gene_str)+2];
1049  sprintf(gene_match_name, "%s/%s", match_name, gene_str);
1050  if (selection_id) selection_id->insert(result, gene_match_name); // @@@ wert fuer awar eintragen
1051  }
1052  else {
1053  sprintf(result, "%c %s", flags[0], match_info); // only first flag ( = species related)
1054  if (selection_id) selection_id->insert(result, match_name); // @@@ wert fuer awar eintragen
1055 
1056  // storing probe data into linked lists
1057  g_spd->probeSeq.push_back(std::string(match_info));
1058  g_spd->probeSpecies.push_back(std::string(match_name));
1059  }
1060  mcount++;
1061  }
1062 
1063  free(gene_str);
1064  }
1065 
1066  if (error) error = GBS_static_string(error); // make static copy (error may be freed by delete parser)
1067  delete parser;
1068  free(result);
1069 
1070  GB_pop_transaction(gb_main);
1071  }
1072 
1073  if (error) {
1074  if (event_param) event_param->hits_summary = "[none]"; // clear hits
1075  }
1076  else {
1077  if (unknown_species_count>0) {
1078  error = GBS_global_string("%li matches hit unknown species -- PT-server is out-of-date or build upon a different database", unknown_species_count);
1079  }
1080  if (unknown_gene_count>0 && !error) {
1081  error = GBS_global_string("%li matches hit unknown genes -- PT-server is out-of-date or build upon a different database", unknown_gene_count);
1082  }
1083 
1084  if (selection_id) { // if !selection_id then probe match window is not opened
1085  pd_assert(g_spd);
1086  event_param->refresh_sai_display = true; // want refresh of SAI/Probe window
1087  }
1088  }
1089 
1090  if (counter) *counter = mcount;
1091 
1092  aisc_close(PD.link, PD.com);
1093  PD.link = NULp;
1094 
1095  if (selection_id) {
1096  const char *last_line = NULp;
1097  if (error) last_line = GBS_global_string("****** Error: %s *******", error);
1098  else if (matches_truncated) last_line = "****** List is truncated *******";
1099  else last_line = "****** End of List *******";
1100 
1101  selection_id->insert_default(last_line, "");
1102  selection_id->update();
1103  }
1104 
1105  free(bs.data);
1106  }
1107  return error;
1108 }
1109 
1112  GB_ERROR error = probe_match_event(ProbeMatchSettings(root), event_param);
1113  aw_message_if(error);
1114 
1116 
1117  if (event_param) {
1118  if (event_param->refresh_sai_display) {
1119  root->awar(AWAR_SPV_DB_FIELD_NAME)->touch(); // force refresh of SAI/Probe window
1120  }
1121  if (event_param->selection_id) {
1122  root->awar(AWAR_PD_MATCH_NHITS)->write_string(event_param->hits_summary.c_str()); // update hits in probe match window
1123  }
1124  }
1125  root->awar(AWAR_TREE_REFRESH)->touch(); // refresh tree
1126  }
1127 }
1128 
1129 static void probe_match_all_event(AW_window *aww, AW_selection_list *iselection_id, GBDATA *gb_main) {
1130  AW_selection_list_iterator selentry(iselection_id);
1131  arb_progress progress("Matching all resolved strings", iselection_id->size());
1132  ProbeMatchSettings matchSettings(aww->get_root());
1133  const bool got_result = selentry;
1134 
1135  while (selentry) {
1136  const char *entry = selentry.get_value()->get_string(); // @@@ rename -> probe
1137  matchSettings.targetString = entry;
1138 
1139  int counter = -1;
1140  ProbeMatchEventParam match_event(gb_main, &counter);
1141  GB_ERROR error = probe_match_event(matchSettings, &match_event);
1142 
1143  // write # of hits to list entries:
1144  {
1145 #define DISP_FORMAT "%7i %s"
1146  const char *displayed;
1147  if (error) {
1148  displayed = GBS_global_string(DISP_FORMAT " (Error: %s)", 0, entry, error);
1149  }
1150  else {
1151  displayed = GBS_global_string(DISP_FORMAT, counter, entry);
1152  }
1153  selentry.set_displayed(displayed);
1154 #undef DISP_FORMAT
1155  }
1156 
1157  ++selentry;
1158  progress.inc();
1159  }
1160 
1161  if (got_result) {
1162  iselection_id->sort(true, true);
1163  iselection_id->update();
1164  }
1165 }
1166 
1167 static void resolved_probe_chosen(AW_root *root) {
1168  char *string = root->awar(AWAR_PD_MATCH_RESOLVE)->read_string();
1169  root->awar(AWAR_TARGET_STRING)->write_string(string);
1170 }
1171 
1173  // this gets called when ever the selected probe match changes
1174  char *temp;
1175  char *selected_match = root->awar(AWAR_PD_SELECTED_MATCH)->read_string();
1176 
1177  if (strchr(selected_match, '/')) { // "organism/gene"
1178  temp = strtok(selected_match, "/");
1179  root->awar(AWAR_SPECIES_NAME)->write_string(temp);
1180  temp = strtok(NULp, " /\n");
1181  root->awar(AWAR_GENE_NAME)->write_string(temp);
1182  }
1183  else {
1184  root->awar(AWAR_SPECIES_NAME)->write_string(selected_match);
1185  }
1186 
1187  {
1188  LocallyModify<bool> flag(allow_probe_match_event, false); // avoid recursion
1189  root->awar(AWAR_TARGET_STRING)->touch(); // forces editor to jump to probe match in gene
1190  }
1191 
1192  free(selected_match);
1193 }
1194 
1195 static void probelength_changed_cb(AW_root *root, bool maxChanged) {
1196  static bool avoid_recursion = false;
1197  if (!avoid_recursion) {
1198  AW_awar *awar_minl = root->awar(AWAR_PD_DESIGN_MIN_LENGTH);
1199  AW_awar *awar_maxl = root->awar(AWAR_PD_DESIGN_MAX_LENGTH);
1200 
1201  int minl = awar_minl->read_int();
1202  int maxl = awar_maxl->read_int();
1203 
1204  if (minl>maxl) {
1205  if (maxChanged) awar_minl->write_int(maxl);
1206  else awar_maxl->write_int(minl);
1207  }
1208  }
1209 }
1210 
1211 static void minmax_awar_pair_changed_cb(AW_root *root, bool maxChanged, const char *minAwarName, const char *maxAwarName) {
1212  static bool avoid_recursion = false;
1213  if (!avoid_recursion) {
1214  LocallyModify<bool> flag(avoid_recursion, true);
1215 
1216  AW_awar *awar_min = root->awar(minAwarName);
1217  AW_awar *awar_max = root->awar(maxAwarName);
1218 
1219  float currMin = awar_min->read_float();
1220  float currMax = awar_max->read_float();
1221 
1222  if (currMin>currMax) { // invalid -> correct
1223  if (maxChanged) awar_min->write_float(currMax);
1224  else awar_max->write_float(currMin);
1225  }
1226  }
1227 }
1228 static void gc_minmax_changed_cb(AW_root *root, bool maxChanged) {
1230 }
1231 static void temp_minmax_changed_cb(AW_root *root, bool maxChanged) {
1233 }
1234 
1236  PD.win = NULp; // design result window not created
1237 
1238  root->awar_string(AWAR_SPECIES_NAME, "", props);
1240  root->awar_float (AWAR_PD_DESIGN_EXP_DTEDGE, .5, props);
1241  root->awar_float (AWAR_PD_DESIGN_EXP_DT, .5, props);
1242 
1243  double default_bonds[16] = {
1244  0.0, 0.0, 0.5, 1.1,
1245  0.0, 0.0, 1.5, 0.0,
1246  0.5, 1.5, 0.4, 0.9,
1247  1.1, 0.0, 0.9, 0.0
1248  };
1249 
1250  for (int i=0; i<16; i++) {
1251  root->awar_float(bond_awar_name(i), default_bonds[i], props)->set_minmax(0, 3.0);
1252  }
1253  root->awar_float(AWAR_PD_COMMON_EXP_SPLIT, .5, props);
1254  root->awar_float(AWAR_PD_DESIGN_EXP_DTEDGE, .5, props);
1255  root->awar_float(AWAR_PD_DESIGN_EXP_DT, .5, props);
1256 
1257  root->awar_int (AWAR_PD_DESIGN_CLIPRESULT, 50, props)->set_minmax(0, 1000);
1258  root->awar_int (AWAR_PD_DESIGN_MISHIT, 0, props)->set_minmax(0, 100000);
1259  root->awar_int (AWAR_PD_DESIGN_MAXBOND, 4, props)->set_minmax(0, 20);
1260  root->awar_float(AWAR_PD_DESIGN_MINTARGETS, 50.0, props)->set_minmax(0, 100);
1261 
1262  AW_awar *awar_min_len = root->awar_int(AWAR_PD_DESIGN_MIN_LENGTH, 18, props);
1263  awar_min_len->set_minmax(DOMAIN_MIN_LENGTH, 100)->add_callback(makeRootCallback(probelength_changed_cb, false));
1264  root->awar_int(AWAR_PD_DESIGN_MAX_LENGTH, awar_min_len->read_int(), props)->set_minmax(DOMAIN_MIN_LENGTH, 100)->add_callback(makeRootCallback(probelength_changed_cb, true));
1265 
1266  root->awar_float(AWAR_PD_DESIGN_MIN_TEMP, 30.0, props)->set_minmax(0, 1000)->add_callback(makeRootCallback(temp_minmax_changed_cb, false));
1267  root->awar_float(AWAR_PD_DESIGN_MAX_TEMP, 100.0, props)->set_minmax(0, 1000)->add_callback(makeRootCallback(temp_minmax_changed_cb, true));
1268 
1269  root->awar_float(AWAR_PD_DESIGN_MIN_GC, 50.0, props)->add_callback(makeRootCallback(gc_minmax_changed_cb, false));
1270  root->awar_float(AWAR_PD_DESIGN_MAX_GC, 100.0, props)->add_callback(makeRootCallback(gc_minmax_changed_cb, true));
1271 
1272  gc_minmax_changed_cb(root, false);
1273  gc_minmax_changed_cb(root, true);
1274 
1275  root->awar_string(AWAR_PD_DESIGN_MIN_ECOLIPOS, "", props);
1276  root->awar_string(AWAR_PD_DESIGN_MAX_ECOLIPOS, "", props);
1277 
1278  root->awar_int(AWAR_PT_SERVER, 0, props);
1279  root->awar_int(AWAR_PD_DESIGN_GENE, 0, props);
1280 
1281  root->awar_int(AWAR_PD_MATCH_MARKHITS, 1, props);
1282  root->awar_int(AWAR_PD_MATCH_SORTBY, 0, props);
1283  root->awar_int(AWAR_PD_MATCH_WRITE2TMP, 0, props);
1284  root->awar_int(AWAR_PD_MATCH_ALSO_REVCOMP, 0, props);
1285 
1286  root->awar_int (AWAR_MAX_MISMATCHES, 0, db)->set_minmax(0, 200);
1287  root->awar_string(AWAR_TARGET_STRING, NULp, db);
1288 
1289  root->awar_string(AWAR_PD_MATCH_NHITS, "[none]", props);
1290  root->awar_int (AWAR_PD_MATCH_NMATCHES, 1, props);
1291  root->awar_int (AWAR_PD_MATCH_LIM_NMATCH, 4, props);
1292  root->awar_int (AWAR_PD_MATCH_MAX_RES, 1000000, props);
1293 
1295 
1297  root->awar_string(AWAR_ITARGET_STRING, "", db);
1298 
1299  root->awar_int(AWAR_PROBE_ADMIN_PT_SERVER, 0, db);
1301 
1302  root->awar_string(AWAR_SPV_SAI_2_PROBE, "", db); // name of SAI selected in list
1303  root->awar_string(AWAR_SPV_DB_FIELD_NAME, "name", db); // name of displayed species field
1304  root->awar_int (AWAR_SPV_DB_FIELD_WIDTH, 10, db); // width of displayed species field
1305  root->awar_string(AWAR_SPV_ACI_COMMAND, "", db); // User defined or pre-defined ACI command to display
1306 
1307  root->awar_int(AWAR_PC_MATCH_NHITS, 0, db);
1308  root->awar_int(AWAR_PC_AUTO_MATCH, 0, props);
1309 
1312  root->awar_string(AWAR_PC_SELECTED_PROBE, "", db);
1313 
1314  root->awar_float(AWAR_PC_MATCH_WIDTH, 1.0, db)->set_minmax(0.01, 100.0);
1315  root->awar_float(AWAR_PC_MATCH_BIAS, 0.0, db)->set_minmax(-1.0, 1.0);
1316 
1317  root->awar_float(AWAR_PC_MISMATCH_THRESHOLD, 0.0, db)->set_minmax(0, 100); // Note: limits will be modified by probe_match_with_specificity_event
1318 
1319  float default_weights[16] = {0.0};
1320  float default_width = 1.0;
1321  float default_bias = 0.0;
1322 
1323  ArbProbeCollection& g_probe_collection = get_probe_collection();
1324  g_probe_collection.getParameters(default_weights, default_width, default_bias);
1325  g_probe_collection.clear();
1326 
1327  char buffer[256] = {0};
1328 
1329  for (int i = 0; i < 16 ; i++) {
1330  sprintf(buffer, AWAR_PC_MATCH_WEIGHTS"%i", i);
1331  AW_awar *awar = root->awar_float(buffer, 0.0, db);
1332 
1333  awar->set_minmax(0, 10);
1334  default_weights[i] = awar->read_float();
1335  }
1336 
1337  g_probe_collection.setParameters(default_weights, default_width, default_bias);
1338 
1339  // read probes from DB and add them to collection
1340  {
1341  AW_awar *awar_current = root->awar_string(AWAR_PC_CURRENT_COLLECTION, "", db);
1342  char *current = awar_current->read_string();
1343 
1344  if (current && current[0]) {
1345  // Note: target sequences/names do not contain '#'/':' (see REPLACE_TARGET_CONTROL_CHARS)
1346  ConstStrArray probes;
1347  GBT_splitNdestroy_string(probes, current, "#", true);
1348 
1349  for (size_t i = 0; i<probes.size(); ++i) {
1350  const char *probe = probes[i];
1351  const char *colon = strchr(probe, ':');
1352 
1353  if (colon) {
1354  char *name = ARB_strpartdup(probe, colon-1);
1355  const char *seq = colon+1;
1356  g_probe_collection.add(name, seq);
1357  free(name);
1358  }
1359  else {
1360  aw_message(GBS_global_string("Saved probe ignored: has wrong format ('%s', expected 'name:seq')", probe));
1361  }
1362  }
1363  }
1364  free(current);
1365  }
1366  root->awar_string(AWAR_SPV_SELECTED_PROBE, "", db); // For highlighting the selected PROBE
1367 }
1368 
1369 static AW_window *create_probe_expert_window(AW_root *root, bool for_design) {
1370  AW_window_simple *aws = new AW_window_simple;
1371  if (for_design) {
1372  aws->init(root, "PD_exp", "Probe Design (Expert)");
1373  aws->load_xfig("pd_spec.fig");
1374  }
1375  else {
1376  aws->init(root, "PM_exp", "Probe Match (Expert)");
1377  aws->load_xfig("pm_spec.fig");
1378  }
1379 
1380  aws->label_length(30);
1381  aws->button_length(10);
1382 
1383  aws->at("close");
1384  aws->callback(AW_POPDOWN);
1385  aws->create_button("CLOSE", "CLOSE", "C");
1386 
1387  aws->callback(makeHelpCallback(for_design ? "pd_spec_param.hlp" : "pm_spec_param.hlp")); // uses_hlp_res("pm_spec_param.hlp", "pd_spec_param.hlp"); see ../SOURCE_TOOLS/check_resources.pl@uses_hlp_res
1388  aws->at("help");
1389  aws->create_button("HELP", "HELP", "C");
1390 
1391  for (int i=0; i<16; i++) { // bond matrix
1392  char bondAt[20];
1393  sprintf(bondAt, "%i", i);
1394  aws->at(bondAt);
1395 
1396  aws->create_input_field(bond_awar_name(i), 4);
1397  }
1398 
1399  aws->sens_mask(AWM_EXP);
1400  aws->at("split"); aws->create_input_field(AWAR_PD_COMMON_EXP_SPLIT, 6);
1401 
1402  if (for_design) {
1403  aws->at("dt_edge"); aws->create_input_field(AWAR_PD_DESIGN_EXP_DTEDGE, 6);
1404  aws->at("dt"); aws->create_input_field(AWAR_PD_DESIGN_EXP_DT, 6);
1405  aws->sens_mask(AWM_ALL);
1406  }
1407  else {
1408  aws->at("nmatches"); aws->create_input_field(AWAR_PD_MATCH_NMATCHES, 3);
1409  aws->at("lim_nmatch"); aws->create_input_field(AWAR_PD_MATCH_LIM_NMATCH, 3);
1410  aws->sens_mask(AWM_ALL);
1411  aws->at("max_res"); aws->create_input_field(AWAR_PD_MATCH_MAX_RES, 14);
1412  }
1413 
1414  return aws;
1415 }
1416 
1418  // main window:
1419  { AWAR_PD_DESIGN_CLIPRESULT, "clip" },
1420  { AWAR_PD_DESIGN_MISHIT, "mishit" },
1421  { AWAR_PD_DESIGN_MAXBOND, "maxbond" },
1422  { AWAR_PD_DESIGN_MINTARGETS, "mintarget" },
1423  { AWAR_PD_DESIGN_MIN_LENGTH, "probelen" },
1424  { AWAR_PD_DESIGN_MAX_LENGTH, "probemaxlen" },
1425  { AWAR_PD_DESIGN_MIN_TEMP, "mintemp" },
1426  { AWAR_PD_DESIGN_MAX_TEMP, "maxtemp" },
1427  { AWAR_PD_DESIGN_MIN_GC, "mingc" },
1428  { AWAR_PD_DESIGN_MAX_GC, "maxgc" },
1429  { AWAR_PD_DESIGN_MIN_ECOLIPOS, "minecoli" },
1430  { AWAR_PD_DESIGN_MAX_ECOLIPOS, "maxecoli" },
1431  { AWAR_PD_DESIGN_GENE, "gene" },
1432 
1433  // expert window:
1434  { AWAR_PD_DESIGN_EXP_DTEDGE, "dtedge" },
1435  { AWAR_PD_DESIGN_EXP_DT, "dt" },
1436 
1437  { NULp, NULp }
1438 };
1439 
1441  cdef.add(mapping);
1442 
1443  // entries common for both expert windows (design + match)
1444  cdef.add(AWAR_PD_COMMON_EXP_SPLIT, "split");
1445  for (int i = 0; i<16; ++i) {
1446  cdef.add(bond_awar_name(i), "bond", i);
1447  }
1448 }
1449 
1451  bool is_genom_db;
1452  {
1453  GB_transaction ta(gb_main);
1454  is_genom_db = GEN_is_genome_db(gb_main, -1);
1455  }
1456 
1457  AW_window_simple *aws = new AW_window_simple;
1458  aws->init(root, "PROBE_DESIGN", "PROBE DESIGN");
1459 
1460  aws->load_xfig("pd_main.fig");
1461 
1462  aws->at("close");
1463  aws->callback(AW_POPDOWN);
1464  aws->create_button("CLOSE", "CLOSE", "C");
1465 
1466  aws->at("help");
1467  aws->callback(makeHelpCallback("probedesign.hlp"));
1468  aws->create_button("HELP", "HELP", "H");
1469 
1470  aws->callback(makeWindowCallback(probe_design_event, gb_main));
1471  aws->at("design");
1472  aws->highlight();
1473  aws->create_button("GO", "GO", "G");
1474 
1475  aws->callback(makeWindowCallback(popup_probe_design_result_window, gb_main));
1476  aws->at("result");
1477  aws->create_button("RESULT", "RESULT", "S");
1478 
1479  aws->callback(makeCreateWindowCallback(create_probe_expert_window, true));
1480  aws->at("expert");
1481  aws->create_button("EXPERT", "EXPERT", "S");
1482 
1483  aws->at("pt_server");
1484  aws->label("PT-Server:");
1486 
1487  aws->at("lenout"); aws->create_input_field(AWAR_PD_DESIGN_CLIPRESULT, 6);
1488  aws->at("mishit"); aws->create_input_field(AWAR_PD_DESIGN_MISHIT, 6);
1489  aws->sens_mask(AWM_EXP);
1490  aws->at("maxbonds"); aws->create_input_field(AWAR_PD_DESIGN_MAXBOND, 6);
1491  aws->sens_mask(AWM_ALL);
1492  aws->at("minhits"); aws->create_input_field(AWAR_PD_DESIGN_MINTARGETS, 6);
1493 
1494  aws->at("minlen"); aws->create_input_field(AWAR_PD_DESIGN_MIN_LENGTH, 5);
1495  aws->at("maxlen"); aws->create_input_field(AWAR_PD_DESIGN_MAX_LENGTH, 5);
1496  aws->at("mint"); aws->create_input_field(AWAR_PD_DESIGN_MIN_TEMP, 5);
1497  aws->at("maxt"); aws->create_input_field(AWAR_PD_DESIGN_MAX_TEMP, 5);
1498  aws->at("mingc"); aws->create_input_field(AWAR_PD_DESIGN_MIN_GC, 5);
1499  aws->at("maxgc"); aws->create_input_field(AWAR_PD_DESIGN_MAX_GC, 5);
1500  aws->at("minpos"); aws->create_input_field(AWAR_PD_DESIGN_MIN_ECOLIPOS, 5);
1501  aws->at("maxpos"); aws->create_input_field(AWAR_PD_DESIGN_MAX_ECOLIPOS, 5);
1502 
1503  if (is_genom_db) {
1504  aws->at("gene");
1505  aws->label("Gene probes?");
1506  aws->create_toggle(AWAR_PD_DESIGN_GENE);
1507  }
1508 
1509  aws->at("save");
1510  AWT_insert_config_manager(aws, AW_ROOT_DEFAULT, "probe_design", makeConfigSetupCallback(setup_probe_config, probe_design_mapping_def));
1511 
1512  return aws;
1513 }
1514 
1515 // -------------------------------------------------------------------
1516 
1517 inline void my_strupr(char *s) {
1518  pd_assert(s);
1519  for (int i=0; s[i]; i++) {
1520  s[i] = toupper(s[i]);
1521  }
1522 }
1523 
1525  selection_id->clear();
1526 
1527  GB_ERROR error = NULp;
1528  char *ali_name = GBT_get_default_alignment(gb_main);
1529  if (!ali_name) {
1530  error = GB_await_error();
1531  }
1532  else {
1533  GB_alignment_type ali_type = GBT_get_alignment_type(gb_main, ali_name);
1534  if (ali_type != GB_AT_RNA && ali_type!=GB_AT_DNA) {
1535  error = GB_append_exportedError("Wrong alignment type");
1536  }
1537  else {
1538  int index = ali_type==GB_AT_RNA ? 1 : 0;
1539  char *istring = root->awar(AWAR_ITARGET_STRING)->read_string();
1540 
1541  if (istring && istring[0]) { // contains sth?
1542  my_strupr(istring);
1543 
1544  int bases_to_resolve = 0;
1545  char *istr = istring;
1546  int istring_length = strlen(istring);
1547 
1548  for (;;) {
1549  char i = *istr++;
1550  if (!i) break;
1551  if (i=='?') continue; // ignore '?'
1552 
1553  int idx = i-'A';
1554  if (idx<0 || idx>=26 || !iupac::nuc_group[idx][index].members) {
1555  error = GBS_global_string("Illegal character '%c' in IUPAC-String", i);
1556  break;
1557  }
1558 
1559  if (iupac::nuc_group[idx][index].count>1) {
1560  bases_to_resolve++;
1561  }
1562  }
1563 
1564  if (!error) {
1565  int *offsets_to_resolve = new int[bases_to_resolve];
1566  int resolutions = 1;
1567  {
1568  istr = istring;
1569  int offset = 0;
1570  int offset_count = 0;
1571  for (;;) {
1572  char i = *istr++;
1573  if (!i) break;
1574 
1575  if (i!='?') {
1576  int idx = iupac::to_index(i);
1577  pd_assert(iupac::nuc_group[idx][index].members);
1578 
1579  if (iupac::nuc_group[idx][index].count>1) {
1580  offsets_to_resolve[offset_count++] = offset; // store string offsets of non-unique base-codes
1581  resolutions *= iupac::nuc_group[idx][index].count; // calc # of resolutions
1582  }
1583  }
1584  offset++;
1585  }
1586  }
1587 
1588  {
1589  int *resolution_idx = new int[bases_to_resolve];
1590  int *resolution_max_idx = new int[bases_to_resolve];
1591  {
1592  int i;
1593  for (i=0; i<bases_to_resolve; i++) {
1594  resolution_idx[i] = 0;
1595  int idx = iupac::to_index(istring[offsets_to_resolve[i]]);
1596  resolution_max_idx[i] = iupac::nuc_group[idx][index].count-1;
1597  }
1598  }
1599 
1600  char *buffer = new char[istring_length+1];
1601  int not_last = resolutions-1;
1602 
1603  for (;;) {
1604  // create string according to resolution_idx[]:
1605  int i;
1606 
1607  memcpy(buffer, istring, istring_length+1);
1608  for (i=0; i<bases_to_resolve; i++) {
1609  int off = offsets_to_resolve[i];
1610  int idx = iupac::to_index(istring[off]);
1611 
1612  pd_assert(iupac::nuc_group[idx][index].members);
1613  buffer[off] = iupac::nuc_group[idx][index].members[resolution_idx[i]];
1614  }
1615 
1616  selection_id->insert(buffer, buffer);
1617  not_last--;
1618 
1619  // permute indices:
1620  int nidx = bases_to_resolve-1;
1621  int done = 0;
1622  while (!done && nidx>=0) {
1623  if (resolution_idx[nidx]<resolution_max_idx[nidx]) {
1624  resolution_idx[nidx]++;
1625  done = 1;
1626  break;
1627  }
1628  nidx--;
1629  }
1630  if (!done) break; // we did all permutations!
1631 
1632  nidx++; // do not touch latest incremented index
1633  while (nidx<bases_to_resolve) resolution_idx[nidx++] = 0; // zero all other indices
1634  }
1635 
1636  delete [] buffer;
1637  delete [] resolution_max_idx;
1638  delete [] resolution_idx;
1639 
1640  pd_assert(!error);
1641  selection_id->insert_default("", "");
1642  }
1643 
1644  delete [] offsets_to_resolve;
1645  }
1646  }
1647  else { // empty input
1648  selection_id->insert_default("", "");
1649  }
1650  }
1651  free(ali_name);
1652  }
1653  if (error) selection_id->insert_default(error, "");
1654  selection_id->update();
1655 }
1656 
1658 
1659 static void modify_target_string(AW_window *aww, GBDATA *gb_main, ModMode mod_mode) {
1660  AW_root *root = aww->get_root();
1661  char *target_string = root->awar(AWAR_TARGET_STRING)->read_string();
1662  GB_ERROR error = NULp;
1663 
1664  if (mod_mode == TS_MOD_CLEAR) target_string[0] = 0;
1665  else {
1666  GB_transaction ta(gb_main);
1667 
1668  if (ta.ok()) {
1669  char *ali_name = GBT_get_default_alignment(gb_main);
1670  if (!ali_name) {
1671  error = GB_await_error();
1672  }
1673  else {
1674  GB_alignment_type ali_type = GBT_get_alignment_type(gb_main, ali_name);
1675  pd_assert(ali_type != GB_AT_UNKNOWN);
1676 
1677  if (mod_mode == TS_MOD_REV_COMPL) {
1678  char T_or_U;
1679  error = GBT_determine_T_or_U(ali_type, &T_or_U, "reverse-complement");
1680  if (!error) GBT_reverseComplementNucSequence(target_string, strlen(target_string), T_or_U);
1681  }
1682  else if (mod_mode == TS_MOD_COMPL) {
1683  char T_or_U;
1684  error = GBT_determine_T_or_U(ali_type, &T_or_U, "complement");
1685  if (!error) freeset(target_string, GBT_complementNucSequence(target_string, strlen(target_string), T_or_U));
1686  }
1687  free(ali_name);
1688  }
1689  }
1690  }
1691 
1692  if (error) aw_message(error);
1693  else root->awar(AWAR_TARGET_STRING)->write_string(target_string);
1694  free(target_string);
1695 }
1696 
1697 static void clear_itarget(AW_window *aww) {
1699 }
1700 
1702  AW_window_simple *aws = new AW_window_simple;
1703 
1704  aws->init(root, "PROBE_MATCH_RESOLVE_IUPAC", "Resolve IUPAC for Probe Match");
1705  aws->load_xfig("pd_match_iupac.fig");
1706 
1707  aws->button_length(11);
1708 
1709  aws->at("close");
1710  aws->callback(AW_POPDOWN);
1711  aws->create_button("CLOSE", "CLOSE", "C");
1712 
1713  aws->at("help");
1714  aws->callback(makeHelpCallback("pd_match_iupac.hlp"));
1715  aws->create_button("HELP", "HELP", "H");
1716 
1717  aws->at("istring");
1718  aws->create_input_field(AWAR_ITARGET_STRING, 32);
1719 
1720  aws->at("iresult");
1721  AW_selection_list *iselection_id;
1722  iselection_id = aws->create_selection_list(AWAR_PD_MATCH_RESOLVE, 32, 15);
1723  iselection_id->insert_default("---empty---", "");
1724 
1725  // add callback for automatic decomposition of AWAR_ITARGET_STRING:
1726  RootCallback upd_cb = makeRootCallback(resolve_IUPAC_target_string, iselection_id, gb_main);
1727  AW_awar *awar_itarget = root->awar(AWAR_ITARGET_STRING);
1728  awar_itarget->add_callback(upd_cb);
1729  root->awar(AWAR_DEFAULT_ALIGNMENT)->add_callback(upd_cb);
1730 
1731  aws->at("match_all");
1732  aws->callback(makeWindowCallback(probe_match_all_event, iselection_id, gb_main));
1733  aws->create_button("MATCH_ALL", "Match all", "M");
1734 
1735  aws->at("clear");
1736  aws->callback(clear_itarget);
1737  aws->create_button("CLEAR", "Clear", "r");
1738 
1739  aws->at("iupac_info");
1740  aws->callback(AWT_create_IUPAC_info_window);
1741  aws->create_button("IUPAC_INFO", "IUPAC info", "I");
1742 
1743  awar_itarget->touch(); // force initial refresh for saved value
1744 
1745  return aws;
1746 }
1747 
1749  static AW_window *aw_saiProbeMatch = NULp;
1750 
1751  if (!aw_saiProbeMatch) aw_saiProbeMatch = createSaiProbeMatchWindow(aw->get_root(), gb_main);
1752  if (g_spd) transferProbeData(g_spd); // transferring probe data to saiProbeMatch function
1753 
1754  aw_saiProbeMatch->activate();
1755 }
1756 
1758  // main window:
1759  { AWAR_TARGET_STRING, "target" },
1760  { AWAR_PD_MATCH_ALSO_REVCOMP, "complement" },
1761  { AWAR_PD_MATCH_MARKHITS, "markhits" },
1762  { AWAR_PD_MATCH_WRITE2TMP, "writetmp" },
1763  { AWAR_PD_MATCH_AUTOMATCH, "automatch" },
1764 
1765  // expert window:
1766  { AWAR_PD_MATCH_NMATCHES, "nmatches" },
1767  { AWAR_PD_MATCH_LIM_NMATCH, "limitnmatch" },
1768  { AWAR_PD_MATCH_MAX_RES, "maxresults" },
1769 
1770  { NULp, NULp }
1771 };
1772 
1773 
1775  static AW_window_simple *aws = NULp; // the one and only probe match window
1776  if (!aws) {
1777  aws = new AW_window_simple;
1778 
1779  aws->init(root, "PROBE_MATCH", "PROBE MATCH");
1780  aws->load_xfig("pd_match.fig");
1781 
1782  aws->auto_space(5, 5);
1783 
1784  aws->at("close");
1785  aws->callback(AW_POPDOWN);
1786  aws->create_button("CLOSE", "CLOSE", "C");
1787 
1788  aws->callback(makeHelpCallback("probematch.hlp"));
1789  aws->at("help");
1790  aws->create_button("HELP", "HELP", "H");
1791 
1792  aws->at("string");
1793  aws->create_input_field(AWAR_TARGET_STRING, 32);
1794 
1795  AW_selection_list *selection_id;
1796  aws->at("result");
1797  selection_id = aws->create_selection_list(AWAR_PD_SELECTED_MATCH, 110, 15);
1798  selection_id->insert_default("****** No results yet *******", ""); // if list is empty -> crashed if new species was selected in ARB_EDIT4
1799 
1800  static SmartPtr<TypedSelectionList> typed_selection = new TypedSelectionList("match", selection_id, "probe match", "probe_match");
1801  aws->at("print");
1802  aws->callback(makeWindowCallback(create_print_box_for_selection_lists, &*typed_selection));
1803  aws->create_button("PRINT", "PRINT", "P");
1804 
1805  aws->at("matchSai");
1806  aws->help_text("saiProbe.hlp");
1807  aws->callback(makeWindowCallback(popupSaiProbeMatchWindow, gb_main));
1808  aws->create_button("MATCH_SAI", "Match SAI", "S");
1809 
1810  aws->callback(makeCreateWindowCallback(create_probe_expert_window, false));
1811  aws->at("expert");
1812  aws->create_button("EXPERT", "EXPERT", "X");
1813 
1814  aws->at("pt_server");
1816 
1817  aws->at("complement");
1818  aws->create_toggle(AWAR_PD_MATCH_ALSO_REVCOMP);
1819 
1820  aws->at("mark");
1821  aws->create_toggle(AWAR_PD_MATCH_MARKHITS);
1822 
1823  aws->at("weighted");
1824  aws->create_toggle(AWAR_PD_MATCH_SORTBY);
1825 
1826  aws->at("mismatches");
1827  aws->create_input_field_with_scaler(AWAR_MAX_MISMATCHES, 5, 200, AW_SCALER_EXP_LOWER);
1828 
1829  aws->at("tmp");
1830  aws->create_toggle(AWAR_PD_MATCH_WRITE2TMP);
1831 
1832  aws->at("nhits");
1833  aws->create_button(NULp, AWAR_PD_MATCH_NHITS);
1834 
1835  aws->button_length(9);
1836 
1837  ProbeMatchEventParam *event_param = new ProbeMatchEventParam(gb_main, selection_id);
1838  aws->callback(RootAsWindowCallback::simple(probe_match_event_using_awars, event_param));
1839  aws->at("match");
1840  aws->create_button("MATCH", "MATCH", "D");
1841 
1842  aws->at("auto");
1843  aws->label("Auto");
1844  aws->create_toggle(AWAR_PD_MATCH_AUTOMATCH);
1845  enable_auto_match_cb(root, event_param);
1846 
1847  aws->callback(makeWindowCallback(modify_target_string, gb_main, TS_MOD_CLEAR));
1848  aws->at("clear");
1849  aws->create_button("CLEAR", "Clear", "0");
1850 
1851  aws->callback(makeWindowCallback(modify_target_string, gb_main, TS_MOD_REV_COMPL));
1852  aws->at("revcompl");
1853  aws->create_button("REVCOMPL", "RevCompl", "R");
1854 
1855  aws->callback(makeWindowCallback(modify_target_string, gb_main, TS_MOD_COMPL));
1856  aws->at("compl");
1857  aws->create_button("COMPL", "Compl", "C");
1858 
1859  aws->callback(makeCreateWindowCallback(create_IUPAC_resolve_window, gb_main));
1860  aws->at("iupac");
1861  aws->create_button("IUPAC", "IUPAC", "I");
1862 
1863  aws->at("config");
1864  AWT_insert_config_manager(aws, AW_ROOT_DEFAULT, "probe_match", makeConfigSetupCallback(setup_probe_config, probe_match_mapping_def));
1865  }
1866  return aws;
1867 }
1868 
1869 static void pd_start_pt_server(AW_window *aww) {
1870  const char *server_tag = GBS_ptserver_tag(aww->get_root()->awar(AWAR_PROBE_ADMIN_PT_SERVER)->read_int());
1871  arb_progress progress("Connecting PT-server");
1873  if (error) aw_message(error);
1874 }
1875 
1876 static void pd_kill_pt_server(AW_window *aww, bool kill_all) {
1877  if (aw_ask_sure("kill_ptserver",
1878  GBS_global_string("Are you sure to stop %s", kill_all ? "all servers" : "that server")))
1879  {
1880  long min = 0;
1881  long max = 0;
1882 
1883  if (kill_all) {
1884  const char * const *pt_servers = GBS_get_arb_tcp_entries("ARB_PT_SERVER*");
1885  while (pt_servers[max]) max++;
1886  }
1887  else {
1888  min = max = aww->get_root()->awar(AWAR_PROBE_ADMIN_PT_SERVER)->read_int(); // selected server
1889  }
1890 
1891  arb_progress progress("Stopping PT-servers..", max-min+1);
1892  GB_ERROR error = NULp;
1893 
1894  for (int i = min; i <= max && !error; i++) {
1895  if (i == -1) {
1896  error = "no server selected to stop";
1897  }
1898  else {
1899  char *choice = GBS_ptserver_id_to_choice(i, 0);
1900  if (!choice) {
1901  error = GB_await_error();
1902  }
1903  else {
1904  progress.subtitle(GBS_global_string("Trying to stop '%s'", choice));
1905 
1906  const char *server_tag = GBS_ptserver_tag(i);
1907  GB_ERROR kill_error = arb_look_and_kill_server(AISC_MAGIC_NUMBER, server_tag);
1908 
1909  if (kill_error) aw_message(GBS_global_string("Could not stop '%s' (Reason: %s)", choice, kill_error));
1910  else aw_message(GBS_global_string("Stopped '%s'", choice));
1911 
1912  free(choice);
1913  }
1914  }
1915  progress.inc_and_check_user_abort(error);
1916  }
1917  progress.done();
1918  aw_message_if(error);
1919  }
1920 }
1921 
1922 static const char *ptserver_directory_info_command(const char *dirname, const char *directory) {
1923  return GBS_global_string("echo 'Contents of directory %s:'; echo; (cd \"%s\"; ls -hl); echo; "
1924  "echo 'Available disk space in %s:'; echo; df -h \"%s\"; echo; ",
1925  dirname, directory,
1926  dirname, directory);
1927 
1928 }
1929 
1930 static void pd_query_pt_server(AW_window *aww) {
1931  int server_id = aww->get_root()->awar(AWAR_PROBE_ADMIN_PT_SERVER)->read_int();
1932  const char *server_tag = GBS_ptserver_tag(server_id);
1933  GB_ERROR error = NULp;
1934 
1935  if (server_id == -1) {
1936  error = "No pt-server selected.";
1937  }
1938  else {
1939  GBS_strstruct query_cmd(1024);
1940  query_cmd.cat(ptserver_directory_info_command("ARBHOME/lib/pts", "$ARBHOME/lib/pts"));
1941 
1942  const char *ARB_LOCAL_PTS = ARB_getenv_ignore_empty("ARB_LOCAL_PTS");
1943  if (ARB_LOCAL_PTS) query_cmd.cat(ptserver_directory_info_command("ARB_LOCAL_PTS", "$ARB_LOCAL_PTS")); // only defined if called via 'arb'-script
1944  else query_cmd.cat(ptserver_directory_info_command("HOME/.arb_pts", "${HOME}/.arb_pts"));
1945 
1946  query_cmd.cat("echo 'Running ARB programs:'; echo; ");
1947 
1948  {
1949  const char *socketid = GBS_read_arb_tcp(server_tag);
1950  if (!socketid) {
1951  error = GB_await_error();
1952  }
1953  else {
1954  char *arb_who = createCallOnSocketHost(socketid, "$ARBHOME/bin/", "arb_who", WAIT_FOR_TERMINATION, NULp);
1955  query_cmd.cat(arb_who);
1956  free(arb_who);
1957  }
1958  }
1959 
1960  if (!error) error = GB_xcmd(query_cmd.get_data(), XCMD_ASYNC_WAITKEY);
1961  }
1962  aw_message_if(error);
1963 }
1964 
1966  AW_root *awr = aww->get_root();
1967  GB_ERROR error = NULp;
1968 
1969  bool create_gene_server = awr->awar(AWAR_PROBE_CREATE_GENE_SERVER)->read_int();
1970  {
1971  GB_transaction ta(gb_main);
1972  if (create_gene_server && !GEN_is_genome_db(gb_main, -1)) create_gene_server = false;
1973 
1974  // check alignment first
1975  if (create_gene_server) {
1976  GBDATA *gb_ali = GBT_get_alignment(gb_main, GENOM_ALIGNMENT);
1977  if (!gb_ali) error = GB_await_error();
1978  }
1979  else { // normal pt server
1980  char *use = GBT_get_default_alignment(gb_main);
1981  if (!use) {
1982  error = GB_await_error();
1983  }
1984  else {
1985  GB_alignment_type alitype = GBT_get_alignment_type(gb_main, use);
1986  pd_assert(alitype != GB_AT_UNKNOWN);
1987  if (alitype == GB_AT_AA) error = "The PT-server does only support RNA/DNA sequence data";
1988  free(use);
1989  }
1990  }
1991  }
1992 
1993  long server_num = awr->awar(AWAR_PROBE_ADMIN_PT_SERVER)->read_int();
1994  const char *server_tag = GBS_ptserver_tag(server_num);
1995 
1996  if (server_num == -1) {
1997  error = "no pt-server selected.";
1998  }
1999 
2000  if (!error &&
2001  aw_question("update_ptserver",
2002  "This function will send your loaded database to the pt_server,\n"
2003  "which will need a long time (up to several hours) to analyse the data.\n"
2004  "Until the new server has analyzed all data, no server functions are available.\n\n"
2005  "Note 1: You must have the write permissions to do that ($ARBHOME/lib/pts/xxx))\n"
2006  "Note 2: The server will do the job in background,\n"
2007  " quitting this program won't affect the server",
2008  "Cancel,Do it"))
2009  {
2010  arb_progress progress("Updating PT-server");
2011  progress.subtitle("Stopping PT-server");
2013 
2014  const char *ipPort = GBS_read_arb_tcp(server_tag);
2015  const char *file = NULp;
2016  if (!ipPort) error = GB_await_error();
2017  else {
2018  file = GBS_scan_arb_tcp_param(ipPort, "-d");
2019  GBS_add_ptserver_logentry(GBS_global_string("Started build of '%s'", file));
2020 
2021  char *db_name = awr->awar(AWAR_SAVED_DB_PATH)->read_string();
2022  const char *log_entry = GBS_global_string("Exporting DB '%s'", db_name);
2023  puts(log_entry);
2024  GBS_add_ptserver_logentry(log_entry);
2025  free(db_name);
2026  }
2027 
2028  if (!error) {
2029  progress.subtitle("Exporting the database");
2030  {
2031  const char *mode = GB_supports_mapfile() ? "mbf" : "bf"; // save PT-server database with Fastload file (if supported)
2032  if (create_gene_server) {
2033  char *temp_server_name = GBS_string_eval(file, "*.arb=*_temp.arb");
2034  error = GB_save_as(gb_main, temp_server_name, mode);
2035 
2036  if (!error) {
2037  // convert database (genes -> species)
2038  progress.subtitle("Preparing DB for gene PT server");
2039  GBS_add_ptserver_logentry("Preparing DB for gene PT server");
2040  char *command = GBS_global_string_copy("$ARBHOME/bin/arb_gene_probe %s %s", temp_server_name, file);
2041  error = GBK_system(command);
2042  if (error) error = GBS_global_string("Couldn't convert database for gene pt server\n(Reason: %s)", error);
2043  free(command);
2044  }
2045  free(temp_server_name);
2046  }
2047  else { // normal pt_server
2048  error = GB_save_as(gb_main, file, mode);
2049  }
2050  }
2051  }
2052 
2053  if (!error) { // set pt-server database file to same permissions as pts directory
2054  char *dir = const_cast<char*>(strrchr(file, '/'));
2055  if (dir) {
2056  *dir = 0;
2057  long modi = GB_mode_of_file(file);
2058  *dir = '/';
2059  modi &= 0666;
2060  error = GB_set_mode_of_file(file, modi);
2061  }
2062  }
2063 
2064  if (!error) {
2065  progress.subtitle("Start PT-server (builds in background)");
2066  error = arb_start_server(server_tag, 1);
2067  }
2068  }
2069  if (error) aw_message(error);
2070 }
2071 
2074 }
2076  AWT_system_in_console_cb("arb_show_log.pl server", XCMD_ASYNC_WAIT_ON_ERROR);
2077 }
2078 
2080  bool is_genom_db;
2081  {
2082  GB_transaction ta(gb_main);
2083  is_genom_db = GEN_is_genome_db(gb_main, -1);
2084  }
2085 
2086  AW_window_simple *aws = new AW_window_simple;
2087  aws->init(root, "PT_SERVER_ADMIN", "PT_SERVER ADMIN");
2088 
2089  aws->load_xfig("pd_admin.fig");
2090 
2091 
2092  aws->callback(makeHelpCallback("probeadmin.hlp"));
2093  aws->at("help");
2094  aws->create_button("HELP", "HELP", "H");
2095 
2096  aws->at("close");
2097  aws->callback(AW_POPDOWN);
2098  aws->create_button("CLOSE", "CLOSE", "C");
2099 
2100  aws->button_length(18);
2101 
2102  aws->at("pt_server");
2104 
2105  aws->at("start");
2106  aws->callback(pd_start_pt_server);
2107  aws->create_button("START_SERVER", "Start server");
2108 
2109  aws->at("kill");
2110  aws->callback(makeWindowCallback(pd_kill_pt_server, false));
2111  aws->create_button("KILL_SERVER", "Stop server");
2112 
2113  aws->at("query");
2114  aws->callback(pd_query_pt_server);
2115  aws->create_button("CHECK_SERVER", "Check server");
2116 
2117  aws->at("kill_all");
2118  aws->callback(makeWindowCallback(pd_kill_pt_server, true));
2119  aws->create_button("KILL_ALL_SERVERS", "Stop all servers");
2120 
2121  aws->at("edit");
2122  aws->callback(awt_edit_arbtcpdat_cb);
2123  aws->create_button("CREATE_TEMPLATE", "Configure");
2124 
2125  aws->at("log");
2126  aws->callback(pd_edit_ptserver_log);
2127  aws->create_button("EDIT_LOG", "Build history");
2128 
2129  aws->at("slog");
2130  aws->callback(pd_view_server_console);
2131  aws->create_button("VIEW_SERVER_LOG", "View server log");
2132 
2133  aws->at("export");
2134  aws->callback(makeWindowCallback(pd_export_pt_server, gb_main));
2135  aws->create_button("UPDATE_SERVER", "Build server");
2136 
2137  if (is_genom_db) {
2138  aws->at("gene_server");
2139  aws->label("Gene server?");
2140  aws->create_toggle(AWAR_PROBE_CREATE_GENE_SERVER);
2141  }
2142 
2143  return aws;
2144 }
2145 
2146 // ----------------------------------------------------------------------------
2147 
2149  static AW_window_simple *aws = NULp;
2150 
2151  if (!aws) {
2152  aws = new AW_window_simple;
2153 
2154  aws->init(root, "MATCH_DISPLAYCONTROL", "MATCH DISPLAY CONTROL");
2155 
2156  aws->auto_space(10, 10);
2157  aws->label_length(35);
2158 
2159  const int FIELDSIZE = 5;
2160  const int SCALERSIZE = 500;
2161 
2162  aws->label("Mismatch threshold");
2163  aws->create_input_field_with_scaler(AWAR_PC_MISMATCH_THRESHOLD, FIELDSIZE, SCALERSIZE);
2164 
2165  aws->at_newline();
2166 
2167  aws->label("Clade marked threshold");
2168  aws->create_input_field_with_scaler(AWAR_DTREE_GROUP_MARKED_THRESHOLD, FIELDSIZE, SCALERSIZE);
2169 
2170  aws->at_newline();
2171 
2172  aws->label("Clade partially marked threshold");
2173  aws->create_input_field_with_scaler(AWAR_DTREE_GROUP_PARTIALLY_MARKED_THRESHOLD, FIELDSIZE, SCALERSIZE);
2174 
2175  aws->at_newline();
2176 
2177  aws->callback(TREE_create_marker_settings_window);
2178  aws->create_autosize_button("MARKER_SETTINGS", "Marker display settings", "d");
2179 
2180  aws->at_newline();
2181  }
2182 
2183  return aws;
2184 }
2185 
2186 // ----------------------------------------------------------------------------
2187 
2191 
2193  probes_id(NULp),
2194  ntw(NULp)
2195  {}
2196 };
2197 
2199 
2200 static void probe_match_update_probe_list(ArbPM_Context *pContext);
2202 
2204  FILE *pFile;
2207 
2209  pFile(NULp),
2210  pProgress(NULp),
2211  nLastPercent(0)
2212  {}
2213 };
2214 
2215 // ----------------------------------------------------------------------------
2216 
2217 static bool probe_match_with_specificity_enum_callback(void *pVoidContext, const char *pResult, bool bIsComment, int nItem, int nItems) {
2218  ArbWriteFile_Context *pContext = (ArbWriteFile_Context*)pVoidContext;
2219  int nPercent = (int)(100.0 * nItem / nItems);
2220 
2221  if (!bIsComment) {
2222  if (pContext->nLastPercent != nPercent) {
2223  pContext->nLastPercent = nPercent;
2224  pContext->pProgress->inc();
2225  }
2226  }
2227 
2228  if (pContext->pFile) {
2229  // Update status - put after matching cause matching writes its own status messages
2230  fprintf(pContext->pFile, "%s\n", pResult);
2231  }
2232 
2233  return pContext->pProgress->aborted();
2234 }
2235 
2236 // ----------------------------------------------------------------------------
2237 
2239  AW_edit(get_results_manager().resultsFileName());
2240 }
2241 
2242 // ----------------------------------------------------------------------------
2243 
2244 class GetMatchesContext { // @@@ merge with ProbeCollDisplay?
2245  float mismatchThreshold;
2246  int nProbes;
2247 
2248  typedef ArbMatchResultPtrByStringMultiMap MatchMap;
2249  typedef ArbMatchResultPtrByStringMultiMapConstIter MatchMapIter;
2250 
2251  const MatchMap& results;
2252 public:
2253  GetMatchesContext(float misThres, int numProbes)
2254  : mismatchThreshold(misThres),
2255  nProbes(numProbes),
2256  results(get_results_manager().resultsMap())
2257  {}
2258 
2259  void detect(std::string speciesName, NodeMarkers& matches) const {
2260  std::pair<MatchMapIter,MatchMapIter> iter = results.equal_range(speciesName);
2261 
2262  for (; iter.first != iter.second ; ++iter.first) {
2263  const ArbMatchResult *pMatchResult = iter.first->second;
2264  if (pMatchResult->weight() <= mismatchThreshold) {
2265  int nProbe = pMatchResult->index();
2266  matches.incMarker(nProbe);
2267  }
2268  }
2269  matches.incNodeSize();
2270  }
2271 };
2272 
2274 
2276  ArbProbe *find_probe(int markerIdx) const {
2277  const ArbProbePtrList& rProbeList = get_probe_collection().probeList();
2278  ArbProbePtrListConstIter wanted = rProbeList.begin();
2279 
2280  if (markerIdx>=0 && markerIdx<int(rProbeList.size())) advance(wanted, markerIdx);
2281  else wanted = rProbeList.end();
2282 
2283  return wanted == rProbeList.end() ? NULp : *wanted;
2284  }
2285 
2286 public:
2287  ProbeCollDisplay(int numProbes)
2288  : MarkerDisplay(numProbes)
2289  {}
2290 
2291  // MarkerDisplay interface
2292  const char *get_marker_name(int markerIdx) const OVERRIDE {
2293  ArbProbe *probe = find_probe(markerIdx);
2294  return probe ? probe->name().c_str() : GBS_global_string("<invalid probeindex %i>", markerIdx);
2295  }
2296  void retrieve_marker_state(const char *speciesName, NodeMarkers& matches) OVERRIDE {
2297  getMatchesContext->detect(speciesName, matches);
2298  }
2299 
2301  // select probe in selection list
2302  ArbProbe *probe = find_probe(markerIdx);
2303  if (probe) AW_root::SINGLETON->awar(AWAR_PC_SELECTED_PROBE)->write_string(probe->sequence().c_str());
2304 #if defined(DEBUG)
2305  else fprintf(stderr, "ProbeCollDisplay::handle_click: no probe found for markerIdx=%i\n", markerIdx);
2306 #endif
2307  }
2308 };
2309 
2310 inline bool displays_probeColl_markers(MarkerDisplay *md) { return dynamic_cast<ProbeCollDisplay*>(md); }
2311 
2313  // setup parameters for display of probe collection matches and trigger tree refresh
2315 
2317  bool display = get_results_manager().hasResults();
2318 
2319  MarkerDisplay *markerDisplay = agt->get_marker_display();
2320  bool redraw = false;
2321  if (display) {
2322  size_t probesCount = get_probe_collection().probeList().size();
2323  getMatchesContext = new GetMatchesContext(root->awar(AWAR_PC_MISMATCH_THRESHOLD)->read_float(), probesCount);
2324 
2325  if (displays_probeColl_markers(markerDisplay) && probesCount == size_t(markerDisplay->size())) {
2326  markerDisplay->flush_cache();
2327  }
2328  else {
2329  agt->set_marker_display(new ProbeCollDisplay(get_probe_collection().probeList().size()));
2330  }
2331  redraw = true;
2332  }
2333  else {
2334  if (displays_probeColl_markers(markerDisplay)) {
2335  agt->hide_marker_display();
2336  redraw = true;
2337  }
2338  }
2339 
2340  if (redraw) root->awar(AWAR_TREE_REFRESH)->touch();
2341 }
2342 
2343 // ----------------------------------------------------------------------------
2344 
2347  GB_ERROR error = NULp;
2348 
2349  ProbeMatchSettings matchSettings(root);
2350  matchSettings.markHits = 0;
2351  matchSettings.write2tmp = 0;
2352 
2353  ArbMatchResultsManager& g_results_manager = get_results_manager();
2354  g_results_manager.reset();
2355 
2356  // Using g_probe_collection instance of ArbProbeCollection, need to loop
2357  // through all the probes in the collect and then call probe_match_event,
2358  // collating the results as we go. The results can be obtained from the
2359  // g_spd->probeSeq list.
2360  const ArbProbePtrList& rProbeList = get_probe_collection().probeList();
2361 
2362  const long nItems = rProbeList.size();
2363  long nItem = 1;
2364 
2365  int nHits = 0;
2366  int nProbeIndex = 0;
2367 
2368  // This extra scope needed to ensure the arb_progress object is released
2369  // prior to the next one being used to show progress on write results to file
2370  {
2371  arb_progress progress("Matching probe collection", nItems);
2372 
2373  ArbProbeCollection& g_probe_collection = get_probe_collection();
2374 
2375  for (ArbProbePtrListConstIter ProbeIter = rProbeList.begin() ; ProbeIter != rProbeList.end() && !error; ++ProbeIter) {
2376  const ArbProbe *pProbe = *ProbeIter;
2377 
2378  if (pProbe) {
2379  int nMatches;
2380  ArbMatchResultSet *pResultSet = g_results_manager.addResultSet(pProbe);
2381 
2382  // Update status - put after matching cause matching writes its own status messages
2383  progress.subtitle(GBS_global_string("Matching probe %li of %li", nItem, nItems));
2384 
2385  // Perform match on pProbe
2386  matchSettings.targetString = pProbe->sequence();
2387  matchSettings.maxMismatches = pProbe->allowedMismatches();
2388 
2389  int counter = -1;
2390  ProbeMatchEventParam match_event(ntw->gb_main, &counter);
2391 
2392  error = probe_match_event(matchSettings, &match_event);
2393 
2394  pResultSet->initialise(pProbe, nProbeIndex);
2395  nProbeIndex++;
2396 
2397  if (g_spd && g_spd->getHeadline() && !error) {
2398  ProbeMatchParser parser(pProbe->sequence().c_str(), g_spd->getHeadline());
2399 
2400  if (parser.get_error()) {
2401  error = parser.get_error();
2402  }
2403  else {
2404  int nStartFullName = 0;
2405  int nEndFullName = 0;
2406 
2407  parser.getColumnRange("fullname", &nStartFullName, &nEndFullName);
2408 
2409  pResultSet->headline(g_spd->getHeadline(), nEndFullName);
2410 
2411  // Collate match results
2412  nMatches = g_spd->probeSeq.size();
2413 
2414  for (int cn = 0 ; cn < nMatches && !error ; cn++) {
2415  const std::string& sResult = g_spd->probeSeq[cn];
2416 
2417  ParsedProbeMatch parsed(sResult.c_str(), parser);
2418 
2419  if (parsed.get_error()) {
2420  error = parsed.get_error();
2421  }
2422  else {
2423  char *pName = parsed.get_column_content("name", true);
2424  char *pFullName = parsed.get_column_content("fullname", true);
2425  const char *pMatchPart = parsed.get_probe_region();
2426 
2427  pResultSet->add(pName,
2428  pFullName,
2429  pMatchPart,
2430  sResult.c_str(),
2431  g_probe_collection.matchWeighting());
2432 
2433  free(pName);
2434  free(pFullName);
2435  }
2436  }
2437  }
2438  }
2439 
2440  if (error) error = GBS_global_string("while matching probe #%li: %s", nItem, error);
2441 
2442  nItem++;
2443  }
2444  progress.inc_and_check_user_abort(error);
2445  }
2446  }
2447 
2448  if (!error) {
2449  ArbWriteFile_Context Context;
2450 
2451  arb_progress progress("Writing results to file", 100L);
2452  progress.subtitle(g_results_manager.resultsFileName());
2453 
2454  Context.pFile = fopen(g_results_manager.resultsFileName(), "w");
2455  Context.pProgress = &progress;
2456  Context.nLastPercent = 0;
2457 
2458  nHits = g_results_manager.enumerate_results(probe_match_with_specificity_enum_callback, (void*)&Context);
2459 
2460  fclose(Context.pFile);
2461 
2462  if (!error) error = progress.error_if_aborted();
2463  progress.done();
2464  }
2465 
2466  root->awar(AWAR_PC_MATCH_NHITS)->write_int(nHits);
2467 
2468  if (error) {
2469  aw_message(error);
2470 
2471  // Clear the results set
2472  g_results_manager.reset();
2473  }
2474  else {
2475  // Open the Probe Match Specificity dialog to interactively show how the
2476  // matches target the phylongeny
2478 
2479  double oldMaxWeight = g_results_manager.maximumWeight();
2480  g_results_manager.updateResults();
2481  double newMaxWeight = g_results_manager.maximumWeight();
2482 
2483  if (newMaxWeight != oldMaxWeight) {
2484  // set new limits for scaler and force current value into limits
2485  newMaxWeight = std::max(newMaxWeight, 0.000001); // avoid invalid limits
2486  root->awar(AWAR_PC_MISMATCH_THRESHOLD)->set_minmax(0.0, newMaxWeight)->touch();
2487  }
2488  }
2489 
2491  }
2492 }
2493 
2494 static void auto_match_cb(AW_root *root, TREE_canvas *ntw) {
2495  if (root->awar(AWAR_PC_AUTO_MATCH)->read_int()) {
2497  }
2498 }
2499 static void trigger_auto_match(AW_root *root) {
2500  root->awar(AWAR_PC_AUTO_MATCH)->touch();
2501 }
2502 
2503 // ----------------------------------------------------------------------------
2504 
2506  AW_root *root = aww->get_root();
2507 
2509  root->awar(AWAR_PC_MATCH_NHITS)->write_int(0);
2510  refresh_matchedProbesDisplay_cb(root, pContext->ntw);
2511 }
2512 
2514  char *pSequence = root->awar(AWAR_PC_SELECTED_PROBE)->read_string();
2515  if (pSequence) {
2516  const ArbProbe *pProbe = get_probe_collection().find(pSequence);
2517  if (pProbe) {
2518  const char *seq = pProbe->sequence().c_str();
2520  root->awar(AWAR_PC_TARGET_NAME) ->write_string(pProbe->name().c_str());
2521 
2522  root->awar(AWAR_TARGET_STRING)->write_string(seq); // copy to probe match & match in edit4
2523  }
2524  }
2525  free(pSequence);
2526 }
2527 
2528 static void target_string_changed_cb(AW_root *root) {
2529  char *pSequence = root->awar(AWAR_PC_TARGET_STRING)->read_string();
2530  if (pSequence && pSequence[0]) {
2531  const ArbProbe *pProbe = get_probe_collection().find(pSequence);
2532  if (pProbe) root->awar(AWAR_PC_SELECTED_PROBE)->write_string(pSequence);
2533  }
2534  free(pSequence);
2535 }
2536 
2537 static void match_changed_cb(AW_root *root) {
2538  // automatically adapt to last probe matched
2539  // (also adapts to last selected designed probe)
2540  char *pSequence = root->awar(AWAR_TARGET_STRING)->read_string();
2541  if (pSequence && pSequence[0]) {
2542  AW_awar *awar_target = root->awar(AWAR_PC_TARGET_STRING);
2543  if (strcmp(awar_target->read_char_pntr(), pSequence) != 0) {
2544  root->awar(AWAR_PC_TARGET_NAME)->write_string(""); // clear name
2545  }
2546  awar_target->write_string(pSequence);
2547  }
2548  free(pSequence);
2549 }
2550 
2551 // ----------------------------------------------------------------------------
2552 
2554  static AW_window_simple *aws = NULp; // the one and only probeSpec window
2555 
2556  if (!aws) {
2558 
2559  aws = new AW_window_simple;
2560 
2561  aws->init(root, "PROBE_MATCH_WITH_SPECIFICITY", "PROBE MATCH WITH SPECIFICITY");
2562 
2563  aws->load_xfig("pd_match_with_specificity.fig");
2564 
2565  aws->at("close");
2566  aws->callback(AW_POPDOWN);
2567  aws->create_button("CLOSE", "CLOSE", "C");
2568 
2569  aws->callback(makeHelpCallback("probespec.hlp"));
2570  aws->at("help");
2571  aws->create_button("HELP", "HELP", "H");
2572 
2573  AW_selection_list *probes_id;
2574 
2575  aws->at("probes");
2576  probes_id = aws->create_selection_list(AWAR_PC_SELECTED_PROBE, 110, 10);
2577  probes_id->insert_default("", "");
2578 
2579  PM_Context.probes_id = probes_id;
2580  PM_Context.ntw = ntw;
2581 
2582  aws->callback(makeWindowCallback(probe_match_with_specificity_edit_event));
2583  aws->at("results");
2584  aws->create_button("RESULTS", "RESULTS", "R");
2585 
2586  aws->at("pt_server");
2588 
2589  aws->at("nhits");
2590  aws->create_button(NULp, AWAR_PC_MATCH_NHITS);
2591 
2592  aws->callback(makeCreateWindowCallback(create_probe_collection_window, &PM_Context));
2593  aws->at("edit");
2594  aws->create_button("EDIT", "EDIT", "E");
2595 
2597  aws->at("match");
2598  aws->create_button("MATCH", "MATCH", "M");
2599 
2600  aws->callback(makeWindowCallback(probe_forget_matches_event, &PM_Context));
2601  aws->at("forget");
2602  aws->create_button("FORGET", "FORGET", "F");
2603 
2604  aws->at("auto");
2605  aws->label("Auto match");
2606  aws->create_toggle(AWAR_PC_AUTO_MATCH);
2607 
2608  AW_awar *awar_automatch = root->awar(AWAR_PC_AUTO_MATCH);
2609  awar_automatch->add_callback(makeRootCallback(auto_match_cb, ntw));
2610 
2611  aws->callback(makeCreateWindowCallback(create_probe_match_specificity_control_window));
2612  aws->at("control");
2613  aws->create_autosize_button("CONTROL", "Display control", "D");
2614 
2615  probe_match_update_probe_list(&PM_Context);
2616 
2619  root->awar(AWAR_TARGET_STRING)->add_callback(makeRootCallback(match_changed_cb));
2620 
2621  awar_automatch->touch(); // automatically run match if 'auto-match' is checked at startup
2622  }
2623 
2624  return aws;
2625 }
2626 
2627 // ----------------------------------------------------------------------------
2628 
2632 
2634  selection_id(NULp),
2635  PM_Context(NULp)
2636  {}
2637 };
2638 
2640 
2641 // ----------------------------------------------------------------------------
2642 
2643 static void save_probe_list_to_DB(const ArbProbePtrList& rProbeList, AW_root *root) {
2644  std::string saved;
2645  for (ArbProbePtrListConstIter ProbeIter = rProbeList.begin() ; ProbeIter != rProbeList.end() ; ++ProbeIter) {
2646  const ArbProbe *pProbe = *ProbeIter;
2647  if (pProbe) {
2648  // Note: target sequences/names do not contain '#'/':' (see REPLACE_TARGET_CONTROL_CHARS)
2649  saved = saved + '#'+pProbe->name()+':'+pProbe->sequence();
2650  }
2651  }
2652 
2653  root->awar(AWAR_PC_CURRENT_COLLECTION)->write_string(saved.empty() ? "" : saved.c_str()+1);
2654 }
2655 
2656 static void show_probes_in_sellist(const ArbProbePtrList& rProbeList, AW_selection_list *sellist) {
2657  sellist->clear();
2658  sellist->insert_default("", "");
2659  for (ArbProbePtrListConstIter ProbeIter = rProbeList.begin() ; ProbeIter != rProbeList.end() ; ++ProbeIter) {
2660  const ArbProbe *pProbe = *ProbeIter;
2661  if (pProbe) {
2662  sellist->insert(pProbe->displayName().c_str(), pProbe->sequence().c_str());
2663  }
2664  }
2665  sellist->update();
2666 }
2667 
2668 static void load_probe_collection(AW_window *aww, ArbPC_Context *Context, const char * const *awar_filename) {
2669  char *pFileName = aww->get_root()->awar(*awar_filename)->read_string();
2670 
2671  ArbProbeCollection ProbeCollection;
2672  std::string sErrorMessage;
2673 
2674  if (ProbeCollection.openXML(pFileName, sErrorMessage)) {
2675  int cn;
2676  char buffer[256] = {0};
2677  float weights[16] = {0.0};
2678  float dWidth = 1.0;
2679  float dBias = 0.0;
2680 
2681  ArbProbeCollection& g_probe_collection = get_probe_collection();
2682  g_probe_collection = ProbeCollection;
2683 
2684  g_probe_collection.getParameters(weights, dWidth, dBias);
2685 
2686  AW_root *root = AW_root::SINGLETON;
2687  root->awar(AWAR_PC_MATCH_WIDTH)->write_float(dWidth);
2688  root->awar(AWAR_PC_MATCH_BIAS)->write_float(dBias);
2689 
2690  for (cn = 0; cn < 16 ; cn++) {
2691  sprintf(buffer, AWAR_PC_MATCH_WEIGHTS"%i", cn);
2692 
2693  root->awar(buffer)->write_float(weights[cn]);
2694  }
2695 
2696  const ArbProbePtrList& rProbeList = g_probe_collection.probeList();
2697 
2698  save_probe_list_to_DB(rProbeList, root);
2699  show_probes_in_sellist(rProbeList, Context->selection_id);
2700 
2702  aww->hide();
2703  trigger_auto_match(root);
2704  }
2705  else {
2706  // Print error message
2707  aw_message(sErrorMessage.c_str());
2708  }
2709 
2710  free(pFileName);
2711 }
2712 
2713 // ----------------------------------------------------------------------------
2714 
2716  AW_root *root = AW_root::SINGLETON;
2717 
2718  int cn;
2719  char buffer[256] = {0};
2720 
2721  float weights[16] = {0.0};
2722  float dWidth = root->awar(AWAR_PC_MATCH_WIDTH)->read_float();
2723  float dBias = root->awar(AWAR_PC_MATCH_BIAS)->read_float();
2724 
2725  for (cn = 0; cn < 16 ; cn++) {
2726  sprintf(buffer, AWAR_PC_MATCH_WEIGHTS"%i", cn);
2727 
2728  weights[cn] = root->awar(buffer)->read_float();
2729  }
2730 
2731  ArbProbeCollection& g_probe_collection = get_probe_collection();
2732  g_probe_collection.setParameters(weights, dWidth, dBias);
2733 
2734  save_probe_list_to_DB(g_probe_collection.probeList(), root);
2735 }
2736 
2737 // ----------------------------------------------------------------------------
2738 
2739 static void save_probe_collection(AW_window *aww, const char * const *awar_filename) {
2740  char *pFileName = aww->get_root()->awar(*awar_filename)->read_string();
2741 
2742  struct stat FileStatus;
2743  int nResult = ::stat(pFileName, &FileStatus);
2744  bool bWrite = true;
2745 
2746  if (nResult == 0) {
2747  bWrite = (aw_question("probe_collection_save", "File already exists. Overwrite?", "YES,NO") == 0);
2748  }
2749 
2750  if (bWrite) {
2752  get_probe_collection().saveXML(pFileName);
2753 
2754  aww->hide();
2755  }
2756 
2757  free(pFileName);
2758 }
2759 
2760 // ----------------------------------------------------------------------------
2761 
2763  AW_selection_list *selection_id = pContext->selection_id;
2764  if (selection_id) {
2765  AW_root *root = aww->get_root();
2766  char *pSequence = root->awar(AWAR_PC_TARGET_STRING)->read_string();
2767  char *pName = root->awar(AWAR_PC_TARGET_NAME)->read_string();
2768 
2769  GB_ERROR error = NULp;
2770  if (!pSequence || !pSequence[0]) {
2771  error = "Please enter a target string";
2772  }
2773  else if (get_probe_collection().find(pSequence)) {
2774  error = "Target string already in collection";
2775  }
2776 
2777  if (!error) {
2778  const ArbProbe *pProbe = NULp;
2779 
2780  if (get_probe_collection().add(pName, pSequence, &pProbe) && pProbe) {
2781  selection_id->insert(pProbe->displayName().c_str(), pSequence);
2782  selection_id->update();
2785 
2786  root->awar(AWAR_PC_SELECTED_PROBE)->write_string(pSequence);
2787  trigger_auto_match(root);
2788  }
2789  else {
2790  error = "failed to add probe";
2791  }
2792  }
2793 
2794  aw_message_if(error);
2795 
2796  free(pName);
2797  free(pSequence);
2798  }
2799 }
2800 
2801 static void modify_probe_event(AW_window *aww, ArbPC_Context *pContext) {
2802  AW_selection_list *selection_id = pContext->selection_id;
2803  if (selection_id) {
2804  AW_root *root = aww->get_root();
2805  AW_awar *awar_selected = root->awar(AWAR_PC_SELECTED_PROBE);
2806  char *oldSequence = awar_selected->read_string();
2807  char *pSequence = root->awar(AWAR_PC_TARGET_STRING)->read_string();
2808  char *pName = root->awar(AWAR_PC_TARGET_NAME)->read_string();
2809  bool sequenceChanged = false;
2810 
2811  GB_ERROR error = NULp;
2812  if (!pSequence || !pSequence[0]) {
2813  error = "Please enter a target string";
2814  }
2815  else if (!oldSequence || !oldSequence[0]) {
2816  error = "Please select probe to modify";
2817  }
2818  else {
2819  sequenceChanged = strcmp(oldSequence, pSequence) != 0;
2820  if (sequenceChanged) { // sequence changed -> test vs duplicate
2821  if (get_probe_collection().find(pSequence)) {
2822  error = "Target string already in collection";
2823  }
2824  }
2825  }
2826 
2827  if (!error) {
2828  const ArbProbe *pProbe = NULp;
2829 
2830  if (get_probe_collection().replace(oldSequence, pName, pSequence, &pProbe) && pProbe) {
2831  AW_selection_list_iterator entry(selection_id, selection_id->get_index_of_selected());
2832  entry.set_displayed(pProbe->displayName().c_str());
2833  entry.set_value(AW_scalar(pSequence));
2834  selection_id->update();
2835 
2838 
2839  awar_selected->write_string(pSequence);
2840  trigger_auto_match(root);
2841  }
2842  else {
2843  error = "failed to replace probe";
2844  }
2845  }
2846 
2847  aw_message_if(error);
2848 
2849  free(pName);
2850  free(pSequence);
2851  free(oldSequence);
2852  }
2853 }
2854 
2856  AW_selection_list *selection_id = pContext->selection_id;
2857  if (selection_id) {
2858  AW_root *root = aww->get_root();
2859  char *pSequence = root->awar(AWAR_PC_SELECTED_PROBE)->read_string();
2860  if (pSequence) {
2861  const ArbProbe *pProbe = get_probe_collection().find(pSequence);
2862  if (pProbe) {
2863  int idx = selection_id->get_index_of_selected();
2864  selection_id->delete_element_at(idx);
2865 
2866  if (selection_id->size() < 1) {
2867  selection_id->insert_default("", "");
2868  }
2869  selection_id->update();
2870  selection_id->select_element_at(idx); // select next probe for deletion
2871 
2872  get_probe_collection().remove(pSequence);
2875 
2876  trigger_auto_match(root);
2877  }
2878  free(pSequence);
2879  }
2880  }
2881 }
2882 
2883 // ----------------------------------------------------------------------------
2884 
2886  static char *awar_name = NULp; // do not free, bound to callback
2887  return awt_create_load_box(root, "Load", "probe collection",
2888  ".", "xpc", &awar_name,
2889  makeWindowCallback(load_probe_collection, pContext, (const char*const*)&awar_name));
2890 }
2892  static char *awar_name = NULp; // do not free, bound to callback
2893  return awt_create_load_box(root, "Save", "probe collection",
2894  ".", "xpc", &awar_name,
2895  makeWindowCallback(save_probe_collection, (const char*const*)&awar_name));
2896 }
2897 
2898 // ----------------------------------------------------------------------------
2899 
2901  if (pContext) {
2902  AW_selection_list *sellist = pContext->probes_id;
2903  if (sellist) show_probes_in_sellist(get_probe_collection().probeList(), sellist);
2904  }
2905 }
2907  if (get_probe_collection().clear()) {
2909  show_probes_in_sellist(get_probe_collection().probeList(), pContext->selection_id);
2910  trigger_auto_match(aww->get_root());
2911  }
2912 }
2913 
2914 // ----------------------------------------------------------------------------
2915 
2918  aww->hide();
2919 }
2920 
2921 // ----------------------------------------------------------------------------
2922 
2924  static AW_window_simple *aws = NULp; // the one and only probe match window
2925  char buffer[256];
2926 
2927  pd_assert(pContext);
2928  PC_Context.PM_Context = pContext;
2929 
2930  if (!aws) {
2931  aws = new AW_window_simple;
2932 
2933  aws->init(root, "PROBE_COLLECTION", "PROBE COLLECTION");
2934 
2935  aws->load_xfig("pd_match_probe_collection.fig");
2936 
2937  aws->callback(probe_collection_close);
2938  aws->at("close");
2939  aws->create_button("CLOSE", "CLOSE", "C");
2940 
2941  aws->callback(makeHelpCallback("probespec.hlp"));
2942  aws->at("help");
2943  aws->create_button("HELP", "HELP", "H");
2944 
2945  AW_selection_list *selection_id;
2946 
2947  aws->at("probes");
2948  selection_id = aws->create_selection_list(AWAR_PC_SELECTED_PROBE, 110, 10);
2949  selection_id->insert_default("", "");
2950 
2951  PC_Context.selection_id = selection_id;
2952 
2953  aws->at("string");
2954  aws->create_input_field(AWAR_PC_TARGET_STRING, 32);
2955 
2956  aws->at("name");
2957  aws->create_input_field(AWAR_PC_TARGET_NAME, 32);
2958 
2959  aws->callback(makeWindowCallback(add_probe_to_collection_event, &PC_Context));
2960  aws->at("add");
2961  aws->create_button("ADD", "ADD", "A");
2962 
2963  aws->callback(makeWindowCallback(modify_probe_event, &PC_Context));
2964  aws->at("modify");
2965  aws->create_button("MODIFY", "MODIFY", "M");
2966 
2967  aws->callback(makeWindowCallback(remove_probe_from_collection_event, &PC_Context));
2968  aws->at("remove");
2969  aws->create_button("REMOVE", "REMOVE", "R");
2970 
2971  aws->callback(makeCreateWindowCallback(probe_collection_load_prompt, &PC_Context));
2972  aws->at("open");
2973  aws->create_button("LOAD", "LOAD", "L");
2974 
2975  aws->callback(makeCreateWindowCallback(probe_collection_save_prompt));
2976  aws->at("save");
2977  aws->create_button("SAVE", "SAVE", "S");
2978 
2979  aws->callback(makeWindowCallback(clear_probe_collection_event, &PC_Context));
2980  aws->at("clear");
2981  aws->create_button("CLEAR", "CLEAR", "L");
2982 
2983  for (int i = 0 ; i < 16 ; i++) {
2984  sprintf(buffer, "%i", i);
2985  aws->at(buffer);
2986  sprintf(buffer, AWAR_PC_MATCH_WEIGHTS"%i", i);
2987  aws->create_input_field(buffer, 4);
2988  root->awar(buffer)->add_callback(trigger_auto_match);
2989  }
2990 
2991  aws->at("width");
2992  aws->create_input_field(AWAR_PC_MATCH_WIDTH, 5);
2994 
2995  aws->at("bias");
2996  aws->create_input_field(AWAR_PC_MATCH_BIAS, 5);
2998 
2999  show_probes_in_sellist(get_probe_collection().probeList(), selection_id);
3000  }
3001  return aws;
3002 }
3003 
3004 // --------------------------------------------------------------------------------
3005 
3006 #ifdef UNIT_TESTS
3007 #ifndef TEST_UNIT_H
3008 #include <test_unit.h>
3009 #endif
3010 
3011 void TEST_pd_get_the_names() {
3012  GB_shell shell;
3013  GBDATA *gb_main = GB_open("TEST_pt_src.arb", "rw");
3014  TEST_REJECT_NULL(gb_main);
3015 
3016  {
3017  GB_transaction ta(gb_main);
3018 
3019  // mark some species:
3020  TEST_EXPECT_NO_ERROR(GBT_restore_marked_species(gb_main, "PbrPropi;PsAAAA00;DlcTolu2;FrhhPhil;PbcAcet2;PslFlave"));
3022  }
3023 
3024  bytestring bs = { NULp, 0 };
3025  bytestring checksum = { NULp, 0 };
3026 
3027  TEST_EXPECT_NO_ERROR(pd_get_the_names(gb_main, bs, checksum));
3028 
3029  TEST_EXPECT_EQUAL(bs.data, "DlcTolu2#PbcAcet2#PbrPropi#FrhhPhil#PsAAAA00#PslFlave");
3030  TEST_EXPECT_EQUAL(checksum.data, "2170459355#3425507407#727314028#2492024995#2931521641#2778470002");
3031 
3032  free(checksum.data);
3033  free(bs.data);
3034 
3035  GB_close(gb_main);
3036 }
3037 
3038 static void mark_all_genes(GBDATA *gb_main) {
3039  for (GBDATA *gb_species = GEN_first_organism(gb_main); gb_species; gb_species = GEN_next_organism(gb_species)) {
3040  for (GBDATA *gb_gene = GEN_first_gene(gb_species); gb_gene; gb_gene = GEN_next_gene(gb_gene)) {
3041  GB_write_flag(gb_gene, 1);
3042  }
3043  }
3044 }
3045 
3046 void TEST_pd_get_the_gene_names() {
3047  GB_shell shell;
3048  GBDATA *gb_main = GB_open("TEST_gpt_src.arb", "rw");
3049  TEST_REJECT_NULL(gb_main);
3050 
3051  {
3052  GB_transaction ta(gb_main);
3053  mark_all_genes(gb_main);
3054  }
3055 
3056  bytestring bs = { NULp, 0 };
3057  bytestring checksum = { NULp, 0 };
3058 
3059  TEST_EXPECT_NO_ERROR(pd_get_the_gene_names(gb_main, bs, checksum));
3060 
3061  TEST_EXPECT_EQUAL(bs.data, "genome1/gene1#genome1/gene2#genome1/gene3#genome1/joined1#genome2/gene1#genome2/gene2#genome2/gene3#genome2/joined1");
3062  TEST_EXPECT_EQUAL(checksum.data, "2151640631#4022586387#1662310901#364505133#84218586#1757287028#1057001327#2202967910");
3063 
3064  free(checksum.data);
3065  free(bs.data);
3066 
3067  GB_close(gb_main);
3068 }
3069 
3070 #endif // UNIT_TESTS
3071 
3072 // --------------------------------------------------------------------------------
3073 
AutoMatchSettings(ProbeMatchEventParam *event_param_, bool disable_)
const char * GBS_ptserver_logname(void)
Definition: adtcp.cxx:425
GB_ERROR GB_begin_transaction(GBDATA *gbd)
Definition: arbdb.cxx:2528
std::string hits_summary
ArbMatchResultSet * addResultSet(const ArbProbe *pProbe)
GB_ERROR GBK_system(const char *system_command)
Definition: arb_msg.cxx:571
const char * GB_ERROR
Definition: arb_core.h:25
void set_marker_display(MarkerDisplay *display)
#define AWAR_PC_MISMATCH_THRESHOLD
static void selected_probe_changed_cb(AW_root *root)
string result
GBDATA * GB_open(const char *path, const char *opent)
Definition: ad_load.cxx:1363
void sort(bool backward, bool case_sensitive)
Definition: AW_select.cxx:502
void cut_tail(size_t byte_count)
Definition: arb_strbuf.h:145
static void target_string_changed_cb(AW_root *root)
static void trigger_auto_match(AW_root *root)
AW_awar * set_srt(const char *srt)
Definition: AW_awar.cxx:567
#define AWAR_SAVED_DB_PATH
#define AWAR_PD_MATCH_LIM_NMATCH
AW_window * create_probe_design_window(AW_root *root, GBDATA *gb_main)
GetMatchesContext(float misThres, int numProbes)
GBDATA * GEN_next_gene(GBDATA *gb_gene)
Definition: adGene.cxx:138
void add(const char *awar_name, const char *config_name)
GBDATA * GBT_first_marked_species(GBDATA *gb_main)
Definition: aditem.cxx:113
static GB_ERROR pd_get_the_gene_names(GBDATA *gb_main, bytestring &bs, bytestring &checksum)
size_t size() const
Definition: arb_strarray.h:85
#define AWAR_PD_MATCH_ALSO_REVCOMP
GBDATA * GBT_first_marked_species_rel_species_data(GBDATA *gb_species_data)
Definition: aditem.cxx:109
static void match_changed_cb(AW_root *root)
#define AWAR_PC_MATCH_WIDTH
const char * get_error() const
ProbeCollDisplay(int numProbes)
return string(buffer, length)
void space()
Definition: test_unit.h:414
std::vector< std::string > probeSeq
#define AWAR_PD_DESIGN_MINTARGETS
void select_element_at(int wanted_index)
Definition: AW_select.cxx:433
GB_ERROR GB_append_exportedError(GB_ERROR error)
Definition: arb_msg.cxx:387
GB_ERROR GBT_restore_marked_species(GBDATA *gb_main, const char *stored_marked)
Definition: aditem.cxx:446
void set_displayed(const char *disp)
Definition: aw_select.hxx:162
GB_ERROR GB_write_string(GBDATA *gbd, const char *s)
Definition: arbdb.cxx:1387
#define AWAR_PROBE_CREATE_GENE_SERVER
void load_xfig(const char *file, bool resize=true)
Definition: AW_window.cxx:720
const TypedSelectionList & get_typedsellist() const
const ArbProbePtrList & probeList() const
void insert_default(const char *displayed, const AW_scalar &value)
Definition: AW_select.cxx:385
#define AWAR_SPV_DB_FIELD_NAME
GBDATA * GEN_find_gene(GBDATA *gb_species, const char *name)
Definition: adGene.cxx:64
AW_window * createSaiProbeMatchWindow(AW_root *awr, GBDATA *gb_main)
void AW_edit(const char *path)
Definition: AW_edit.cxx:16
#define AWAR_PD_DESIGN_EXP_DT
AW_window * awt_create_load_box(AW_root *aw_root, const char *action, const char *what, const char *default_directory, const char *file_extension, char **set_file_name_awar, const WindowCallback &ok_cb, const WindowCallback &close_cb, const char *close_button_text)
char * GBT_complementNucSequence(const char *s, int len, char T_or_U)
Definition: adRevCompl.cxx:78
void create_probe_design_variables(AW_root *root, AW_default props, AW_default db)
static void modify_probe_event(AW_window *aww, ArbPC_Context *pContext)
long GB_mode_of_file(const char *path)
Definition: arb_file.cxx:60
int aisc_close(aisc_com *link, AISC_Object &object)
Definition: client.c:249
const char *const members
Definition: iupac.h:47
char * get_column_content(const char *columnName, bool chop_spaces) const
#define AWAR_PD_DESIGN_MIN_TEMP
AW_selection_list * selection_id
GB_ERROR GB_end_transaction(GBDATA *gbd, GB_ERROR error)
Definition: arbdb.cxx:2561
#define AWAR_PD_MATCH_AUTOMATCH
long
Definition: AW_awar.cxx:152
static void probe_match_event_using_awars(AW_root *root, ProbeMatchEventParam *event_param)
void awt_clear_selection_list_cb(AW_window *, AW_selection_list *sellist)
AW_selection_list * selection_id
GBDATA * GBT_get_alignment(GBDATA *gb_main, const char *aliname)
Definition: adali.cxx:808
void add(int v)
Definition: ClustalV.cxx:461
static int init_local_com_struct()
#define pd_assert(bed)
Definition: probe_local.hxx:17
double maximumWeight() const
#define AWAR_PC_MATCH_WEIGHTS
ArbProbePtrList::const_iterator ArbProbePtrListConstIter
const char * ARB_getenv_ignore_empty(const char *envvar)
Definition: arb_misc.cxx:102
bool ok() const
Definition: arbdb.h:162
static void pd_export_pt_server(AW_window *aww, GBDATA *gb_main)
char * ARB_strdup(const char *str)
Definition: arb_string.h:27
AW_selection_list * resultList
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_DEFAULT_ALIGNMENT
Definition: aw_awar_defs.hxx:8
AW_window * create_probe_match_with_specificity_window(AW_root *root, TREE_canvas *ntw)
#define AWAR_SPV_DB_FIELD_WIDTH
GB_ERROR arb_look_and_start_server(long magic_number, const char *arb_tcp_env)
long read_int() const
Definition: AW_awar.cxx:184
static void auto_match_cb(AW_root *root)
static void probe_collection_close(AW_window *aww)
static saiProbeData * g_spd
GB_ERROR arb_look_and_kill_server(int magic_number, const char *arb_tcp_env)
AW_awar * set_minmax(float min, float max)
Definition: AW_awar.cxx:530
ArbPM_Context * PM_Context
static void probelength_changed_cb(AW_root *root, bool maxChanged)
void my_strupr(char *s)
void delete_element_at(int index)
Definition: AW_select.cxx:248
const char * GBS_global_string(const char *templat,...)
Definition: arb_msg.cxx:203
int aisc_nput(aisc_com *link, int o_type, const AISC_Object &object,...)
Definition: client.c:564
#define AWAR_PD_COMMON_EXP_BONDS_FORMAT
#define AWAR_MAX_MISMATCHES
bool displays_probeColl_markers(MarkerDisplay *md)
#define AWAR_PD_DESIGN_CLIPRESULT
char * GBS_string_eval(const char *insource, const char *icommand)
Definition: admatch.cxx:699
void AW_POPDOWN(AW_window *window)
Definition: AW_window.cxx:52
char * release()
Definition: arb_strbuf.h:129
static AW_window * probe_collection_save_prompt(AW_root *root)
#define AWAR_PD_DESIGN_MISHIT
void cat(const char *from)
Definition: arb_strbuf.h:183
int get_index_of_selected()
Definition: AW_select.cxx:316
static void save_probe_collection(AW_window *aww, const char *const *awar_filename)
char * ARB_strpartdup(const char *start, const char *end)
Definition: arb_string.h:51
#define AWAR_DTREE_GROUP_MARKED_THRESHOLD
Definition: TreeDisplay.hxx:75
static void probe_collection_update_parameters()
int allowedMismatches() const
ProbeMatchEventParam(GBDATA *gb_main_, AW_selection_list *id)
static void setup_probe_config(AWT_config_definition &cdef, const AWT_config_mapping_def *mapping)
char * GBS_ptserver_id_to_choice(int i, int showBuild)
Definition: adtcp.cxx:447
GBDATA * GB_get_grandfather(GBDATA *gbd)
Definition: arbdb.cxx:1728
static bool probe_match_with_specificity_enum_callback(void *pVoidContext, const char *pResult, bool bIsComment, int nItem, int nItems)
char buffer[MESSAGE_BUFFERSIZE]
Definition: seq_search.cxx:34
GB_ERROR GB_push_transaction(GBDATA *gbd)
Definition: arbdb.cxx:2494
void activate()
Definition: aw_window.hxx:360
FILE * seq
Definition: rns.c:46
GB_ERROR arb_start_server(const char *arb_tcp_env, int do_sleep)
void incMarker(size_t markerIdx)
#define DOWNCAST(totype, expr)
Definition: downcast.h:141
void GBT_split_string(ConstStrArray &dest, const char *namelist, const char *separator, bool dropEmptyTokens)
Definition: arb_strarray.h:232
static const char * ptserver_directory_info_command(const char *dirname, const char *directory)
static GB_ERROR pd_get_the_names(GBDATA *gb_main, bytestring &bs, bytestring &checksum)
bool openXML(const char *pFileAndPath, std::string &rErrorMessage)
GB_ERROR error_if_aborted()
Definition: arb_progress.h:323
AW_awar * add_callback(const RootCallback &cb)
Definition: AW_awar.cxx:231
GB_ERROR GB_delete(GBDATA *&source)
Definition: arbdb.cxx:1916
static void modify_target_string(AW_window *aww, GBDATA *gb_main, ModMode mod_mode)
static int probe_match_send_data(const ProbeMatchSettings &matchSettings)
#define TEST_EXPECT_MORE(val, ref)
Definition: test_unit.h:1306
void flush_cache()
GBDATA * GBT_first_species_rel_species_data(GBDATA *gb_species_data)
Definition: aditem.cxx:121
void insert(const char *displayed, const AW_scalar &value)
Definition: AW_select.cxx:380
const char * get_string() const
Definition: aw_scalar.hxx:72
void setHeadline(const char *hline)
static struct aisc_static_set_mem md
static AW_window * probe_collection_load_prompt(AW_root *root, ArbPC_Context *pContext)
static void pd_query_pt_server(AW_window *aww)
static FullNameMap names
#define AWAR_SPV_SELECTED_PROBE
const char * read_char_pntr() const
Definition: AW_awar.cxx:168
static AW_window * create_IUPAC_resolve_window(AW_root *root, GBDATA *gb_main)
void putlong(long l)
Definition: arb_strbuf.h:224
#define AWAR_PD_DESIGN_MIN_LENGTH
void handle_click(int markerIdx, AW_MouseButton, AWT_graphic_exports &) OVERRIDE
int aisc_put(aisc_com *link, int o_type, const AISC_Object &object,...)
Definition: client.c:539
uchar flags
Definition: probe_tree.h:38
size_t GB_read_string_count(GBDATA *gbd)
Definition: arbdb.cxx:916
GB_ERROR GB_await_error()
Definition: arb_msg.cxx:342
static bool deny_read
Definition: aw_awar.hxx:106
static AW_root * SINGLETON
Definition: aw_root.hxx:102
void show()
Definition: AW_window.cxx:1683
static ArbPM_Context PM_Context
#define AWAR_PC_SELECTED_PROBE
AW_window * TREE_create_marker_settings_window(AW_root *root)
static AutoMatchSettings auto_match_cb_settings
WindowCallback makeHelpCallback(const char *helpfile)
Definition: aw_window.hxx:106
const char * getHeadline() const
void detect(std::string speciesName, NodeMarkers &matches) const
#define AWAR_PT_SERVER
void getParameters(float aValues[16], float &dWidth, float &dBias) const
static void pd_start_pt_server(AW_window *aww)
const char * GBS_read_arb_tcp(const char *env)
Definition: adtcp.cxx:325
static void pd_edit_ptserver_log(AW_window *)
int get_probe_region_offset() const
void awt_edit_arbtcpdat_cb(AW_window *)
NOT4PERL void GBT_reverseComplementNucSequence(char *seq, long length, char T_or_U)
Definition: adRevCompl.cxx:102
const char * GBS_scan_arb_tcp_param(const char *ipPort, const char *wantedParam)
Definition: adtcp.cxx:275
ArbProbeCollection & get_probe_collection()
AW_window * AWT_create_IUPAC_info_window(AW_root *aw_root)
Definition: AWT_misc.cxx:21
AW_awar * awar_float(const char *var_name, float default_value=0.0, AW_default default_file=AW_ROOT_DEFAULT)
Definition: AW_root.cxx:560
AW_MouseButton
Definition: aw_window.hxx:70
bool remove(const char *pSequence)
char * createCallOnSocketHost(const char *host, const char *remotePrefix, const char *command, SpawnMode spawnmode, const char *logfile)
Definition: servercntrl.cxx:75
GBDATA * GEN_first_marked_gene(GBDATA *gb_species)
Definition: adGene.cxx:143
GBDATA * gb_species_data
Definition: adname.cxx:33
static int probe_design_send_data(AW_root *root, const T_PT_PDC &pdc)
static void pd_view_server_console(AW_window *)
Generic smart pointer.
Definition: smartptr.h:149
static void probe_match_with_specificity_edit_event()
bool aborted()
Definition: arb_progress.h:335
void hide_marker_display()
const char * resultsFileName() const
int enumerate_results(ArbMatchResultsEnumCallback pCallback, void *pContext)
void index(int nIndex) const
#define true
Definition: ureadseq.h:14
void transferProbeData(saiProbeData *spd)
void incNodeSize()
bool add(const char *pName, const char *pSequence, const ArbProbe **ppProbe=NULp)
T_PT_MAIN com
#define AWAR_PD_MATCH_MAX_RES
static void popup_probe_design_result_window(AW_window *aww, GBDATA *gb_main)
char * data
Definition: bytestring.h:16
MarkerDisplay * get_marker_display()
GB_ERROR GB_save_as(GBDATA *gbd, const char *path, const char *savetype)
#define AWAR_PD_MATCH_NHITS
static int weights[MAX_BASETYPES][MAX_BASETYPES]
Definition: ClustalV.cxx:71
static void load_probe_collection(AW_window *aww, ArbPC_Context *Context, const char *const *awar_filename)
AW_selection_list * probes_id
static const char * auto_match_sensitive_awars[]
#define TEST_REJECT_NULL(n)
Definition: test_unit.h:1325
static void probe_match_all_event(AW_window *aww, AW_selection_list *iselection_id, GBDATA *gb_main)
void touch()
Definition: AW_awar.cxx:207
static void remove_probe_from_collection_event(AW_window *aww, ArbPC_Context *pContext)
static void error(const char *msg)
Definition: mkptypes.cxx:96
#define AWAR_PD_DESIGN_MAXBOND
static void add_probe_to_collection_event(AW_window *aww, ArbPC_Context *pContext)
#define AWAR_TREE_REFRESH
static void show_probes_in_sellist(const ArbProbePtrList &rProbeList, AW_selection_list *sellist)
static AWT_config_mapping_def probe_design_mapping_def[]
static void popup_match_window_cb(AW_window *aww, GBDATA *gb_main)
#define AWAR_PD_MATCH_WRITE2TMP
ArbMatchResultsManager & get_results_manager()
static __ATTR__USERESULT GB_ERROR probe_match_event(const ProbeMatchSettings &matchSettings, ProbeMatchEventParam *event_param)
static char * readableUnknownNames(const ConstStrArray &unames)
void GBT_splitNdestroy_string(ConstStrArray &names, char *&namelist, const char *separator, bool dropEmptyTokens)
GBDATA * GBT_next_marked_species(GBDATA *gb_species)
Definition: aditem.cxx:116
const char * get_error() const
ArbMatchResultPtrByStringMultiMap::const_iterator ArbMatchResultPtrByStringMultiMapConstIter
#define AWAR_PD_DESIGN_MAX_GC
ProbeMatchEventParam(GBDATA *gb_main_, int *counter_)
void create_print_box_for_selection_lists(AW_window *aw_window, const TypedSelectionList *typedsellist)
static void clear_itarget(AW_window *aww)
const Nuc_Group nuc_group[26][2]
Definition: iupac.cxx:24
static void probe_forget_matches_event(AW_window *aww, ArbPM_Context *pContext)
GB_alignment_type GBT_get_alignment_type(GBDATA *gb_main, const char *aliname)
Definition: adali.cxx:873
#define AWAR_PD_DESIGN_MAX_LENGTH
#define AWAR_SPECIES_NAME
const std::string & displayName() const
GBDATA * GEN_find_gene_data(GBDATA *gb_species)
Definition: adGene.cxx:50
GBDATA * GEN_next_organism(GBDATA *gb_organism)
Definition: adGene.cxx:745
#define AWAR_TARGET_STRING
#define AWAR_PD_SELECTED_MATCH
#define AWAR_PD_COMMON_EXP_SPLIT
int size() const
NOT4PERL GB_ERROR GB_xcmd(const char *cmd, XCMD_TYPE exectype) __ATTR__USERESULT_TODO
Definition: adsocket.cxx:906
int GB_read_flag(GBDATA *gbd)
Definition: arbdb.cxx:2796
GBDATA * GBT_find_species_rel_species_data(GBDATA *gb_species_data, const char *name)
Definition: aditem.cxx:133
static void resolved_probe_chosen(AW_root *root)
#define AWAR_PD_MATCH_NMATCHES
char * read_string() const
Definition: AW_awar.cxx:198
static WindowCallback simple(void(*root_cb)(AW_root *, T), T t)
Definition: rootAsWin.h:47
#define AWAR_PC_TARGET_STRING
bool initialized() const
int to_index(char c)
Definition: iupac.h:53
AW_awar * awar(const char *awar)
Definition: AW_root.cxx:554
GB_ERROR GB_pop_transaction(GBDATA *gbd)
Definition: arbdb.cxx:2524
Definition: arbdb.h:86
#define GENOM_ALIGNMENT
Definition: adGene.h:19
GBDATA * GBT_find_sequence(GBDATA *gb_species, const char *aliname)
Definition: adali.cxx:708
GB_ERROR GB_set_mode_of_file(const char *path, long mode)
Definition: arb_file.cxx:231
char * GBT_read_gene_sequence(GBDATA *gb_gene, bool use_revComplement, char partSeparator)
Definition: adali.cxx:1057
AW_awar * remove_callback(const RootCallback &cb)
Definition: AW_awar.cxx:525
void awt_create_PTSERVER_selection_list(AW_window *aws, const char *varname)
AW_window * create_load_box_for_selection_lists(AW_root *aw_root, const StorableSelectionList *storabsellist)
static void probe_design_event(AW_window *aww, GBDATA *gb_main)
arb_progress * pProgress
void awt_create_PTSERVER_selection_button(AW_window *aws, const char *varname)
long GBT_count_marked_species(GBDATA *gb_main)
Definition: aditem.cxx:372
#define AWAR_PD_MATCH_MARKHITS
float read_float() const
Definition: AW_awar.cxx:177
const char * arb_look_and_start_ptserver(int magic_number, int ptserver_id, GB_ERROR &error)
GB_alignment_type
Definition: arbdb_base.h:61
long int flag
Definition: f2c.h:39
#define AISC_MAGIC_NUMBER
Definition: client_privat.h:51
const ArbProbeMatchWeighting & matchWeighting() const
#define AWAR_PD_DESIGN_MIN_ECOLIPOS
bool aw_ask_sure(const char *unique_id, const char *msg)
static void minmax_awar_pair_changed_cb(AW_root *root, bool maxChanged, const char *minAwarName, const char *maxAwarName)
const char * get_marker_name(int markerIdx) const OVERRIDE
static void resolve_IUPAC_target_string(AW_root *root, AW_selection_list *selection_id, GBDATA *gb_main)
std::vector< std::string > probeSpecies
int aw_question(const char *unique_id, const char *question, const char *buttons, bool sameSizeButtons, const char *helpfile)
Definition: AW_question.cxx:26
AWT_graphic * gfx
Definition: awt_canvas.hxx:339
#define AWAR_PD_DESIGN_MAX_ECOLIPOS
const char *const * GBS_get_arb_tcp_entries(const char *matching)
Definition: adtcp.cxx:390
#define AWAR_PC_CURRENT_COLLECTION
#define AWAR_PC_MATCH_NHITS
std::list< ArbProbe * > ArbProbePtrList
GB_ERROR GB_export_errorf(const char *templat,...)
Definition: arb_msg.cxx:262
ProbeCommonSettings(AW_root *root)
AW_awar * awar_int(const char *var_name, long default_value=0, AW_default default_file=AW_ROOT_DEFAULT)
Definition: AW_root.cxx:580
#define DISP_FORMAT
void retrieve_marker_state(const char *speciesName, NodeMarkers &matches) OVERRIDE
static void gc_minmax_changed_cb(AW_root *root, bool maxChanged)
static void clear_probe_collection_event(AW_window *aww, ArbPC_Context *pContext)
void GB_write_flag(GBDATA *gbd, long flag)
Definition: arbdb.cxx:2773
static AW_window * create_probe_match_specificity_control_window(AW_root *root)
T_PT_LOCS locs
static int ecolipos2int(const char *awar_val)
str readable(const copy< T > &v)
Definition: test_unit.h:345
int gene_flag
Definition: PT_main.cxx:39
static GB_ERROR gene_requires(GBDATA *gb_gene, const char *whats_required)
const AW_scalar * get_value() const
Definition: aw_select.hxx:160
static ArbPC_Context PC_Context
GB_CSTR GB_getenvUSER(void)
Definition: adsocket.cxx:545
#define REPLACE_TARGET_CONTROL_CHARS
aisc_com * link
#define OVERRIDE
Definition: cxxforward.h:110
static void auto_match_changed(AW_root *root)
#define AWAR_PC_MATCH_BIAS
static void probe_match_update_probe_list(ArbPM_Context *pContext)
size_t const count
Definition: iupac.h:48
aisc_com * aisc_open(const char *path, AISC_Object &main_obj, long magic, GB_ERROR *error)
Definition: client.c:205
#define __ATTR__USERESULT
Definition: attributes.h:58
void nprintf(size_t maxlen, const char *templat,...) __ATTR__FORMAT_MEMBER(2)
Definition: arb_strbuf.cxx:29
const std::string & sequence() const
bool is_gene_result() const
static void save_probe_list_to_DB(const ArbProbePtrList &rProbeList, AW_root *root)
static void temp_minmax_changed_cb(AW_root *root, bool maxChanged)
#define AWAR_PD_DESIGN_EXP_DTEDGE
void subtitle(const char *stitle)
Definition: arb_progress.h:321
char * GB_read_string(GBDATA *gbd)
Definition: arbdb.cxx:909
std::string targetString
#define AWAR_PROBE_ADMIN_PT_SERVER
Definition: probe_gui.hxx:24
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:212
void setProbeTarget(const char *target)
#define AWAR_PD_MATCH_RESOLVE
const char * bond_awar_name(int i)
ProbeMatchSettings(AW_root *root)
uint32_t GBS_checksum(const char *seq, int ignore_case, const char *exclude)
Definition: adstring.cxx:352
static bool deny_write
Definition: aw_awar.hxx:107
#define TEST_EXPECT_NO_ERROR(call)
Definition: test_unit.h:1118
#define AWAR_GENE_NAME
Definition: GEN.hxx:33
void aw_message(const char *msg)
Definition: AW_status.cxx:1142
void hide()
Definition: AW_window.cxx:1835
ModMode
static int probe_common_send_data(const ProbeCommonSettings &commonSettings)
AW_root * get_root()
Definition: aw_window.hxx:354
ProbeMatchEventParam * event_param
GBDATA * GEN_first_gene(GBDATA *gb_species)
Definition: adGene.cxx:130
AW_window_simple * win
GBDATA * GBT_next_species(GBDATA *gb_species)
Definition: aditem.cxx:128
#define NULp
Definition: cxxforward.h:114
GBDATA * GBT_find_species(GBDATA *gb_main, const char *name)
Definition: aditem.cxx:139
void AWT_system_in_console_cb(AW_window *, const char *command, XCMD_TYPE exectype)
Definition: AWT_misc.cxx:90
int aisc_get(aisc_com *link, int o_type, const AISC_Object &object,...)
Definition: client.c:266
#define AWAR_PD_DESIGN_MAX_TEMP
static struct @25 PD
static AWT_config_mapping_def probe_match_mapping_def[]
GB_ERROR write_string(const char *aw_string)
static char * command
Definition: arb_a2ps.c:319
#define AWAR_PC_AUTO_MATCH
#define offset(field)
Definition: GLwDrawA.c:73
static void selected_match_changed_cb(AW_root *root)
char * GBT_get_default_alignment(GBDATA *gb_main)
Definition: adali.cxx:747
static SmartPtr< GetMatchesContext > getMatchesContext
const char * get_data() const
Definition: arb_strbuf.h:120
#define AWAR_PD_DESIGN_MIN_GC
void setParameters(const float aValues[16], float dWidth, float dBias)
static AW_window * create_probe_collection_window(AW_root *root, ArbPM_Context *pContext)
TREE_canvas * ntw
void GBS_add_ptserver_logentry(const char *entry)
Definition: adtcp.cxx:429
GB_transaction ta(gb_var)
GB_CSTR GB_read_char_pntr(GBDATA *gbd)
Definition: arbdb.cxx:904
GBDATA * gb_main
Definition: adname.cxx:32
std::multimap< std::string, ArbMatchResult * > ArbMatchResultPtrByStringMultiMap
AW_awar * awar_string(const char *var_name, const char *default_value="", AW_default default_file=AW_ROOT_DEFAULT)
Definition: AW_root.cxx:570
GB_ERROR write_float(float aw_float)
GBDATA * GEN_next_marked_gene(GBDATA *gb_gene)
Definition: adGene.cxx:146
const std::string & name() const
const char * GBS_ptserver_tag(int id)
Definition: adtcp.cxx:312
GBDATA * GB_search(GBDATA *gbd, const char *fieldpath, GB_TYPES create)
Definition: adquery.cxx:531
GBDATA * GEN_first_organism(GBDATA *gb_main)
Definition: adGene.cxx:739
static GB_ERROR species_requires(GBDATA *gb_species, const char *whats_required)
GB_CSTR GBT_get_name_or_description(GBDATA *gb_item)
Definition: aditem.cxx:459
bool GEN_is_genome_db(GBDATA *gb_main, int default_value)
Definition: adGene.cxx:20
static void pd_kill_pt_server(AW_window *aww, bool kill_all)
static void probe_match_with_specificity_event(AW_root *root, TREE_canvas *ntw)
AW_window * create_probe_match_window(AW_root *root, GBDATA *gb_main)
#define AWAR_ITARGET_STRING
bool saveXML(const char *pFileAndPath) const
#define min(a, b)
Definition: f2c.h:153
static void enable_auto_match_cb(AW_root *root, ProbeMatchEventParam *event_param)
#define AWAR_SPV_ACI_COMMAND
#define AWAR_DTREE_GROUP_PARTIALLY_MARKED_THRESHOLD
Definition: TreeDisplay.hxx:76
static void popupSaiProbeMatchWindow(AW_window *aw, GBDATA *gb_main)
#define AWAR_PD_MATCH_SORTBY
#define AW_ROOT_DEFAULT
Definition: aw_base.hxx:106
static bool allow_probe_match_event
#define TEST_EXPECT_EQUAL(expr, want)
Definition: test_unit.h:1294
GB_ERROR write_int(long aw_int)
#define AWAR_PD_DESIGN_GENE
double weight() const
static AW_window * create_probe_expert_window(AW_root *root, bool for_design)
AW_window * create_probe_admin_window(AW_root *root, GBDATA *gb_main)
GBDATA * GB_entry(GBDATA *father, const char *key)
Definition: adquery.cxx:334
void inc_and_check_user_abort(GB_ERROR &error)
Definition: arb_progress.h:332
int aisc_create(aisc_com *link, int father_type, const AISC_Object &father, int attribute, int object_type, AISC_Object &object,...)
Definition: client.c:593
static void refresh_matchedProbesDisplay_cb(AW_root *root, TREE_canvas *ntw)
size_t get_position() const
Definition: arb_strbuf.h:112
void aw_message_if(GB_ERROR error)
Definition: aw_msg.hxx:21
bool GB_supports_mapfile(void)
Definition: admap.cxx:644
char * GBS_global_string_copy(const char *templat,...)
Definition: arb_msg.cxx:194
void GB_close(GBDATA *gbd)
Definition: arbdb.cxx:655
#define AWAR_PC_TARGET_NAME
NOT4PERL GB_ERROR GBT_determine_T_or_U(GB_alignment_type alignment_type, char *T_or_U, const char *supposed_target)
Definition: adRevCompl.cxx:90
const ArbProbe * find(const char *pSequence) const
GBDATA * gb_main
Definition: awt_canvas.hxx:336
void put(char c)
Definition: arb_strbuf.h:158
#define AWAR_SPV_SAI_2_PROBE
GBDATA * GBT_get_species_data(GBDATA *gb_main)
Definition: aditem.cxx:105
#define max(a, b)
Definition: f2c.h:154
GB_write_int const char s
Definition: AW_awar.cxx:154