ARB
AWT_sel_boxes.cxx
Go to the documentation of this file.
1 // ================================================================ //
2 // //
3 // File : AWT_sel_boxes.cxx //
4 // Purpose : //
5 // //
6 // Institute of Microbiology (Technical University Munich) //
7 // http://www.arb-home.de/ //
8 // //
9 // ================================================================ //
10 
11 #include "awt.hxx"
12 #include "awt_sel_boxes.hxx"
13 
14 #include <item_sel_list.h>
15 
16 #include <aw_awars.hxx>
17 #include <aw_file.hxx>
18 #include <aw_msg.hxx>
19 #include <aw_root.hxx>
20 #include <aw_edit.hxx>
21 
22 #include <ad_config.h>
23 #include <ad_cb.h>
24 
25 #include <arbdbt.h>
26 #include <arb_strbuf.h>
27 #include <arb_strarray.h>
28 #include <arb_file.h>
29 #include <arb_global_defs.h>
30 #include <arb_stdstring.h>
31 
32 #include "awt_modules.hxx"
33 #include <BufferedFileReader.h>
34 
35 #include <list>
36 #include <map>
37 #include <set>
38 
39 using namespace std;
40 
41 typedef map<string, AW_window*> WinMap;
42 
44  string awar_name;
45  static WinMap window_map; // contains popup windows of all selection list popups
46 
47  virtual AW_DB_selection *create(AW_selection_list *sellist) const = 0;
48  AW_DB_selection *init(AW_selection_list *sellist) const {
49  AW_DB_selection *sel = create(sellist);
50  sel->refresh();
51  return sel;
52  }
53 
54 public:
55  SelectionListSpec(const char *awar_name_)
56  : awar_name(awar_name_)
57  {}
58  virtual ~SelectionListSpec() {}
59 
60  virtual const char *get_macro_id() const = 0;
61  virtual const char *get_title() const = 0;
62 
63  const char *get_awar_name() const { return awar_name.c_str(); }
64 
65  AW_DB_selection *create_list(AW_window *aws, bool fallback2default) const {
66  return init(aws->create_selection_list(get_awar_name(), 40, 4, fallback2default));
67  }
68 
69  void popup() const {
70  WinMap::iterator found = window_map.find(awar_name);
71  if (found == window_map.end()) {
72  AW_window_simple *aws = new AW_window_simple;
73  aws->init(AW_root::SINGLETON, get_macro_id(), get_title());
74  aws->load_xfig("select_simple.fig");
75 
76  aws->at("selection");
78  create_list(aws, true);
79 
80  aws->at("button");
81  aws->callback(AW_POPDOWN);
82  aws->create_button("CLOSE", "CLOSE", "C");
83 
84  aws->window_fit();
85 
86  window_map[awar_name] = aws;
87  aws->activate();
88  }
89  else {
90  found->second->activate();
91  }
92  }
93 
94  void createButton(AW_window *aws) const;
95 };
96 WinMap SelectionListSpec::window_map;
97 
99  spec->popup();
100 }
101 
103  // WARNING: this is bound to callback (do not free)
104  aws->callback(makeWindowCallback(popup_SelectionListSpec_cb, this));
105  aws->create_button(get_macro_id(), get_awar_name());
106 }
107 
108 // --------------------------------------
109 // selection boxes on alignments
110 
111 class ALI_selection : public AW_DB_selection { // derived from a Noncopyable
112  char *ali_type_match; // filter for wanted alignments (GBS_string_eval command)
113 public:
114  ALI_selection(AW_selection_list *sellist_, GBDATA *gb_presets, const char *ali_type_match_)
115  : AW_DB_selection(sellist_, gb_presets),
116  ali_type_match(nulldup(ali_type_match_))
117  {}
118 
119  void fill() OVERRIDE {
120  GBDATA *gb_presets = get_gbd();
121  GB_transaction ta(gb_presets);
122 
123  for (GBDATA *gb_alignment = GB_entry(gb_presets, "alignment");
124  gb_alignment;
125  gb_alignment = GB_nextEntry(gb_alignment))
126  {
127  char *alignment_type = GBT_read_string(gb_alignment, "alignment_type");
128  char *alignment_name = GBT_read_string(gb_alignment, "alignment_name");
129  char *str = GBS_string_eval(alignment_type, ali_type_match);
130 
131  if (!*str) insert(alignment_name, alignment_name);
132  free(str);
133  free(alignment_type);
134  free(alignment_name);
135  }
136  insert_default(DISPLAY_NONE, NO_ALI_SELECTED);
137  }
138 
139  void reconfigure(const char *new_ali_type_match) {
140  freedup(ali_type_match, new_ali_type_match);
141  refresh();
142  }
143 };
144 
146  GBDATA *gb_main;
147  string ali_type_match;
148 
149  AW_DB_selection *create(AW_selection_list *sellist) const {
150  GB_transaction ta(gb_main);
151  return new ALI_selection(sellist, GBT_get_presets(gb_main), ali_type_match.c_str());
152  }
153 
154 public:
155  ALI_sellst_spec(const char *awar_name_, GBDATA *gb_main_, const char *ali_type_match_)
156  : SelectionListSpec(awar_name_),
157  gb_main(gb_main_),
158  ali_type_match(ali_type_match_)
159  {}
160 
161  const char *get_macro_id() const { return "SELECT_ALI"; }
162  const char *get_title() const { return "Select alignment"; }
163 };
164 
165 AW_DB_selection *awt_create_ALI_selection_list(GBDATA *gb_main, AW_window *aws, const char *varname, const char *ali_type_match) {
166  // Create selection lists on alignments
167  //
168  // if 'ali_type_match' is set, then only insert alignments,
169  // where 'ali_type_match' GBS_string_eval's the alignment type
170 
171  ALI_sellst_spec spec(varname, gb_main, ali_type_match);
172  return spec.create_list(aws, true);
173 }
174 
175 void awt_create_ALI_selection_button(GBDATA *gb_main, AW_window *aws, const char *varname, const char *ali_type_match) {
176  (new ALI_sellst_spec(varname, gb_main, ali_type_match))->createButton(aws); // do not free (bound to callback)
177 }
178 
179 void awt_reconfigure_ALI_selection_list(AW_DB_selection *dbsel, const char *ali_type_match) {
180  ALI_selection *alisel = dynamic_cast<ALI_selection*>(dbsel);
181  alisel->reconfigure(ali_type_match);
182 }
183 
184 // ---------------------------------
185 // selection boxes on trees
186 
188  AWT_tree_selection(AW_selection_list *sellist_, GBDATA *gb_tree_data)
189  : AW_DB_selection(sellist_, gb_tree_data)
190  {}
191 
192  void fill() OVERRIDE {
194  GB_transaction ta(gb_main);
195 
196  ConstStrArray tree_names;
197  GBT_get_tree_names(tree_names, gb_main, true);
198 
199  if (!tree_names.empty()) {
200  int maxTreeNameLen = 0;
201  for (int i = 0; tree_names[i]; ++i) {
202  const char *tree = tree_names[i];
203  int len = strlen(tree);
204  if (len>maxTreeNameLen) maxTreeNameLen = len;
205  }
206  for (int i = 0; tree_names[i]; ++i) {
207  const char *tree = tree_names[i];
208  const char *info = GBT_tree_info_string(gb_main, tree, maxTreeNameLen);
209  if (info) {
210  insert(info, tree);
211  }
212  else {
214  insert(tree, tree);
215  }
216  }
217  }
218  insert_default(DISPLAY_NONE, NO_TREE_SELECTED);
219  }
220 };
221 
222 AW_DB_selection *awt_create_TREE_selection_list(GBDATA *gb_main, AW_window *aws, const char *varname, bool fallback2default) {
223  GBDATA *gb_tree_data;
224  {
225  GB_transaction ta(gb_main);
226  gb_tree_data = GBT_get_tree_data(gb_main);
227  }
228  AW_selection_list *sellist = aws->create_selection_list(varname, 40, 4, fallback2default);
229  AWT_tree_selection *treesel = new AWT_tree_selection(sellist, gb_tree_data); // owned by nobody
230  treesel->refresh();
231  return treesel;
232 }
233 
234 
235 // --------------------------------------
236 // selection boxes on pt-servers
237 
238 #define PT_SERVERNAME_LENGTH 23 // that's for buttons
239 #define PT_SERVERNAME_SELLIST_WIDTH 30 // this for lists
240 
241 class PT_selection : public AW_selection {
242  typedef list<PT_selection*> PT_selections;
243 
244  static PT_selections ptserver_selections;
245 public:
246  PT_selection(AW_selection_list *sellist_);
247 
248  void fill() OVERRIDE;
249 
250  static void refresh_all();
251 };
252 
253 PT_selection::PT_selections PT_selection::ptserver_selections;
254 
256  const char * const *pt_servers = GBS_get_arb_tcp_entries("ARB_PT_SERVER*");
257 
258  int count = 0;
259  while (pt_servers[count]) count++;
260 
261  for (int i=0; i<count; i++) {
262  char *choice = GBS_ptserver_id_to_choice(i, 1);
263  if (!choice) {
265  break;
266  }
267  insert(choice, (long)i);
268  free(choice);
269  }
270 
271  insert_default("-undefined-", (long)-1);
272 }
273 
275  PT_selections::iterator end = ptserver_selections.end();
276  for (PT_selections::iterator pts_sel = ptserver_selections.begin(); pts_sel != end; ++pts_sel) {
277  (*pts_sel)->refresh();
278  }
279 }
280 
281 static void ptserverlog_changed_cb(const char *) { PT_selection::refresh_all(); }
282 static void arbtcpdat_changed_cb(const char*) { PT_selection::refresh_all(); }
283 
285  : AW_selection(sellist_)
286 {
287  if (ptserver_selections.empty()) {
288  // first pt server selection list -> install log tracker
290  }
291  ptserver_selections.push_back(this);
292 }
293 
294 
296  char *filename = GB_arbtcpdat_path();
297  AW_edit_notified(filename, makeFileChangedCallback(arbtcpdat_changed_cb));
298  free(filename);
299 }
300 
301 void awt_auto_popdown_cb(AW_root*, AW_window_simple *aw_popup) {
305  aw_popup->hide();
306 }
307 
308 static char *readable_pt_servername(int index, int maxlength) {
309  char *fullname = GBS_ptserver_id_to_choice(index, 0);
310  if (!fullname) {
311 #ifdef DEBUG
312  printf("awar given to ptserver-selection does not contain a valid index\n");
313 #endif
314  GB_clear_error();
315  return ARB_strdup("-undefined-");
316  }
317 
318  int len = strlen(fullname);
319  if (len <= maxlength) {
320  return fullname;
321  }
322 
323  int remove = len-maxlength;
324  fullname[0] = '.';
325  fullname[1] = '.';
326  strcpy(fullname+2, fullname+2+remove);
327 
328  return fullname;
329 }
330 
331 static void update_ptserver_button(AW_root *, AW_awar *awar_ptserver, AW_awar *awar_buttontext_name) {
332  char *readable_name = readable_pt_servername(awar_ptserver->read_int(), PT_SERVERNAME_LENGTH);
333  awar_buttontext_name->write_string(readable_name);
334  free(readable_name);
335 }
336 
337 static AW_window *create_PTSERVER_selection_window(AW_root *aw_root, const char *varname) {
338  AW_window_simple *aw_popup = new AW_window_simple;
339 
340  aw_popup->init(aw_root, "SELECT_PT_SERVER", "Select a PT-Server");
341  aw_popup->auto_space(10, 10);
342 
343  const char *CLOSE_ID = "CLOSE";
344 
345  aw_popup->at_newline();
346  aw_root->awar(varname)->add_callback(makeRootCallback(awt_auto_popdown_cb, aw_popup));
347  AW_selection_list *sellist = aw_popup->create_selection_list(varname, PT_SERVERNAME_SELLIST_WIDTH, 20, true);
348 
349  aw_popup->at_newline();
350  aw_popup->callback(AW_POPDOWN);
351  aw_popup->create_button(CLOSE_ID, "CLOSE", "C");
352 
353  aw_popup->window_fit();
354  aw_popup->recalc_pos_atShow(AW_REPOS_TO_MOUSE);
355 
356  (new PT_selection(sellist))->refresh();
357 
358  return aw_popup;
359 }
360 
361 void awt_create_PTSERVER_selection_button(AW_window *aws, const char *varname) {
362  AW_root *aw_root = aws->get_root();
363  char *awar_buttontext_name = GBS_global_string_copy("/tmp/%s_BUTTON", varname);
364  AW_awar *awar_ptserver = aw_root->awar(varname);
365  int ptserver_index = awar_ptserver->read_int();
366 
367  if (ptserver_index<0) { // fix invalid pt_server indices
368  ptserver_index = 0;
369  awar_ptserver->write_int(ptserver_index);
370  }
371 
372  char *readable_name = readable_pt_servername(ptserver_index, PT_SERVERNAME_LENGTH);
373 
375 
376  AW_awar *awar_buttontext = aw_root->awar_string(awar_buttontext_name, readable_name, AW_ROOT_DEFAULT);
377  awar_ptserver->add_callback(makeRootCallback(update_ptserver_button, awar_ptserver, awar_buttontext));
378 
379  int old_button_length = aws->get_button_length();
380 
382  aws->callback(makeCreateWindowCallback(create_PTSERVER_selection_window, awar_ptserver->awar_name));
383  aws->create_button("CURR_PT_SERVER", awar_buttontext_name);
384 
385  aws->button_length(old_button_length);
386 
387  free(readable_name);
388  free(awar_buttontext_name);
389 }
390 void awt_create_PTSERVER_selection_list(AW_window *aws, const char *varname) {
391  (new PT_selection(aws->create_selection_list(varname, true)))->refresh();
392 }
393 
394 // -------------------------------------------------
395 // selection boxes on editor configurations
396 
398  AWT_configuration_selection(AW_selection_list *sellist_, GBDATA *gb_configuration_data)
399  : AW_DB_selection(sellist_, gb_configuration_data)
400  {}
401 
402  int getConfigInfo(const char *name, string& comment) {
403  // returns number of species in config + sets comment
404  GB_ERROR error;
405  GBT_config cfg(get_gb_main(), name, error);
406 
407  int count = 0;
408  if (!error) {
409  const char *cmt = cfg.get_comment();
410  comment = null2empty(cmt);
411  for (int area = 0; area<2; ++area) {
412  GBT_config_parser parser(cfg, area);
413  while (1) {
414  const GBT_config_item& item = parser.nextItem(error);
415  if (error || item.type == CI_END_OF_CONFIG) break;
416  if (item.type == CI_SPECIES) ++count;
417  }
418  }
419  }
420  else {
421  comment = "";
422  }
423  return count;
424  }
425 
426  void fill() OVERRIDE {
427  ConstStrArray config;
429 
430  if (!config.empty()) {
431  int maxlen = 0;
432  int maxcount = 0;
433  int *count = new int[config.size()];
434  string *comment = new string[config.size()];
435 
436  for (int c = 0; config[c]; ++c) {
437  maxlen = max(maxlen, int(strlen(config[c])));
438  count[c] = getConfigInfo(config[c], comment[c]);
439  maxcount = max(maxcount, count[c]);
440  }
441  int maxdigits = calc_digits(maxcount);
442  for (int c = 0; config[c]; ++c) {
443  int digits = calc_digits(count[c]);
444  insert(GBS_global_string("%-*s %*s(%i) %s", maxlen, config[c], (maxdigits-digits), "", count[c], comment[c].c_str()), config[c]);
445  }
446  delete [] comment;
447  delete [] count;
448  }
450  }
451 };
452 
453 AW_DB_selection *awt_create_CONFIG_selection_list(GBDATA *gb_main, AW_window *aws, const char *varname, bool fallback2default) {
454  GBDATA *gb_configuration_data;
455  {
456  GB_transaction ta(gb_main);
457  gb_configuration_data = GB_search(gb_main, CONFIG_DATA_PATH, GB_CREATE_CONTAINER);
458  }
459  AW_selection_list *sellist = aws->create_selection_list(varname, 40, 15, fallback2default);
460  AWT_configuration_selection *confSel = new AWT_configuration_selection(sellist, gb_configuration_data);
461  confSel->refresh();
462  return confSel;
463 }
464 
465 // ----------------------
466 // SAI selection
467 
468 
469 static char *get_SAI_description(GBDATA *gb_extended) {
470  const char *name = GBT_get_name_or_description(gb_extended);
471  GBDATA *gb_group = GB_entry(gb_extended, "sai_group");
472 
473  if (gb_group) {
474  const char *group = GB_read_char_pntr(gb_group);
475  return GBS_global_string_copy("[%s] %s", group, name);
476  }
477  return ARB_strdup(name);
478 }
479 
480 const SaiSelectionlistFilterCallback& awt_std_SAI_filter_cb() {
481  static SaiSelectionlistFilterCallback std_SAI_filter_cb = makeSaiSelectionlistFilterCallback(get_SAI_description);
482  return std_SAI_filter_cb;
483 }
484 
485 class SAI_selection : public AW_DB_selection { // derived from a Noncopyable
486  SaiSelectionlistFilterCallback filter_cb;
487 
488 public:
489 
490  SAI_selection(AW_selection_list *sellist_, GBDATA *gb_sai_data, const SaiSelectionlistFilterCallback& fcb)
491  : AW_DB_selection(sellist_, gb_sai_data),
492  filter_cb(fcb)
493  {}
494 
495  void fill() OVERRIDE;
496 };
497 
500  sel->clear();
501 
503  GB_transaction ta(gb_main);
504 
505  for (GBDATA *gb_extended = GBT_first_SAI(gb_main);
506  gb_extended;
507  gb_extended = GBT_next_SAI(gb_extended))
508  {
509  char *res = filter_cb(gb_extended);
510  if (res) {
511  sel->insert(res, GBT_get_name_or_description(gb_extended));
512  free(res);
513  }
514  }
515  sel->sort(false, false);
516 
517  sel->insert_default(DISPLAY_NONE, "");
518  sel->update();
519 }
520 
522  GBDATA *gb_main;
523  SaiSelectionlistFilterCallback filter_cb;
524 
525  AW_DB_selection *create(AW_selection_list *sellist) const {
526  GB_transaction ta(gb_main);
527  return new SAI_selection(sellist, GBT_get_SAI_data(gb_main), filter_cb);
528  }
529 
530 public:
531  SAI_sellst_spec(const char *awar_name_, GBDATA *gb_main_, const SaiSelectionlistFilterCallback& fcb)
532  : SelectionListSpec(awar_name_),
533  gb_main(gb_main_),
534  filter_cb(fcb)
535  {
536  // Warning: do not use different filters for same awar! (wont work as expected) // @@@ add assertion against
537  }
538 
539  const char *get_macro_id() const { return "SELECT_SAI"; }
540  const char *get_title() const { return "Select SAI"; }
541 };
542 
543 void awt_popup_SAI_selection_list(AW_window *, const char *awar_name, GBDATA *gb_main) {
544  SAI_sellst_spec spec(awar_name, gb_main, awt_std_SAI_filter_cb());
545  spec.popup();
546 }
547 
548 AW_DB_selection *awt_create_SAI_selection_list(GBDATA *gb_main, AW_window *aws, const char *varname, bool fallback2default, const SaiSelectionlistFilterCallback& fcb) {
549  /* Selection list for SAIs
550  * only shows those SAIs for which fcb returns a string (string must be a heap copy)
551  */
552  SAI_sellst_spec spec(varname, gb_main, fcb);
553  return spec.create_list(aws, fallback2default);
554 }
555 
556 void awt_create_SAI_selection_button(GBDATA *gb_main, AW_window *aws, const char *varname, const SaiSelectionlistFilterCallback& fcb) {
557  (new SAI_sellst_spec(varname, gb_main, fcb))->createButton(aws); // do not free (bound to callback)
558 }
559 
560 // --------------------------------------------------
561 // save/load selection content to/from file
562 
563 static GB_ERROR standard_list2file(const CharPtrArray& display, const CharPtrArray& value, StrArray& line) {
564  GB_ERROR error = NULp;
565  for (size_t i = 0; i<display.size() && !error; ++i) {
566  const char *disp = display[i];
567 
568  if (disp[0] == '#') { // would interpret as comment when loaded
569  error = "Invalid character '#' at start of displayed text (won't load)";
570  }
571  else {
572  if (strchr(disp, ',')) {
573  // would be interpreted as separator between display and value on load
574  error = "Invalid character ',' in displayed text (won't load correctly)";
575  }
576  else {
577  awt_assert(!strchr(disp, '\n'));
578 
579  const char *val = value[i];
580  if (strcmp(disp, val) == 0) {
581  line.put(ARB_strdup(disp));
582  }
583  else {
584  char *escaped = GBS_escape_string(val, "\n", '\\');
585  line.put(GBS_global_string_copy("%s,%s", disp, escaped));
586  free(escaped);
587  }
588  }
589  }
590  }
591  return NULp;
592 }
593 
594 
595 
596 static GB_ERROR standard_file2list(const CharPtrArray& line, StrArray& display, StrArray& value) {
597  for (size_t i = 0; i<line.size(); ++i) {
598  if (line[i][0] == '#') continue; // ignore comments
599 
600  const char *comma = strchr(line[i], ',');
601  if (comma) {
602  display.put(ARB_strpartdup(line[i], comma-1));
603 
604  comma++;
605  const char *rest = comma+strspn(comma, " \t");
606  char *unescaped = GBS_unescape_string(rest, "\n", '\\');
607  value.put(unescaped);
608  }
609  else {
610  display.put(ARB_strdup(line[i]));
611  value.put(ARB_strdup(line[i]));
612  }
613  }
614 
615  return NULp;
616 }
617 
619  : tsl(tsl_),
620  list2file(standard_list2file),
621  file2list(standard_file2list)
622 {}
623 
624 inline char *get_shared_sellist_awar_base(const TypedSelectionList& typedsellst) {
625  return GBS_global_string_copy("tmp/sellist/%s", typedsellst.get_shared_id());
626 }
627 inline char *get_shared_sellist_awar_name(const TypedSelectionList& typedsellst, const char *name) {
628  char *base = get_shared_sellist_awar_base(typedsellst);
629  char *awar_name = GBS_global_string_copy("%s/%s", base, name);
630  free(base);
631  return awar_name;
632 }
633 
634 GB_ERROR StorableSelectionList::save(const char *filename, long number_of_lines) const {
635  // number_of_lines == 0 -> save all lines (otherwise truncate after 'number_of_lines')
636 
637  StrArray display, values;
638  AW_selection_list *sellist = tsl.get_sellist();
639 
640  sellist->to_array(display, false);
641  sellist->to_array(values, true);
642 
643  awt_assert(display.size() == values.size());
644 
645  if (number_of_lines>0) { // limit number of lines?
646  display.resize(number_of_lines);
647  values.resize(number_of_lines);
648  }
649 
650  GB_ERROR error = NULp;
651  if (display.size()<1) {
652  error = "List is empty (did not save)";
653  }
654  else {
655  StrArray line;
656  error = list2file(display, values, line);
657  if (!error) {
658  if (line.size()<1) {
659  error = "list>file conversion produced nothing (internal error)";
660  }
661  else {
662  FILE *out = fopen(filename, "wt");
663  if (!out) {
664  error = GB_IO_error("writing", filename);
665  }
666  else {
667  const char *warning = NULp;
668  for (size_t i = 0; i<line.size(); ++i) {
669  if (!warning && strchr(line[i], '\n')) {
670  warning = "Warning: Saved content contains LFs (loading will be impossible)";
671  }
672  fputs(line[i], out);
673  fputc('\n', out);
674  }
675  fclose(out);
676  error = warning;
677  }
678  }
679  }
680  }
681 
682  return error;
683 }
684 
685 GB_ERROR StorableSelectionList::load(const char *filemask, bool append) const {
686  GB_ERROR error = NULp;
687  StrArray fnames;
688 
689  if (GB_is_directory(filemask)) {
690  error = GBS_global_string("refusing to load all files from directory\n"
691  "'%s'\n"
692  "(one possibility is to enter '*.%s')'",
693  filemask, get_filter());
694  }
695  else {
696  GBS_read_dir(fnames, filemask, NULp);
697  error = GB_incur_error_if(fnames.empty());
698  }
699 
700  StrArray lines;
701  for (int f = 0; fnames[f] && !error; ++f) {
702  FILE *in = fopen(fnames[f], "rb");
703  if (!in) {
704  error = GB_IO_error("reading", fnames[f]);
705  }
706  else {
707  BufferedFileReader file(fnames[f], in);
708  string line;
709  while (file.getLine(line)) {
710  if (!line.empty()) lines.put(ARB_stringdup(line));
711  }
712  }
713  }
714 
715  AW_selection_list *sellist = tsl.get_sellist();
716  if (!append) sellist->clear();
717 
718  if (!error) {
719  StrArray displayed, values;
720  error = file2list(lines, displayed, values);
721  if (!error) {
722  int dsize = displayed.size();
723  int vsize = values.size();
724 
725  if (dsize != vsize) {
726  error = GBS_global_string("Error in translation (value/display mismatch: %i!=%i)", vsize, dsize);
727  }
728  else {
729  for (int i = 0; i<dsize; ++i) {
730  sellist->insert(displayed[i], values[i]);
731  }
732  sellist->insert_default("", "");
733  }
734  }
735  }
736 
737  if (error) {
738  sellist->insert_default(GBS_global_string("Error: %s", error), "");
739  }
740  sellist->update();
741 
742  return error;
743 }
744 
745 static void save_list_cb(AW_window *aww, const StorableSelectionList *storabsellist) {
746  const TypedSelectionList& typedsellist = storabsellist->get_typedsellist();
747 
748  char *awar_prefix = get_shared_sellist_awar_base(typedsellist);
749  char *bline_anz = get_shared_sellist_awar_name(typedsellist, "line_anz");
750  AW_root *aw_root = aww->get_root();
751  char *filename = AW_get_selected_fullname(aw_root, awar_prefix);
752 
753  long lineLimit = aw_root->awar(bline_anz)->read_int();
754  GB_ERROR error = storabsellist->save(filename, lineLimit);
755 
756  if (!error) AW_refresh_fileselection(aw_root, awar_prefix);
757  aww->hide_or_notify(error);
758 
759  free(filename);
760  free(bline_anz);
761  free(awar_prefix);
762 }
763 
764 static void load_list_cb(AW_window *aww, const StorableSelectionList *storabsellist) {
765  const TypedSelectionList& typedsellist = storabsellist->get_typedsellist();
766 
767  AW_root *aw_root = aww->get_root();
768  char *awar_prefix = get_shared_sellist_awar_base(typedsellist);
769  char *awar_append = get_shared_sellist_awar_name(typedsellist, "append");
770  bool append = aw_root->awar(awar_append)->read_int();
771  char *filename = AW_get_selected_fullname(aw_root, awar_prefix);
772  GB_ERROR error = storabsellist->load(filename, append);
773 
774  aww->hide_or_notify(error);
775 
776  free(filename);
777  free(awar_append);
778  free(awar_prefix);
779 }
780 
782  const TypedSelectionList& typedsellist = storabsellist->get_typedsellist();
783 
784  char *awar_base = get_shared_sellist_awar_base(typedsellist);
785  char *awar_line_anz = get_shared_sellist_awar_name(typedsellist, "line_anz");
786  {
787  char *def_name = GBS_string_2_key(typedsellist.whats_contained());
788  AW_create_fileselection_awars(aw_root, awar_base, ".", storabsellist->get_filter(), def_name);
789  free(def_name);
790  aw_root->awar_int(awar_line_anz, 0, AW_ROOT_DEFAULT);
791  }
792 
793  AW_window_simple *aws = new AW_window_simple;
794 
795  char *window_id = GBS_global_string_copy("SAVE_SELECTION_BOX_%s", typedsellist.get_unique_id());
796  char *window_title = GBS_global_string_copy("Save %s", typedsellist.whats_contained());
797 
798  aws->init(aw_root, window_id, window_title);
799  aws->load_xfig("sl_s_box.fig");
800 
801  aws->button_length(10);
802 
803  aws->at("cancel");
804  aws->callback(AW_POPDOWN);
805  aws->create_button("CANCEL", "CANCEL", "C");
806 
807  aws->at("save");
808  aws->highlight();
809  aws->callback(makeWindowCallback(save_list_cb, storabsellist));
810  aws->create_button("SAVE", "SAVE", "S");
811 
812  aws->at("nlines");
813  aws->create_option_menu(awar_line_anz, true);
814  aws->insert_default_option("all", "a", 0);
815  aws->insert_option ("10", "", 10);
816  aws->insert_option ("50", "", 50);
817  aws->insert_option ("100", "", 100);
818  aws->insert_option ("500", "", 500);
819  aws->insert_option ("1000", "", 1000);
820  aws->insert_option ("5000", "", 5000);
821  aws->insert_option ("10000", "", 10000);
822  aws->update_option_menu();
823 
824  AW_create_standard_fileselection(aws, awar_base);
825 
826  free(window_title);
827  free(window_id);
828  free(awar_line_anz);
829  free(awar_base);
830 
831  aws->recalc_pos_atShow(AW_REPOS_TO_MOUSE);
832 
833  return aws;
834 }
835 
837  const TypedSelectionList& typedsellist = storabsellist->get_typedsellist();
838 
839  char *awar_base_name = get_shared_sellist_awar_base(typedsellist);
840  char *awar_append = get_shared_sellist_awar_name(typedsellist, "append");
841 
842  AW_create_fileselection_awars(aw_root, awar_base_name, ".", storabsellist->get_filter(), "");
843  aw_root->awar_int(awar_append, 1); // append is default ( = old behavior)
844 
845  AW_window_simple *aws = new AW_window_simple;
846 
847  char *window_id = GBS_global_string_copy("LOAD_SELECTION_BOX_%s", typedsellist.get_unique_id());
848  char *window_title = GBS_global_string_copy("Load %s", typedsellist.whats_contained());
849 
850  aws->init(aw_root, window_id, window_title);
851  aws->load_xfig("sl_l_box.fig");
852 
853  aws->at("cancel");
854  aws->callback(AW_POPDOWN);
855  aws->create_button("CANCEL", "CANCEL", "C");
856 
857  aws->at("load");
858  aws->highlight();
859  aws->callback(makeWindowCallback(load_list_cb, storabsellist));
860  aws->create_button("LOAD", "LOAD", "L");
861 
862  aws->at("append");
863  aws->label("Append?");
864  aws->create_toggle(awar_append);
865 
866  AW_create_fileselection(aws, awar_base_name, "", "PWD", ANY_DIR, true);
867 
868  aws->recalc_pos_atShow(AW_REPOS_TO_MOUSE);
869 
870  free(window_title);
871  free(window_id);
872  free(awar_append);
873  free(awar_base_name);
874 
875  return aws;
876 }
877 
879  sellist->clear();
880  sellist->insert_default("", "");
881  sellist->update();
882 }
883 
885  char *data = typedsellist->get_sellist()->get_content_as_string(0);
886  AWT_create_ascii_print_window(aw_window->get_root(), data, typedsellist->whats_contained());
887  free(data);
888 }
889 
891  const char *action,
892  const char *what,
893  const char *default_directory,
894  const char *file_extension,
895  char **set_file_name_awar,
896  const WindowCallback& ok_cb,
897  const WindowCallback& close_cb,
898  const char *close_button_text)
899 {
900  /* general purpose file selection box
901  *
902  * 'action' describes what is intended to be done (e.g. "Load").
903  * used for window title and button.
904  *
905  * 'what' describes what is going to be loaded (e.g. "destination database")
906  * It is also used to create the awars for the filebox, i.e. same description for multiple
907  * fileboxes makes them share the awars.
908  *
909  * if 'set_file_name_awar' is non-NULp, it'll be set to a heap-copy of the awar-name
910  * containing the full selected filename.
911  *
912  * 'default_directory' specifies the directory opened in the filebox
913  *
914  * 'file_extension' specifies the filter to be used (which files are shown)
915  *
916  * You have to provide an 'ok_cb', which will be called when 'OK' is pressed.
917  * Optionally you may pass a 'close_cb' which will be called when 'CLOSE' is pressed.
918  * If not given, AW_POPDOWN will be called.
919  *
920  * Both callbacks will be called as callbacks of the load-box-window.
921  * The load-box does not popdown, the callback has to do that.
922  *
923  * Optionally you may also pass the button text for the 'CLOSE'-button (e.g. 'EXIT' or 'Abort')
924  */
925 
926 
927  char *what_key = GBS_string_2_key(what);
928  char *base_name = GBS_global_string_copy("tmp/load_box_%s", what_key);
929 
930  AW_create_fileselection_awars(aw_root, base_name, default_directory, file_extension, "");
931 
932  if (set_file_name_awar) {
933  *set_file_name_awar = GBS_global_string_copy("%s/file_name", base_name);
934  }
935 
936  AW_window_simple *aws = new AW_window_simple;
937  {
938  char title[100];
939  sprintf(title, "%s %s", action, what);
940  aws->init(aw_root, title, title);
941  aws->load_xfig("load_box.fig");
942  }
943 
944  aws->at("close");
945  aws->callback(close_cb);
946  if (close_button_text) {
947  aws->create_button("CLOSE", close_button_text, "");
948  }
949  else {
950  aws->create_button("CLOSE", "CLOSE", "C");
951  }
952 
953 #if 0
954  // @@@ allow to pass helpfile
955  aws->at("help");
956  aws->callback(makeHelpCallback(""));
957  aws->create_button("HELP", "HELP");
958 #endif
959 
960  aws->at("go");
961  aws->callback(ok_cb);
962  aws->create_autosize_button("GO", action);
963 
964  AW_create_standard_fileselection(aws, base_name);
965  free(base_name);
966  free(what_key);
967  aws->recalc_pos_atShow(AW_REPOS_TO_MOUSE);
968 
969  return aws;
970 }
971 
972 // --------------------------------------------------------------------------------
973 
974 #define SUBSET_NOELEM_DISPLAY "<none>"
975 
976 class AW_subset_selection : public AW_selection { // only works with string-type selections
977  AW_selection_list& parent_sellist;
978 
979  SubsetChangedCb subChanged_cb;
980  AW_CL cl_user;
981 
982  static void finish_fill_box(AW_selection_list *parent_sellist, AW_selection_list *sub_sellist) {
983  sub_sellist->insert_default(parent_sellist->get_default_display(), *parent_sellist->get_default_value());
984  sub_sellist->update();
985  }
986 
987  static AW_selection_list *create_box(AW_window *aww, AW_selection_list& parent_sellist) {
988  const char *parent_awar_name = parent_sellist.get_awar_name();
989  awt_assert(parent_awar_name[0] != '/');
990  awt_assert(parent_sellist.get_awar_type() == GB_STRING); // only impl for strings
991 
992  AW_root *aw_root = aww->get_root();
993  char *awar_name = GBS_global_string_copy("tmp/subsel/%s", parent_awar_name);
994 
995  aw_root->awar_string(awar_name);
996 
997  AW_selection_list *sub_sellist = aww->create_selection_list(awar_name, true);
998  finish_fill_box(&parent_sellist, sub_sellist);
999 
1000  free(awar_name);
1001 
1002  return sub_sellist;
1003  }
1004 
1005  void callChangedCallback(bool interactive_change) { if (subChanged_cb) subChanged_cb(this, interactive_change, cl_user); }
1006 
1007 public:
1008  AW_subset_selection(AW_window *aww, AW_selection_list& parent_sellist_, SubsetChangedCb subChanged_cb_, AW_CL cl_user_)
1009  : AW_selection(create_box(aww, parent_sellist_)),
1010  parent_sellist(parent_sellist_),
1011  subChanged_cb(subChanged_cb_),
1012  cl_user(cl_user_)
1013  {
1014  callChangedCallback(false);
1015  }
1016 
1017  AW_selection_list *get_parent_sellist() const { return &parent_sellist; }
1018 
1019  const char *default_select_value() const { return parent_sellist.get_default_value()->get_string(); }
1020  const char *default_select_display() const { return parent_sellist.get_default_display(); }
1021 
1022  void fill() OVERRIDE { awt_assert(0); } // unused
1023 
1025  AW_selection_list *subset_list = get_sellist();
1026  AW_selection_list *whole_list = get_parent_sellist();
1027 
1028  switch(what) {
1029  case ACM_FILL:
1030  for (AW_selection_list_iterator listEntry(whole_list); listEntry; ++listEntry) {
1031  if (subset_list->get_index_of(*listEntry.get_value()) == -1) { // only add not already existing elements
1032  subset_list->insert(listEntry.get_displayed(), *listEntry.get_value());
1033  }
1034  }
1035  finish_fill_box(whole_list, subset_list);
1036  break;
1037 
1038  case ACM_ADD: {
1039  if (!whole_list->default_is_selected()) {
1040  AW_scalar selected = whole_list->get_awar_value();
1041  int src_index = whole_list->get_index_of(selected);
1042 
1043  if (subset_list->get_index_of(selected) == -1) { // not yet in subset_list
1044  AW_selection_list_iterator entry(whole_list, src_index);
1045  subset_list->insert(entry.get_displayed(), *entry.get_value());
1046  subset_list->update();
1047  }
1048 
1049  subset_list->set_awar_value(selected); // position right side to newly added or already existing alignment
1050  whole_list->select_element_at(src_index+1); // go down 1 position on left side
1051  }
1052 
1053  break;
1054  }
1055  case ACM_REMOVE: {
1056  if (!subset_list->default_is_selected()) {
1057  AW_scalar selected = subset_list->get_awar_value();
1058  int old_position = subset_list->get_index_of(selected);
1059 
1060  subset_list->delete_element_at(old_position);
1061  finish_fill_box(whole_list, subset_list);
1062 
1063  subset_list->select_element_at(old_position);
1064  whole_list->set_awar_value(selected); // set left selection to deleted alignment
1065  }
1066  break;
1067  }
1068  case ACM_EMPTY:
1069  subset_list->clear();
1070  finish_fill_box(whole_list, subset_list);
1071  break;
1072  }
1073  callChangedCallback(true);
1074  }
1076  AW_selection_list *subset_list = get_sellist();
1077 
1078  if (!subset_list->default_is_selected()) {
1079  AW_scalar selected = subset_list->get_awar_value();
1080 
1081  StrArray listContent;
1082  subset_list->to_array(listContent, true);
1083 
1084  int old_pos = listContent.index_of(selected.get_string());
1085  if (old_pos >= 0) {
1086  int new_pos = 0;
1087  switch (dest) {
1088  case ARM_TOP: new_pos= 0; break;
1089  case ARM_UP: new_pos= old_pos-1; break;
1090  case ARM_DOWN: new_pos= old_pos+1; break;
1091  case ARM_BOTTOM: new_pos= -1; break;
1092  }
1093  if (old_pos != new_pos) {
1094  listContent.move(old_pos, new_pos);
1095  subset_list->init_from_array(listContent, subset_list->get_default_display(), subset_list->get_default_value()->get_string());
1096  }
1097  }
1098  }
1099  callChangedCallback(true);
1100  }
1101 
1103  // check subset for entries missing in parent,
1104  // delete these and update
1105  typedef std::set<const char*, charpLess> Entries;
1106 
1107  bool deleted = false;
1108  Entries pEntry;
1109  {
1110  AW_selection_list_iterator pIter(&parent_sellist);
1111  while (pIter) {
1112  pEntry.insert(pIter.get_value()->get_string());
1113  ++pIter;
1114  }
1115  }
1116 
1117  AW_selection_list *subsel = get_sellist();
1118  int size = subsel->size();
1119 
1120  for (int i = 0; i<size; ++i) {
1121  if (pEntry.find(subsel->get_value_at(i)->get_string()) == pEntry.end()) { // entry missing in parent list
1122  subsel->delete_element_at(i);
1123  deleted = true;
1124  --i; --size;
1125  }
1126  }
1127 
1128  if (deleted) {
1129  subsel->update();
1130  callChangedCallback(false);
1131  }
1132  }
1133 
1135  AW_selection_list *subset_list = get_sellist();
1136  subset_list->clear();
1137 
1138  for (size_t e = 0; e<values.size(); ++e) {
1139  const char *value = values[e];
1140 
1141  AW_selection_list_iterator pIter(&parent_sellist);
1142  while (pIter) {
1143  if (strcmp(pIter.get_value()->get_string(), value) == 0) {
1144  subset_list->insert(pIter.get_displayed(), *pIter.get_value());
1145  break;
1146  }
1147  ++pIter;
1148  }
1149  }
1150 
1151  finish_fill_box(&parent_sellist, subset_list);
1152  callChangedCallback(false);
1153  }
1154 };
1155 
1158 
1160  AW_subset_selection *subsel = (AW_subset_selection*)cl_subsel;
1161  aw_assert(subsel->get_parent_sellist() == parent_sel);
1163 }
1164 
1165 AW_selection *awt_create_subset_selection_list(AW_window *aww, AW_selection_list *parent_selection, const char *at_box, const char *at_add, const char *at_sort, bool autocorrect_subselection, SubsetChangedCb subChanged_cb, AW_CL cl_user) {
1166  awt_assert(parent_selection);
1167 
1168  aww->at(at_box);
1169  int x_list = aww->get_at_xposition();
1170 
1171  AW_subset_selection *subsel = new AW_subset_selection(aww, *parent_selection, subChanged_cb, cl_user);
1172 
1173  aww->button_length(0);
1174 
1175  aww->at(at_add);
1176  int x_buttons = aww->get_at_xposition();
1177 
1178  bool move_rightwards = x_list>x_buttons;
1179  awt_create_collect_buttons(aww, move_rightwards, collect_subset_cb, subsel);
1180 
1181  aww->at(at_sort);
1183 
1184  if (autocorrect_subselection) parent_selection->set_update_callback(correct_subselection_cb, AW_CL(subsel));
1185 
1186  return subsel;
1187 }
1188 
1194  AW_subset_selection *subset_sel = dynamic_cast<AW_subset_selection*>(subset_sel_);
1195  if (subset_sel) subset_sel->fill_entries_matching_values(values);
1196 }
1197 
1198 AW_selection_list *awt_create_selection_list_with_input_field(AW_window *aww, const char *awar_name, const char *at_box, const char *at_field) {
1205  aww->at(at_field);
1206  aww->create_input_field(awar_name);
1207  aww->at(at_box);
1208  return aww->create_selection_list(awar_name, false);
1209 }
1210 
1211 
const char * GBS_ptserver_logname(void)
Definition: adtcp.cxx:431
const char * default_select_value() const
const char * GB_ERROR
Definition: arb_core.h:25
char * get_shared_sellist_awar_name(const TypedSelectionList &typedsellst, const char *name)
void insert_default(const char *displayed, const char *value)
Definition: aw_select.hxx:184
GBDATA * GBT_first_SAI(GBDATA *gb_main)
Definition: aditem.cxx:160
void sort(bool backward, bool case_sensitive)
Definition: AW_select.cxx:502
void button_length(int length)
Definition: AW_at.cxx:283
size_t size() const
Definition: arb_strarray.h:85
#define PT_SERVERNAME_LENGTH
int get_at_xposition() const
Definition: AW_at.cxx:296
void fill() OVERRIDE
static void collect_subset_cb(AW_window *, awt_collect_mode what, AW_subset_selection *subsel)
static void popup_SelectionListSpec_cb(UNFIXED, const SelectionListSpec *spec)
static void reorder_subset_cb(AW_window *, awt_reorder_mode dest, AW_subset_selection *subsel)
void createButton(AW_window *aws) const
SAI_sellst_spec(const char *awar_name_, GBDATA *gb_main_, const SaiSelectionlistFilterCallback &fcb)
void select_element_at(int wanted_index)
Definition: AW_select.cxx:433
const char * get_awar_name() const
const TypedSelectionList & get_typedsellist() const
void insert_default(const char *displayed, const AW_scalar &value)
Definition: AW_select.cxx:385
void fill() OVERRIDE
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)
SelectionListSpec(const char *awar_name_)
GBDATA * GB_nextEntry(GBDATA *entry)
Definition: adquery.cxx:339
void at(int x, int y)
Definition: AW_at.cxx:93
AW_selection * awt_create_subset_selection_list(AW_window *aww, AW_selection_list *parent_selection, const char *at_box, const char *at_add, const char *at_sort, bool autocorrect_subselection, SubsetChangedCb subChanged_cb, AW_CL cl_user)
void fill() OVERRIDE
static void arbtcpdat_changed_cb(const char *)
void awt_clear_selection_list_cb(AW_window *, AW_selection_list *sellist)
void AW_create_standard_fileselection(AW_window *aws, const char *awar_prefix)
Definition: aw_file.hxx:30
#define awt_assert(cond)
Definition: awt.hxx:28
void AW_edit_notified(const char *path, const FileChangedCallback &callback)
Definition: AW_edit.cxx:33
#define NO_TREE_SELECTED
const SaiSelectionlistFilterCallback & awt_std_SAI_filter_cb()
GB_ERROR GB_IO_error(const char *action, const char *filename)
Definition: arb_msg.cxx:293
char * ARB_strdup(const char *str)
Definition: arb_string.h:27
#define PT_SERVERNAME_SELLIST_WIDTH
long read_int() const
Definition: AW_awar.cxx:187
void fill() OVERRIDE
void awt_create_ALI_selection_button(GBDATA *gb_main, AW_window *aws, const char *varname, const char *ali_type_match)
AW_subset_selection(AW_window *aww, AW_selection_list &parent_sellist_, SubsetChangedCb subChanged_cb_, AW_CL cl_user_)
void set_awar_value(const AW_scalar &new_value)
Definition: AW_select.cxx:444
void delete_element_at(int index)
Definition: AW_select.cxx:248
const char * GBS_global_string(const char *templat,...)
Definition: arb_msg.cxx:204
void warning(int warning_num, const char *warning_message)
Definition: util.cxx:61
const char * title
Definition: readseq.c:22
char * AW_get_selected_fullname(AW_root *awr, const char *awar_prefix)
Definition: AW_file.cxx:906
static char * alignment_name
int getConfigInfo(const char *name, string &comment)
bool GB_have_error()
Definition: arb_msg.cxx:349
STL namespace.
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 * GBS_escape_string(const char *str, const char *chars_to_escape, char escape_char)
Definition: adstring.cxx:124
char * ARB_stringdup(const std::string &str)
Definition: arb_stdstring.h:24
CONSTEXPR_INLINE int calc_digits(NUM val)
Definition: arbtools.h:202
char * GBS_string_2_key(const char *str)
Definition: adstring.cxx:52
AW_DB_selection * awt_create_CONFIG_selection_list(GBDATA *gb_main, AW_window *aws, const char *varname, bool fallback2default)
bool default_is_selected() const
Definition: AW_select.cxx:203
GBDATA * GBT_get_tree_data(GBDATA *gb_main)
Definition: adtree.cxx:26
char * ARB_strpartdup(const char *start, const char *end)
Definition: arb_string.h:51
AW_selection_list * get_sellist() const
void awt_create_SAI_selection_button(GBDATA *gb_main, AW_window *aws, const char *varname, const SaiSelectionlistFilterCallback &fcb)
void fill() OVERRIDE
char * GBS_ptserver_id_to_choice(int i, int showBuild)
Definition: adtcp.cxx:453
#define DISPLAY_NONE
bool empty() const
Definition: arb_strarray.h:86
AWT_configuration_selection(AW_selection_list *sellist_, GBDATA *gb_configuration_data)
void(* SubsetChangedCb)(AW_selection *, bool interactive_change, AW_CL cl_user)
void insert(const char *displayed, const char *value)
Definition: aw_select.hxx:183
GB_ERROR GB_incur_error_if(bool error_may_occur)
Definition: arb_msg.h:56
AW_awar * add_callback(const RootCallback &cb)
Definition: AW_awar.cxx:234
struct Unfixed_cb_parameter * UNFIXED
Definition: cb_base.h:15
void collect_subset_cb(awt_collect_mode what)
void awt_popup_SAI_selection_list(AW_window *, const char *awar_name, GBDATA *gb_main)
void insert(const char *displayed, const AW_scalar &value)
Definition: AW_select.cxx:380
const char * get_title() const
const char * get_string() const
Definition: aw_scalar.hxx:72
const char * get_macro_id() const
void to_array(StrArray &array, bool values)
Definition: AW_select.cxx:516
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
void awt_auto_popdown_cb(AW_root *, AW_window_simple *aw_popup)
char * GBT_read_string(GBDATA *gb_container, const char *fieldpath)
Definition: adtools.cxx:267
static AW_window * create_PTSERVER_selection_window(AW_root *aw_root, const char *varname)
static void load_list_cb(AW_window *aww, const StorableSelectionList *storabsellist)
void awt_edit_arbtcpdat_cb(AW_window *)
void popup() const
ALI_selection(AW_selection_list *sellist_, GBDATA *gb_presets, const char *ali_type_match_)
const AW_scalar * get_value_at(int index)
Definition: AW_select.cxx:425
AW_selection_list * create_selection_list(const char *awar_name, int columns, int rows, bool fallback2default)
Definition: AW_button.cxx:1212
GB_TYPES get_awar_type() const
Definition: aw_select.hxx:84
const char * GBT_tree_info_string(GBDATA *gb_main, const char *tree_name, int maxTreeNameLen)
Definition: adtree.cxx:1068
GBDATA * get_gb_main()
Definition: AW_select.cxx:592
void set_update_callback(sellist_update_cb ucb, AW_CL cl_user)
Definition: AW_select.cxx:92
void AW_add_inotification(const char *file, const FileChangedCallback &fccb)
Definition: AW_inotify.cxx:473
GBT_CONFIG_ITEM_TYPE type
Definition: ad_config.h:80
static int group[MAXN+1]
Definition: ClustalV.cxx:65
void GB_clear_error()
Definition: arb_msg.cxx:365
#define aw_assert(bed)
Definition: aw_position.hxx:29
#define CONFIG_DATA_PATH
Definition: ad_config.h:24
const char * get_macro_id() const
const char * get_filter() const
static void refresh_all()
char * get_shared_sellist_awar_base(const TypedSelectionList &typedsellst)
int get_index_of(const AW_scalar &searched_value)
Definition: AW_select.cxx:303
const char * get_comment() const
Definition: ad_config.h:60
static void error(const char *msg)
Definition: mkptypes.cxx:96
#define NO_CONFIG_SELECTED
void AW_create_fileselection_awars(AW_root *awr, const char *awar_base, const char *directories, const char *filter, const char *file_name)
Definition: AW_file.cxx:72
fputc('\n', stderr)
const char * get_displayed()
Definition: aw_select.hxx:159
virtual bool getLine(string &line)
awt_collect_mode
Definition: awt_modules.hxx:29
void create_print_box_for_selection_lists(AW_window *aw_window, const TypedSelectionList *typedsellist)
const char * default_select_display() const
PT_selection(AW_selection_list *sellist_)
virtual ~SelectionListSpec()
AW_DB_selection * create_list(AW_window *aws, bool fallback2default) const
void reorder_subset_cb(awt_reorder_mode dest)
SAI_selection(AW_selection_list *sellist_, GBDATA *gb_sai_data, const SaiSelectionlistFilterCallback &fcb)
AW_awar * awar(const char *awar)
Definition: AW_root.cxx:554
void awt_create_order_buttons(AW_window *aws, awt_orderfun reorder_cb, AW_CL cl_user)
Definition: AWT_modules.cxx:17
void awt_set_subset_selection_content(AW_selection *subset_sel_, const CharPtrArray &values)
void GBS_read_dir(StrArray &names, const char *dir, const char *mask)
Definition: adfile.cxx:213
int get_button_length() const
Definition: AW_at.cxx:287
void AW_refresh_fileselection(AW_root *awr, const char *awar_prefix)
Definition: AW_file.cxx:944
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)
const char * get_title() const
void awt_create_PTSERVER_selection_button(AW_window *aws, const char *varname)
map< string, AW_window * > WinMap
AW_selection_list * awt_create_selection_list_with_input_field(AW_window *aww, const char *awar_name, const char *at_box, const char *at_field)
char * GBS_unescape_string(const char *str, const char *escaped_chars, char escape_char)
Definition: adstring.cxx:175
AWT_tree_selection(AW_selection_list *sellist_, GBDATA *gb_tree_data)
AW_DB_selection * awt_create_ALI_selection_list(GBDATA *gb_main, AW_window *aws, const char *varname, const char *ali_type_match)
char * awar_name
Definition: aw_awar.hxx:103
GBDATA * GBT_next_SAI(GBDATA *gb_sai)
Definition: aditem.cxx:164
const char *const * GBS_get_arb_tcp_entries(const char *matching)
Definition: adtcp.cxx:396
void create_input_field(const char *awar_name, int columns=0)
Definition: AW_button.cxx:855
AW_DB_selection * awt_create_TREE_selection_list(GBDATA *gb_main, AW_window *aws, const char *varname, bool fallback2default)
fputs(TRACE_PREFIX, stderr)
static void correct_subselection_cb(AW_selection_list *parent_sel, AW_CL cl_subsel)
AW_awar * awar_int(const char *var_name, long default_value=0, AW_default default_file=AW_ROOT_DEFAULT)
Definition: AW_root.cxx:580
void auto_space(int xspace, int yspace)
Definition: AW_at.cxx:259
#define IF_ASSERTION_USED(x)
Definition: arb_assert.h:308
long AW_CL
Definition: cb.h:21
void awt_create_collect_buttons(AW_window *aws, bool collect_rightwards, awt_collectfun collect_cb, AW_CL cl_user)
Definition: AWT_modules.cxx:46
const AW_scalar * get_value() const
Definition: aw_select.hxx:160
void delete_entries_missing_in_parent()
static char * get_SAI_description(GBDATA *gb_extended)
void AWT_create_ascii_print_window(AW_root *awr, const char *text_to_print, const char *title=NULp)
const GBT_config_item & nextItem(GB_ERROR &error)
Definition: ad_config.cxx:140
bool GB_is_directory(const char *path)
Definition: arb_file.cxx:176
#define OVERRIDE
Definition: cxxforward.h:93
char * get_content_as_string(long number_of_lines)
Definition: AW_select.cxx:280
const char * get_awar_name() const
Definition: aw_select.hxx:82
AW_selection_list * get_parent_sellist() const
awt_reorder_mode
Definition: awt_modules.hxx:22
static char * readable_pt_servername(int index, int maxlength)
static void save_list_cb(AW_window *aww, const StorableSelectionList *storabsellist)
AW_window * create_save_box_for_selection_lists(AW_root *aw_root, const StorableSelectionList *storabsellist)
void awt_reconfigure_ALI_selection_list(AW_DB_selection *dbsel, const char *ali_type_match)
void GBT_get_tree_names(ConstStrArray &names, GBDATA *gb_main, bool sorted)
Definition: adtree.cxx:1136
char * GB_arbtcpdat_path(void)
Definition: adtcp.cxx:215
static ARB_init_perl_interface init
Definition: ARB_ext.c:101
void aw_message(const char *msg)
Definition: AW_status.cxx:932
const char * get_default_display() const
Definition: AW_select.cxx:295
AW_root * get_root()
Definition: aw_window.hxx:348
void GBT_get_configuration_names(ConstStrArray &configNames, GBDATA *gb_main)
Definition: ad_config.cxx:21
static int line
Definition: arb_a2ps.c:296
#define NULp
Definition: cxxforward.h:97
GB_ERROR save(const char *filename, long number_of_lines=0) const
#define NO_ALI_SELECTED
static void ptserverlog_changed_cb(const char *)
void AW_create_fileselection(AW_window *aws, const char *awar_prefix, const char *at_prefix, const char *pwd, DirDisplay disp_dirs, bool allow_wildcards)
Definition: AW_file.cxx:870
const char * whats_contained() const
GB_ERROR write_string(const char *aw_string)
const char * get_awar_name(const char *awar_base_name, const char *entry)
Definition: MG_main.cxx:358
AW_DB_selection * awt_create_SAI_selection_list(GBDATA *gb_main, AW_window *aws, const char *varname, bool fallback2default, const SaiSelectionlistFilterCallback &fcb)
const char * get_unique_id() const
const AW_scalar * get_default_value() const
Definition: AW_select.cxx:298
GB_ERROR load(const char *filemask, bool append) const
GB_transaction ta(gb_var)
void callback(const WindowCallback &cb)
Definition: AW_window.cxx:130
GB_CSTR GB_read_char_pntr(GBDATA *gbd)
Definition: arbdb.cxx:874
GBDATA * gb_main
Definition: adname.cxx:33
void fill_entries_matching_values(const CharPtrArray &values)
void init_from_array(const CharPtrArray &entries, const char *default_displayed, const char *default_value)
Definition: AW_select.cxx:322
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 * GBT_get_presets(GBDATA *gb_main)
Definition: adali.cxx:29
GBDATA * GBT_get_SAI_data(GBDATA *gb_main)
Definition: aditem.cxx:152
static void update_ptserver_button(AW_root *, AW_awar *awar_ptserver, AW_awar *awar_buttontext_name)
GBDATA * GB_search(GBDATA *gbd, const char *fieldpath, GB_TYPES create)
Definition: adquery.cxx:531
void hide_or_notify(const char *error)
Definition: AW_window.cxx:1817
GB_CSTR GBT_get_name_or_description(GBDATA *gb_item)
Definition: aditem.cxx:437
static GB_ERROR standard_file2list(const CharPtrArray &line, StrArray &display, StrArray &value)
GBDATA * get_gb_main(DbSel db)
Definition: merge.hxx:88
static int info[maxsites+1]
void reconfigure(const char *new_ali_type_match)
static GB_ERROR standard_list2file(const CharPtrArray &display, const CharPtrArray &value, StrArray &line)
const char * get_shared_id() const
#define AW_ROOT_DEFAULT
Definition: aw_base.hxx:106
GB_ERROR write_int(long aw_int)
StorableSelectionList(const TypedSelectionList &tsl_)
GBDATA * GB_entry(GBDATA *father, const char *key)
Definition: adquery.cxx:334
AW_scalar get_awar_value() const
Definition: AW_select.cxx:274
AW_selection_list * get_sellist()
Definition: aw_select.hxx:196
char * GBS_global_string_copy(const char *templat,...)
Definition: arb_msg.cxx:195
ALI_sellst_spec(const char *awar_name_, GBDATA *gb_main_, const char *ali_type_match_)
void create_button(const char *macro_name, AW_label label, const char *mnemonic=NULp, const char *color=NULp)
Definition: AW_button.cxx:446
void refresh()
Definition: AW_select.cxx:184
#define max(a, b)
Definition: f2c.h:154