ARB
graph_aligner_gui.cxx
Go to the documentation of this file.
1 // =============================================================== //
2 // //
3 // File : graph_aligner_gui.cxx //
4 // Purpose : //
5 // //
6 // Coded by Elmar Pruesse in October 2008 //
7 // Institute of Microbiology (Technical University Munich) //
8 // http://www.arb-home.de/ //
9 // //
10 // =============================================================== //
11 
12 #include "graph_aligner_gui.hxx"
13 
14 #include "ed4_defs.hxx"
15 
16 // need to use AlignDataAccess defined here to get selected species
17 #include <fast_aligner.hxx>
18 
19 #include <aw_awars.hxx>
20 #include <aw_msg.hxx>
21 #include <aw_root.hxx>
22 #include <awt_sel_boxes.hxx>
23 #include <awt_config_manager.hxx>
24 #include <servercntrl.h>
25 #include <PT_com.h>
26 #include <client.h>
27 #include <arbdbt.h>
28 #include <arb_strbuf.h>
29 #include <arb_misc.h>
30 
31 #include <sys/types.h>
32 #include <sys/wait.h>
33 
34 #include <unistd.h>
35 
36 #include <string>
37 #include <sstream>
38 #include <iostream>
39 #include <vector>
40 
41 using std::cerr;
42 using std::cout;
43 using std::endl;
44 
45 #define GA_AWAR_ROOT "sina/"
46 
47 #define GA_AWAR_CMD GA_AWAR_ROOT "command"
48 #define GA_AWAR_TGT GA_AWAR_ROOT "target"
49 #define GA_AWAR_SAI GA_AWAR_ROOT "sai"
50 #define GA_AWAR_ALIGNMENT GA_AWAR_ROOT "alignment"
51 #define GA_AWAR_PROTECTION GA_AWAR_ROOT "protection"
52 #define GA_AWAR_TURN_CHECK GA_AWAR_ROOT "turncheck"
53 #define GA_AWAR_REALIGN GA_AWAR_ROOT "realign"
54 #define GA_AWAR_COPYMARKREF GA_AWAR_ROOT "copymarkref"
55 #define GA_AWAR_MATCH_SCORE GA_AWAR_ROOT "match_score"
56 #define GA_AWAR_MISMATCH_SCORE GA_AWAR_ROOT "mismatch_score"
57 #define GA_AWAR_GAP_PEN GA_AWAR_ROOT "gap_pen"
58 #define GA_AWAR_GAP_EXT GA_AWAR_ROOT "gap_ext"
59 #define GA_AWAR_ADVANCED GA_AWAR_ROOT "advanced"
60 #define GA_AWAR_FS_MIN GA_AWAR_ROOT "fs_min"
61 #define GA_AWAR_FS_MAX GA_AWAR_ROOT "fs_max"
62 #define GA_AWAR_FS_MSC GA_AWAR_ROOT "fs_msc"
63 #define GA_AWAR_MIN_FULL GA_AWAR_ROOT "min_full"
64 #define GA_AWAR_FULL_MINLEN GA_AWAR_ROOT "full_minlen"
65 #define GA_AWAR_OVERHANG GA_AWAR_ROOT "overhang"
66 #define GA_AWAR_THREADS GA_AWAR_ROOT "threads"
67 #define GA_AWAR_QSIZE GA_AWAR_ROOT "qsize"
68 #define GA_AWAR_KMER_LEN GA_AWAR_ROOT "kmer_len"
69 #define GA_AWAR_KMER_MM GA_AWAR_ROOT "kmer_mm"
70 #define GA_AWAR_MIN_LEN GA_AWAR_ROOT "min_len"
71 #define GA_AWAR_WEIGHT GA_AWAR_ROOT "weight"
72 #define GA_AWAR_INSERT GA_AWAR_ROOT "insert"
73 #define GA_AWAR_LOWERCASE GA_AWAR_ROOT "lowercase"
74 #define GA_AWAR_AUTOFILTER GA_AWAR_ROOT "autofilter"
75 #define GA_AWAR_KMER_NOREL GA_AWAR_ROOT "kmer_norel"
76 #define GA_AWAR_KMER_NOFAST GA_AWAR_ROOT "kmer_nofast"
77 #define GA_AWAR_SHOW_DIST GA_AWAR_ROOT "show_dist"
78 #define GA_AWAR_SHOW_DIFF GA_AWAR_ROOT "show_diff"
79 #define GA_AWAR_COLOR GA_AWAR_ROOT "color"
80 #define GA_AWAR_GENE_START GA_AWAR_ROOT "gene_start"
81 #define GA_AWAR_GENE_END GA_AWAR_ROOT "gene_end"
82 #define GA_AWAR_FS_COVER_GENE GA_AWAR_ROOT "fs_cover_gene"
83 
85  root->awar_string(GA_AWAR_CMD, "sina", db1);
86  root->awar_int (GA_AWAR_TGT, 2, db1);
87  root->awar_int (AWAR_PT_SERVER, 0, db1);
88  root->awar_string(GA_AWAR_SAI, "", db1);
89  root->awar_int (GA_AWAR_PROTECTION, 0, db1);
90  root->awar_int (GA_AWAR_TURN_CHECK, 1, db1);
91  root->awar_int (GA_AWAR_REALIGN, 1, db1);
92  root->awar_int (GA_AWAR_COPYMARKREF, 0, db1);
93  root->awar_float (GA_AWAR_GAP_PEN, 5.0, db1);
94  root->awar_float (GA_AWAR_GAP_EXT, 2.0, db1);
95  root->awar_float (GA_AWAR_MATCH_SCORE, 2.0, db1);
96  root->awar_float (GA_AWAR_MISMATCH_SCORE, -1.0, db1);
97  root->awar_int (GA_AWAR_ADVANCED, 0, db1);
98  root->awar_int (GA_AWAR_FS_MIN, 40, db1);
99  root->awar_int (GA_AWAR_FS_MAX, 40, db1);
100  root->awar_float (GA_AWAR_FS_MSC, .7, db1);
101  root->awar_int (GA_AWAR_MIN_FULL, 1, db1);
102  root->awar_int (GA_AWAR_FULL_MINLEN, 1400, db1);
103  root->awar_string(GA_AWAR_OVERHANG, "attach", db1);
104  root->awar_int (GA_AWAR_THREADS, 1, db1);
105  root->awar_int (GA_AWAR_QSIZE, 1, db1);
106  root->awar_int (GA_AWAR_KMER_LEN, 10, db1);
107  root->awar_int (GA_AWAR_KMER_MM, 0, db1);
108  root->awar_int (GA_AWAR_MIN_LEN, 150, db1);
109  root->awar_float (GA_AWAR_WEIGHT, 1, db1);
110  root->awar_string(GA_AWAR_INSERT, "shift", db1);
111  root->awar_string(GA_AWAR_LOWERCASE, "none", db1);
112  root->awar_string(GA_AWAR_AUTOFILTER, "none", db1);
113  root->awar_int (GA_AWAR_KMER_NOREL, 0, db1);
114  root->awar_int (GA_AWAR_KMER_NOFAST, 0, db1);
115  root->awar_int (GA_AWAR_SHOW_DIST, 0, db1);
116  root->awar_int (GA_AWAR_SHOW_DIFF, 0, db1);
117  root->awar_int (GA_AWAR_COLOR, 1, db1);
118  root->awar_int (GA_AWAR_GENE_START, 0, db1);
119  root->awar_int (GA_AWAR_GENE_END, 0, db1);
120  root->awar_int (GA_AWAR_FS_COVER_GENE, 1, db1);
121 }
122 
124  const char *sinaName = root->awar(GA_AWAR_CMD)->read_char_pntr();
125  char *sina = ARB_executable(sinaName, GB_getenv("PATH"));
126  const char *fail_reason = NULp;
127 
128  if (sina) {
130  char *description = GBS_global_string_copy("the sina executable derived from\n"
131  "- gui property '%s' and\n"
132  "- environment variable PATH", sinaName);
133  ARB_warn_about_unwanted_chars(sina, description);
134  free(description);
135  }
136 
137  int exitstatus = system(GBS_global_string("%s --has-cli-vers ARB5.99", sina));
138  exitstatus = WEXITSTATUS(exitstatus);
139 
140  switch (exitstatus) {
141  case EXIT_SUCCESS:
142  break;
143 
144  case EXIT_FAILURE:
145  fail_reason = "Incompatible SINA and ARB versions";
146  break;
147 
148  case 127: // libs missing
149  default: // unexpected
150  fail_reason = GBS_global_string("Could execute SINA binary '%s' (exitstatus was %i)",
151  sinaName, exitstatus);
152  break;
153  }
154  free(sina);
155  }
156  else {
157  fail_reason = GBS_global_string("'%s' not found", sinaName);
158  }
159 
160  if (fail_reason) {
161  fprintf(stderr,
162  "Note: SINA (SILVA Aligner) disabled (Reason: %s)\n",
163  fail_reason);
164  }
165 
166  return fail_reason ? AWM_DISABLED : AWM_ALL;
167 }
168 
169 inline const char *stream2static(const std::stringstream& str) {
170  return GBS_static_string(str.str().c_str());
171 }
172 
173 inline const char *empty_as_none(const char *sainame) {
174  // see http://bugs.arb-home.de/ticket/519
175  if (sainame && !sainame[0]) sainame = "none";
176  return sainame;
177 }
178 
179 static void sina_start(AW_window *window, const AlignDataAccess *data_access) {
180  cerr << "Starting SINA..." << endl;
181 
182  // make string from pt server selection
183  AW_root *root = window->get_root();
184  int pt = root->awar(AWAR_PT_SERVER)->read_int();
185 
186  std::stringstream ptnam;
187  ptnam << "ARB_PT_SERVER" << pt;
188 
189  const char *pt_server = GBS_read_arb_tcp(ptnam.str().c_str());
190  GB_ERROR gb_error = NULp;
191 
192  if (!pt_server) {
193  gb_error = GBS_global_string("Unable to find definition for chosen PT-server\n(Reason: %s)", GB_await_error());
194  }
195  else {
196  const char *pt_db = pt_server + strlen(pt_server) + 1;
197  pt_db += strlen(pt_db)+3;
198 
199  // start pt server if necessary
200  gb_error = arb_look_and_start_server(AISC_MAGIC_NUMBER, ptnam.str().c_str());
201  if (gb_error) {
202  std::stringstream tmp;
203  tmp << "Cannot contact PT server. Aborting" << endl
204  << " ID: \"" << tmp.str().c_str()
205  << "\" PORT: \"" << pt_server
206  << "\" DB: \"" << pt_db << endl
207  << "\" GBERROR: \"" << gb_error << "\"" << endl;
208  gb_error = stream2static(tmp);
209  }
210  else {
211  // create temporary file
212  char* tmpfile;
213  FILE* tmpfile_F;
214  {
215  char* tmpfile_tpl = GB_unique_filename("sina_select", "tmp");
216  tmpfile_F = GB_fopen_tempfile(tmpfile_tpl, "w", &tmpfile);
217  free(tmpfile_tpl);
218  }
219 
220  if (!tmpfile_F) {
221  std::stringstream tmp;
222  tmp << "Error: Unable to create temporary file \"" << tmpfile << "\"!";
223  gb_error = stream2static(tmp);
224  }
225  else {
226  GB_remove_on_exit(tmpfile);
227  GBDATA *gb_main = data_access->gb_main;
228 
229  std::vector<std::string> spec_names;
230  switch (root->awar(GA_AWAR_TGT)->read_int()) {
231  case 0: { // current
232  char *spec_name = root->awar(AWAR_SPECIES_NAME)->read_string();
233  if (spec_name) {
234  fwrite(spec_name, strlen(spec_name), 1, tmpfile_F);
235  fwrite("\n", 1, 1, tmpfile_F);
236  }
237  else {
238  gb_error = "Unable to get name of currently active species";
239  }
240  free(spec_name);
241  break;
242  }
243  case 1: { // selected
244  GB_begin_transaction(gb_main);
245  int num_selected = 0;
246  for (GBDATA *gb_spec = data_access->get_first_selected_species(&num_selected);
247  gb_spec;
248  gb_spec = data_access->get_next_selected_species())
249  {
250  GBDATA *gbd_name = GB_find(gb_spec, "name", SEARCH_CHILD);
251  if (gbd_name) {
252  const char *str = GB_read_char_pntr(gbd_name);
253  fwrite(str, strlen(str), 1, tmpfile_F);
254  fwrite("\n", 1, 1, tmpfile_F);
255  }
256  }
257  GB_commit_transaction(gb_main);
258  break;
259  }
260  case 2: { // marked
261  GB_begin_transaction(gb_main);
262  for (GBDATA *gb_spec = GBT_first_marked_species(gb_main);
263  gb_spec; gb_spec = GBT_next_marked_species(gb_spec)) {
264  GBDATA *gbd_name = GB_find(gb_spec, "name", SEARCH_CHILD);
265  if (gbd_name) {
266  const char *str = GB_read_char_pntr(gbd_name);
267  fwrite(str, strlen(str), 1, tmpfile_F);
268  fwrite("\n", 1, 1, tmpfile_F);
269  }
270  }
271  GB_commit_transaction(gb_main);
272  break;
273  }
274  }
275  fclose(tmpfile_F);
276 
277  if (!gb_error) {
278  // build command line
279  GBS_strstruct *cl = GBS_stropen(2000);
280 
281  GBS_strcat(cl, root->awar(GA_AWAR_CMD)->read_char_pntr());
282  GBS_strcat(cl, " -i :");
283  GBS_strcat(cl, " --ptdb :");
284  GBS_strcat(cl, " --ptport "); GBS_strcat(cl, pt_server);
285  GBS_strcat(cl, " --turn "); GBS_strcat(cl, root->awar(GA_AWAR_TURN_CHECK)->read_int() ? "all" : "none");
286  GBS_strcat(cl, " --overhang "); GBS_strcat(cl, root->awar(GA_AWAR_OVERHANG)->read_char_pntr());
287  GBS_strcat(cl, " --filter "); GBS_strcat(cl, empty_as_none(root->awar(GA_AWAR_SAI)->read_char_pntr()));
288  GBS_strcat(cl, " --fs-min "); GBS_intcat(cl, root->awar(GA_AWAR_FS_MIN)->read_int());
289  GBS_strcat(cl, " --fs-msc "); GBS_floatcat(cl, root->awar(GA_AWAR_FS_MSC)->read_float());
290  GBS_strcat(cl, " --fs-max "); GBS_intcat(cl, root->awar(GA_AWAR_FS_MAX)->read_int());
291  GBS_strcat(cl, " --fs-req 1");
292  GBS_strcat(cl, " --fs-req-full "); GBS_intcat(cl, root->awar(GA_AWAR_MIN_FULL)->read_int());
293  GBS_strcat(cl, " --fs-full-len "); GBS_intcat(cl, root->awar(GA_AWAR_FULL_MINLEN)->read_int());
294  GBS_strcat(cl, " --fs-kmer-len "); GBS_intcat(cl, root->awar(GA_AWAR_KMER_LEN)->read_int());
295  GBS_strcat(cl, " --fs-kmer-mm "); GBS_intcat(cl, root->awar(GA_AWAR_KMER_MM)->read_int());
296  GBS_strcat(cl, " --fs-min-len "); GBS_intcat(cl, root->awar(GA_AWAR_MIN_LEN)->read_int());
297  GBS_strcat(cl, " --fs-weight "); GBS_intcat(cl, root->awar(GA_AWAR_WEIGHT)->read_float()); // @@@ possible type conflict?
298  GBS_strcat(cl, " --pen-gap "); GBS_floatcat(cl, root->awar(GA_AWAR_GAP_PEN)->read_float());
299  GBS_strcat(cl, " --pen-gapext "); GBS_floatcat(cl, root->awar(GA_AWAR_GAP_EXT)->read_float());
300  GBS_strcat(cl, " --match-score "); GBS_floatcat(cl, root->awar(GA_AWAR_MATCH_SCORE)->read_float());
301  GBS_strcat(cl, " --mismatch-score "); GBS_floatcat(cl, root->awar(GA_AWAR_MISMATCH_SCORE)->read_float());
302  GBS_strcat(cl, " --prot-level "); GBS_intcat(cl, root->awar(GA_AWAR_PROTECTION)->read_int());
303  GBS_strcat(cl, " --select-file "); GBS_strcat(cl, tmpfile);
304  GBS_strcat(cl, " --insertion "); GBS_strcat(cl, root->awar(GA_AWAR_INSERT)->read_char_pntr());
305  GBS_strcat(cl, " --lowercase "); GBS_strcat(cl, root->awar(GA_AWAR_LOWERCASE)->read_char_pntr());
306  GBS_strcat(cl, " --auto-filter-field "); GBS_strcat(cl, root->awar(GA_AWAR_AUTOFILTER)->read_char_pntr());
307  GBS_strcat(cl, " --gene-start "); GBS_intcat(cl, root->awar(GA_AWAR_GENE_START)->read_int());
308  GBS_strcat(cl, " --gene-end "); GBS_intcat(cl, root->awar(GA_AWAR_GENE_END)->read_int());
309  GBS_strcat(cl, " --fs-cover-gene ");GBS_intcat(cl, root->awar(GA_AWAR_FS_COVER_GENE)->read_int());
310 
311 
312  if (root->awar(GA_AWAR_KMER_NOREL)->read_int()) GBS_strcat(cl, " --fs-kmer-norel ");
313  if (root->awar(GA_AWAR_KMER_NOFAST)->read_int()) GBS_strcat(cl, " --fs-kmer-no-fast ");
314  if (root->awar(GA_AWAR_SHOW_DIST)->read_int()) GBS_strcat(cl, " --show-dist ");
315  if (root->awar(GA_AWAR_SHOW_DIFF)->read_int()) GBS_strcat(cl, " --show-diff ");
316  if (root->awar(GA_AWAR_COLOR)->read_int()) GBS_strcat(cl, " --color");
317  if (root->awar(GA_AWAR_REALIGN)->read_int()) GBS_strcat(cl, " --realign");
318 
319  gb_error = GB_xcmd(GBS_mempntr(cl), XCMD_ASYNC_WAITKEY);
320  GBS_strforget(cl);
321  }
322 
323  if (!gb_error) aw_message("SINA finished aligning.");
324  }
325  free(tmpfile);
326  }
327  }
328 
329  aw_message_if(gb_error);
330 }
331 
332 
333 
334 static char* filter_posvar_SAI_for_ali(GBDATA *gb_extended, const char *ali_name) {
335  char *result = NULp;
336  char *typePath = GBS_global_string_copy("%s/_TYPE", ali_name);
337  GBDATA *gbd = GB_search(gb_extended, typePath, GB_FIND);
338  if (gbd) {
339  const char* type = GB_read_char_pntr(gbd);
340  if (type && strncmp("PV", type, 2) == 0) {
341  gbd = GB_find(gb_extended, "name", SEARCH_CHILD);
342  result = GB_read_string(gbd);
343  }
344  }
345  free(typePath);
346  return result;
347 }
348 
350  // both
351  { GA_AWAR_TGT, "target" },
352  { GA_AWAR_OVERHANG, "overhang" },
353  { GA_AWAR_INSERT, "insertions" },
354  { GA_AWAR_LOWERCASE, "lowercase" },
355  { GA_AWAR_WEIGHT, "weight" },
356  { GA_AWAR_FULL_MINLEN, "fullminlen" },
357 
358  // advanced only
359  { GA_AWAR_SAI, "sai" },
360  { GA_AWAR_AUTOFILTER, "autofilter" },
361  { GA_AWAR_TURN_CHECK, "turncheck" },
362  { GA_AWAR_REALIGN, "realign" },
363  { GA_AWAR_GAP_PEN, "gappen" },
364  { GA_AWAR_GAP_EXT, "gapext" },
365  { GA_AWAR_MATCH_SCORE, "matchscore" },
366  { GA_AWAR_MISMATCH_SCORE, "mismatchscore" },
367  { GA_AWAR_FS_MIN, "fs_min" },
368  { GA_AWAR_FS_MSC, "fs_minscore" },
369  { GA_AWAR_FS_MAX, "fs_min" },
370  { GA_AWAR_MIN_FULL, "minfull" },
371  { GA_AWAR_KMER_LEN, "kmerlen" },
372  { GA_AWAR_KMER_MM, "kmermm" },
373  { GA_AWAR_MIN_LEN, "refminlen" },
374  { GA_AWAR_GENE_START, "genestart" },
375  { GA_AWAR_GENE_END, "geneend" },
376  { GA_AWAR_FS_COVER_GENE, "fs_covergene" },
377  { GA_AWAR_KMER_NOFAST, "kmernofast" },
378  { GA_AWAR_KMER_NOREL, "kmernorel" },
379 
380  // both
381  { GA_AWAR_SHOW_DIFF, "showdiff" },
382  { GA_AWAR_COLOR, "color" },
383  { GA_AWAR_SHOW_DIST, "showdist" },
384 
385  { NULp, NULp }
386 };
387 
388 static AW_window_simple* new_sina_simple(AW_root *root, const AlignDataAccess *alignData, bool adv) {
389  int closex, closey, startx, starty, winx, winy;
390  const int hgap = 10;
391  AW_window_simple *aws = new AW_window_simple;
392 
393  aws->init(root, adv ? "XSINA" : "SINA", "SINA (SILVA Incremental Aligner)");
394 
395  aws->button_length(12);
396  aws->at(10, 10);
397  aws->auto_space(5, 5);
398 
399  aws->callback(AW_POPDOWN);
400  aws->create_button("CLOSE", "CLOSE", "O");
401  aws->get_at_position(&closex, &closey);
402 
403  aws->at_shift(10, 0);
404  aws->label_length(0);
405  aws->label("Show advanced options");
406  aws->create_toggle(GA_AWAR_ADVANCED);
407 
408  bool cbInstalled = false;
409  if (!cbInstalled) {
410  root->awar(GA_AWAR_ADVANCED)->add_callback(makeRootCallback(show_sina_window, alignData));
411  cbInstalled = true;
412  }
413 
414  aws->at_newline();
415  aws->at_shift(0, hgap);
416  aws->label_length(15);
417  aws->create_toggle_field(GA_AWAR_TGT, "Align what?", "A");
418  aws->insert_toggle("Current Species:", "C", 0);
419  aws->insert_toggle("Selected Species", "S", 1);
420  aws->insert_default_toggle("Marked Species", "M", 2);
421  aws->update_toggle_field();
422 
423  aws->at_shift(0, 3);
424  aws->create_input_field(AWAR_SPECIES_NAME, 20);
425 
426  aws->at_newline();
427  aws->at_shift(0, hgap);
428  aws->button_length(24);
429  aws->label("PT Server:");
431 
432  aws->at_newline();
433  aws->label_length(0);
434  aws->label("Overhang placement");
435  aws->create_option_menu(GA_AWAR_OVERHANG, true);
436  aws->insert_option("keep attached", NULp, "attach");
437  aws->insert_option("move to edge", NULp, "edge");
438  aws->insert_option("remove", NULp, "remove");
439  aws->update_option_menu();
440 
441  aws->at_newline();
442  aws->label("Handling of unmappable insertions");
443  aws->create_option_menu(GA_AWAR_INSERT, true);
444  aws->insert_option("Shift surrounding bases", NULp, "shift");
445  aws->insert_option("Forbid during DP alignment", NULp, "forbid");
446  aws->insert_option("Delete bases", NULp, "remove");
447  aws->update_option_menu();
448 
449  aws->at_newline();
450  aws->label("Character Case");
451  aws->create_option_menu(GA_AWAR_LOWERCASE, true);
452  aws->insert_option("Do not modify", NULp, "original");
453  aws->insert_option("Show unaligned bases as lower case", NULp, "unaligned");
454  aws->insert_option("Uppercase all", NULp, "none");
455  aws->update_option_menu();
456 
457  aws->at_newline();
458  aws->label("Family conservation weight (0-1)");
459  aws->create_input_field(GA_AWAR_WEIGHT, 3);
460 
461  aws->at_newline();
462  aws->label("Size of full-length sequences");
463  aws->create_input_field(GA_AWAR_FULL_MINLEN, 5);
464 
465  if (adv) {
466  aws->at_newline();
467  aws->at_shift(0, hgap);
468 
469  aws->at_newline();
470 
471  aws->label("Pos. Var.:");
472  awt_create_SAI_selection_button(alignData->gb_main, aws, GA_AWAR_SAI, makeSaiSelectionlistFilterCallback(filter_posvar_SAI_for_ali, alignData->alignment_name.c_str()));
473 
474  aws->at_newline();
475  aws->label("Field used for automatic filter selection");
476  aws->create_input_field(GA_AWAR_AUTOFILTER, 20);
477 
478  aws->label("Turn check");
479  aws->create_toggle(GA_AWAR_TURN_CHECK);
480 
481  aws->at_newline();
482  aws->label("Realign");
483  aws->create_toggle(GA_AWAR_REALIGN);
484 
485  /*
486  aws->at_newline();
487  aws->label("(Copy and) mark sequences used as reference");
488  aws->create_toggle(GA_AWAR_COPYMARKREF);
489  */
490 
491  aws->at_newline();
492  aws->at_shift(0, hgap);
493  aws->label_length(0);
494 
495  aws->label("Gap insertion/extension penalties");
496  aws->create_input_field(GA_AWAR_GAP_PEN, 5);
497  aws->create_input_field(GA_AWAR_GAP_EXT, 5);
498 
499  aws->at_newline();
500  aws->label("Match score");
501  aws->create_input_field(GA_AWAR_MATCH_SCORE, 3);
502  aws->label("Mismatch score");
503  aws->create_input_field(GA_AWAR_MISMATCH_SCORE, 3);
504 
505  aws->at_newline();
506  aws->label("Family search min/min_score/max");
507  aws->create_input_field(GA_AWAR_FS_MIN, 3);
508  aws->create_input_field(GA_AWAR_FS_MSC, 3);
509  aws->create_input_field(GA_AWAR_FS_MAX, 3);
510 
511  aws->at_newline();
512  aws->label("Minimal number of full length sequences");
513  aws->create_input_field(GA_AWAR_MIN_FULL, 3);
514 
515  aws->at_newline();
516  aws->label("Family search oligo length / mismatches");
517  aws->create_input_field(GA_AWAR_KMER_LEN, 3);
518  aws->create_input_field(GA_AWAR_KMER_MM, 3);
519 
520  aws->at_newline();
521  aws->label("Minimal reference sequence length");
522  aws->create_input_field(GA_AWAR_MIN_LEN, 5);
523 
524  aws->at_newline();
525  aws->label("Alignment bounds: start");
526  aws->create_input_field(GA_AWAR_GENE_START, 6);
527  aws->label("end");
528  aws->create_input_field(GA_AWAR_GENE_END, 6);
529 
530  aws->at_newline();
531  aws->label("Number of references required to touch bounds");
532  aws->create_input_field(GA_AWAR_FS_COVER_GENE, 3);
533 
534  aws->at_newline();
535  aws->label("Disable fast search");
536  aws->create_toggle(GA_AWAR_KMER_NOFAST);
537 
538  aws->at_newline();
539  aws->label("Score search results by absolute oligo match count");
540  aws->create_toggle(GA_AWAR_KMER_NOREL);
541 
542  aws->at_newline();
543  aws->label("SINA command");
544  aws->create_input_field(GA_AWAR_CMD, 20);
545 
546  aws->at_shift(0, hgap);
547  }
548 
549  aws->at_newline();
550  aws->at_shift(0, hgap);
551 
552  aws->label_length(17);
553  aws->label("Protection Level");
554  aws->create_option_menu(GA_AWAR_PROTECTION, true);
555  aws->insert_option("0", NULp, 0);
556  aws->insert_option("1", NULp, 1);
557  aws->insert_option("2", NULp, 2);
558  aws->insert_option("3", NULp, 3);
559  aws->insert_option("4", NULp, 4);
560  aws->insert_option("5", NULp, 5);
561  aws->insert_option("6", NULp, 6);
562  aws->update_option_menu();
563 
564  aws->at_newline();
565  aws->label("Show changed sections of alignment");
566  aws->create_toggle(GA_AWAR_SHOW_DIFF);
567  aws->label("color bases");
568  aws->create_toggle(GA_AWAR_COLOR);
569 
570  aws->at_newline();
571  aws->label("Show statistics");
572  aws->create_toggle(GA_AWAR_SHOW_DIST);
573 
574  aws->get_window_size(winx, winy);
575  aws->get_at_position(&startx, &starty);
576 
577  aws->button_length(12);
578 
579  aws->at(winx-closex+5, closey);
580  aws->callback(makeHelpCallback("sina_main.hlp"));
581  aws->create_button("HELP", "HELP");
582 
583  aws->at(winx-closex+5, starty);
584  aws->callback(makeWindowCallback(sina_start, alignData));
585  aws->highlight();
586  aws->create_button("Start", "Start", "S");
587 
588  aws->at(winx-50, starty-50);
589  AWT_insert_config_manager(aws, AW_ROOT_DEFAULT, "sina", sina_config_mapping);
590 
591  return aws;
592 }
593 
594 void show_sina_window(UNFIXED, const AlignDataAccess *alignData) {
595  AW_root *root = AW_root::SINGLETON;
596 
597  static AW_window_simple *ga_aws = new_sina_simple(root, alignData, false);
598  static AW_window_simple *ga_aws_adv = new_sina_simple(root, alignData, true);
599 
600  if (root->awar(GA_AWAR_ADVANCED)->read_int()) {
601  ga_aws_adv->show();
602  ga_aws->hide();
603  }
604  else {
605  ga_aws->show();
606  ga_aws_adv->hide();
607  }
608 }
609 
GB_ERROR GB_begin_transaction(GBDATA *gbd)
Definition: arbdb.cxx:2516
#define GA_AWAR_GENE_START
const char * stream2static(const std::stringstream &str)
AW_bitset AW_active
Definition: aw_base.hxx:45
string result
GB_TYPES type
#define GA_AWAR_FS_MAX
GB_ERROR GB_commit_transaction(GBDATA *gbd)
Definition: arbdb.cxx:2539
void GB_remove_on_exit(const char *filename)
Definition: adsocket.cxx:1224
GBDATA * GBT_first_marked_species(GBDATA *gb_main)
Definition: aditem.cxx:113
static char * filter_posvar_SAI_for_ali(GBDATA *gb_extended, const char *ali_name)
#define GA_AWAR_SHOW_DIST
#define GA_AWAR_COLOR
#define GA_AWAR_OVERHANG
GBDATA * GB_find(GBDATA *gbd, const char *key, GB_SEARCH_TYPE gbs)
Definition: adquery.cxx:295
void ARB_warn_about_unwanted_chars(const char *path, const char *path_description)
Definition: arb_misc.cxx:138
Aligner_get_first_selected_species get_first_selected_species
#define GA_AWAR_LOWERCASE
#define GA_AWAR_TURN_CHECK
void GBS_intcat(GBS_strstruct *strstr, long val)
Definition: arb_strbuf.cxx:127
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)
GB_ERROR arb_look_and_start_server(long magic_number, const char *arb_tcp_env)
long read_int() const
Definition: AW_awar.cxx:187
const char * GBS_global_string(const char *templat,...)
Definition: arb_msg.cxx:204
#define GA_AWAR_FS_MSC
void AW_POPDOWN(AW_window *window)
Definition: AW_window.cxx:52
#define GA_AWAR_WEIGHT
std::string alignment_name
#define GA_AWAR_CMD
static AW_window_simple * new_sina_simple(AW_root *root, const AlignDataAccess *alignData, bool adv)
#define EXIT_SUCCESS
Definition: arb_a2ps.c:154
Aligner_get_next_selected_species get_next_selected_species
void awt_create_SAI_selection_button(GBDATA *gb_main, AW_window *aws, const char *varname, const SaiSelectionlistFilterCallback &fcb)
#define GA_AWAR_MIN_FULL
#define GA_AWAR_REALIGN
#define GA_AWAR_SHOW_DIFF
#define GA_AWAR_MISMATCH_SCORE
AW_awar * add_callback(const RootCallback &cb)
Definition: AW_awar.cxx:234
struct Unfixed_cb_parameter * UNFIXED
Definition: cb_base.h:15
#define GA_AWAR_KMER_MM
const char * empty_as_none(const char *sainame)
const char * read_char_pntr() const
Definition: AW_awar.cxx:171
char * ARB_executable(const char *exe_name, const char *path)
Definition: arb_misc.cxx:107
GBS_strstruct * GBS_stropen(long init_size)
Definition: arb_strbuf.cxx:39
GB_ERROR GB_await_error()
Definition: arb_msg.cxx:353
static AW_root * SINGLETON
Definition: aw_root.hxx:102
WindowCallback makeHelpCallback(const char *helpfile)
Definition: aw_window.hxx:106
#define AWAR_PT_SERVER
#define GA_AWAR_COPYMARKREF
const char * GBS_read_arb_tcp(const char *env)
Definition: adtcp.cxx:325
#define GA_AWAR_KMER_NOFAST
#define GA_AWAR_INSERT
#define GA_AWAR_FULL_MINLEN
void show_sina_window(UNFIXED, const AlignDataAccess *alignData)
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
void GBS_strcat(GBS_strstruct *strstr, const char *ptr)
Definition: arb_strbuf.cxx:108
FILE * GB_fopen_tempfile(const char *filename, const char *fmode, char **res_fullname)
Definition: adsocket.cxx:1142
#define GA_AWAR_GAP_EXT
GBDATA * GBT_next_marked_species(GBDATA *gb_species)
Definition: aditem.cxx:116
#define GA_AWAR_ADVANCED
#define AWAR_SPECIES_NAME
#define GA_AWAR_KMER_NOREL
static AWT_config_mapping_def sina_config_mapping[]
NOT4PERL GB_ERROR GB_xcmd(const char *cmd, XCMD_TYPE exectype) __ATTR__USERESULT_TODO
Definition: adsocket.cxx:874
char * read_string() const
Definition: AW_awar.cxx:201
AW_awar * awar(const char *awar)
Definition: AW_root.cxx:554
void GBS_strforget(GBS_strstruct *strstr)
Definition: arb_strbuf.cxx:76
Definition: arbdb.h:86
#define GA_AWAR_THREADS
#define GA_AWAR_FS_MIN
#define EXIT_FAILURE
Definition: arb_a2ps.c:157
void awt_create_PTSERVER_selection_button(AW_window *aws, const char *varname)
float read_float() const
Definition: AW_awar.cxx:180
GB_CSTR GB_getenv(const char *env)
Definition: adsocket.cxx:677
#define AISC_MAGIC_NUMBER
Definition: client_privat.h:51
char * GB_unique_filename(const char *name_prefix, const char *suffix)
Definition: adsocket.cxx:1199
#define GA_AWAR_PROTECTION
#define GA_AWAR_QSIZE
AW_active sina_mask(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
char * GBS_mempntr(GBS_strstruct *strstr)
Definition: arb_strbuf.cxx:86
char ARB_path_contains_unwanted_chars(const char *path)
Definition: arb_misc.cxx:131
char * GB_read_string(GBDATA *gbd)
Definition: arbdb.cxx:903
const char * GBS_static_string(const char *str)
Definition: arb_msg.cxx:213
#define GA_AWAR_KMER_LEN
void aw_message(const char *msg)
Definition: AW_status.cxx:932
AW_root * get_root()
Definition: aw_window.hxx:348
#define GA_AWAR_GAP_PEN
#define NULp
Definition: cxxforward.h:97
void GBS_floatcat(GBS_strstruct *strstr, double val)
Definition: arb_strbuf.cxx:133
#define GA_AWAR_AUTOFILTER
#define GA_AWAR_TGT
#define GA_AWAR_SAI
#define GA_AWAR_GENE_END
#define GA_AWAR_MATCH_SCORE
GB_CSTR GB_read_char_pntr(GBDATA *gbd)
Definition: arbdb.cxx:898
GBDATA * gb_main
Definition: adname.cxx:33
AW_awar * awar_string(const char *var_name, const char *default_value="", AW_default default_file=AW_ROOT_DEFAULT)
Definition: AW_root.cxx:570
GBDATA * GB_search(GBDATA *gbd, const char *fieldpath, GB_TYPES create)
Definition: adquery.cxx:531
void create_sina_variables(AW_root *root, AW_default db1)
#define GA_AWAR_MIN_LEN
#define AW_ROOT_DEFAULT
Definition: aw_base.hxx:106
void aw_message_if(GB_ERROR error)
Definition: aw_msg.hxx:21
char * GBS_global_string_copy(const char *templat,...)
Definition: arb_msg.cxx:195
#define GA_AWAR_FS_COVER_GENE
static void sina_start(AW_window *window, const AlignDataAccess *data_access)