1 | #include <arbdbt.h> |
---|
2 | #include <ad_cb.h> |
---|
3 | |
---|
4 | #include <aw_preset.hxx> |
---|
5 | #include <aw_awar.hxx> |
---|
6 | #include <aw_msg.hxx> |
---|
7 | #include <aw_root.hxx> |
---|
8 | #include <aw_question.hxx> |
---|
9 | |
---|
10 | #include <arb_progress.h> |
---|
11 | #include <arb_strbuf.h> |
---|
12 | |
---|
13 | #include <ed4_extern.hxx> |
---|
14 | |
---|
15 | #include "ed4_class.hxx" |
---|
16 | #include "ed4_awars.hxx" |
---|
17 | #include "ed4_edit_string.hxx" |
---|
18 | #include "ed4_list.hxx" |
---|
19 | |
---|
20 | ED4_group_manager *ED4_base::is_in_folded_group() const { |
---|
21 | if (!parent) return NULL; |
---|
22 | ED4_base *group = get_parent(LEV_GROUP); |
---|
23 | if (!group) return NULL; |
---|
24 | if (group->has_property(PROP_IS_FOLDED)) return group->to_group_manager(); |
---|
25 | return group->is_in_folded_group(); |
---|
26 | } |
---|
27 | |
---|
28 | void ED4_base::changed_by_database() |
---|
29 | { |
---|
30 | e4_assert(0); |
---|
31 | // this happens if you add a new species_pointer to a ED4_base-derived type |
---|
32 | // without defining changed_by_database for this type |
---|
33 | } |
---|
34 | |
---|
35 | void ED4_manager::changed_by_database() { request_refresh(); } |
---|
36 | |
---|
37 | void ED4_terminal::changed_by_database() |
---|
38 | { |
---|
39 | if (GB_read_clock(GLOBAL_gb_main) > curr_timestamp) { // only if timer_cb occurred after last change by EDIT4 |
---|
40 | |
---|
41 | // test if alignment length has changed: |
---|
42 | { |
---|
43 | GBDATA *gb_alignment = GBT_get_alignment(GLOBAL_gb_main, ED4_ROOT->alignment_name); |
---|
44 | e4_assert(gb_alignment); |
---|
45 | GBDATA *gb_alignment_len = GB_search(gb_alignment, "alignment_len", GB_FIND); |
---|
46 | int alignment_length = GB_read_int(gb_alignment_len); |
---|
47 | |
---|
48 | if (MAXSEQUENCECHARACTERLENGTH!=alignment_length) { |
---|
49 | ED4_alignment_length_changed(gb_alignment_len, GB_CB_CHANGED); |
---|
50 | } |
---|
51 | } |
---|
52 | |
---|
53 | GBDATA *gb_seq = get_species_pointer(); |
---|
54 | int type = GB_read_type(gb_seq); |
---|
55 | |
---|
56 | if (type==GB_STRING) { |
---|
57 | char *data = (char*)GB_read_old_value(); |
---|
58 | if (data) { |
---|
59 | int data_len = GB_read_old_size(); |
---|
60 | e4_assert(data_len >= 0); |
---|
61 | char *dup_data = new char[data_len+1]; |
---|
62 | |
---|
63 | memcpy(dup_data, data, data_len); |
---|
64 | dup_data[data_len] = 0; |
---|
65 | |
---|
66 | #if defined(DEBUG) && 0 |
---|
67 | char *n = GB_read_string(gb_seq); |
---|
68 | e4_assert(strcmp(n, dup_data)!=0); // not really changed |
---|
69 | delete n; |
---|
70 | #endif |
---|
71 | |
---|
72 | ED4_species_manager *spman = get_parent(LEV_SPECIES)->to_species_manager(); |
---|
73 | spman->do_callbacks(); |
---|
74 | |
---|
75 | if (has_property(PROP_CONSENSUS_RELEVANT)) { |
---|
76 | ED4_multi_species_manager *multiman = get_parent(LEV_MULTI_SPECIES)->to_multi_species_manager(); |
---|
77 | multiman->update_bases_and_rebuild_consensi(dup_data, data_len, spman, ED4_U_UP); |
---|
78 | request_refresh(); |
---|
79 | } |
---|
80 | |
---|
81 | delete [] dup_data; |
---|
82 | } |
---|
83 | else { // sth else changed (e.g. protection) |
---|
84 | GB_clear_error(); |
---|
85 | } |
---|
86 | } |
---|
87 | } |
---|
88 | } |
---|
89 | |
---|
90 | void ED4_base::deleted_from_database() { |
---|
91 | my_species_pointer.notify_deleted(); |
---|
92 | } |
---|
93 | |
---|
94 | void ED4_terminal::deleted_from_database() { |
---|
95 | ED4_base::deleted_from_database(); |
---|
96 | } |
---|
97 | |
---|
98 | void ED4_text_terminal::deleted_from_database() { |
---|
99 | ED4_terminal::deleted_from_database(); |
---|
100 | parent->Delete(); |
---|
101 | } |
---|
102 | |
---|
103 | void ED4_sequence_terminal::deleted_from_database() |
---|
104 | { |
---|
105 | #if defined(DEBUG) |
---|
106 | printf("ED4_sequence_terminal::deleted_from_database (%p)\n", this); |
---|
107 | #endif // DEBUG |
---|
108 | |
---|
109 | ED4_terminal::deleted_from_database(); |
---|
110 | |
---|
111 | bool was_consensus_relevant = has_property(PROP_CONSENSUS_RELEVANT); |
---|
112 | |
---|
113 | clr_property(ED4_properties(PROP_CONSENSUS_RELEVANT|PROP_ALIGNMENT_DATA)); |
---|
114 | |
---|
115 | if (was_consensus_relevant) { |
---|
116 | const char *data = (const char*)GB_read_old_value(); |
---|
117 | int data_len = GB_read_old_size(); |
---|
118 | |
---|
119 | ED4_multi_species_manager *multi_species_man = get_parent(LEV_MULTI_SPECIES)->to_multi_species_manager(); |
---|
120 | |
---|
121 | multi_species_man->update_bases(data, data_len, 0); |
---|
122 | multi_species_man->rebuild_consensi(get_parent(LEV_SPECIES)->to_species_manager(), ED4_U_UP); |
---|
123 | } |
---|
124 | |
---|
125 | parent->Delete(); |
---|
126 | } |
---|
127 | |
---|
128 | void ED4_manager::deleted_from_database() { |
---|
129 | if (is_species_manager()) { |
---|
130 | ED4_species_manager *species_man = to_species_manager(); |
---|
131 | ED4_multi_species_manager *multi_man = species_man->parent->to_multi_species_manager(); |
---|
132 | |
---|
133 | multi_man->remove_member(species_man); |
---|
134 | GB_push_transaction(GLOBAL_gb_main); |
---|
135 | multi_man->update_consensus(multi_man, 0, species_man); |
---|
136 | multi_man->rebuild_consensi(species_man, ED4_U_UP); |
---|
137 | GB_pop_transaction(GLOBAL_gb_main); |
---|
138 | |
---|
139 | request_resize(); |
---|
140 | // parent = 0; |
---|
141 | // delete this; // @@@ crashes when removing callback deleted_from_database() |
---|
142 | } |
---|
143 | else { |
---|
144 | e4_assert(0); |
---|
145 | } |
---|
146 | } |
---|
147 | |
---|
148 | static void sequence_changed_cb(GBDATA *gb_seq, ED4_base *base, GB_CB_TYPE gbtype) { |
---|
149 | if (base->get_species_pointer()!=gb_seq) { |
---|
150 | e4_assert(0); |
---|
151 | aw_message("Illegal callback (ED4_sequence_changed_cb())"); |
---|
152 | } |
---|
153 | |
---|
154 | if (gbtype&GB_CB_DELETE) { |
---|
155 | e4_assert(gbtype==GB_CB_DELETE); |
---|
156 | base->deleted_from_database(); |
---|
157 | } |
---|
158 | |
---|
159 | if (gbtype&GB_CB_CHANGED) { |
---|
160 | base->changed_by_database(); |
---|
161 | } |
---|
162 | |
---|
163 | if (gbtype&GB_CB_SON_CREATED) { |
---|
164 | // @@@ New son for database-member was created ... what may we do now? |
---|
165 | } |
---|
166 | } |
---|
167 | |
---|
168 | ED4_species_pointer::ED4_species_pointer() { |
---|
169 | species_pointer = 0; |
---|
170 | } |
---|
171 | ED4_species_pointer::~ED4_species_pointer() { |
---|
172 | e4_assert(species_pointer==0); // must be destroyed before |
---|
173 | } |
---|
174 | |
---|
175 | void ED4_species_pointer::addCallback(ED4_base *base) { |
---|
176 | GB_transaction ta(GLOBAL_gb_main); |
---|
177 | GB_add_callback(species_pointer, GB_CB_CHANGED_OR_DELETED, makeDatabaseCallback(sequence_changed_cb, base)); |
---|
178 | } |
---|
179 | void ED4_species_pointer::removeCallback(ED4_base *base) { |
---|
180 | GB_transaction ta(GLOBAL_gb_main); |
---|
181 | GB_remove_callback(species_pointer, GB_CB_CHANGED_OR_DELETED, makeDatabaseCallback(sequence_changed_cb, base)); |
---|
182 | } |
---|
183 | |
---|
184 | void ED4_species_pointer::Set(GBDATA *gbd, ED4_base *base) { |
---|
185 | if (species_pointer) removeCallback(base); |
---|
186 | species_pointer = gbd; |
---|
187 | if (species_pointer) addCallback(base); |
---|
188 | } |
---|
189 | |
---|
190 | // ----------------- |
---|
191 | // ED4_base |
---|
192 | |
---|
193 | inline bool ranges_overlap(int p1, int p2, int r1, int r2) { |
---|
194 | // return true if ranges p1..p2 and r1..r2 overlap |
---|
195 | e4_assert(p1 <= p2); |
---|
196 | e4_assert(r1 <= r2); |
---|
197 | |
---|
198 | return !((r2 <= p1) || (p2 <= r1)); // "exactly adjacent" means "not overlapping" |
---|
199 | } |
---|
200 | |
---|
201 | inline bool range_contained_in(int p1, int p2, int r1, int r2) { |
---|
202 | // return true if range p1..p2 is contained in range r1..r2 |
---|
203 | e4_assert(p1 <= p2); |
---|
204 | e4_assert(r1 <= r2); |
---|
205 | |
---|
206 | return p1 >= r1 && p2 <= r2; |
---|
207 | } |
---|
208 | |
---|
209 | bool ED4_window::partly_shows(int x1, int y1, int x2, int y2) const { |
---|
210 | // return true if rectangle x1/y1/x2/y2 overlaps with clipped screen |
---|
211 | e4_assert(x1 <= x2); |
---|
212 | e4_assert(y1 <= y2); |
---|
213 | |
---|
214 | bool visible = (ranges_overlap(x1, x2, coords.window_left_clip_point, coords.window_right_clip_point) && |
---|
215 | ranges_overlap(y1, y2, coords.window_upper_clip_point, coords.window_lower_clip_point)); |
---|
216 | |
---|
217 | return visible; |
---|
218 | } |
---|
219 | |
---|
220 | bool ED4_window::completely_shows(int x1, int y1, int x2, int y2) const { |
---|
221 | // return true if rectangle x1/y1/x2/y2 is contained in clipped screen |
---|
222 | e4_assert(x1 <= x2); |
---|
223 | e4_assert(y1 <= y2); |
---|
224 | |
---|
225 | bool visible = (range_contained_in(x1, x2, coords.window_left_clip_point, coords.window_right_clip_point) && |
---|
226 | range_contained_in(y1, y2, coords.window_upper_clip_point, coords.window_lower_clip_point)); |
---|
227 | |
---|
228 | return visible; |
---|
229 | } |
---|
230 | |
---|
231 | char *ED4_base::resolve_pointer_to_string_copy(int *) const { return NULL; } |
---|
232 | const char *ED4_base::resolve_pointer_to_char_pntr(int *) const { return NULL; } |
---|
233 | |
---|
234 | ED4_group_manager *ED4_build_group_manager_start(ED4_manager *group_parent, |
---|
235 | GB_CSTR group_name, |
---|
236 | int group_depth, |
---|
237 | bool is_folded, |
---|
238 | ED4_reference_terminals& refterms, |
---|
239 | ED4_multi_species_manager*& multi_species_manager) |
---|
240 | { |
---|
241 | char namebuffer[NAME_BUFFERSIZE]; |
---|
242 | |
---|
243 | sprintf(namebuffer, "Group_Manager.%ld", ED4_counter); // create new group manager |
---|
244 | ED4_group_manager *group_manager = new ED4_group_manager(namebuffer, 0, 0, group_parent); |
---|
245 | group_parent->append_member(group_manager); |
---|
246 | |
---|
247 | sprintf(namebuffer, "Bracket_Terminal.%ld", ED4_counter); |
---|
248 | ED4_bracket_terminal *bracket_terminal = new ED4_bracket_terminal(namebuffer, BRACKET_WIDTH, 0, group_manager); |
---|
249 | group_manager->append_member(bracket_terminal); |
---|
250 | |
---|
251 | sprintf(namebuffer, "MultiSpecies_Manager.%ld", ED4_counter); // create new multi_species_manager |
---|
252 | multi_species_manager = new ED4_multi_species_manager(namebuffer, 0, 0, group_manager); |
---|
253 | group_manager->append_member(multi_species_manager); |
---|
254 | |
---|
255 | if (is_folded) group_manager->set_property(PROP_IS_FOLDED); |
---|
256 | group_manager->set_property(PROP_MOVABLE); |
---|
257 | |
---|
258 | multi_species_manager->set_property(PROP_IS_HANDLE); |
---|
259 | bracket_terminal ->set_property(PROP_IS_HANDLE); |
---|
260 | |
---|
261 | { |
---|
262 | sprintf(namebuffer, "Group_Spacer_Terminal_Beg.%ld", ED4_counter); // spacer at beginning of group |
---|
263 | ED4_spacer_terminal *group_spacer_terminal = new ED4_spacer_terminal(namebuffer, false, 10, SPACER_HEIGHT, multi_species_manager); |
---|
264 | multi_species_manager->append_member(group_spacer_terminal); |
---|
265 | } |
---|
266 | |
---|
267 | { |
---|
268 | sprintf(namebuffer, "Consensus_Manager.%ld", ED4_counter); |
---|
269 | ED4_species_manager *species_manager = new ED4_species_manager(ED4_SP_CONSENSUS, namebuffer, 0, 0, multi_species_manager); |
---|
270 | species_manager->set_property(PROP_MOVABLE); |
---|
271 | multi_species_manager->append_member(species_manager); |
---|
272 | |
---|
273 | { |
---|
274 | ED4_species_name_terminal *species_name_terminal = new ED4_species_name_terminal(group_name, MAXNAME_WIDTH - group_depth*BRACKET_WIDTH, TERMINAL_HEIGHT, species_manager); |
---|
275 | species_name_terminal->set_property((ED4_properties) (PROP_SELECTABLE | PROP_DRAGABLE | PROP_IS_HANDLE)); |
---|
276 | species_name_terminal->set_links(NULL, refterms.sequence()); |
---|
277 | species_manager->append_member(species_name_terminal); |
---|
278 | } |
---|
279 | |
---|
280 | |
---|
281 | { |
---|
282 | // add flag header terminal |
---|
283 | sprintf(namebuffer, "Flag_Header_Terminal.%ld", ED4_counter); |
---|
284 | ED4_flag_header_terminal *flag_header_terminal = new ED4_flag_header_terminal(namebuffer, 100, TERMINAL_HEIGHT, species_manager); |
---|
285 | flag_header_terminal->set_links(NULL, refterms.sequence()); |
---|
286 | species_manager->append_member(flag_header_terminal); |
---|
287 | } |
---|
288 | |
---|
289 | { |
---|
290 | sprintf(namebuffer, "Consensus_Seq_Manager.%ld", ED4_counter); |
---|
291 | ED4_sequence_manager *sequence_manager = new ED4_sequence_manager(namebuffer, 0, 0, species_manager); |
---|
292 | sequence_manager->set_property(PROP_MOVABLE); |
---|
293 | species_manager->append_member(sequence_manager); |
---|
294 | |
---|
295 | { |
---|
296 | ED4_sequence_info_terminal *seq_info_term = new ED4_sequence_info_terminal("CONS", SEQUENCE_INFO_WIDTH, TERMINAL_HEIGHT, sequence_manager); // group info |
---|
297 | seq_info_term->set_both_links(refterms.sequence_info()); |
---|
298 | seq_info_term->set_property((ED4_properties) (PROP_SELECTABLE | PROP_DRAGABLE | PROP_IS_HANDLE)); |
---|
299 | sequence_manager->append_member(seq_info_term); |
---|
300 | } |
---|
301 | |
---|
302 | { |
---|
303 | sprintf(namebuffer, "Consensus_Seq_Terminal.%ld", ED4_counter); |
---|
304 | ED4_sequence_terminal *sequence_terminal = new ED4_consensus_sequence_terminal(namebuffer, 0, TERMINAL_HEIGHT, sequence_manager); |
---|
305 | sequence_terminal->set_property(PROP_CURSOR_ALLOWED); |
---|
306 | sequence_terminal->set_both_links(refterms.sequence()); |
---|
307 | sequence_manager->append_member(sequence_terminal); |
---|
308 | } |
---|
309 | } |
---|
310 | } |
---|
311 | |
---|
312 | bracket_terminal->set_links(NULL, multi_species_manager); |
---|
313 | |
---|
314 | return group_manager; |
---|
315 | } |
---|
316 | |
---|
317 | void ED4_build_group_manager_end(ED4_multi_species_manager *multi_species_manager) { |
---|
318 | char namebuffer[NAME_BUFFERSIZE]; |
---|
319 | |
---|
320 | sprintf(namebuffer, "Group_Spacer_Terminal_End.%ld", ED4_counter); // spacer at end of group |
---|
321 | ED4_spacer_terminal *group_spacer_terminal = new ED4_spacer_terminal(namebuffer, false, 10, SPACER_HEIGHT, multi_species_manager); |
---|
322 | multi_species_manager->append_member(group_spacer_terminal); |
---|
323 | } |
---|
324 | |
---|
325 | void ED4_base::generate_configuration_string(GBS_strstruct& buffer) { |
---|
326 | const char SEPARATOR = '\1'; |
---|
327 | if (is_manager()) { |
---|
328 | ED4_container *container = to_manager(); |
---|
329 | if (is_group_manager()) { |
---|
330 | buffer.put(SEPARATOR); |
---|
331 | buffer.put(has_property(PROP_IS_FOLDED) ? 'F' : 'G'); |
---|
332 | |
---|
333 | for (int writeConsensus = 1; writeConsensus>=0; --writeConsensus) { |
---|
334 | for (int i=0; i<container->members(); ++i) { |
---|
335 | ED4_base *child = container->member(i); |
---|
336 | bool isConsensus = child->is_consensus_manager(); |
---|
337 | |
---|
338 | if (bool(writeConsensus) == isConsensus) { |
---|
339 | child->generate_configuration_string(buffer); |
---|
340 | } |
---|
341 | } |
---|
342 | } |
---|
343 | |
---|
344 | buffer.put(SEPARATOR); |
---|
345 | buffer.put('E'); |
---|
346 | } |
---|
347 | else { |
---|
348 | for (int i=0; i<container->members(); i++) { |
---|
349 | container->member(i)->generate_configuration_string(buffer); |
---|
350 | } |
---|
351 | } |
---|
352 | } |
---|
353 | else { |
---|
354 | if (is_species_name_terminal() && !((ED4_terminal*)this)->tflag.deleted) { |
---|
355 | ED4_species_type species_type = get_species_type(); |
---|
356 | switch (species_type) { |
---|
357 | case ED4_SP_CONSENSUS: { |
---|
358 | // write group name (control info already written inside manager-branch above) |
---|
359 | const char *paren = strchr(id, '('); |
---|
360 | if (paren) { |
---|
361 | int namelen = std::max(int(paren-id)-1, 0); // skip starting at " (" behind consensus name |
---|
362 | |
---|
363 | if (namelen>0) buffer.ncat(id, namelen); |
---|
364 | else buffer.cat("<unnamed>"); |
---|
365 | } |
---|
366 | else buffer.cat(id); |
---|
367 | break; |
---|
368 | } |
---|
369 | case ED4_SP_SAI: |
---|
370 | buffer.put(SEPARATOR); |
---|
371 | buffer.put('S'); |
---|
372 | buffer.cat(resolve_pointer_to_char_pntr(NULL)); |
---|
373 | break; |
---|
374 | case ED4_SP_SPECIES: |
---|
375 | buffer.put(SEPARATOR); |
---|
376 | buffer.put('L'); |
---|
377 | buffer.cat(resolve_pointer_to_char_pntr(NULL)); |
---|
378 | break; |
---|
379 | case ED4_SP_NONE: |
---|
380 | e4_assert(0); |
---|
381 | break; |
---|
382 | } |
---|
383 | } |
---|
384 | } |
---|
385 | } |
---|
386 | |
---|
387 | |
---|
388 | ARB_ERROR ED4_base::route_down_hierarchy(const ED4_route_cb& cb) { |
---|
389 | // executes 'cb' for every element in hierarchy |
---|
390 | return cb(this); |
---|
391 | } |
---|
392 | |
---|
393 | ARB_ERROR ED4_manager::route_down_hierarchy(const ED4_route_cb& cb) { |
---|
394 | ARB_ERROR error = cb(this); |
---|
395 | if (!error) { |
---|
396 | for (int i=0; i<members() && !error; i++) { |
---|
397 | error = member(i)->route_down_hierarchy(cb); |
---|
398 | } |
---|
399 | } |
---|
400 | return error; |
---|
401 | } |
---|
402 | |
---|
403 | ED4_base *ED4_manager::find_first_that(ED4_level level, const ED4_basePredicate& fulfills_predicate) { |
---|
404 | if ((spec.level&level) && fulfills_predicate(this)) { |
---|
405 | return this; |
---|
406 | } |
---|
407 | |
---|
408 | for (int i=0; i<members(); i++) { |
---|
409 | ED4_base *child = member(i); |
---|
410 | |
---|
411 | if (child->is_manager()) { |
---|
412 | ED4_base *found = child->to_manager()->find_first_that(level, fulfills_predicate); |
---|
413 | if (found) { |
---|
414 | return found; |
---|
415 | } |
---|
416 | } |
---|
417 | else if ((child->spec.level&level) && fulfills_predicate(child)) { |
---|
418 | return child; |
---|
419 | } |
---|
420 | } |
---|
421 | |
---|
422 | return 0; |
---|
423 | } |
---|
424 | |
---|
425 | int ED4_base::calc_group_depth() { |
---|
426 | int cntr = 0; |
---|
427 | ED4_base *temp_parent = parent; |
---|
428 | while (temp_parent->parent && !(temp_parent->is_area_manager())) { |
---|
429 | if (temp_parent->is_group_manager()) cntr++; |
---|
430 | temp_parent = temp_parent->parent; |
---|
431 | } |
---|
432 | return cntr; // don't count our own group |
---|
433 | } |
---|
434 | |
---|
435 | ED4_returncode ED4_base::remove_callbacks() // removes callbacks |
---|
436 | { |
---|
437 | return ED4_R_IMPOSSIBLE; |
---|
438 | } |
---|
439 | |
---|
440 | |
---|
441 | ED4_base *ED4_base::search_spec_child_rek(ED4_level level) { // recursive search for level |
---|
442 | return spec.level&level ? this : NULL; |
---|
443 | } |
---|
444 | |
---|
445 | ED4_base *ED4_manager::search_spec_child_rek(ED4_level level) { |
---|
446 | if (spec.level & level) return this; |
---|
447 | |
---|
448 | for (int i=0; i<members(); i++) { // first check children |
---|
449 | if (member(i)->spec.level & level) { |
---|
450 | return member(i); |
---|
451 | } |
---|
452 | } |
---|
453 | |
---|
454 | for (int i=0; i<members(); i++) { |
---|
455 | ED4_base *result = member(i)->search_spec_child_rek(level); |
---|
456 | if (result) { |
---|
457 | return result; |
---|
458 | } |
---|
459 | } |
---|
460 | |
---|
461 | return 0; |
---|
462 | } |
---|
463 | |
---|
464 | ED4_terminal *ED4_base::get_next_terminal() |
---|
465 | { |
---|
466 | ED4_terminal *terminal = 0; |
---|
467 | |
---|
468 | if (parent) { |
---|
469 | terminal = parent->get_first_terminal(index+1); |
---|
470 | if (!terminal) { |
---|
471 | terminal = parent->get_next_terminal(); |
---|
472 | } |
---|
473 | } |
---|
474 | |
---|
475 | return terminal; |
---|
476 | } |
---|
477 | |
---|
478 | ED4_terminal *ED4_base::get_prev_terminal() |
---|
479 | { |
---|
480 | ED4_terminal *terminal = 0; |
---|
481 | |
---|
482 | if (parent) { |
---|
483 | if (index) { |
---|
484 | terminal = parent->get_last_terminal(index-1); |
---|
485 | } |
---|
486 | if (!terminal) { |
---|
487 | terminal = parent->get_prev_terminal(); |
---|
488 | } |
---|
489 | } |
---|
490 | |
---|
491 | return terminal; |
---|
492 | } |
---|
493 | |
---|
494 | |
---|
495 | bool ED4_base::has_parent(ED4_manager *Parent) |
---|
496 | { |
---|
497 | // return true if 'parent' is a parent of this |
---|
498 | |
---|
499 | if (is_manager()) { |
---|
500 | if (this == static_cast<ED4_base*>(Parent)) { |
---|
501 | return true; |
---|
502 | } |
---|
503 | } |
---|
504 | |
---|
505 | if (!parent) return false; |
---|
506 | return parent->has_parent(Parent); |
---|
507 | } |
---|
508 | |
---|
509 | |
---|
510 | ED4_AREA_LEVEL ED4_base::get_area_level(ED4_multi_species_manager **multi_species_manager) const { |
---|
511 | ED4_base *area_base = get_parent(LEV_AREA); |
---|
512 | ED4_AREA_LEVEL result = ED4_A_ERROR; |
---|
513 | |
---|
514 | if (area_base) { |
---|
515 | ED4_area_manager *area_man = area_base->to_area_manager(); |
---|
516 | |
---|
517 | if (area_man == ED4_ROOT->top_area_man) result = ED4_A_TOP_AREA; |
---|
518 | else if (area_man == ED4_ROOT->middle_area_man) result = ED4_A_MIDDLE_AREA; |
---|
519 | |
---|
520 | if (result != ED4_A_ERROR && multi_species_manager) { |
---|
521 | *multi_species_manager = area_man->get_multi_species_manager(); |
---|
522 | } |
---|
523 | } |
---|
524 | return result; |
---|
525 | } |
---|
526 | |
---|
527 | |
---|
528 | void ED4_multi_species_manager::update_group_id() { |
---|
529 | ED4_species_name_terminal *consensus_name_terminal = get_consensus_name_terminal(); |
---|
530 | if (consensus_name_terminal) { // top managers dont show consensus |
---|
531 | e4_assert(has_valid_counters()); |
---|
532 | |
---|
533 | const char *cntid = consensus_name_terminal->id; |
---|
534 | char *name = ARB_calloc<char>(strlen(cntid)+10); |
---|
535 | |
---|
536 | int i; |
---|
537 | for (i=0; cntid[i] && cntid[i] != '('; i++) { |
---|
538 | name[i] = cntid[i]; |
---|
539 | } |
---|
540 | if (i>0 && cntid[i-1] == ' ') --i; // skip terminal space |
---|
541 | sprintf(name+i, " (%d)", species); |
---|
542 | |
---|
543 | freeset(consensus_name_terminal->id, name); |
---|
544 | |
---|
545 | consensus_name_terminal->request_refresh(); |
---|
546 | } |
---|
547 | } |
---|
548 | |
---|
549 | PosRange ED4_abstract_sequence_terminal::pixel2index(PosRange pixel_range) { |
---|
550 | int length_of_char = ED4_ROOT->font_group.get_width(ED4_G_SEQUENCES); |
---|
551 | |
---|
552 | int left_index = int((pixel_range.start()-CHARACTEROFFSET)/length_of_char); |
---|
553 | int right_index = int((pixel_range.end() -CHARACTEROFFSET)/length_of_char) + 1; |
---|
554 | |
---|
555 | return PosRange(left_index, std::min(right_index, MAXSEQUENCECHARACTERLENGTH-1)); |
---|
556 | } |
---|
557 | |
---|
558 | PosRange ED4_abstract_sequence_terminal::calc_interval_displayed_in_rectangle(AW_screen_area *rect) { // rect contains win-coords |
---|
559 | AW_pos x, y; |
---|
560 | calc_world_coords(&x, &y); |
---|
561 | current_ed4w()->world_to_win_coords(&x, &y); |
---|
562 | |
---|
563 | int rel_left_x = int(rect->l-x); |
---|
564 | int rel_right_x = int(rect->r-x); |
---|
565 | |
---|
566 | return pixel2index(PosRange(rel_left_x, rel_right_x)); // changed behavior: clip at MAXSEQUENCECHARACTERLENGTH-1 (was MAXSEQUENCECHARACTERLENGTH) |
---|
567 | } |
---|
568 | |
---|
569 | PosRange ED4_abstract_sequence_terminal::calc_update_interval() { |
---|
570 | AW_pos x, y; |
---|
571 | calc_world_coords(&x, &y); |
---|
572 | |
---|
573 | const AW_screen_area& clip_rect = current_device()->get_cliprect(); |
---|
574 | |
---|
575 | int scroll_shift = current_ed4w()->coords.window_left_clip_point-x; // Verschiebung der Sequenz (durch Scrollen) == slider Position |
---|
576 | int rel_left_x = int(clip_rect.l - x + scroll_shift); // Abstand vom linken Terminalrand zum Anfang des Clipping rectangles + scroll_shift |
---|
577 | int rel_right_x = int(clip_rect.r - x + scroll_shift); |
---|
578 | |
---|
579 | return pixel2index(PosRange(rel_left_x, rel_right_x)); |
---|
580 | } |
---|
581 | |
---|
582 | void ED4_manager::create_consensus(ED4_abstract_group_manager *upper_group_manager, arb_progress *progress) { |
---|
583 | // creates consensus |
---|
584 | // is called by group manager |
---|
585 | |
---|
586 | ED4_abstract_group_manager *group_manager_for_child = upper_group_manager; |
---|
587 | |
---|
588 | if (is_abstract_group_manager()) { |
---|
589 | ED4_abstract_group_manager *group_manager = to_abstract_group_manager(); |
---|
590 | |
---|
591 | group_manager->table().init(MAXSEQUENCECHARACTERLENGTH); |
---|
592 | group_manager_for_child = group_manager; |
---|
593 | |
---|
594 | if (progress) progress->inc(); |
---|
595 | } |
---|
596 | |
---|
597 | for (int i=0; i<members(); i++) { |
---|
598 | ED4_base *child = member(i); |
---|
599 | |
---|
600 | if (child->is_species_manager()) { |
---|
601 | ED4_species_manager *species_manager = child->to_species_manager(); |
---|
602 | const ED4_terminal *sequence_data_terminal = species_manager->get_consensus_relevant_terminal(); |
---|
603 | |
---|
604 | if (sequence_data_terminal) { |
---|
605 | int db_pointer_len; |
---|
606 | char *db_pointer = sequence_data_terminal->resolve_pointer_to_string_copy(&db_pointer_len); |
---|
607 | group_manager_for_child->table().add(db_pointer, db_pointer_len); |
---|
608 | e4_assert(!group_manager_for_child->table().empty()); |
---|
609 | free(db_pointer); |
---|
610 | |
---|
611 | if (progress) progress->inc(); |
---|
612 | } |
---|
613 | } |
---|
614 | else if (child->is_group_manager()) { |
---|
615 | ED4_group_manager *sub_group = child->to_group_manager(); |
---|
616 | |
---|
617 | sub_group->create_consensus(sub_group, progress); |
---|
618 | e4_assert(sub_group!=upper_group_manager); |
---|
619 | upper_group_manager->table().add(sub_group->table()); |
---|
620 | #if defined(TEST_CHAR_TABLE_INTEGRITY) |
---|
621 | if (!sub_group->table().empty() && !sub_group->table().is_ignored()) { |
---|
622 | e4_assert(!upper_group_manager->table().empty()); |
---|
623 | } |
---|
624 | #endif |
---|
625 | } |
---|
626 | else if (child->is_manager()) { |
---|
627 | child->to_manager()->create_consensus(group_manager_for_child, progress); |
---|
628 | } |
---|
629 | } |
---|
630 | } |
---|
631 | |
---|
632 | const ED4_terminal *ED4_base::get_consensus_relevant_terminal() const { |
---|
633 | int i; |
---|
634 | |
---|
635 | if (is_terminal()) { |
---|
636 | if (has_property(PROP_CONSENSUS_RELEVANT)) { |
---|
637 | return this->to_terminal(); |
---|
638 | } |
---|
639 | return NULL; |
---|
640 | } |
---|
641 | |
---|
642 | const ED4_manager *manager = this->to_manager(); |
---|
643 | const ED4_terminal *relevant_terminal = 0; |
---|
644 | |
---|
645 | int members = manager->members(); |
---|
646 | |
---|
647 | for (i=0; !relevant_terminal && i<members; ++i) { |
---|
648 | ED4_base *child = manager->member(i); |
---|
649 | relevant_terminal = child->get_consensus_relevant_terminal(); |
---|
650 | } |
---|
651 | |
---|
652 | #if defined(DEBUG) |
---|
653 | if (relevant_terminal) { |
---|
654 | for (; i<members; ++i) { |
---|
655 | ED4_base *child = manager->member(i); |
---|
656 | e4_assert(!child->get_consensus_relevant_terminal()); // there shall be only 1 consensus relevant terminal, since much code assumes that |
---|
657 | } |
---|
658 | } |
---|
659 | #endif // DEBUG |
---|
660 | |
---|
661 | return relevant_terminal; |
---|
662 | } |
---|
663 | |
---|
664 | int ED4_multi_species_manager::count_visible_children() // is called by a multi_species_manager |
---|
665 | { |
---|
666 | int counter = 0; |
---|
667 | |
---|
668 | for (int i=0; i<members(); i++) { |
---|
669 | ED4_base *child = member(i); |
---|
670 | if (child->is_species_manager()) { |
---|
671 | counter ++; |
---|
672 | } |
---|
673 | else if (child->is_group_manager()) { |
---|
674 | ED4_group_manager *group_manager = child->to_group_manager(); |
---|
675 | if (group_manager->has_property(PROP_IS_FOLDED)) { |
---|
676 | counter ++; |
---|
677 | } |
---|
678 | else { |
---|
679 | ED4_multi_species_manager *multi_species_manager = group_manager->get_multi_species_manager(); |
---|
680 | counter += multi_species_manager->count_visible_children(); |
---|
681 | } |
---|
682 | } |
---|
683 | } |
---|
684 | return counter; |
---|
685 | } |
---|
686 | |
---|
687 | |
---|
688 | |
---|
689 | ED4_base *ED4_base::get_parent(ED4_level lev) const |
---|
690 | { |
---|
691 | ED4_base *temp_parent = this->parent; |
---|
692 | |
---|
693 | while (temp_parent && !(temp_parent->spec.level & lev)) { |
---|
694 | temp_parent = temp_parent->parent; |
---|
695 | } |
---|
696 | |
---|
697 | return temp_parent; |
---|
698 | } |
---|
699 | |
---|
700 | void ED4_base::unlink_from_parent() { |
---|
701 | e4_assert(parent); |
---|
702 | parent->remove_member(this); |
---|
703 | } |
---|
704 | |
---|
705 | char *ED4_base::get_name_of_species() { |
---|
706 | char *name = 0; |
---|
707 | ED4_species_manager *species_man = get_parent(LEV_SPECIES)->to_species_manager(); |
---|
708 | if (species_man) { |
---|
709 | ED4_species_name_terminal *species_name = species_man->search_spec_child_rek(LEV_SPECIES_NAME)->to_species_name_terminal(); |
---|
710 | if (species_name) { |
---|
711 | GBDATA *gb_name = species_name->get_species_pointer(); |
---|
712 | if (gb_name) { |
---|
713 | GB_transaction ta(gb_name); |
---|
714 | name = GB_read_as_string(gb_name); |
---|
715 | } |
---|
716 | } |
---|
717 | } |
---|
718 | return name; |
---|
719 | } |
---|
720 | |
---|
721 | ED4_base *ED4_manager::get_defined_level(ED4_level lev) const { |
---|
722 | for (int i=0; i<members(); i++) { // first test direct children .. |
---|
723 | if (member(i)->spec.level & lev) { |
---|
724 | return member(i); |
---|
725 | } |
---|
726 | } |
---|
727 | |
---|
728 | for (int i=0; i<members(); i++) { // .. then all containers |
---|
729 | ED4_base *child = member(i); |
---|
730 | |
---|
731 | if (child->is_multi_species_manager()) { |
---|
732 | return child->to_multi_species_manager()->get_defined_level(lev); |
---|
733 | } |
---|
734 | else if (child->is_group_manager()) { |
---|
735 | return child->to_group_manager()->member(1)->to_multi_species_manager()->get_defined_level(lev); |
---|
736 | } |
---|
737 | else { |
---|
738 | e4_assert(!child->is_manager()); |
---|
739 | } |
---|
740 | } |
---|
741 | return NULL; |
---|
742 | } |
---|
743 | |
---|
744 | ED4_returncode ED4_base::set_width() { |
---|
745 | // sets object length of terminals to Consensus_Name_terminal if existing |
---|
746 | // else to MAXNAME_WIDTH |
---|
747 | |
---|
748 | if (is_species_manager()) { |
---|
749 | ED4_species_manager *species_manager = to_species_manager(); |
---|
750 | |
---|
751 | if (!species_manager->is_consensus_manager()) { |
---|
752 | ED4_multi_name_manager *multi_name_manager = species_manager->get_defined_level(LEV_MULTI_NAME)->to_multi_name_manager(); // case I'm a species |
---|
753 | ED4_species_name_terminal *consensus_terminal = parent->to_multi_species_manager()->get_consensus_name_terminal(); |
---|
754 | |
---|
755 | for (int i=0; i<multi_name_manager->members(); i++) { |
---|
756 | ED4_name_manager *name_manager = multi_name_manager->member(i)->to_name_manager(); |
---|
757 | ED4_base *nameTerm = name_manager->member(0); |
---|
758 | int width = consensus_terminal ? consensus_terminal->extension.size[WIDTH] : MAXNAME_WIDTH; |
---|
759 | |
---|
760 | nameTerm->extension.size[WIDTH] = width; |
---|
761 | nameTerm->request_resize(); |
---|
762 | } |
---|
763 | |
---|
764 | for (int i=0; i<species_manager->members(); i++) { // adjust all managers as far as possible |
---|
765 | ED4_base *smember = species_manager->member(i); |
---|
766 | if (consensus_terminal) { |
---|
767 | ED4_base *kmember = consensus_terminal->parent->member(i); |
---|
768 | if (kmember) { |
---|
769 | smember->extension.position[X_POS] = kmember->extension.position[X_POS]; |
---|
770 | ED4_base::touch_world_cache(); |
---|
771 | } |
---|
772 | } |
---|
773 | else { // got no consensus |
---|
774 | ED4_species_manager *a_species = parent->get_defined_level(LEV_SPECIES)->to_species_manager(); |
---|
775 | if (a_species) { |
---|
776 | smember->extension.position[X_POS] = a_species->member(i)->extension.position[X_POS]; |
---|
777 | ED4_base::touch_world_cache(); |
---|
778 | } |
---|
779 | } |
---|
780 | smember->request_resize(); |
---|
781 | } |
---|
782 | } |
---|
783 | } |
---|
784 | else if (is_group_manager()) { |
---|
785 | ED4_group_manager *group_manager = to_group_manager(); |
---|
786 | ED4_multi_species_manager *multi_species_manager = group_manager->get_multi_species_manager(); |
---|
787 | ED4_species_name_terminal *mark_consensus_terminal = multi_species_manager->get_consensus_name_terminal(); |
---|
788 | ED4_species_name_terminal *consensus_terminal = parent->to_multi_species_manager()->get_consensus_name_terminal(); |
---|
789 | |
---|
790 | if (consensus_terminal) { // we're a group in another group |
---|
791 | mark_consensus_terminal->extension.size[WIDTH] = consensus_terminal->extension.size[WIDTH] - BRACKET_WIDTH; |
---|
792 | } |
---|
793 | else { // we're at the top (no consensus terminal) |
---|
794 | mark_consensus_terminal->extension.size[WIDTH] = MAXNAME_WIDTH - BRACKET_WIDTH; |
---|
795 | } |
---|
796 | |
---|
797 | mark_consensus_terminal->request_resize(); |
---|
798 | |
---|
799 | for (int i=0; i<multi_species_manager->members(); i++) { |
---|
800 | multi_species_manager->member(i)->set_width(); |
---|
801 | } |
---|
802 | |
---|
803 | for (int i=0; i < group_manager->members(); i++) { // for all groups below from us |
---|
804 | if (group_manager->member(i)->is_group_manager()) { |
---|
805 | group_manager->member(i)->set_width(); |
---|
806 | } |
---|
807 | } |
---|
808 | } |
---|
809 | |
---|
810 | return ED4_R_OK; |
---|
811 | } |
---|
812 | |
---|
813 | |
---|
814 | short ED4_base::in_border(AW_pos x, AW_pos y, ED4_movemode mode) // determines if given world coords x and y |
---|
815 | { // are within borders of current object according to move mode |
---|
816 | AW_pos world_x, world_y; |
---|
817 | |
---|
818 | calc_world_coords(&world_x, &world_y); // calculate absolute extension of current object |
---|
819 | |
---|
820 | switch (mode) // which direction ? |
---|
821 | { |
---|
822 | case ED4_M_HORIZONTAL: |
---|
823 | { |
---|
824 | if ((x >= world_x) && (x < (world_x + extension.size[WIDTH]))) |
---|
825 | return (1); // target location is within the borders of parent |
---|
826 | break; |
---|
827 | } |
---|
828 | case ED4_M_VERTICAL: |
---|
829 | { |
---|
830 | if ((y >= world_y) && (y < (world_y + extension.size[HEIGHT]))) |
---|
831 | return (1); // target location is within the borders of parent |
---|
832 | break; |
---|
833 | } |
---|
834 | case ED4_M_FREE: |
---|
835 | { |
---|
836 | return (in_border(x, y, ED4_M_HORIZONTAL) && in_border(x, y, ED4_M_VERTICAL)); |
---|
837 | } |
---|
838 | case ED4_M_NO_MOVE: |
---|
839 | { |
---|
840 | break; |
---|
841 | } |
---|
842 | } |
---|
843 | |
---|
844 | return (0); |
---|
845 | } |
---|
846 | |
---|
847 | |
---|
848 | void ED4_base::calc_rel_coords(AW_pos *x, AW_pos *y) // calculates coordinates relative to current object from given world coords |
---|
849 | { |
---|
850 | AW_pos world_x, world_y; |
---|
851 | |
---|
852 | calc_world_coords(&world_x, &world_y); // calculate world coordinates of current object |
---|
853 | |
---|
854 | *x -= world_x; // calculate relative coordinates by subtracting world |
---|
855 | *y -= world_y; // coords of current object |
---|
856 | } |
---|
857 | |
---|
858 | |
---|
859 | ED4_returncode ED4_base::event_sent_by_parent(AW_event * /* event */, AW_window * /* aww */) |
---|
860 | { |
---|
861 | return (ED4_R_OK); |
---|
862 | } |
---|
863 | |
---|
864 | void ED4_manager::hide_children() { |
---|
865 | for (int i=0; i<members(); i++) { |
---|
866 | ED4_base *child = member(i); |
---|
867 | if (!child->is_spacer_terminal() && !child->is_consensus_manager()) { // don't hide spacer and Consensus |
---|
868 | child->flag.hidden = 1; |
---|
869 | } |
---|
870 | } |
---|
871 | request_resize(); |
---|
872 | } |
---|
873 | |
---|
874 | |
---|
875 | void ED4_manager::unhide_children() { |
---|
876 | for (int i=0; i<members(); i++) { |
---|
877 | member(i)->flag.hidden = 0; // make child visible |
---|
878 | } |
---|
879 | request_resize(); |
---|
880 | } |
---|
881 | |
---|
882 | void ED4_group_manager::unfold() { |
---|
883 | for (int i=0; i<members(); i++) { |
---|
884 | ED4_base *child = member(i); |
---|
885 | |
---|
886 | if (child->is_multi_species_manager()) { |
---|
887 | ED4_multi_species_manager *multi_species_manager = child->to_multi_species_manager(); |
---|
888 | multi_species_manager->unhide_children(); |
---|
889 | } |
---|
890 | } |
---|
891 | |
---|
892 | clr_property(PROP_IS_FOLDED); |
---|
893 | ED4_request_relayout(); |
---|
894 | } |
---|
895 | |
---|
896 | void ED4_group_manager::fold() { |
---|
897 | ED4_multi_species_manager *multi_species_manager = get_defined_level(LEV_MULTI_SPECIES)->to_multi_species_manager(); |
---|
898 | |
---|
899 | bool consensus_shown = false; |
---|
900 | if (!(multi_species_manager->member(1)->is_consensus_manager())) { // if consensus is not at top => move to top |
---|
901 | ED4_manager *consensus_manager = NULL; |
---|
902 | int i; |
---|
903 | for (i=0; i<multi_species_manager->members(); i++) { // search for consensus |
---|
904 | if (multi_species_manager->member(i)->is_consensus_manager()) { |
---|
905 | consensus_manager = multi_species_manager->member(i)->to_manager(); |
---|
906 | break; |
---|
907 | } |
---|
908 | } |
---|
909 | |
---|
910 | if (consensus_manager) { |
---|
911 | multi_species_manager->move_member(i, 1); // move Consensus to top of list |
---|
912 | consensus_manager->extension.position[Y_POS] = SPACER_HEIGHT; |
---|
913 | ED4_base::touch_world_cache(); |
---|
914 | consensus_shown = true; |
---|
915 | } |
---|
916 | } |
---|
917 | else { |
---|
918 | consensus_shown = true; |
---|
919 | } |
---|
920 | |
---|
921 | if (consensus_shown && ED4_ROOT->aw_root->awar(ED4_AWAR_CONSENSUS_SHOW)->read_int()==0) { |
---|
922 | consensus_shown = false; |
---|
923 | } |
---|
924 | |
---|
925 | multi_species_manager->hide_children(); |
---|
926 | set_property(PROP_IS_FOLDED); |
---|
927 | |
---|
928 | ED4_request_relayout(); |
---|
929 | } |
---|
930 | |
---|
931 | void ED4_group_manager::toggle_folding() { |
---|
932 | if (has_property(PROP_IS_FOLDED)) unfold(); |
---|
933 | else fold(); |
---|
934 | } |
---|
935 | void ED4_bracket_terminal::toggle_folding() { |
---|
936 | parent->to_group_manager()->toggle_folding(); |
---|
937 | } |
---|
938 | |
---|
939 | void ED4_base::check_all() |
---|
940 | { |
---|
941 | AW_pos x, y; |
---|
942 | |
---|
943 | calc_world_coords(&x, &y); |
---|
944 | |
---|
945 | printf("Typ des Aufrufers :\t\t\t%s\n", is_manager() ? "Manager" : "Terminal"); |
---|
946 | printf("Name des Aufrufers von Check_All : \t%.30s\n", (id) ? id : "Keine ID"); |
---|
947 | printf("Linke obere Ecke x, y : \t\t%f, %f\n", extension.position[0], extension.position[1]); |
---|
948 | printf("Breite und Hoehe x, y : \t\t%f, %f\n", extension.size[0], extension.size[1]); |
---|
949 | printf("World Coords x, y : \t\t%f, %f\n\n", x, y); |
---|
950 | printf("***********************************************\n\n"); |
---|
951 | } |
---|
952 | |
---|
953 | int ED4_base::adjust_clipping_rectangle() { |
---|
954 | // return 0 if clipping rectangle disappeared (nothing left to draw) |
---|
955 | AW::Rectangle base_area = get_win_area(current_ed4w()); |
---|
956 | return current_device()->reduceClipBorders(base_area.top(), base_area.bottom(), base_area.left(), base_area.right()); |
---|
957 | } |
---|
958 | |
---|
959 | void ED4_base::set_links(ED4_base *width_ref, ED4_base *height_ref) { |
---|
960 | // links 'this' to (one or two) reference terminal(s) |
---|
961 | // => 'this' will resize when size of reference changes (maybe more effects?) |
---|
962 | // (Note: passing NULL means "do not change") |
---|
963 | |
---|
964 | if (width_ref) { |
---|
965 | if (width_link) width_link->linked_objects->remove_elem(this); |
---|
966 | width_link = width_ref; |
---|
967 | if (!width_ref->linked_objects) width_ref->linked_objects = new ED4_base_list; |
---|
968 | width_ref->linked_objects->append_elem(this); |
---|
969 | } |
---|
970 | |
---|
971 | if (height_ref) { |
---|
972 | if (height_link) height_link->linked_objects->remove_elem(this); |
---|
973 | height_link = height_ref; |
---|
974 | if (!height_ref->linked_objects) height_ref->linked_objects = new ED4_base_list; |
---|
975 | height_ref->linked_objects->append_elem(this); |
---|
976 | } |
---|
977 | } |
---|
978 | |
---|
979 | int ED4_base::currTimestamp = 1; |
---|
980 | |
---|
981 | #if defined(DEBUG) |
---|
982 | // #define VISIBLE_AREA_REFRESH |
---|
983 | #endif |
---|
984 | |
---|
985 | ED4_returncode ED4_base::clear_background(int color) { |
---|
986 | if (current_device()) { // @@@ should clear be done for all windows? |
---|
987 | AW_pos x, y; |
---|
988 | calc_world_coords(&x, &y); |
---|
989 | current_ed4w()->world_to_win_coords(&x, &y); |
---|
990 | |
---|
991 | current_device()->push_clip_scale(); |
---|
992 | if (adjust_clipping_rectangle()) { |
---|
993 | if (!color) { |
---|
994 | #if defined(VISIBLE_AREA_REFRESH) |
---|
995 | // for debugging draw each clear in different color: |
---|
996 | static int gc_area = ED4_G_FIRST_COLOR_GROUP; |
---|
997 | |
---|
998 | current_device()->box(gc_area, true, x, y, extension.size[WIDTH], extension.size[HEIGHT]); |
---|
999 | gc_area = (gc_area == ED4_G_LAST_COLOR_GROUP) ? ED4_G_FIRST_COLOR_GROUP : gc_area+1; |
---|
1000 | #else // !defined(VISIBLE_AREA_REFRESH) |
---|
1001 | current_device()->clear_part(x, y, extension.size[WIDTH], extension.size[HEIGHT], AW_ALL_DEVICES); |
---|
1002 | #endif |
---|
1003 | } |
---|
1004 | else { |
---|
1005 | // fill range with color for debugging |
---|
1006 | current_device()->box(color, AW::FillStyle::SOLID, x, y, extension.size[WIDTH], extension.size[HEIGHT]); |
---|
1007 | } |
---|
1008 | } |
---|
1009 | current_device()->pop_clip_scale(); |
---|
1010 | } |
---|
1011 | return (ED4_R_OK); |
---|
1012 | } |
---|
1013 | |
---|
1014 | void ED4_main_manager::clear_whole_background() { |
---|
1015 | // clear AW_MIDDLE_AREA |
---|
1016 | for (ED4_window *window = ED4_ROOT->first_window; window; window=window->next) { |
---|
1017 | AW_device *device = window->get_device(); |
---|
1018 | if (device) { |
---|
1019 | device->push_clip_scale(); |
---|
1020 | device->clear(AW_ALL_DEVICES); |
---|
1021 | device->pop_clip_scale(); |
---|
1022 | } |
---|
1023 | } |
---|
1024 | } |
---|
1025 | |
---|
1026 | void ED4_base::draw_bb(int color) { |
---|
1027 | if (current_device()) { |
---|
1028 | current_device()->push_clip_scale(); |
---|
1029 | if (adjust_clipping_rectangle()) { |
---|
1030 | AW_pos x1, y1; |
---|
1031 | calc_world_coords(&x1, &y1); |
---|
1032 | current_ed4w()->world_to_win_coords(&x1, &y1); |
---|
1033 | current_device()->box(color, AW::FillStyle::EMPTY, x1, y1, extension.size[WIDTH]-1, extension.size[HEIGHT]-1); |
---|
1034 | } |
---|
1035 | current_device()->pop_clip_scale(); |
---|
1036 | } |
---|
1037 | } |
---|
1038 | |
---|
1039 | ED4_base::ED4_base(const ED4_objspec& spec_, GB_CSTR temp_id, AW_pos width, AW_pos height, ED4_manager *temp_parent) |
---|
1040 | : spec(spec_) |
---|
1041 | { |
---|
1042 | index = 0; |
---|
1043 | dynamic_prop = ED4_properties(PROP_NONE | (spec.static_prop & PROP_DYNA_RESIZE)); |
---|
1044 | timestamp = 0; // invalid - almost always.. |
---|
1045 | |
---|
1046 | e4_assert(temp_id); |
---|
1047 | if (temp_id) { |
---|
1048 | id = ARB_alloc<char>(strlen(temp_id)+1); |
---|
1049 | strcpy(id, temp_id); |
---|
1050 | } |
---|
1051 | |
---|
1052 | linked_objects = NULL; |
---|
1053 | |
---|
1054 | extension.position[X_POS] = -1; // position set here has no effect (will be overwritten by next resize) |
---|
1055 | extension.position[Y_POS] = -1; |
---|
1056 | |
---|
1057 | ED4_base::touch_world_cache(); // invalidate position |
---|
1058 | |
---|
1059 | extension.size[WIDTH] = width; |
---|
1060 | extension.size[HEIGHT] = height; |
---|
1061 | |
---|
1062 | extension.y_folded = 0; |
---|
1063 | parent = temp_parent; |
---|
1064 | width_link = NULL; |
---|
1065 | height_link = NULL; |
---|
1066 | |
---|
1067 | memset((char*)&update_info, 0, sizeof(update_info)); |
---|
1068 | memset((char*)&flag, 0, sizeof(flag)); |
---|
1069 | } |
---|
1070 | |
---|
1071 | |
---|
1072 | ED4_base::~ED4_base() { |
---|
1073 | // before calling this function the first time, parent has to be set NULL |
---|
1074 | e4_assert(!parent); // unlink from parent first! |
---|
1075 | |
---|
1076 | if (linked_objects) { |
---|
1077 | ED4_base_list_elem *list_elem = linked_objects->head(); |
---|
1078 | while (list_elem) { |
---|
1079 | ED4_base *object = list_elem->elem(); |
---|
1080 | if (object->width_link == this) { |
---|
1081 | object->width_link->linked_objects->remove_elem(this); // delete link and |
---|
1082 | object->width_link = NULL; |
---|
1083 | } |
---|
1084 | |
---|
1085 | if (object->height_link == this) { |
---|
1086 | object->height_link->linked_objects->remove_elem(this); // delete link and |
---|
1087 | object->height_link = NULL; |
---|
1088 | } |
---|
1089 | |
---|
1090 | ED4_base_list_elem *old_elem = list_elem; |
---|
1091 | list_elem = list_elem->next(); |
---|
1092 | linked_objects->remove_elem(old_elem->elem()); |
---|
1093 | } |
---|
1094 | delete linked_objects; |
---|
1095 | } |
---|
1096 | |
---|
1097 | if (update_info.linked_to_scrolled_rectangle) |
---|
1098 | { |
---|
1099 | if (ED4_ROOT->main_manager) |
---|
1100 | { |
---|
1101 | ED4_base *sequence_terminal = ED4_ROOT->main_manager->search_spec_child_rek(LEV_SEQUENCE_STRING); |
---|
1102 | |
---|
1103 | if (sequence_terminal) |
---|
1104 | sequence_terminal->update_info.linked_to_scrolled_rectangle = 1; |
---|
1105 | |
---|
1106 | update_info.linked_to_scrolled_rectangle = 0; |
---|
1107 | ED4_ROOT->scroll_links.link_for_hor_slider = sequence_terminal; |
---|
1108 | |
---|
1109 | ED4_window *ed4w = ED4_ROOT->first_window; |
---|
1110 | while (ed4w != NULL) { |
---|
1111 | ed4w->scrolled_rect.replace_x_width_link_to(this, sequence_terminal); |
---|
1112 | ed4w = ed4w->next; |
---|
1113 | } |
---|
1114 | } |
---|
1115 | } |
---|
1116 | |
---|
1117 | if (width_link) { |
---|
1118 | width_link->linked_objects->remove_elem(this); |
---|
1119 | width_link = NULL; |
---|
1120 | } |
---|
1121 | |
---|
1122 | if (height_link) { |
---|
1123 | height_link->linked_objects->remove_elem(this); |
---|
1124 | height_link = NULL; |
---|
1125 | } |
---|
1126 | |
---|
1127 | set_species_pointer(0); // clear pointer to database and remove callbacks |
---|
1128 | free(id); |
---|
1129 | } |
---|
1130 | |
---|