ARB
ED4_terminal.cxx
Go to the documentation of this file.
1 // =============================================================== //
2 // //
3 // File : ED4_terminal.cxx //
4 // Purpose : //
5 // //
6 // Institute of Microbiology (Technical University Munich) //
7 // http://www.arb-home.de/ //
8 // //
9 // =============================================================== //
10 
11 #include <ed4_extern.hxx>
12 #include "ed4_class.hxx"
13 #include "ed4_awars.hxx"
14 #include "ed4_edit_string.hxx"
15 #include "ed4_block.hxx"
16 #include "ed4_nds.hxx"
17 #include "ed4_ProteinViewer.hxx"
18 #include "ed4_seq_colors.hxx"
19 #include "ed4_flags.hxx"
20 
21 #include <arbdbt.h>
22 #include <items.h>
23 
24 #include <aw_preset.hxx>
25 #include <aw_awar.hxx>
26 #include <aw_awar_defs.hxx>
27 #include <aw_msg.hxx>
28 #include <aw_root.hxx>
29 #include <aw_question.hxx>
30 
31 #include <st_window.hxx>
32 
33 // -----------------------------------
34 // static terminal properties
35 
37  PROP_IS_TERMINAL, // static props
38  LEV_TREE, // level
39  LEV_NONE, // allowed children level
40  LEV_NONE, // handled object
41  LEV_NONE // restriction level
42  );
43 
45  PROP_IS_TERMINAL, // static props
46  LEV_BRACKET, // level
47  LEV_NONE, // allowed children level
48  LEV_NONE, // handled object
49  LEV_NONE // restriction level
50  );
51 
54  LEV_SPECIES_NAME, // level
55  LEV_NONE, // allowed children level
56  LEV_SPECIES, // handled object
57  LEV_NONE // restriction level
58  );
59 
62  LEV_FLAG_HEADER, // level
63  LEV_NONE, // allowed children level
64  LEV_NONE, // handled object
65  LEV_NONE // restriction level
66  );
67 
68 static ED4_objspec flag_spec(
70  LEV_FLAG, // level
71  LEV_NONE, // allowed children level
72  LEV_NONE, // handled object
73  LEV_NONE // restriction level
74  );
75 
78  LEV_SEQUENCE_INFO, // level
79  LEV_NONE, // allowed children level
80  LEV_SEQUENCE, // handled object
81  LEV_NONE // restriction level
82  );
83 
85  PROP_IS_TERMINAL, // static props
86  LEV_SEQUENCE_STRING, // level
87  LEV_NONE, // allowed children level
88  LEV_NONE, // handled object
89  LEV_NONE // restriction level
90  );
91 
93  PROP_IS_TERMINAL, // static props
94  LEV_ORF, // level
95  LEV_NONE, // allowed children level
96  LEV_NONE, // handled object
97  LEV_NONE // restriction level
98  );
99 
101  PROP_IS_TERMINAL, // static props
102  LEV_PURE_TEXT, // level
103  LEV_NONE, // allowed children level
104  LEV_NONE, // handled object
105  LEV_NONE // restriction level
106  );
107 
110  LEV_SPACER, // level
111  LEV_NONE, // allowed children level
112  LEV_NONE, // handled object
113  LEV_NONE // restriction level
114  );
115 
118  LEV_LINE, // level
119  LEV_NONE, // allowed children level
120  LEV_NONE, // handled object
121  LEV_NONE // restriction level
122  );
123 
125  PROP_IS_TERMINAL, // static props
126  LEV_COL_STAT, // level
127  LEV_NONE, // allowed children level
128  LEV_NONE, // handled object
129  LEV_NONE // restriction level
130  );
131 
132 
134  int len;
135  const char *s = resolve_pointer_to_char_pntr(&len);
136  char *t = ARB_strduplen(s, len); // space for zero byte is allocated by ARB_strduplen
137 
138  if (str_len) *str_len = len;
139  return t;
140 }
141 
142 const char *ED4_terminal::resolve_pointer_to_char_pntr(int *str_len) const {
143  const char *result = NULp;
144  GBDATA *gbd = get_species_pointer();
145  bool detect_len = true;
146 
147  if (!gbd) {
148  result = id; // if we don't have a link to the database we (have to) use our id
149  }
150  else {
152 
153  switch (GB_read_type(gbd)) {
154  case GB_STRING:
155  result = GB_read_char_pntr(gbd);
156  if (str_len) {
157  *str_len = GB_read_string_count(gbd);
158  detect_len = false;
159  }
160  break;
161  case GB_BITS:
162  result = GB_read_bits_pntr(gbd, '.', '+');
163  if (str_len) {
164  *str_len = GB_read_bits_count(gbd);
165  detect_len = false;
166  }
167  break;
168  case GB_BYTES:
169  result = GB_read_bytes_pntr(gbd);
170  if (str_len) {
171  *str_len = GB_read_bytes_count(gbd);
172  detect_len = false;
173  }
174  break;
175 
176  case GB_DB: result = "GB_DB"; break;
177  case GB_INT: result = "GB_INT"; break;
178  case GB_INTS: result = "GB_INTS"; break;
179  case GB_FLOAT: result = "GB_FLOAT"; break;
180  case GB_FLOATS: result = "GB_FLOATS"; break;
181 
182  default:
183  result = "Unknown data type\n";
184  e4_assert(0);
185  break;
186  }
187  }
188 
189  if (str_len) {
190  if (detect_len) {
191  *str_len = result ? strlen(result) : 0;
192  }
193  else {
194  e4_assert(*str_len == (int)strlen(result));
195  }
196  }
197 
198  return result;
199 }
200 
201 GB_ERROR ED4_terminal::write_sequence(const char *seq, int seq_len) {
202  GB_ERROR err = NULp;
203  GBDATA *gbd = get_species_pointer();
204  e4_assert(gbd); // we must have a link to the database!
205 
207  GB_push_transaction(gb_main);
208 
209  int old_seq_len;
210  char *old_seq = resolve_pointer_to_string_copy(&old_seq_len);
211 
212  bool allow_write_data = true;
214  long old_checksum = GBS_checksum(old_seq, 1, "-.");
215  long new_checksum = GBS_checksum(seq, 1, "-.");
216 
217  if (old_checksum != new_checksum) {
218  if (aw_question(NULp, "Checksum changed!", "Allow, Reject") == 1) {
219  allow_write_data = false;
220  }
221 
222  }
223  }
224 
225  if (allow_write_data) {
226  GB_TYPES gb_type = GB_read_type(gbd);
227  switch (gb_type) {
228  case GB_STRING: {
229  err = GB_write_string(gbd, seq);
230  break;
231  }
232  case GB_BITS: {
233  err = GB_write_bits(gbd, seq, seq_len, ".-");
234  break;
235  }
236  default: {
237  e4_assert(0);
238  break;
239  }
240  }
241  }
242 
243  GB_pop_transaction(gb_main);
244 
245  if (!err && has_property(PROP_CONSENSUS_RELEVANT)) {
246  if (old_seq) {
247  curr_timestamp = GB_read_clock(gb_main);
248 
249  get_parent(LEV_MULTI_SPECIES)->to_multi_species_manager()
250  ->update_bases_and_rebuild_consensi(old_seq, old_seq_len, get_parent(LEV_SPECIES)->to_species_manager(), ED4_U_UP); // bases_check
251  }
252  else {
253  aw_message("Couldn't read old sequence data");
254  }
255 
256  request_refresh();
257  }
258 
259  if (old_seq) free(old_seq);
260 
261  return err;
262 }
263 
264 
266  if (get_species_pointer()) {
268  tflag.deleted = 1; // @@@ why ?
270  request_refresh();
271  }
272 }
273 
274 #if 0
275 static ARB_ERROR ed4_remove_species_manager_callbacks(ED4_base *base) { // @@@ unused since [8286]
276  if (base->is_species_manager()) {
277  base->to_species_manager()->remove_all_callbacks();
278  }
279  return NULp;
280 }
281 #endif
282 
283 inline void remove_from_consensus(ED4_manager *group_or_species_man) {
285  ED4_manager *parent_manager = group_or_species_man->parent;
286  parent_manager->update_consensus(parent_manager, NULp, group_or_species_man);
287  parent_manager->rebuild_consensi(parent_manager, ED4_U_UP);
288 }
289 
291  ED4_species_manager *species_manager = get_parent(LEV_SPECIES)->to_species_manager();
292 
293  if (species_manager->is_consensus_manager()) { // kill whole group
294  if (ED4_find_MoreSequences_manager()==species_manager->parent) {
295  aw_message("This group has to exist - deleting it isn't allowed");
296  return ED4_R_IMPOSSIBLE;
297  }
298 
299  ED4_manager *group_manager = species_manager->get_parent(LEV_GROUP)->to_group_manager();
300  remove_from_consensus(group_manager);
301  group_manager->Delete();
302  }
303  else { // kill single species/SAI
304  remove_from_consensus(species_manager);
305  species_manager->Delete();
306  }
307 
308  return ED4_R_OK;
309 }
310 
312  // draws drag box of object at location abs_x, abs_y
313 
314  if (cursor_y!=-1) {
315  ED4_base *drag_target = NULp;
316  {
317  ED4_extension location;
318  location.position[X_POS] = 0;
319  location.position[Y_POS] = (AW_pos)cursor_y; // cursor_y is already in world coordinates
320 
322  }
323 
324  if (drag_target) {
325  AW_pos target_x, target_y;
326 
327  drag_target->calc_world_coords (&target_x, &target_y);
328  current_ed4w()->world_to_win_coords(&target_x, &target_y);
329 
330 #define ARROW_LENGTH 3
331  AW_pos drag_line_x0[3], drag_line_y0[3];
332  AW_pos drag_line_x1[3], drag_line_y1[3];
333 
334  drag_line_x0[0] = target_x + 5; // horizontal
335  drag_line_y0[0] = target_y + drag_target->extension.size[HEIGHT];
336  drag_line_x1[0] = drag_line_x0[0] + 50;
337  drag_line_y1[0] = target_y + drag_target->extension.size[HEIGHT];
338 
339  drag_line_x0[1] = drag_line_x0[0] -ARROW_LENGTH; // arrow
340  drag_line_y0[1] = drag_line_y0[0] -ARROW_LENGTH;
341  drag_line_x1[1] = drag_line_x0[0];
342  drag_line_y1[1] = drag_line_y0[0];
343 
344  drag_line_x0[2] = drag_line_x0[0] -ARROW_LENGTH; // arrow
345  drag_line_y0[2] = drag_line_y0[0] + ARROW_LENGTH;
346  drag_line_x1[2] = drag_line_x0[0];
347  drag_line_y1[2] = drag_line_y0[0];
348 #undef ARROW_LENGTH
349 
350  for (ED4_index i = 0; i <= 2; i++) {
351  current_device()->line(ED4_G_DRAG, drag_line_x0[i], drag_line_y0[i], drag_line_x1[i], drag_line_y1[i], AW_SCREEN);
352  }
353  }
354  }
355 
356  if (text) {
357  current_device()->text(ED4_G_DRAG, text, (x + 20), (y + INFO_TERM_TEXT_YOFFSET), 0, AW_SCREEN);
358  }
359 
360  return ED4_R_OK;
361 }
362 
365  else select_all(false); // species and SAI
366 
368 }
369 
370 #if defined(DEBUG) && 1
371 static inline void dumpEvent(const char *where, AW_event *event) {
372  printf("%s: x=%i y=%i\n", where, event->x, event->y);
373 }
374 #else
375 #define dumpEvent(w, e)
376 #endif
377 
379  // handles an input event coming from parent
380 
381  // static data to move terminal:
382  static ED4_species_name_terminal *dragged_name_terminal = NULp;
383 
384  static bool pressed_left_button = false;
385  static int other_x, other_y; // coordinates of last event
386  static bool dragged_was_selected = false; // the dragged terminal is temp. added to selected
387 
388  // ----------------------------
389  // drag/drop terminal
390  if (dragged_name_terminal) {
391  if (event->button == AW_BUTTON_LEFT) {
392  switch (event->type) {
393  case AW_Mouse_Drag: {
394  ED4_selection_entry *sel_info = dragged_name_terminal->selection_info;
395 
396  if (pressed_left_button) {
397  AW_pos world_x, world_y;
398 
399  dragged_name_terminal->calc_world_coords(&world_x, &world_y);
400  current_ed4w()->world_to_win_coords(&world_x, &world_y);
401 
402  sel_info->drag_old_x = world_x;
403  sel_info->drag_old_y = world_y;
404  sel_info->drag_off_x = world_x-other_x;
405  sel_info->drag_off_y = world_y-other_y;
406  sel_info->old_event_y = -1;
407 
408  pressed_left_button = false;
409  }
410 
411  GB_CSTR text = dragged_name_terminal->get_displayed_text();
412 
413  if (dragged_name_terminal->dragged) {
414  dragged_name_terminal->draw_drag_box(sel_info->drag_old_x, sel_info->drag_old_y, text, sel_info->old_event_y);
415  }
416 
417  AW_pos new_x = sel_info->drag_off_x + event->x;
418  AW_pos new_y = sel_info->drag_off_y + event->y;
419 
420  dragged_name_terminal->draw_drag_box(new_x, new_y, text, event->y); // @@@ event->y ist falsch, falls vertikal gescrollt ist!
421 
422  sel_info->drag_old_x = new_x;
423  sel_info->drag_old_y = new_y;
424  sel_info->old_event_y = event->y;
425 
426  dragged_name_terminal->dragged = true;
427  break;
428  }
429  case AW_Mouse_Release: {
430  if (dragged_name_terminal->dragged) {
431  {
432  char *db_pointer = dragged_name_terminal->resolve_pointer_to_string_copy();
433  ED4_selection_entry *sel_info = dragged_name_terminal->selection_info;
434 
435  dragged_name_terminal->draw_drag_box(sel_info->drag_old_x, sel_info->drag_old_y, db_pointer, sel_info->old_event_y);
436  dragged_name_terminal->dragged = false;
437 
438  free(db_pointer);
439  }
440  {
441  ED4_move_info mi;
442 
443  mi.object = dragged_name_terminal;
444  mi.end_x = event->x;
445  mi.end_y = event->y;
446  mi.mode = ED4_M_FREE;
448 
449  dragged_name_terminal->parent->move_requested_by_child(&mi);
450  }
451  {
452  ED4_device_manager *device_manager = ED4_ROOT->get_device_manager();
453 
454  for (int i=0; i<device_manager->members(); i++) { // when moving species numbers have to be recalculated
455  ED4_base *member = device_manager->member(i);
456 
457  if (member->is_area_manager()) {
458  member->to_area_manager()->get_multi_species_manager()->update_requested_by_child();
459  }
460  }
461  }
462  }
463  if (!dragged_was_selected) {
464  ED4_ROOT->remove_from_selected(dragged_name_terminal);
465  }
466 
467  pressed_left_button = false;
468  dragged_name_terminal = NULp;
469  break;
470  }
471  default:
472  break;
473  }
474  }
475  }
476  else {
477  switch (event->button) {
478  case AW_BUTTON_LEFT: {
479  if (is_species_name_terminal()) {
480  switch (ED4_ROOT->species_mode) {
481  case ED4_SM_KILL: {
482  if (event->type == AW_Mouse_Press) {
483  if (containing_species_manager()->is_selected()) ED4_ROOT->remove_from_selected(this->to_species_name_terminal());
484  kill_object();
485  return ED4_R_BREAK;
486  }
487  break;
488  }
489  case ED4_SM_MOVE: {
490  if (event->type == AW_Mouse_Press) {
491  dragged_name_terminal = to_species_name_terminal();
492  pressed_left_button = true;
493 
494  other_x = event->x;
495  other_y = event->y;
496 
497  dragged_was_selected = containing_species_manager()->is_selected();
498  if (!dragged_was_selected) {
499  ED4_ROOT->add_to_selected(dragged_name_terminal);
501  }
502  }
503  break;
504  }
505  case ED4_SM_INFO:
506  case ED4_SM_MARK: {
507  static ED4_species_manager *prev_clicked_species_man = NULp;
508  ED4_species_manager *species_man = get_parent(LEV_SPECIES)->to_species_manager();
509 
510  GBDATA *gbd = species_man->get_species_pointer();
511  if (gbd) {
512  bool acceptClick = false;
513  static int markHow = -1; // -1=invert, 0=unmark, 1=mark
514  {
515  switch (event->type) {
516  case AW_Mouse_Press:
517  acceptClick = true;
518  markHow = -1;
519  break;
520 
521  case AW_Mouse_Drag:
522  acceptClick = prev_clicked_species_man != species_man;
523  break;
524 
525  case AW_Mouse_Release:
526  acceptClick = prev_clicked_species_man != species_man;
527  prev_clicked_species_man = NULp;
528  break;
529 
530  case AW_Keyboard_Press:
531  case AW_Keyboard_Release:
532  e4_assert(0); // impossible
533  break;
534  }
535  }
536 
537  if (acceptClick) {
539  if (markHow<0) markHow = !GB_read_flag(gbd);
540  GB_write_flag(gbd, markHow);
541  request_refresh();
542  if (ED4_ROOT->alignment_type == GB_AT_DNA) PV_RefreshWindow(aww->get_root()); // ProtView: Refreshing orf terminals (@@@ weird place to perform refresh)
543  }
544  else {
546 
547  const char *name = GBT_get_name(gbd);
548  if (name) {
549  const char *awar_select = species_man->inside_SAI_manager() ? AWAR_SAI_NAME : AWAR_SPECIES_NAME;
550  ED4_ROOT->aw_root->awar(awar_select)->write_string(name);
551  }
552  }
553  prev_clicked_species_man = species_man;
554  }
555  }
556  else {
557  prev_clicked_species_man = NULp;
558  }
559  break;
560  }
561  }
562  }
563  else if (is_bracket_terminal()) { // fold/unfold group
564  if (event->type == AW_Mouse_Press) {
565  to_bracket_terminal()->toggle_folding();
566  }
567  }
568  else if (is_sequence_terminal()) {
571  current_cursor().show_clicked_cursor(event->x, this);
572  }
573  }
574  else if (is_flag_terminal()) {
575  if (event->type == AW_Mouse_Press) {
576  to_flag_terminal()->handle_left_click(current_ed4w()->world_to_win_coords(AW::Position(event->x, event->y)));
577  }
578  }
579 
580  break;
581  }
582  case AW_BUTTON_RIGHT: {
583  // static data for block-selection:
584  static bool select_started_on_seqterm = false;
585 
586  switch (event->type) {
587  case AW_Mouse_Press: {
588  select_started_on_seqterm = false;
589  if (is_species_name_terminal()) {
590  ED4_species_manager *species_man = get_parent(LEV_SPECIES)->to_species_manager();
591 
592  if (species_man->is_consensus_manager()) { // click on consensus-name
593  ED4_multi_species_manager *multi_man = species_man->get_parent(LEV_MULTI_SPECIES)->to_multi_species_manager();
594  multi_man->toggle_selected_species();
595  }
596  else { // click on species or SAI name
597  if (!species_man->is_selected()) { // select if not selected
598  if (ED4_ROOT->add_to_selected(this->to_species_name_terminal()) == ED4_R_OK) ED4_correctBlocktypeAfterSelection();
599  }
600  else { // deselect if already selected
601  ED4_ROOT->remove_from_selected(this->to_species_name_terminal());
603  }
604  }
605  }
606  else if (is_bracket_terminal()) {
608  if (group) {
609  group->to_group_manager()->get_multi_species_manager()->toggle_selected_species();
610  }
611  }
612  else if (is_sequence_terminal()) {
614  ED4_setColumnblockCorner(event, to_sequence_terminal()); // mark columnblock
615  select_started_on_seqterm = true;
616  }
617  break;
618  }
619 
620  case AW_Mouse_Drag:
621  case AW_Mouse_Release:
622  if (select_started_on_seqterm && is_sequence_terminal()) {
624  ED4_setColumnblockCorner(event, to_sequence_terminal()); // mark columnblock
625  }
626  break;
627 
628  default:
629  break;
630  }
631  break;
632  }
633 
634  default: break;
635  }
636  }
637 
638  return ED4_R_OK;
639 }
640 
642 
644  // calculates the smallest rectangle containing the object.
645  // requests refresh and returns true if bounding box has changed.
646 
647  bool bb_changed = false;
648 
649  if (width_link) {
650  bb_changed = extension.set_size_does_change(WIDTH, width_link->extension.size[WIDTH]) || bb_changed;
651  }
652 
653  if (height_link) {
654  bb_changed = extension.set_size_does_change(HEIGHT, height_link->extension.size[HEIGHT]) || bb_changed;
655  }
656 
657 
658  if (bb_changed) {
660  request_refresh();
661  }
662  return bb_changed;
663 }
664 
666  if (update_info.resize) { // likes to resize?
668  }
669 }
670 
671 
676 }
677 
678 
679 ED4_base* ED4_terminal::search_ID(const char *temp_id) {
680  if (id && strcmp(temp_id, id) == 0) return this;
681  return NULp;
682 }
683 
684 void ED4_terminal::Show(bool IF_ASSERTION_USED(refresh_all), bool is_cleared) {
685  e4_assert(update_info.refresh || refresh_all);
688  if (update_info.clear_at_refresh && !is_cleared) {
690  }
691  draw();
692  }
694 }
695 
696 ED4_terminal::ED4_terminal(const ED4_objspec& spec_, GB_CSTR temp_id, AW_pos width, AW_pos height, ED4_manager *temp_parent) :
697  ED4_base(spec_, temp_id, width, height, temp_parent)
698 {
699  memset((char*)&tflag, 0, sizeof(tflag));
700  curr_timestamp = 0;
701 }
702 
703 
705  for (ED4_window *window = ED4_ROOT->first_window; window; window=window->next) {
706  ED4_cursor& cursor = window->cursor;
707  if (this == cursor.owner_of_cursor) {
708  cursor.init();
709  }
710  }
711 }
712 
713 ED4_tree_terminal::ED4_tree_terminal(const char *temp_id, AW_pos width, AW_pos height, ED4_manager *temp_parent)
714  : ED4_terminal(tree_terminal_spec, temp_id, width, height, temp_parent)
715 {}
716 
717 void ED4_tree_terminal::draw() {
718  AW_pos x, y;
719  AW_pos text_x, text_y;
720  char *db_pointer;
721 
722  calc_world_coords(&x, &y);
724 
725  text_x = x + CHARACTEROFFSET; // don't change
726  text_y = y + SEQ_TERM_TEXT_YOFFSET;
727 
728  db_pointer = resolve_pointer_to_string_copy();
729  current_device()->text(ED4_G_STANDARD, db_pointer, text_x, text_y, 0, AW_SCREEN);
730  free(db_pointer);
731 }
732 
733 ED4_bracket_terminal::ED4_bracket_terminal(const char *temp_id, AW_pos width, AW_pos height, ED4_manager *temp_parent)
734  : ED4_terminal(bracket_terminal_spec, temp_id, width, height, temp_parent)
735 {}
736 
738  using namespace AW;
739 
740  Rectangle term_area = get_win_area(current_ed4w());
741  AW_device *device = current_device();
742 
743  ED4_multi_species_manager *multi_man = get_parent(LEV_GROUP)->to_group_manager()->get_multi_species_manager();
744  if (multi_man->get_no_of_selected_species()) { // if multi_species_manager contains selected species
745 #if defined(DEBUG) && 0
746  static bool toggle = false;
747  toggle = !toggle;
748  device->box(toggle ? ED4_G_SELECTED : ED4_G_SELECTED+1, AW::FillStyle::SOLID, term_area);
749 #else // !defined(DEBUG)
750  device->box(ED4_G_SELECTED, AW::FillStyle::SOLID, term_area);
751 #endif
752  }
753 
755  if (parent->has_property(PROP_IS_FOLDED)) { // for folded group, paint triangle pointing rightwards
756  Position t = term_area.upper_left_corner()+Vector(4,4);
757  Position b = t+Vector(0,12);
758 
759  for (int i = 0; i<6; ++i) {
760  device->line(ED4_G_STANDARD, t, b, AW_SCREEN);
761  t += Vector(1, 1);
762  b += Vector(1, -1);
763  }
764  e4_assert(nearlyEqual(t, b));
765  device->line(ED4_G_STANDARD, t, b, AW_SCREEN); // arrowhead
766  }
767  else { // for unfolded group, paint triangle pointing downwards
768  Position l = term_area.upper_left_corner()+Vector(4,5);
769  Position r = l+Vector(6,0);
770 
771  for (int i = 0; i<3; ++i) {
772  device->line(ED4_G_STANDARD, l, r, AW_SCREEN);
773  l += Vector( 0, 1);
774  r += Vector( 0, 1);
775  device->line(ED4_G_STANDARD, l, r, AW_SCREEN);
776  l += Vector( 1, 1);
777  r += Vector(-1, 1);
778  }
779  e4_assert(nearlyEqual(l, r));
780  device->line(ED4_G_STANDARD, l, r+Vector(0,1), AW_SCREEN); // arrowhead
781  }
782 
783  {
784  Rectangle bracket(term_area.upper_left_corner()+Vector(2,2), term_area.diagonal()+Vector(-2,-4));
785 
786  device->line(ED4_G_STANDARD, bracket.upper_edge(), AW_SCREEN);
787  device->line(ED4_G_STANDARD, bracket.lower_edge(), AW_SCREEN);
788  device->line(ED4_G_STANDARD, bracket.left_edge(), AW_SCREEN);
789  }
790 }
791 
792 ED4_species_name_terminal::ED4_species_name_terminal(GB_CSTR temp_id, AW_pos width, AW_pos height, ED4_manager *temp_parent) :
793  ED4_text_terminal(species_name_terminal_spec, temp_id, width, height, temp_parent),
794  selection_info(NULp),
795  dragged(false)
796 {}
797 
798 #define MAXNAMELEN MAXNAME_WIDTH // @@@ seems wrong (MAXNAME_WIDTH contains pixel)
799 #define BUFFERSIZE (MAXNAMELEN<<1)
800 GB_CSTR ED4_species_name_terminal::get_displayed_text() const {
801  static char *real_name;
802  static int allocatedSize;
803 
804  if (!real_name || allocatedSize<(BUFFERSIZE+1)) {
805  free(real_name);
806  allocatedSize = BUFFERSIZE+1;
807  ARB_alloc(real_name, allocatedSize);
808  }
809  memset(real_name, 0, allocatedSize);
810 
811  ED4_species_manager *spec_man = get_parent(LEV_SPECIES)->to_species_manager();
812 
813  if (spec_man->is_consensus_manager()) {
814  char *db_pointer = resolve_pointer_to_string_copy();
815  char *bracket = strchr(db_pointer, '(');
816 
817  if (bracket) {
818  int bracket_len = strlen(bracket);
819  int name_len = bracket-db_pointer;
820 
821  if (bracket[-1]==' ') {
822  name_len--;
823  }
824 
825  if ((name_len+1+bracket_len)<=MAXNAMELEN) {
826  strcpy(real_name, db_pointer);
827  }
828  else {
829  int short_name_len = MAXNAMELEN-bracket_len-1;
830 
831  memcpy(real_name, db_pointer, short_name_len);
832  real_name[short_name_len] = ' ';
833  strcpy(real_name+short_name_len+1, bracket);
834  }
835  }
836  else {
837  strncpy(real_name, db_pointer, BUFFERSIZE);
838  }
839 
840  free(db_pointer);
841  }
842  else if (spec_man->is_SAI_manager()) {
843  char *db_pointer = resolve_pointer_to_string_copy();
844 
845  strcpy(real_name, "SAI: ");
846  if (strcmp(db_pointer, "ECOLI")==0) {
847  const char *name_for_ecoli = ED4_ROOT->aw_root->awar(ED4_AWAR_NDS_ECOLI_NAME)->read_char_pntr();
848  if (name_for_ecoli[0]==0) name_for_ecoli = db_pointer;
849  strncpy(real_name+5, name_for_ecoli, BUFFERSIZE-5);
850  }
851  else {
852  strncpy(real_name+5, db_pointer, BUFFERSIZE-5);
853  }
854  free(db_pointer);
855  }
856  else { // normal species
857  char *result = ED4_get_NDS_text(spec_man);
858  strncpy(real_name, result, BUFFERSIZE);
859  free(result);
860  }
861 
862  return real_name;
863 }
864 #undef MAXNAMELEN
865 #undef BUFFERSIZE
866 
867 
868 ED4_sequence_info_terminal::ED4_sequence_info_terminal(const char *temp_id, AW_pos width, AW_pos height, ED4_manager *temp_parent)
869  : ED4_text_terminal(sequence_info_terminal_spec, temp_id, width, height, temp_parent)
870 {}
871 
873  : ED4_sequence_terminal(temp_id, width, height, temp_parent, false),
874  temp_cons_seq(NULp)
875 {
876  species_name = NULp;
877 }
878 
880  return get_char_table().size();
881 }
882 
883 
884 ED4_abstract_sequence_terminal::ED4_abstract_sequence_terminal(const ED4_objspec& spec_, const char *temp_id, AW_pos width, AW_pos height, ED4_manager *temp_parent)
885  : ED4_text_terminal(spec_, temp_id, width, height, temp_parent)
886 {
887  species_name = NULp;
888 }
889 
891  free(species_name);
892 }
893 
894 ED4_orf_terminal::ED4_orf_terminal(const char *temp_id, AW_pos width, AW_pos height, ED4_manager *temp_parent)
895  : ED4_abstract_sequence_terminal(orf_terminal_spec, temp_id, width, height, temp_parent)
896 {
897  aaSequence = NULp;
898  aaSeqLen = 0;
899  aaColor = NULp;
900  aaStartPos = 0;
901  aaStrandType = 0;
902 }
903 
905  free(aaSequence);
906  free(aaColor);
907 }
908 
909 ED4_sequence_terminal::ED4_sequence_terminal(const char *temp_id, AW_pos width, AW_pos height, ED4_manager *temp_parent, bool shall_display_secstruct_info_)
910  : ED4_abstract_sequence_terminal(sequence_terminal_spec, temp_id, width, height, temp_parent),
911  shall_display_secstruct_info(shall_display_secstruct_info_)
912 {
913  st_ml_node = NULp;
914 }
915 
916 ED4_pure_text_terminal::ED4_pure_text_terminal(const char *temp_id, AW_pos width, AW_pos height, ED4_manager *temp_parent)
917  : ED4_text_terminal(pure_text_terminal_spec, temp_id, width, height, temp_parent)
918 {}
919 
920 #if defined(DEVEL_RALF) && 0
921 // # define DEBUG_SPACER_TERMINALS 0 // show placeholder-spacers (normally not drawn)
922 // # define DEBUG_SPACER_TERMINALS 1 // show erasing spacers (normally area gets erased)
923 # define DEBUG_SPACER_TERMINALS 2 // show all spacers
924 #endif
925 
926 void ED4_spacer_terminal::Show(bool /*refresh_all*/, bool is_cleared) {
927 #if defined(DEBUG_SPACER_TERMINALS)
928  if (DEBUG_SPACER_TERMINALS == 1) {
929  if (shallDraw) {
930  draw();
931  }
932  else if (update_info.clear_at_refresh && !is_cleared) {
933  clear_background(0);
934  }
935  }
936  else {
937  draw();
938  }
939 #else // !DEBUG_SPACER_TERMINALS
940  if (shallDraw || (update_info.clear_at_refresh && !is_cleared)) {
941  draw();
942  }
943 #endif
944 }
945 
946 
947 void ED4_spacer_terminal::draw() {
948  int gc = 0;
949 #if defined(DEBUG_SPACER_TERMINALS)
950  const int GC_COUNT = ED4_G_LAST_COLOR_GROUP - ED4_G_FIRST_COLOR_GROUP + 1;
951  gc = ((long(this)/32)%GC_COUNT)+ED4_G_FIRST_COLOR_GROUP; // draw colored spacers to make them visible
952 
953  if (DEBUG_SPACER_TERMINALS != 2) {
954  bool highlight = bool(DEBUG_SPACER_TERMINALS) == shallDraw;
955  if (!highlight) gc = 0;
956  }
957 #endif // DEBUG_SPACER_TERMINALS
958  clear_background(gc);
959 }
960 
961 ED4_spacer_terminal::ED4_spacer_terminal(const char *temp_id, bool shallDraw_, AW_pos width, AW_pos height, ED4_manager *temp_parent)
962  : ED4_terminal(spacer_terminal_spec, temp_id, width, height, temp_parent),
963  shallDraw(shallDraw_)
964 {
965  // 'shallDraw_'==true is only needed in very special cases,
966  // eg. for 'Top_Middle_Spacer' (to remove overlapping relicts from half-displayed species below)
967 }
968 
970  AW_pos x1, y1;
971  calc_world_coords(&x1, &y1);
972  current_ed4w()->world_to_win_coords(&x1, &y1);
973 
974  AW_pos x2 = x1+extension.size[WIDTH]-1;
975  AW_pos y2 = y1+extension.size[HEIGHT]-1;
976 
977  AW_device *device = current_device();
978 
979  device->line(ED4_G_STANDARD, x1, y1, x2, y1);
980 #if defined(DEBUG)
981  device->box(ED4_G_MARKED, AW::FillStyle::SOLID, x1, y1+1, x2-x1+1, y2-y1-1);
982 #else
983  device->clear_part(x1, y1+1, x2-x1+1, y2-y1-1, AW_ALL_DEVICES);
984 #endif // DEBUG
985  device->line(ED4_G_STANDARD, x1, y2, x2, y2);
986 }
987 
988 ED4_line_terminal::ED4_line_terminal(const char *temp_id, AW_pos width, AW_pos height, ED4_manager *temp_parent)
989  : ED4_terminal(line_terminal_spec, temp_id, width, height, temp_parent)
990 {}
991 
992 // ---------------------------------
993 // ED4_columnStat_terminal
994 
995 inline char stat2display(int val, bool is_upper_digit) {
996  if (val<0) {
997  e4_assert(val==-1); // -1 indicates that no statistic is existing for that column
998  return '?';
999  }
1000  if (val==20) return ' '; // value if ACGT and - are distributed equally
1001  if (val==100) return '^'; // we have only 2 characters to display likelihood (100 cannot be displayed)
1002 
1003  e4_assert(val>=0 && val<100);
1004 
1005  return '0' + (is_upper_digit ? (val/10) : (val%10));
1006 }
1007 
1008 inline int find_significant_positions(int sig, int like_A, int like_C, int like_G, int like_TU, int *sumPtr) {
1009  // result == 0 -> no base-char has a significant likelihood (>=sig)
1010  // result == 1, 2, 4, 8 -> A, C, G, T/U has a significant likelihood
1011  // else -> the sum two of the likelihoods >= sig (bit-or-ed as in line above)
1012 
1013  int like[4];
1014  like[0] = like_A;
1015  like[1] = like_C;
1016  like[2] = like_G;
1017  like[3] = like_TU;
1018 
1019  int bestSum = 0;
1020  int bestResult = 0;
1021 
1022  int b, c;
1023  for (b=0; b<4; b++) {
1024  int sum = like[b];
1025  if (sum>=sig && sum>=bestSum) {
1026  bestSum = sum;
1027  bestResult = 1<<b;
1028  }
1029  }
1030 
1031  if (!bestResult) {
1032  for (b=0; b<4; b++) {
1033  for (c=b+1; c<4; c++) {
1034  int sum = like[b]+like[c];
1035  if (sum>=sig && sum>=bestSum) {
1036  bestSum = sum;
1037  bestResult = (1<<b)|(1<<c);
1038  }
1039  }
1040  }
1041  }
1042 
1043  if (bestResult) {
1044  if (sumPtr) *sumPtr = bestSum;
1045  return bestResult;
1046  }
1047 
1048  return 0;
1049 }
1050 
1051 void ED4_columnStat_terminal::draw() {
1052  AW_pos x, y;
1053  calc_world_coords(&x, &y);
1054  current_ed4w()->world_to_win_coords(&x, &y);
1055 
1056  AW_pos term_height = extension.size[HEIGHT];
1059 
1060  AW_pos text_x = x + CHARACTEROFFSET;
1061  AW_pos text_y = y + term_height - font_height;
1062 
1063  AW_device *device = current_device();
1064 
1065  if (!update_likelihood()) {
1066  const char *warning = "Failed to calculate likelihood";
1067 
1068  device->text(ED4_G_STANDARD, warning, text_x, text_y, 0, AW_SCREEN);
1069  return;
1070  }
1071 
1072  ED4_sequence_terminal *seq_term = corresponding_sequence_terminal();
1073  const ED4_remap *rm = ED4_ROOT->root_group_man->remap();
1074 
1075  PosRange index_range = rm->clip_screen_range(seq_term->calc_update_interval());
1076  {
1077  int max_seq_len = seq_term->get_length();
1078  int max_seq_pos = rm->sequence_to_screen(max_seq_len);
1079 
1080  index_range = ExplicitRange(index_range, max_seq_pos);
1081  if (index_range.is_empty()) return; // nothing to draw
1082  }
1083 
1084  const int left = index_range.start();
1085  const int right = index_range.end();
1086 
1087  char *sbuffer = new char[right+2]; // used to build displayed terminal content (values = '0'-'9')
1088  memset(sbuffer, ' ', right+1);
1089  sbuffer[right+1] = 0; // eos
1090 
1091  AW_pos y2;
1092  int r;
1093 
1094  // Set background:
1095  {
1096  int significance = int(get_threshold());
1097  // normal columns are colored in ED4_G_STANDARD
1098  // all columns with one (or sum of two) probability above 'significance' are back-colored in ED4_G_CBACK_0
1099  // the responsible probabilities (one or two) are back-colored in ED4_G_CBACK_1..ED4_G_CBACK_9
1100 
1101  int old_color = ED4_G_STANDARD;
1102 
1103  AW_pos x2 = text_x + font_width*left + 1;
1104  AW_pos old_x2 = x2;
1105 
1106  PosRange selection;
1107  bool is_selected = ED4_get_selected_range(seq_term, selection);
1108 
1109  for (int i=left; i<=right; i++, x2+=font_width) { // colorize significant columns in ALL rows
1110  int p = rm->screen_to_sequence(i);
1111  int found = find_significant_positions(significance, likelihood[0][p], likelihood[1][p], likelihood[2][p], likelihood[3][p], NULp);
1112 
1113  int color;
1114  if (is_selected && selection.contains(p)) {
1115  color = ED4_G_SELECTED;
1116  }
1117  else {
1118  color = found ? ED4_G_CBACK_0 : ED4_G_STANDARD;
1119  }
1120 
1121  if (color!=old_color) {
1122  if (x2>old_x2 && old_color!=ED4_G_STANDARD) {
1123  device->box(old_color, AW::FillStyle::SOLID, old_x2, y, x2-old_x2, term_height);
1124  }
1125  old_color = color;
1126  old_x2 = x2;
1127  }
1128  }
1129  if (x2>old_x2 && old_color!=ED4_G_STANDARD) {
1130  device->box(old_color, AW::FillStyle::SOLID, old_x2, y, x2-old_x2, term_height);
1131  }
1132 
1133  x2 = text_x + font_width*left + 1;
1134 
1135  for (int i=left; i<=right; i++, x2+=font_width) { // colorize significant columns in SINGLE rows
1136  int p = rm->screen_to_sequence(i);
1137  int sum;
1138  int found = find_significant_positions(significance, likelihood[0][p], likelihood[1][p], likelihood[2][p], likelihood[3][p], &sum);
1139 
1140  if (found && significance<100) {
1141  e4_assert(sum>=significance && sum<=100);
1142  int color = ED4_G_CBACK_1+((sum-significance)*(ED4_G_CBACK_9-ED4_G_CBACK_1))/(100-significance);
1143  e4_assert(color>=ED4_G_CBACK_1 && color<=ED4_G_CBACK_9);
1144 
1145  if (color!=ED4_G_STANDARD) {
1146  int bit;
1147 
1148  for (r=3, y2=text_y+1, bit=1<<3;
1149  r>=0;
1150  r--, y2-=COLUMN_STAT_ROW_HEIGHT(font_height), bit>>=1)
1151  {
1152  if (found&bit) {
1153  device->box(color, AW::FillStyle::SOLID, x2, y2-2*font_height+1, font_width, 2*font_height);
1154  }
1155  }
1156  }
1157  }
1158  }
1159  }
1160 
1161  // Draw text:
1162  for (r=3, y2=text_y;
1163  r>=0;
1164  r--, y2-=COLUMN_STAT_ROW_HEIGHT(font_height)) { // 4 rows (one for T/U, G, C and A)
1165 
1166  int gc = ED4_ROOT->sequence_colors->char_2_gc[(unsigned char)"ACGU"[r]];
1167  int i;
1168  for (i=left; i<=right; i++) {
1169  int p = rm->screen_to_sequence(i);
1170  int val = likelihood[r][p];
1171  sbuffer[i] = stat2display(val, 0); // calc lower digit
1172  }
1173 
1174  device->text(gc, SizedCstr(sbuffer, right), text_x+font_width*0.2, y2, 0, AW_SCREEN); // draw lower-significant digit (shifted a bit to the right)
1175 
1176  for (i=left; i<=right; i++) {
1177  int p = rm->screen_to_sequence(i);
1178  int val = likelihood[r][p];
1179  sbuffer[i] = stat2display(val, 1); // calc upper digit
1180  }
1181  device->text(gc, SizedCstr(sbuffer, right), text_x, y2-font_height, 0, AW_SCREEN); // draw higher-significant digit
1182  }
1183 
1184  delete [] sbuffer;
1185 }
1186 
1187 int ED4_columnStat_terminal::update_likelihood() {
1188  ED4_sequence_terminal *seq_term = corresponding_sequence_terminal();
1189 
1190  return STAT_update_ml_likelihood(ED4_ROOT->st_ml, likelihood, latest_update, NULp, seq_term->st_ml_node);
1191 }
1192 
1193 ED4_columnStat_terminal::ED4_columnStat_terminal(GB_CSTR temp_id, AW_pos width, AW_pos height, ED4_manager *temp_parent) :
1194  ED4_text_terminal(column_stat_terminal_spec, temp_id, width, height, temp_parent)
1195 {
1196  for (int i=0; i<4; i++) likelihood[i] = NULp;
1197  latest_update = 0;
1198 }
1199 
1200 ED4_columnStat_terminal::~ED4_columnStat_terminal() {
1201  for (int i=0; i<4; i++) free(likelihood[i]);
1202 }
1203 
1204 // ------------------------
1205 // flag terminals
1206 
1207 ED4_flag_header_terminal::ED4_flag_header_terminal(GB_CSTR id_, AW_pos width, AW_pos height, ED4_manager *parent_) :
1208  ED4_text_terminal(flag_header_spec, id_, width, height, parent_)
1209 {}
1210 
1211 GB_CSTR ED4_flag_header_terminal::get_displayed_text() const {
1213 }
1214 int ED4_flag_header_terminal::get_length() const {
1216 }
1217 
1218 ED4_flag_terminal::ED4_flag_terminal(const char *id_, AW_pos width, AW_pos height, ED4_manager *parent_) :
1219  ED4_terminal(flag_spec, id_, width, height, parent_)
1220 {}
1221 
1222 using namespace AW;
1223 
1224 class FlagLayout {
1225  double flag_centerx; // flag x-position relative to terminal
1226  Rectangle box; // box at flag_centerx
1227 
1228 public:
1229  FlagLayout(const Rectangle& area, const SpeciesFlags& flags) {
1230  double boxsize = std::max(1.0, std::min(double(flags.get_min_flag_distance()), area.height()*0.95));
1231  Vector box_diag(boxsize, -boxsize);
1232 
1233  SpeciesFlagCiter curr_flag = flags.begin();
1234  flag_centerx = curr_flag->center_xpos();
1235  Position box_center = area.left_edge().centroid() + Vector(flag_centerx, 0);
1236  box = Rectangle(box_center-box_diag/2, box_diag);
1237  }
1238 
1239  void move_box(double new_flag_centerx) {
1240  box.move(Vector(new_flag_centerx - flag_centerx, 0));
1241  flag_centerx = new_flag_centerx;
1242  }
1243 
1244  const Rectangle& get_box() const { return box; }
1245 };
1246 
1247 void ED4_flag_terminal::draw() {
1249 
1250  int boxes = flags.size();
1251  if (boxes>0) {
1252  FlagLayout layout(get_win_area(current_ed4w()), flags);
1253 
1254  SpeciesFlagCiter curr_flag = flags.begin();
1255  SpeciesFlagCiter end = flags.end();
1256 
1257  AW_device *device = current_device();
1258 
1259  GBDATA *gb_species = get_species();
1260  GB_ERROR error = NULp;
1261 
1262  for (int b = 0; b<boxes && !error; ++b) {
1263  bool filled = false;
1264  {
1265  GBDATA *gb_field = GB_entry(gb_species, curr_flag->get_fieldname().c_str());
1266  if (gb_field) {
1267  uint8_t as_byte = GB_read_lossless_byte(gb_field, error);
1268  if (error) error = GBS_global_string("Failed to read flag value (Reason: %s)", error);
1269  else filled = as_byte;
1270  }
1271  }
1272 
1273  if (filled) device->box(ED4_G_FLAG_FILL, FillStyle::SOLID, layout.get_box(), AW_SCREEN); // filled?
1274  device->box( ED4_G_FLAG_FRAME, FillStyle::EMPTY, layout.get_box(), AW_SCREEN); // frame
1275 
1276  ++curr_flag;
1277  if (curr_flag != end) layout.move_box(curr_flag->center_xpos());
1278  }
1279 
1280  aw_message_if(error);
1281  }
1282 }
1283 
1284 void ED4_flag_terminal::handle_left_click(const Position& click) {
1285  const SpeciesFlags& flags = SpeciesFlags::instance();
1286 
1287  int boxes = flags.size();
1288  if (boxes>0) {
1289  FlagLayout layout(get_win_area(current_ed4w()), flags);
1290 
1291  SpeciesFlagCiter curr_flag = flags.begin();
1292  SpeciesFlagCiter end = flags.end();
1293 
1294  for (int b = 0; b<boxes; ++b) {
1295  if (layout.get_box().contains(click)) break;
1296  ++curr_flag;
1297  if (curr_flag != end) layout.move_box(curr_flag->center_xpos());
1298  }
1299 
1300  if (curr_flag != end) {
1301  GBDATA *gb_species = get_species();
1302  GBDATA *gb_field = GB_entry(gb_species, curr_flag->get_fieldname().c_str());
1303  GB_ERROR error = GB_incur_error_if(!gb_field);
1304 
1305  if (!error && !gb_field) {
1306  const char *key = curr_flag->prepare_itemfield(); // impl using prepare_and_get_selected_itemfield
1307  if (key) gb_field = GBT_searchOrCreate_itemfield_according_to_changekey(gb_species, key, SPECIES_get_selector().change_key_path);
1308  error = GB_incur_error_if(!gb_field);
1309  }
1310 
1311  if (gb_field) {
1312  uint8_t val = GB_read_lossless_byte(gb_field, error);
1313  if (!error) error = GB_write_lossless_byte(gb_field, !val);
1314  }
1315 
1316  aw_message_if(error);
1317  if (!error) request_refresh();
1318  }
1319  }
1320 }
1321 
1322 // ---------------------------------
1323 // ED4_reference_terminals
1324 
1326  delete ref_sequence_info;
1327  delete ref_sequence;
1328  delete ref_column_stat;
1329  delete ref_column_stat_info;
1330  null();
1331 }
1332 
1333 void ED4_reference_terminals::init(ED4_sequence_info_terminal *ref_sequence_info_,
1334  ED4_sequence_terminal *ref_sequence_,
1335  ED4_sequence_info_terminal *ref_column_stat_info_,
1336  ED4_columnStat_terminal *ref_column_stat_)
1337 {
1338  clear();
1339  ref_sequence_info = ref_sequence_info_;
1340  ref_sequence = ref_sequence_;
1341  ref_column_stat_info = ref_column_stat_info_;
1342  ref_column_stat = ref_column_stat_;
1343 }
ED4_base * search_ID(const char *id) OVERRIDE
void clr_property(ED4_properties prop)
Definition: ed4_class.hxx:975
ED4_bracket_terminal(const char *id, AW_pos width, AW_pos height, ED4_manager *parent)
void resize_requested_children() OVERRIDE
const char * GB_ERROR
Definition: arb_core.h:25
GB_ERROR GB_write_bits(GBDATA *gbd, const char *bits, long size, const char *c_0)
Definition: arbdb.cxx:1416
string result
ED4_movemode mode
Definition: ed4_defs.hxx:242
AW_device * current_device()
Definition: ed4_class.hxx:1396
const char * resolve_pointer_to_char_pntr(int *str_len=NULp) const FINAL_OVERRIDE
int screen_to_sequence(int screen_pos) const
#define ED4_AWAR_ANNOUNCE_CHECKSUM_CHANGES
Definition: ed4_awars.hxx:36
void update_requested_children() OVERRIDE
const AW_bitset AW_SCREEN
Definition: aw_device.hxx:34
AW_font_group font_group
Definition: ed4_class.hxx:1464
AW_pos size[2]
Definition: ed4_defs.hxx:261
void draw() OVERRIDE
Position centroid() const
static char * y[maxsp+1]
#define COLUMN_STAT_ROW_HEIGHT(font_height)
Definition: ed4_defs.hxx:84
Definition: arbdb.h:69
ED4_level preferred_parent
Definition: ed4_defs.hxx:243
bool nearlyEqual(const double &val1, const double &val2)
Definition: aw_position.hxx:75
GB_ERROR GB_write_string(GBDATA *gbd, const char *s)
Definition: arbdb.cxx:1385
void remove_callbacks() FINAL_OVERRIDE
ED4_base * member(ED4_index i) const
Definition: ed4_class.hxx:794
const char * get_header_text() const
Definition: ed4_flags.hxx:103
GBDATA * get_species_pointer() const
Definition: ed4_class.hxx:947
void draw() OVERRIDE
~ED4_orf_terminal() OVERRIDE
virtual void clear_part(const AW::Rectangle &rect, AW_bitset filteri)
Definition: AW_device.cxx:317
AW_pos drag_off_y
Definition: ed4_defs.hxx:247
char * id
Definition: ed4_class.hxx:919
int start() const
Definition: pos_range.h:57
ExplicitRange clip_screen_range(PosRange screen_range) const
Definition: ed4_class.hxx:1769
long
Definition: AW_awar.cxx:154
static const SpeciesFlags & instance()
Definition: ed4_flags.hxx:90
bool all_are_selected() const
Definition: ed4_class.hxx:1624
void request_resize()
Definition: ed4_class.hxx:2186
void remove_from_consensus(ED4_manager *group_or_species_man)
long read_int() const
Definition: AW_awar.cxx:187
void remove_from_selected(ED4_species_name_terminal *object)
Definition: ED4_root.cxx:328
void set_species_pointer(GBDATA *gbd)
Definition: ed4_class.hxx:948
#define Y_POS
Definition: ed4_defs.hxx:73
int get_height(int gc) const
long GB_read_bytes_count(GBDATA *gbd)
Definition: arbdb.cxx:963
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
ED4_root * ED4_ROOT
Definition: ED4_main.cxx:48
int is_species_manager() const
Definition: ed4_class.hxx:1108
void ED4_trigger_instant_refresh()
ED4_update_info update_info
Definition: ed4_class.hxx:924
long curr_timestamp
Definition: ed4_class.hxx:1291
const AW_bitset AW_ALL_DEVICES
Definition: aw_device.hxx:44
ED4_terminal * owner_of_cursor
Definition: ed4_class.hxx:643
char stat2display(int val, bool is_upper_digit)
int get_width(int gc) const
ED4_returncode clear_background(int color=0)
Definition: ED4_base.cxx:939
ED4_manager * parent
Definition: ed4_class.hxx:915
long GB_read_bits_count(GBDATA *gbd)
Definition: arbdb.cxx:915
char * ED4_get_NDS_text(ED4_species_manager *species_man)
Definition: ED4_nds.cxx:26
bool is_empty() const
Definition: pos_range.h:69
ED4_orf_terminal(const char *id, AW_pos width, AW_pos height, ED4_manager *parent)
GB_ERROR GB_push_transaction(GBDATA *gbd)
Definition: arbdb.cxx:2482
FILE * seq
Definition: rns.c:46
const Rectangle & get_box() const
static ED4_objspec sequence_info_terminal_spec(ED4_properties(PROP_IS_TERMINAL|PROP_DYNA_RESIZE), LEV_SEQUENCE_INFO, LEV_NONE, LEV_SEQUENCE, LEV_NONE)
int get_header_length() const
Definition: ed4_flags.hxx:107
#define e4_assert(bed)
Definition: ed4_class.hxx:11
const int WIDTH
static int get_species(char *species_string, unsigned int species_number, char *buffer)
Definition: ali_main.cxx:97
GB_ERROR GB_incur_error_if(bool error_may_occur)
Definition: arb_msg.h:56
#define MAXNAMELEN
void ED4_correctBlocktypeAfterSelection()
Definition: ED4_block.cxx:363
void init(ED4_sequence_info_terminal *, ED4_sequence_terminal *, ED4_sequence_info_terminal *, ED4_columnStat_terminal *)
LineVector left_edge() const
bool has_property(ED4_properties prop) const
Definition: ed4_class.hxx:976
void world_to_win_coords(AW_pos *xPtr, AW_pos *yPtr) const
Definition: ed4_class.hxx:353
const AW::Position & calc_world_coords() const
Definition: ed4_class.hxx:987
const char * read_char_pntr() const
Definition: AW_awar.cxx:171
int get_min_flag_distance() const
Definition: ed4_flags.hxx:117
static ED4_objspec column_stat_terminal_spec(PROP_IS_TERMINAL, LEV_COL_STAT, LEV_NONE, LEV_NONE, LEV_NONE)
GB_CSTR GB_read_bytes_pntr(GBDATA *gbd)
Definition: arbdb.cxx:958
GB_ERROR GB_write_lossless_byte(GBDATA *gbd, uint8_t byte)
Definition: arbdb.cxx:1502
uchar flags
Definition: probe_tree.h:38
size_t GB_read_string_count(GBDATA *gbd)
Definition: arbdb.cxx:910
#define ED4_AWAR_NDS_ECOLI_NAME
Definition: ed4_awars.hxx:74
double AW_pos
Definition: aw_base.hxx:29
static ED4_objspec sequence_terminal_spec(PROP_IS_TERMINAL, LEV_SEQUENCE_STRING, LEV_NONE, LEV_NONE, LEV_NONE)
Definition: arbdb.h:67
Definition: arbdb.h:78
char * ARB_strduplen(const char *p, unsigned len)
Definition: arb_string.h:33
GB_TYPES GB_read_type(GBDATA *gbd)
Definition: arbdb.cxx:1641
int SEQ_TERM_TEXT_YOFFSET
Definition: ED4_main.cxx:53
ED4_index members() const
Definition: ed4_class.hxx:796
unsigned int clear_at_refresh
Definition: ed4_defs.hxx:299
TYPE * ARB_alloc(size_t nelem)
Definition: arb_mem.h:56
ED4_window * next
Definition: ed4_class.hxx:705
void ED4_no_dangerous_modes()
Definition: ED4_root.cxx:1207
ED4_returncode
Definition: ed4_defs.hxx:160
void push_clip_scale()
Definition: AW_device.cxx:91
SpeciesFlagList::const_iterator SpeciesFlagCiter
Definition: ed4_flags.hxx:69
bool contains(int pos) const
Definition: pos_range.h:83
GBDATA * get_gb_main() const
Definition: ed4_class.hxx:1420
int sequence_to_screen(int sequence_pos) const
ED4_returncode add_to_selected(ED4_species_name_terminal *object)
Definition: ED4_root.cxx:380
#define X_POS
Definition: ed4_defs.hxx:72
int get_length() const OVERRIDE
Definition: ed4_class.hxx:1996
static int group[MAXN+1]
Definition: ClustalV.cxx:65
void init()
Definition: ED4_cursor.cxx:383
ED4_multi_species_manager * ED4_find_MoreSequences_manager()
Definition: ED4_cursor.cxx:560
void set_refresh(int value)
Definition: ed4_defs.hxx:310
struct ED4_terminal::@8 tflag
double height() const
ED4_sequence_terminal(const char *id, AW_pos width, AW_pos height, ED4_manager *parent, bool shall_display_secstruct_info_)
NOT4PERL uint8_t GB_read_lossless_byte(GBDATA *gbd, GB_ERROR &error)
Definition: arbdb.cxx:1087
#define false
Definition: ureadseq.h:13
bool line(int gc, const AW::LineVector &Line, AW_bitset filteri=AW_ALL_DEVICES_SCALED)
Definition: aw_device.hxx:430
void pop_clip_scale()
Definition: AW_device.cxx:62
ED4_window * first_window
Definition: ed4_class.hxx:1426
static void error(const char *msg)
Definition: mkptypes.cxx:96
int get_length() const OVERRIDE
ED4_returncode show_clicked_cursor(AW_pos click_xpos, ED4_terminal *target_terminal)
void PV_RefreshWindow(AW_root *root)
const Position & upper_left_corner() const
bool calc_bounding_box() FINAL_OVERRIDE
bool set_size_does_change(int idx, AW_pos value)
Definition: ed4_defs.hxx:267
ED4_base * object
Definition: ed4_defs.hxx:240
ED4_root_group_manager * root_group_man
Definition: ed4_class.hxx:1430
bool STAT_update_ml_likelihood(ST_ML *st_ml, char *result[4], int &latest_update, const char *species_name, AP_tree *node)
Definition: ST_window.cxx:122
bool ED4_get_selected_range(ED4_terminal *term, PosRange &range)
Definition: ED4_block.cxx:352
ED4_line_terminal(const char *id, AW_pos width, AW_pos height, ED4_manager *parent)
#define CHARACTEROFFSET
Definition: ed4_defs.hxx:110
int find_significant_positions(int sig, int like_A, int like_C, int like_G, int like_TU, int *sumPtr)
#define AWAR_SPECIES_NAME
#define AWAR_SAI_NAME
ED4_terminal(const ED4_objspec &spec_, GB_CSTR id, AW_pos width, AW_pos height, ED4_manager *parent)
void calc_world_coords(AW_pos *x, AW_pos *y) const
Definition: ed4_class.hxx:982
int GB_read_flag(GBDATA *gbd)
Definition: arbdb.cxx:2784
AW_awar * awar(const char *awar)
Definition: AW_root.cxx:554
char char_2_gc[256]
GB_ERROR GB_pop_transaction(GBDATA *gbd)
Definition: arbdb.cxx:2512
#define ARROW_LENGTH
AW_pos drag_old_y
Definition: ed4_defs.hxx:248
static ED4_objspec flag_spec(ED4_properties(PROP_IS_TERMINAL|PROP_DYNA_RESIZE), LEV_FLAG, LEV_NONE, LEV_NONE, LEV_NONE)
GB_alignment_type alignment_type
Definition: ed4_class.hxx:1439
ED4_returncode event_sent_by_parent(AW_event *event, AW_window *aww) OVERRIDE
const Vector & diagonal() const
#define dumpEvent(w, e)
#define BUFFERSIZE
ED4_extension extension
Definition: ed4_class.hxx:923
static ED4_objspec tree_terminal_spec(PROP_IS_TERMINAL, LEV_TREE, LEV_NONE, LEV_NONE, LEV_NONE)
int adjust_clipping_rectangle()
Definition: ED4_base.cxx:907
int size() const
Definition: chartable.h:242
GBDATA * GBT_searchOrCreate_itemfield_according_to_changekey(GBDATA *gb_item, const char *field_name, const char *change_key_path)
Definition: adChangeKey.cxx:62
Definition: arbdb.h:72
static ED4_objspec pure_text_terminal_spec(PROP_IS_TERMINAL, LEV_PURE_TEXT, LEV_NONE, LEV_NONE, LEV_NONE)
void Delete() FINAL_OVERRIDE
int aw_question(const char *unique_id, const char *question, const char *buttons, bool sameSizeButtons, const char *helpfile)
Definition: AW_question.cxx:26
Definition: ed4_defs.hxx:246
ED4_returncode update_bases_and_rebuild_consensi(const char *old_seq, int old_len, ED4_base *species, ED4_update_flag update_flag, PosRange range=PosRange::whole())
AW_event_type type
Definition: aw_window.hxx:81
static ED4_objspec bracket_terminal_spec(PROP_IS_TERMINAL, LEV_BRACKET, LEV_NONE, LEV_NONE, LEV_NONE)
ED4_base * width_link
Definition: ed4_class.hxx:921
ED4_cursor & current_cursor()
Definition: ed4_class.hxx:1399
#define IF_ASSERTION_USED(x)
Definition: arb_assert.h:308
AW_pos position[2]
Definition: ed4_defs.hxx:258
unsigned int refresh
Definition: ed4_defs.hxx:298
void GB_write_flag(GBDATA *gbd, long flag)
Definition: arbdb.cxx:2761
AW_pos drag_old_x
Definition: ed4_defs.hxx:248
AW_pos drag_off_x
Definition: ed4_defs.hxx:247
void ED4_setColumnblockCorner(AW_event *event, ED4_sequence_terminal *seq_term)
Definition: ED4_block.cxx:465
ED4_returncode kill_object()
static ED4_objspec orf_terminal_spec(PROP_IS_TERMINAL, LEV_ORF, LEV_NONE, LEV_NONE, LEV_NONE)
static ED4_objspec spacer_terminal_spec(ED4_properties(PROP_IS_TERMINAL|PROP_DYNA_RESIZE), LEV_SPACER, LEV_NONE, LEV_NONE, LEV_NONE)
AW_MouseButton button
Definition: aw_window.hxx:86
ED4_abstract_sequence_terminal(const ED4_objspec &spec_, const char *id, AW_pos width, AW_pos height, ED4_manager *parent)
ED4_returncode draw_drag_box(AW_pos x, AW_pos y, GB_CSTR text=NULp, int cursor_y=-1)
GB_ERROR write_sequence(const char *seq, int seq_len)
ED4_window * current_ed4w()
Definition: ed4_class.hxx:1397
ED4_seq_colors * sequence_colors
Definition: ed4_class.hxx:1441
FlagLayout(const Rectangle &area, const SpeciesFlags &flags)
AW_root * aw_root
Definition: ed4_class.hxx:1423
ItemSelector & SPECIES_get_selector()
Definition: species.cxx:139
ED4_properties
Definition: ed4_defs.hxx:175
virtual void draw()=0
~ED4_terminal() OVERRIDE
uint32_t GBS_checksum(const char *seq, int ignore_case, const char *exclude)
Definition: adstring.cxx:353
void request_refresh(int clear=1) FINAL_OVERRIDE
void aw_message(const char *msg)
Definition: AW_status.cxx:932
void select_all(bool only_species)
ED4_returncode refresh_requested_by_child()
AW_root * get_root()
Definition: aw_window.hxx:348
AW_pos end_x
Definition: ed4_defs.hxx:241
long GB_read_clock(GBDATA *gbd)
Definition: arbdb.cxx:1712
ED4_species_manager * containing_species_manager() const
Definition: ed4_class.hxx:1829
#define NULp
Definition: cxxforward.h:97
GB_CSTR GB_read_bits_pntr(GBDATA *gbd, char c_0, char c_1)
Definition: arbdb.cxx:920
unsigned int resize
Definition: ed4_defs.hxx:297
int is_area_manager() const
Definition: ed4_class.hxx:1109
const ED4_remap * remap() const
Definition: ed4_class.hxx:1780
int end() const
Definition: pos_range.h:61
AW::Rectangle get_win_area(ED4_window *ed4w) const
Definition: ed4_class.hxx:1011
void request_resize_of_linked()
GB_ERROR write_string(const char *aw_string)
AW_pos end_y
Definition: ed4_defs.hxx:241
ED4_returncode search_target_species(ED4_extension *location, ED4_properties prop, ED4_base **found_member, ED4_level return_level)
int is_sequence_terminal() const
Definition: ed4_class.hxx:1082
int is_flag_terminal() const
Definition: ed4_class.hxx:1093
const char * GBT_get_name(GBDATA *gb_item)
Definition: aditem.cxx:450
ED4_species_mode species_mode
Definition: ed4_class.hxx:1435
char * resolve_pointer_to_string_copy(int *str_len=NULp) const FINAL_OVERRIDE
GB_TYPES
Definition: arbdb.h:62
int is_bracket_terminal() const
Definition: ed4_class.hxx:1088
static ED4_objspec flag_header_spec(ED4_properties(PROP_IS_TERMINAL|PROP_DYNA_RESIZE), LEV_FLAG_HEADER, LEV_NONE, LEV_NONE, LEV_NONE)
GB_transaction ta(gb_var)
bool box(int gc, AW::FillStyle filled, const AW::Rectangle &rect, AW_bitset filteri=AW_ALL_DEVICES_SCALED)
Definition: aw_device.hxx:471
GB_CSTR GB_read_char_pntr(GBDATA *gbd)
Definition: arbdb.cxx:898
int INFO_TERM_TEXT_YOFFSET
Definition: ED4_main.cxx:52
GBDATA * gb_main
Definition: adname.cxx:33
Definition: arbdb.h:71
ED4_base * height_link
Definition: ed4_class.hxx:922
ED4_device_manager * get_device_manager()
Definition: ed4_class.hxx:2227
ED4_manager * get_parent(ED4_level lev) const
Definition: ed4_class.hxx:1820
void set_clear_at_refresh(int value)
Definition: ed4_defs.hxx:307
void update_consensus(ED4_manager *old_parent, ED4_manager *new_parent, ED4_base *sequence)
#define min(a, b)
Definition: f2c.h:153
void move_box(double new_flag_centerx)
static ED4_objspec line_terminal_spec(ED4_properties(PROP_IS_TERMINAL|PROP_DYNA_RESIZE), LEV_LINE, LEV_NONE, LEV_NONE, LEV_NONE)
#define HEIGHT
Definition: ed4_defs.hxx:75
void Show(bool refresh_all, bool is_cleared) OVERRIDE
const char * GB_CSTR
Definition: arbdb_base.h:25
int is_group_manager() const
Definition: ed4_class.hxx:1104
int old_event_y
Definition: ed4_defs.hxx:250
bool text(int gc, const SizedCstr &cstr, const AW::Position &pos, AW_pos alignment=0.0, AW_bitset filteri=AW_ALL_DEVICES_UNSCALED)
Definition: aw_device.hxx:440
void move(const Vector &movement)
long ED4_index
Definition: ed4_defs.hxx:114
GBDATA * GB_entry(GBDATA *father, const char *key)
Definition: adquery.cxx:334
int is_species_name_terminal() const
Definition: ed4_class.hxx:1079
ST_ML * st_ml
Definition: ed4_class.hxx:1443
void aw_message_if(GB_ERROR error)
Definition: aw_msg.hxx:21
ED4_consensus_sequence_terminal(const char *id, AW_pos width, AW_pos height, ED4_manager *parent)
Definition: arbdb.h:66
static ED4_objspec species_name_terminal_spec(ED4_properties(PROP_IS_TERMINAL|PROP_DYNA_RESIZE), LEV_SPECIES_NAME, LEV_NONE, LEV_SPECIES, LEV_NONE)
#define max(a, b)
Definition: f2c.h:154
GB_write_int const char s
Definition: AW_awar.cxx:156