1 | #include <stdio.h> |
---|
2 | #include <stdlib.h> |
---|
3 | #include <string.h> |
---|
4 | #include <ctype.h> |
---|
5 | #include <math.h> |
---|
6 | |
---|
7 | #include <arbdb.h> |
---|
8 | #include <arbdbt.h> |
---|
9 | #include <ad_config.h> |
---|
10 | |
---|
11 | #include <aw_root.hxx> |
---|
12 | #include <aw_keysym.hxx> |
---|
13 | #include <aw_window.hxx> |
---|
14 | #include <aw_awars.hxx> |
---|
15 | #include <AW_helix.hxx> |
---|
16 | #include <awt.hxx> |
---|
17 | #include <awt_item_sel_list.hxx> |
---|
18 | #include <awt_sel_boxes.hxx> |
---|
19 | #include <awt_seq_colors.hxx> |
---|
20 | #include <AW_rename.hxx> |
---|
21 | |
---|
22 | #include <st_window.hxx> |
---|
23 | |
---|
24 | #include <ed4_extern.hxx> |
---|
25 | |
---|
26 | #include "ed4_awars.hxx" |
---|
27 | #include "ed4_class.hxx" |
---|
28 | #include "ed4_edit_string.hxx" |
---|
29 | #include "ed4_tools.hxx" |
---|
30 | #include "ed4_nds.hxx" |
---|
31 | |
---|
32 | //************************************************* |
---|
33 | //* functions concerning no class beginning * |
---|
34 | //* Most functions are callback functions * |
---|
35 | //************************************************* |
---|
36 | |
---|
37 | void ED4_calc_terminal_extentions(){ |
---|
38 | const AW_font_information *seq_font_info = ED4_ROOT->get_device()->get_font_information( ED4_G_SEQUENCES, '=' ); |
---|
39 | const AW_font_information *info_font_info = ED4_ROOT->get_device()->get_font_information( ED4_G_STANDARD, '.' ); |
---|
40 | |
---|
41 | int info_char_width = info_font_info->max_letter.width; |
---|
42 | int seq_term_descent; |
---|
43 | |
---|
44 | if (ED4_ROOT->helix->is_enabled() || ED4_ROOT->protstruct) { // display helix ? |
---|
45 | ED4_ROOT->helix_spacing = |
---|
46 | seq_font_info->this_letter.ascent // the ascent of '=' |
---|
47 | + ED4_ROOT->helix_add_spacing; // xtra user-defined spacing |
---|
48 | |
---|
49 | seq_term_descent = ED4_ROOT->helix_spacing; |
---|
50 | } |
---|
51 | else { |
---|
52 | ED4_ROOT->helix_spacing = 0; |
---|
53 | seq_term_descent = seq_font_info->max_letter.descent; |
---|
54 | } |
---|
55 | |
---|
56 | // for wanted_seq_term_height ignore descent, because it additionally allocates 'ED4_ROOT->helix_spacing' space: |
---|
57 | int wanted_seq_term_height = seq_font_info->max_letter.ascent + seq_term_descent + ED4_ROOT->terminal_add_spacing; |
---|
58 | int wanted_seq_info_height = info_font_info->max_letter.height + ED4_ROOT->terminal_add_spacing; |
---|
59 | |
---|
60 | TERMINALHEIGHT = (wanted_seq_term_height>wanted_seq_info_height) ? wanted_seq_term_height : wanted_seq_info_height; |
---|
61 | |
---|
62 | { |
---|
63 | int maxchars; |
---|
64 | int maxbrackets; |
---|
65 | |
---|
66 | ED4_get_NDS_sizes(&maxchars, &maxbrackets); |
---|
67 | MAXSPECIESWIDTH = |
---|
68 | (maxchars+1)*info_char_width + // width defined in NDS window plus 1 char for marked-box |
---|
69 | maxbrackets*BRACKETWIDTH; // brackets defined in NDS window |
---|
70 | } |
---|
71 | MAXINFOWIDTH = CHARACTEROFFSET + info_char_width*ED4_ROOT->aw_root->awar(ED4_AWAR_NDS_INFO_WIDTH)->read_int() + 1; |
---|
72 | |
---|
73 | INFO_TERM_TEXT_YOFFSET = info_font_info->max_letter.ascent - 1; |
---|
74 | SEQ_TERM_TEXT_YOFFSET = seq_font_info->max_letter.ascent - 1; |
---|
75 | |
---|
76 | if (INFO_TERM_TEXT_YOFFSET<SEQ_TERM_TEXT_YOFFSET) INFO_TERM_TEXT_YOFFSET = SEQ_TERM_TEXT_YOFFSET; |
---|
77 | |
---|
78 | #if defined(DEBUG) && 0 |
---|
79 | printf("seq_term_descent= %i\n", seq_term_descent); |
---|
80 | printf("TERMINALHEIGHT = %i\n", TERMINALHEIGHT); |
---|
81 | printf("MAXSPECIESWIDTH = %i\n", MAXSPECIESWIDTH); |
---|
82 | printf("MAXINFOWIDTH = %i\n", MAXINFOWIDTH); |
---|
83 | printf("INFO_TERM_TEXT_YOFFSET= %i\n", INFO_TERM_TEXT_YOFFSET); |
---|
84 | printf("SEQ_TERM_TEXT_YOFFSET= %i\n", SEQ_TERM_TEXT_YOFFSET); |
---|
85 | #endif // DEBUG |
---|
86 | } |
---|
87 | |
---|
88 | void ED4_expose_recalculations() { |
---|
89 | ED4_ROOT->recalc_font_group(); |
---|
90 | ED4_calc_terminal_extentions(); |
---|
91 | |
---|
92 | #if defined(DEBUG) |
---|
93 | #warning below calculations have to be done at startup as well - maybe call expose_cb once after create_hierarchy. |
---|
94 | #endif // DEBUG |
---|
95 | |
---|
96 | ED4_ROOT->ref_terminals.get_ref_sequence_info()->extension.size[HEIGHT] = TERMINALHEIGHT; |
---|
97 | ED4_ROOT->ref_terminals.get_ref_sequence()->extension.size[HEIGHT] = TERMINALHEIGHT; |
---|
98 | ED4_ROOT->ref_terminals.get_ref_sequence_info()->extension.size[WIDTH] = MAXINFOWIDTH; |
---|
99 | |
---|
100 | int screenwidth = ED4_ROOT->root_group_man->remap()->sequence_to_screen(MAXSEQUENCECHARACTERLENGTH); |
---|
101 | while (1) { |
---|
102 | ED4_ROOT->ref_terminals.get_ref_sequence()->extension.size[WIDTH] = |
---|
103 | ED4_ROOT->font_group.get_width(ED4_G_SEQUENCES) * |
---|
104 | (screenwidth+3); |
---|
105 | |
---|
106 | ED4_terminal *top_middle_line_terminal = ED4_ROOT->main_manager->get_top_middle_line_terminal(); |
---|
107 | |
---|
108 | ED4_ROOT->main_manager->get_top_middle_spacer_terminal()->extension.size[HEIGHT] = TERMINALHEIGHT - top_middle_line_terminal->extension.size[HEIGHT]; |
---|
109 | |
---|
110 | ED4_ROOT->main_manager->route_down_hierarchy(NULL, NULL, &update_terminal_extension ); |
---|
111 | ED4_ROOT->resize_all(); // may change mapping |
---|
112 | |
---|
113 | int new_screenwidth = ED4_ROOT->root_group_man->remap()->sequence_to_screen(MAXSEQUENCECHARACTERLENGTH); |
---|
114 | if (new_screenwidth == screenwidth) { // mapping did not change |
---|
115 | break; |
---|
116 | } |
---|
117 | screenwidth = new_screenwidth; |
---|
118 | } |
---|
119 | |
---|
120 | ED4_ROOT->get_ed4w()->update_scrolled_rectangle(); |
---|
121 | } |
---|
122 | |
---|
123 | void ED4_expose_cb( AW_window *aww, AW_CL cd1, AW_CL cd2 ) |
---|
124 | { |
---|
125 | static bool dummy = 0; |
---|
126 | |
---|
127 | AWUSE(aww); |
---|
128 | AWUSE(cd1); |
---|
129 | AWUSE(cd2); |
---|
130 | |
---|
131 | ED4_ROOT->use_window(aww); |
---|
132 | |
---|
133 | GB_push_transaction(GLOBAL_gb_main); |
---|
134 | |
---|
135 | if (!dummy) { |
---|
136 | dummy = 1; |
---|
137 | } |
---|
138 | else { |
---|
139 | ED4_expose_recalculations(); // this case is needed every time, except the first |
---|
140 | } |
---|
141 | |
---|
142 | ED4_ROOT->get_ed4w()->update_window_coords(); |
---|
143 | |
---|
144 | ED4_ROOT->get_device()->reset(); |
---|
145 | ED4_ROOT->refresh_window(1); |
---|
146 | |
---|
147 | GB_pop_transaction(GLOBAL_gb_main); |
---|
148 | } |
---|
149 | |
---|
150 | void ED4_resize_cb( AW_window *aww, AW_CL cd1, AW_CL cd2 ) |
---|
151 | { |
---|
152 | AWUSE(aww); |
---|
153 | AWUSE(cd1); |
---|
154 | AWUSE(cd2); |
---|
155 | |
---|
156 | ED4_ROOT->use_window(aww); |
---|
157 | |
---|
158 | GB_push_transaction(GLOBAL_gb_main); |
---|
159 | |
---|
160 | ED4_ROOT->get_device()->reset(); |
---|
161 | // ED4_ROOT->deselect_all(); |
---|
162 | |
---|
163 | ED4_ROOT->get_ed4w()->update_scrolled_rectangle(); |
---|
164 | |
---|
165 | ED4_ROOT->get_ed4w()->slider_pos_horizontal= aww->slider_pos_horizontal; |
---|
166 | ED4_ROOT->get_ed4w()->slider_pos_vertical = aww->slider_pos_vertical; |
---|
167 | |
---|
168 | GB_pop_transaction(GLOBAL_gb_main); |
---|
169 | } |
---|
170 | |
---|
171 | ED4_returncode call_edit( void **error, void **work_info_ptr, ED4_base *object ) // called after editing consensus to edit single sequences |
---|
172 | { |
---|
173 | ED4_work_info *work_info = (ED4_work_info*)(*work_info_ptr); |
---|
174 | ED4_work_info new_work_info; |
---|
175 | ED4_base *species_manager = NULL; |
---|
176 | // ED4_manager *temp_parent; |
---|
177 | GB_TYPES gb_type; |
---|
178 | |
---|
179 | if (((char **) error)[0] || !object->is_terminal()) |
---|
180 | return ED4_R_BREAK; |
---|
181 | |
---|
182 | if (object->get_species_pointer()) { |
---|
183 | gb_type = GB_read_type(object->get_species_pointer()); |
---|
184 | } |
---|
185 | else { |
---|
186 | gb_type = GB_NONE; |
---|
187 | } |
---|
188 | |
---|
189 | species_manager = object->get_parent( ED4_L_SPECIES ); |
---|
190 | |
---|
191 | if (!species_manager || species_manager->flag.is_SAI) { // don't edit SAI's if editing the consensus |
---|
192 | return ED4_R_BREAK; |
---|
193 | } |
---|
194 | |
---|
195 | if ((object->dynamic_prop & ED4_P_CURSOR_ALLOWED) && |
---|
196 | !species_manager->flag.is_consensus && |
---|
197 | (object->dynamic_prop & ED4_P_ALIGNMENT_DATA)) // edit all aligned data - even if not consensus relevant |
---|
198 | { |
---|
199 | new_work_info.event = work_info->event; |
---|
200 | new_work_info.char_position = work_info->char_position; |
---|
201 | new_work_info.out_seq_position = work_info->out_seq_position; |
---|
202 | new_work_info.refresh_needed = false; |
---|
203 | new_work_info.cursor_jump = ED4_JUMP_KEEP_VISIBLE; |
---|
204 | new_work_info.out_string = NULL; |
---|
205 | new_work_info.error = NULL; |
---|
206 | new_work_info.mode = work_info->mode; |
---|
207 | new_work_info.direction = work_info->direction; |
---|
208 | new_work_info.cannot_handle = false; |
---|
209 | new_work_info.is_sequence = work_info->is_sequence; |
---|
210 | new_work_info.working_terminal = object->to_terminal(); |
---|
211 | |
---|
212 | if (object->get_species_pointer()) { |
---|
213 | new_work_info.gb_data = object->get_species_pointer(); |
---|
214 | new_work_info.string = NULL; |
---|
215 | } |
---|
216 | else { |
---|
217 | new_work_info.gb_data = NULL; |
---|
218 | new_work_info.string = object->id; |
---|
219 | } |
---|
220 | |
---|
221 | new_work_info.repeat_count = 1; |
---|
222 | |
---|
223 | ED4_ROOT->edit_string->init_edit( ); |
---|
224 | ED4_ROOT->edit_string->edit( &new_work_info ); |
---|
225 | |
---|
226 | // if (ED4_ROOT->edit_string->old_seq) |
---|
227 | // { |
---|
228 | // temp_parent = species_manager->get_parent( ED4_L_MULTI_SPECIES )->to_manager(); |
---|
229 | |
---|
230 | // ((ED4_terminal *)object)->actual_timestamp = GB_read_clock(gb_main); |
---|
231 | |
---|
232 | // char *seq = ED4_ROOT->edit_string->old_seq; |
---|
233 | // int seq_len = ED4_ROOT->edit_string->old_seq_len; |
---|
234 | |
---|
235 | // temp_parent->check_bases(seq, seq_len, species_manager); |
---|
236 | // } |
---|
237 | |
---|
238 | if (new_work_info.error) { |
---|
239 | ((char **) (error))[0] = new_work_info.error; |
---|
240 | } |
---|
241 | else if (new_work_info.out_string) { |
---|
242 | e4_assert(species_manager->flag.is_consensus); |
---|
243 | object->id = new_work_info.out_string; |
---|
244 | } |
---|
245 | |
---|
246 | if (new_work_info.refresh_needed) { |
---|
247 | object->set_refresh(); |
---|
248 | object->parent->refresh_requested_by_child(); |
---|
249 | |
---|
250 | if (object->is_sequence_terminal()) { |
---|
251 | ED4_sequence_terminal *seq_term = object->to_sequence_terminal(); |
---|
252 | seq_term->results().searchAgain(); |
---|
253 | } |
---|
254 | } |
---|
255 | |
---|
256 | if (move_cursor) { |
---|
257 | ED4_ROOT->get_ed4w()->cursor.jump_sequence_pos(ED4_ROOT->get_aww(), new_work_info.out_seq_position, ED4_JUMP_KEEP_VISIBLE); |
---|
258 | move_cursor = 0; |
---|
259 | } |
---|
260 | } |
---|
261 | |
---|
262 | return ED4_R_OK; |
---|
263 | } |
---|
264 | |
---|
265 | static void executeKeystroke(AW_window *aww, AW_event *event, int repeatCount) { |
---|
266 | ED4_work_info *work_info = new ED4_work_info; |
---|
267 | ED4_cursor *cursor = &ED4_ROOT->get_ed4w()->cursor; |
---|
268 | |
---|
269 | if (event->keycode==AW_KEY_NONE) return; |
---|
270 | |
---|
271 | e4_assert(repeatCount>0); |
---|
272 | |
---|
273 | if (!cursor->owner_of_cursor || cursor->owner_of_cursor->flag.hidden) { |
---|
274 | return; |
---|
275 | } |
---|
276 | |
---|
277 | if (event->keycode == AW_KEY_UP || event->keycode == AW_KEY_DOWN || |
---|
278 | ((event->keymodifier & AW_KEYMODE_CONTROL) && |
---|
279 | (event->keycode == AW_KEY_HOME || event->keycode == AW_KEY_END))) |
---|
280 | { |
---|
281 | GB_transaction dummy(GLOBAL_gb_main); |
---|
282 | while (repeatCount--) { |
---|
283 | cursor->move_cursor(event); |
---|
284 | } |
---|
285 | return; |
---|
286 | } |
---|
287 | |
---|
288 | work_info->cannot_handle = false; |
---|
289 | work_info->event = *event; |
---|
290 | work_info->char_position = cursor->get_screen_pos(); |
---|
291 | work_info->out_seq_position = cursor->get_sequence_pos(); |
---|
292 | work_info->refresh_needed = false; |
---|
293 | work_info->cursor_jump = ED4_JUMP_KEEP_VISIBLE; |
---|
294 | work_info->out_string = NULL; // nur falls new malloc |
---|
295 | work_info->error = NULL; |
---|
296 | work_info->repeat_count = repeatCount; |
---|
297 | |
---|
298 | ED4_terminal *terminal = cursor->owner_of_cursor->to_terminal(); |
---|
299 | e4_assert(terminal->is_text_terminal()); |
---|
300 | |
---|
301 | work_info->working_terminal = terminal; |
---|
302 | |
---|
303 | if (terminal->is_sequence_terminal()) { |
---|
304 | work_info->mode = awar_edit_modus; |
---|
305 | work_info->direction = awar_edit_direction; |
---|
306 | work_info->is_sequence = 1; |
---|
307 | } |
---|
308 | else { |
---|
309 | work_info->direction = 1; |
---|
310 | work_info->is_sequence = 0; |
---|
311 | |
---|
312 | if (terminal->is_pure_text_terminal()) { |
---|
313 | work_info->mode = awar_edit_modus; // AD_INSERT; // why is AD_INSERT forced here ? |
---|
314 | } |
---|
315 | else if (terminal->is_columnStat_terminal()) { |
---|
316 | work_info->mode = AD_NOWRITE; |
---|
317 | } |
---|
318 | else { |
---|
319 | e4_assert(0); |
---|
320 | } |
---|
321 | } |
---|
322 | |
---|
323 | work_info->string = NULL; |
---|
324 | work_info->gb_data = NULL; |
---|
325 | |
---|
326 | if (terminal->get_species_pointer()) { |
---|
327 | work_info->gb_data = terminal->get_species_pointer(); |
---|
328 | } |
---|
329 | else if (terminal->is_columnStat_terminal()) { |
---|
330 | work_info->gb_data = terminal->to_columnStat_terminal()->corresponding_sequence_terminal()->get_species_pointer(); |
---|
331 | } |
---|
332 | else { |
---|
333 | work_info->string = terminal->id; |
---|
334 | } |
---|
335 | |
---|
336 | ED4_Edit_String *edit_string = new ED4_Edit_String; |
---|
337 | ED4_species_manager *species_manager = terminal->get_parent(ED4_L_SPECIES)->to_species_manager(); |
---|
338 | char *error = NULL; |
---|
339 | |
---|
340 | GB_push_transaction(GLOBAL_gb_main); |
---|
341 | |
---|
342 | if (species_manager->flag.is_consensus) { |
---|
343 | ED4_group_manager *group_manager = terminal->get_parent(ED4_L_GROUP)->to_group_manager(); |
---|
344 | |
---|
345 | work_info->string = terminal->id = group_manager->table().build_consensus_string(); |
---|
346 | |
---|
347 | edit_string->edit(work_info); |
---|
348 | cursor->jump_sequence_pos(aww, work_info->out_seq_position, ED4_JUMP_KEEP_VISIBLE); |
---|
349 | |
---|
350 | work_info->string = 0; |
---|
351 | |
---|
352 | if (work_info->cannot_handle) { |
---|
353 | // group_manager = terminal->get_parent( ED4_L_GROUP )->to_group_manager(); |
---|
354 | move_cursor = 1; |
---|
355 | if (!ED4_ROOT->edit_string) { |
---|
356 | ED4_ROOT->edit_string = new ED4_Edit_String(); |
---|
357 | } |
---|
358 | group_manager->route_down_hierarchy((void **) &error, (void **) &work_info, call_edit); |
---|
359 | group_manager->rebuild_consensi( group_manager, ED4_U_UP_DOWN); |
---|
360 | } |
---|
361 | |
---|
362 | delete terminal->id; |
---|
363 | terminal->id = 0; |
---|
364 | } |
---|
365 | else { |
---|
366 | edit_string->edit( work_info ); |
---|
367 | |
---|
368 | // ED4_ROOT->main_manager->Show(); // original version |
---|
369 | ED4_ROOT->main_manager->Show(1, 0); // temporary fix for worst-refresh problems |
---|
370 | cursor->jump_sequence_pos(aww, work_info->out_seq_position, work_info->cursor_jump); |
---|
371 | } |
---|
372 | |
---|
373 | edit_string->finish_edit(); |
---|
374 | |
---|
375 | if (work_info->error || (error && *error == 1)) { |
---|
376 | // hier evtl. nochmal route_down_hierarchy aufrufen ?!! |
---|
377 | aw_message(work_info->error); |
---|
378 | GB_abort_transaction(GLOBAL_gb_main); |
---|
379 | ED4_ROOT->refresh_all_windows(0); |
---|
380 | } |
---|
381 | else { |
---|
382 | GB_pop_transaction( GLOBAL_gb_main ); |
---|
383 | |
---|
384 | if (work_info->refresh_needed) { |
---|
385 | GB_transaction dummy(GLOBAL_gb_main); |
---|
386 | |
---|
387 | terminal->set_refresh(); |
---|
388 | terminal->parent->refresh_requested_by_child(); |
---|
389 | if (terminal->is_sequence_terminal()) { |
---|
390 | ED4_sequence_terminal *seq_term = terminal->to_sequence_terminal(); |
---|
391 | seq_term->results().searchAgain(); |
---|
392 | } |
---|
393 | ED4_ROOT->refresh_all_windows(0); |
---|
394 | } |
---|
395 | } |
---|
396 | |
---|
397 | delete edit_string; |
---|
398 | delete work_info; |
---|
399 | } |
---|
400 | |
---|
401 | void ED4_remote_event(AW_event *faked_event) { // keystrokes forwarded from SECEDIT |
---|
402 | executeKeystroke(ED4_ROOT->get_aww(), faked_event, 1); |
---|
403 | } |
---|
404 | |
---|
405 | void ED4_input_cb(AW_window *aww,AW_CL /*cd1*/, AW_CL /*cd2*/) |
---|
406 | { |
---|
407 | AW_event event; |
---|
408 | static AW_event lastEvent; |
---|
409 | static int repeatCount; |
---|
410 | |
---|
411 | ED4_ROOT->use_window(aww); |
---|
412 | |
---|
413 | aww->get_event(&event); |
---|
414 | |
---|
415 | #if defined(DEBUG) && 0 |
---|
416 | printf("event.type=%i event.keycode=%i event.character='%c' event.keymodifier=%i\n", event.type, event.keycode, event.character, event.keymodifier); |
---|
417 | #endif |
---|
418 | |
---|
419 | switch(event.type) { |
---|
420 | case AW_Keyboard_Press: { |
---|
421 | if (repeatCount==0) { // first key event? |
---|
422 | lastEvent = event; |
---|
423 | repeatCount = 1; |
---|
424 | } |
---|
425 | else { |
---|
426 | if (lastEvent.keycode==event.keycode && |
---|
427 | lastEvent.character==event.character && |
---|
428 | lastEvent.keymodifier==event.keymodifier) { // same key as last? |
---|
429 | repeatCount++; |
---|
430 | } |
---|
431 | else { // other key => execute now |
---|
432 | executeKeystroke(aww, &lastEvent, repeatCount); |
---|
433 | lastEvent = event; |
---|
434 | repeatCount = 1; |
---|
435 | } |
---|
436 | } |
---|
437 | |
---|
438 | if (repeatCount) { |
---|
439 | #if defined(DARWIN) || 1 |
---|
440 | // sth goes wrong with OSX -> always execute keystroke |
---|
441 | // Xfree 4.3 has problems as well, so repeat counting is disabled completely |
---|
442 | executeKeystroke(aww, &lastEvent, repeatCount); |
---|
443 | repeatCount = 0; |
---|
444 | #else |
---|
445 | AW_ProcessEventType nextEventType = ED4_ROOT->aw_root->peek_key_event(aww); |
---|
446 | |
---|
447 | if (nextEventType!=KEY_RELEASED) { // no key waiting => execute now |
---|
448 | executeKeystroke(aww, &lastEvent, repeatCount); |
---|
449 | repeatCount = 0; |
---|
450 | } |
---|
451 | #endif |
---|
452 | } |
---|
453 | break; |
---|
454 | } |
---|
455 | case AW_Keyboard_Release: { |
---|
456 | AW_ProcessEventType nextEventType = ED4_ROOT->aw_root->peek_key_event(aww); |
---|
457 | |
---|
458 | if (nextEventType!=KEY_PRESSED && repeatCount) { // no key follows => execute keystrokes (if any) |
---|
459 | executeKeystroke(aww, &lastEvent, repeatCount); |
---|
460 | repeatCount = 0; |
---|
461 | } |
---|
462 | |
---|
463 | break; |
---|
464 | } |
---|
465 | default: { |
---|
466 | if (event.type == AW_Mouse_Release && event.button == ED4_B_MIDDLE_BUTTON) { |
---|
467 | ED4_ROOT->scroll_picture.scroll = 0; |
---|
468 | return; |
---|
469 | } |
---|
470 | else if (event.type == AW_Mouse_Press && event.button == ED4_B_MIDDLE_BUTTON) { |
---|
471 | ED4_ROOT->scroll_picture.scroll = 1; |
---|
472 | ED4_ROOT->scroll_picture.old_y = event.y; |
---|
473 | ED4_ROOT->scroll_picture.old_x = event.x; |
---|
474 | return; |
---|
475 | } |
---|
476 | |
---|
477 | #if defined(DEBUG) && 0 |
---|
478 | if (event.button==ED4_B_LEFT_BUTTON) { |
---|
479 | printf("[ED4_input_cb] type=%i x=%i y=%i ", (int)event.type, (int)event.x, (int)event.y); |
---|
480 | } |
---|
481 | #endif |
---|
482 | |
---|
483 | AW_pos win_x = event.x; |
---|
484 | AW_pos win_y = event.y; |
---|
485 | ED4_ROOT->win_to_world_coords( aww, &(win_x), &(win_y) ); |
---|
486 | event.x = (int) win_x; |
---|
487 | event.y = (int) win_y; |
---|
488 | |
---|
489 | #if defined(DEBUG) && 0 |
---|
490 | if (event.button==ED4_B_LEFT_BUTTON) { |
---|
491 | printf("-> x=%i y=%i\n", (int)event.type, (int)event.x, (int)event.y); |
---|
492 | } |
---|
493 | #endif |
---|
494 | |
---|
495 | GB_transaction dummy(GLOBAL_gb_main); |
---|
496 | ED4_ROOT->main_manager->event_sent_by_parent( &event, aww ); |
---|
497 | break; |
---|
498 | } |
---|
499 | } |
---|
500 | } |
---|
501 | |
---|
502 | static int get_max_slider_xpos() { |
---|
503 | AW_rectangle rect; |
---|
504 | ED4_ROOT->get_device()->get_area_size(&rect); // screensize |
---|
505 | |
---|
506 | AW_pos x, y; |
---|
507 | ED4_base *horizontal_link = ED4_ROOT->scroll_links.link_for_hor_slider; |
---|
508 | horizontal_link->calc_world_coords(&x, &y); |
---|
509 | |
---|
510 | AW_pos max_xpos = horizontal_link->extension.size[WIDTH] // overall width of virtual scrolling area |
---|
511 | - (rect.r - x); // minus width of visible scroll-area (== relative width of horizontal scrollbar) |
---|
512 | |
---|
513 | if (max_xpos<0) max_xpos = 0; // happens when window-content is smaller then window (e.g. if ARB_EDIT4 is not filled) |
---|
514 | return int(max_xpos+0.5); |
---|
515 | } |
---|
516 | |
---|
517 | static int get_max_slider_ypos() { |
---|
518 | AW_rectangle rect; |
---|
519 | ED4_ROOT->get_device()->get_area_size(&rect); // screensize |
---|
520 | |
---|
521 | AW_pos x, y; |
---|
522 | ED4_base *vertical_link = ED4_ROOT->scroll_links.link_for_ver_slider; |
---|
523 | vertical_link->calc_world_coords(&x, &y); |
---|
524 | |
---|
525 | AW_pos max_ypos = vertical_link->extension.size[HEIGHT] // overall width of virtual scrolling area |
---|
526 | - (rect.b - y); // minus width of visible scroll-area (== relative width of horizontal scrollbar) |
---|
527 | |
---|
528 | if (max_ypos<0) max_ypos = 0; // happens when window-content is smaller then window (e.g. if ARB_EDIT4 is not filled) |
---|
529 | return int(max_ypos+0.5); |
---|
530 | } |
---|
531 | |
---|
532 | void ED4_vertical_change_cb( AW_window *aww, AW_CL cd1, AW_CL cd2 ) |
---|
533 | { |
---|
534 | AWUSE(cd1); |
---|
535 | AWUSE(cd2); |
---|
536 | |
---|
537 | ED4_ROOT->use_window(aww); |
---|
538 | |
---|
539 | GB_push_transaction(GLOBAL_gb_main); |
---|
540 | |
---|
541 | ED4_window *win = ED4_ROOT->get_ed4w(); |
---|
542 | int old_slider_pos = win->slider_pos_vertical; |
---|
543 | |
---|
544 | { // correct slider_pos if neccessary |
---|
545 | int max_slider_ypos = get_max_slider_ypos(); |
---|
546 | |
---|
547 | if (aww->slider_pos_vertical>max_slider_ypos) aww->set_vertical_scrollbar_position(max_slider_ypos); |
---|
548 | if (aww->slider_pos_vertical<0) aww->set_vertical_scrollbar_position(0); |
---|
549 | } |
---|
550 | |
---|
551 | int slider_diff = aww->slider_pos_vertical - old_slider_pos; |
---|
552 | |
---|
553 | win->coords.window_upper_clip_point += slider_diff; |
---|
554 | win->coords.window_lower_clip_point += slider_diff; |
---|
555 | |
---|
556 | win->scroll_rectangle(0, -slider_diff); |
---|
557 | win->slider_pos_vertical = aww->slider_pos_vertical; |
---|
558 | |
---|
559 | GB_pop_transaction(GLOBAL_gb_main); |
---|
560 | win->update_window_coords(); |
---|
561 | } |
---|
562 | |
---|
563 | void ED4_horizontal_change_cb( AW_window *aww, AW_CL cd1, AW_CL cd2 ) |
---|
564 | { |
---|
565 | AWUSE(cd1); |
---|
566 | AWUSE(cd2); |
---|
567 | |
---|
568 | ED4_ROOT->use_window(aww); |
---|
569 | |
---|
570 | GB_push_transaction(GLOBAL_gb_main); |
---|
571 | |
---|
572 | ED4_window *win = ED4_ROOT->get_ed4w(); |
---|
573 | int old_slider_pos = win->slider_pos_horizontal; |
---|
574 | |
---|
575 | { // correct slider_pos if neccessary |
---|
576 | int max_slider_xpos = get_max_slider_xpos(); |
---|
577 | |
---|
578 | if (aww->slider_pos_horizontal>max_slider_xpos) aww->set_horizontal_scrollbar_position(max_slider_xpos); |
---|
579 | if (aww->slider_pos_horizontal<0) aww->set_horizontal_scrollbar_position(0); |
---|
580 | } |
---|
581 | |
---|
582 | int slider_diff = aww->slider_pos_horizontal - old_slider_pos; |
---|
583 | |
---|
584 | win->coords.window_left_clip_point += slider_diff; |
---|
585 | win->coords.window_right_clip_point += slider_diff; |
---|
586 | |
---|
587 | win->scroll_rectangle(-slider_diff, 0); |
---|
588 | win->slider_pos_horizontal = aww->slider_pos_horizontal; |
---|
589 | |
---|
590 | GB_pop_transaction(GLOBAL_gb_main); |
---|
591 | win->update_window_coords(); |
---|
592 | } |
---|
593 | |
---|
594 | void ED4_scrollbar_change_cb(AW_window *aww, AW_CL cd1, AW_CL cd2) |
---|
595 | { |
---|
596 | AWUSE(cd1); |
---|
597 | AWUSE(cd2); |
---|
598 | |
---|
599 | ED4_ROOT->use_window(aww); |
---|
600 | |
---|
601 | GB_push_transaction(GLOBAL_gb_main); |
---|
602 | |
---|
603 | ED4_window *win = ED4_ROOT->get_ed4w(); |
---|
604 | |
---|
605 | int old_hslider_pos = win->slider_pos_horizontal; |
---|
606 | int old_vslider_pos = win->slider_pos_vertical; |
---|
607 | |
---|
608 | { // correct slider_pos if neccessary |
---|
609 | int max_slider_xpos = get_max_slider_xpos(); |
---|
610 | int max_slider_ypos = get_max_slider_ypos(); |
---|
611 | |
---|
612 | if (aww->slider_pos_horizontal>max_slider_xpos) aww->set_horizontal_scrollbar_position(max_slider_xpos); |
---|
613 | if (aww->slider_pos_horizontal<0) aww->set_horizontal_scrollbar_position(0); |
---|
614 | |
---|
615 | if (aww->slider_pos_vertical>max_slider_ypos) aww->set_vertical_scrollbar_position(max_slider_ypos); |
---|
616 | if (aww->slider_pos_vertical<0) aww->set_vertical_scrollbar_position(0); |
---|
617 | } |
---|
618 | |
---|
619 | int slider_hdiff = aww->slider_pos_horizontal - old_hslider_pos; |
---|
620 | int slider_vdiff = aww->slider_pos_vertical - old_vslider_pos; |
---|
621 | |
---|
622 | ED4_coords *coords = &win->coords; |
---|
623 | coords->window_left_clip_point += slider_hdiff; |
---|
624 | coords->window_right_clip_point += slider_hdiff; |
---|
625 | coords->window_upper_clip_point += slider_vdiff; |
---|
626 | coords->window_lower_clip_point += slider_vdiff; |
---|
627 | |
---|
628 | win->scroll_rectangle( -slider_hdiff, -slider_vdiff); |
---|
629 | |
---|
630 | win->slider_pos_vertical = aww->slider_pos_vertical; |
---|
631 | win->slider_pos_horizontal = aww->slider_pos_horizontal; |
---|
632 | |
---|
633 | GB_pop_transaction(GLOBAL_gb_main); |
---|
634 | win->update_window_coords(); |
---|
635 | // paintMarksOfSelectedObjects(); |
---|
636 | } |
---|
637 | |
---|
638 | void ED4_motion_cb( AW_window *aww, AW_CL cd1, AW_CL cd2 ) |
---|
639 | { |
---|
640 | AWUSE(cd1); |
---|
641 | AWUSE(cd2); |
---|
642 | AW_event event; |
---|
643 | |
---|
644 | ED4_ROOT->use_window(aww); |
---|
645 | |
---|
646 | aww->get_event(&event); |
---|
647 | |
---|
648 | if (event.type == AW_Mouse_Drag && event.button == ED4_B_MIDDLE_BUTTON) { |
---|
649 | if (ED4_ROOT->scroll_picture.scroll) { |
---|
650 | int xdiff = ED4_ROOT->scroll_picture.old_x - event.x; |
---|
651 | int ydiff = ED4_ROOT->scroll_picture.old_y - event.y; |
---|
652 | int new_xpos = aww->slider_pos_horizontal + (xdiff*ED4_ROOT->aw_root->awar(ED4_AWAR_SCROLL_SPEED_X)->read_int())/10; |
---|
653 | int new_ypos = aww->slider_pos_vertical + (ydiff*ED4_ROOT->aw_root->awar(ED4_AWAR_SCROLL_SPEED_Y)->read_int())/10; |
---|
654 | |
---|
655 | if (xdiff<0) { // scroll left |
---|
656 | if (new_xpos<0) new_xpos = 0; |
---|
657 | } |
---|
658 | else if (xdiff>0) { // scroll right |
---|
659 | int max_xpos = get_max_slider_xpos(); |
---|
660 | if (max_xpos<0) max_xpos = 0; |
---|
661 | if (new_xpos>max_xpos) new_xpos = max_xpos; |
---|
662 | } |
---|
663 | |
---|
664 | if (ydiff<0) { // scroll left |
---|
665 | if (new_ypos<0) new_ypos = 0; |
---|
666 | } |
---|
667 | else if (ydiff>0) { // scroll right |
---|
668 | int max_ypos = get_max_slider_ypos(); |
---|
669 | if (max_ypos<0) max_ypos = 0; |
---|
670 | if (new_ypos>max_ypos) new_ypos = max_ypos; |
---|
671 | } |
---|
672 | |
---|
673 | if (new_xpos!=aww->slider_pos_horizontal) { |
---|
674 | aww->set_horizontal_scrollbar_position(new_xpos); |
---|
675 | ED4_horizontal_change_cb(aww, cd1, cd2 ); |
---|
676 | ED4_ROOT->scroll_picture.old_x = event.x; |
---|
677 | } |
---|
678 | |
---|
679 | if (new_ypos!=aww->slider_pos_vertical) { |
---|
680 | aww->set_vertical_scrollbar_position(new_ypos); |
---|
681 | ED4_vertical_change_cb(aww, cd1, cd2 ); |
---|
682 | ED4_ROOT->scroll_picture.old_y = event.y; |
---|
683 | } |
---|
684 | } |
---|
685 | } |
---|
686 | else { |
---|
687 | |
---|
688 | #if defined(DEBUG) && 0 |
---|
689 | if (event.button==ED4_B_LEFT_BUTTON) { |
---|
690 | printf("[ED4_motion_cb] type=%i x=%i y=%i ", (int)event.type, (int)event.x, (int)event.y); |
---|
691 | } |
---|
692 | #endif |
---|
693 | |
---|
694 | AW_pos win_x = event.x; |
---|
695 | AW_pos win_y = event.y; |
---|
696 | ED4_ROOT->win_to_world_coords( aww, &win_x, &win_y); |
---|
697 | event.x = (int) win_x; |
---|
698 | event.y = (int) win_y; |
---|
699 | |
---|
700 | #if defined(DEBUG) && 0 |
---|
701 | if (event.button==ED4_B_LEFT_BUTTON) { |
---|
702 | printf("-> x=%i y=%i\n", (int)event.type, (int)event.x, (int)event.y); |
---|
703 | } |
---|
704 | #endif |
---|
705 | |
---|
706 | GB_transaction dummy(GLOBAL_gb_main); |
---|
707 | ED4_ROOT->main_manager->event_sent_by_parent( &event, aww ); |
---|
708 | } |
---|
709 | } |
---|
710 | |
---|
711 | void ED4_remote_set_cursor_cb(AW_root *awr, AW_CL /*cd1*/, AW_CL /*cd2*/) |
---|
712 | { |
---|
713 | AW_awar *awar = awr->awar(AWAR_SET_CURSOR_POSITION); |
---|
714 | long pos = awar->read_int(); |
---|
715 | |
---|
716 | if (pos != -1) { |
---|
717 | ED4_cursor *cursor = &ED4_ROOT->get_ed4w()->cursor; |
---|
718 | cursor->jump_sequence_pos(ED4_ROOT->get_aww(), pos, ED4_JUMP_CENTERED); |
---|
719 | awar->write_int(-1); |
---|
720 | } |
---|
721 | } |
---|
722 | |
---|
723 | void ED4_jump_to_cursor_position(AW_window *aww, char *awar_name, bool /*callback_flag*/) // callback function |
---|
724 | { |
---|
725 | ED4_ROOT->use_window(aww); |
---|
726 | |
---|
727 | ED4_cursor *cursor = &ED4_ROOT->get_ed4w()->cursor; |
---|
728 | GB_ERROR error = 0; |
---|
729 | |
---|
730 | long pos = aww->get_root()->awar(awar_name)->read_int(); |
---|
731 | if (pos>0) pos--; // user->real position (userpos is 1..n) |
---|
732 | |
---|
733 | ED4_remap *remap = ED4_ROOT->root_group_man->remap(); |
---|
734 | long max = remap->screen_to_sequence(remap->get_max_screen_pos()); |
---|
735 | if(pos > max) pos = max; |
---|
736 | |
---|
737 | if (strcmp(awar_name, ED4_ROOT->get_ed4w()->awar_path_for_Ecoli)==0) { // callback from ecoli |
---|
738 | BI_ecoli_ref *ecoli = ED4_ROOT->ecoli_ref; |
---|
739 | |
---|
740 | if (ecoli->gotData()) pos = ecoli->rel_2_abs(pos); |
---|
741 | else error = "No ecoli reference"; |
---|
742 | } |
---|
743 | else if (strcmp(awar_name, ED4_ROOT->get_ed4w()->awar_path_for_basePos)==0) { // callback from basePos |
---|
744 | pos = cursor->base2sequence_position(pos); |
---|
745 | } |
---|
746 | |
---|
747 | if (error) { |
---|
748 | aw_message(error); |
---|
749 | } |
---|
750 | else { |
---|
751 | cursor->jump_sequence_pos(aww, pos, ED4_JUMP_CENTERED); |
---|
752 | } |
---|
753 | } |
---|
754 | |
---|
755 | void ED4_set_helixnr(AW_window *aww, char *awar_name, bool /*callback_flag*/) |
---|
756 | { |
---|
757 | ED4_cursor *cursor = &ED4_ROOT->get_ed4w()->cursor; |
---|
758 | |
---|
759 | if (cursor->owner_of_cursor) { |
---|
760 | AW_root *root = aww->get_root(); |
---|
761 | const char *helix_nr = root->awar(awar_name)->read_string(); |
---|
762 | BI_helix *helix = ED4_ROOT->helix; |
---|
763 | |
---|
764 | if (helix->has_entries()) { |
---|
765 | long pos = helix->first_position(helix_nr); |
---|
766 | |
---|
767 | if (pos == -1) { |
---|
768 | aw_message(GBS_global_string("No helix '%s' found", helix_nr)); |
---|
769 | } |
---|
770 | else { |
---|
771 | cursor->jump_sequence_pos(aww, pos, ED4_JUMP_CENTERED); |
---|
772 | } |
---|
773 | } |
---|
774 | else { |
---|
775 | aw_message("Got no helix information"); |
---|
776 | } |
---|
777 | } |
---|
778 | } |
---|
779 | |
---|
780 | void ED4_set_iupac(AW_window */*aww*/, char *awar_name, bool /*callback_flag*/) |
---|
781 | { |
---|
782 | ED4_cursor *cursor = &ED4_ROOT->get_ed4w()->cursor; |
---|
783 | |
---|
784 | if (cursor->owner_of_cursor) { |
---|
785 | ED4_species_manager *species_manager = cursor->owner_of_cursor->get_parent(ED4_L_SPECIES)->to_species_manager(); |
---|
786 | |
---|
787 | if (species_manager->flag.is_consensus) { |
---|
788 | aw_message("You cannot change the consensus"); |
---|
789 | return; |
---|
790 | } |
---|
791 | int len; |
---|
792 | char *seq = cursor->owner_of_cursor->resolve_pointer_to_string_copy(&len); |
---|
793 | int seq_pos = cursor->get_sequence_pos(); |
---|
794 | |
---|
795 | e4_assert(seq); |
---|
796 | |
---|
797 | if (seq_pos<len) { |
---|
798 | const char *iupac = ED4_ROOT->aw_root->awar(awar_name)->read_string(); |
---|
799 | char new_char = ED4_encode_iupac(iupac, ED4_ROOT->alignment_type); |
---|
800 | |
---|
801 | seq[seq_pos] = new_char; |
---|
802 | cursor->owner_of_cursor->write_sequence(seq, len); |
---|
803 | } |
---|
804 | |
---|
805 | free(seq); |
---|
806 | } |
---|
807 | } |
---|
808 | |
---|
809 | void ED4_gc_is_modified(AW_window *aww,AW_CL cd1, AW_CL cd2) // callback if gc is modified |
---|
810 | { |
---|
811 | ED4_ROOT->use_window(aww); |
---|
812 | |
---|
813 | ED4_resize_cb(aww,cd1,cd2); |
---|
814 | ED4_expose_cb(aww,cd1,cd2); |
---|
815 | } |
---|
816 | |
---|
817 | void ED4_exit() { |
---|
818 | ED4_ROOT->aw_root->unlink_awars_from_DB(GLOBAL_gb_main); |
---|
819 | |
---|
820 | ED4_window *ed4w = ED4_ROOT->first_window; |
---|
821 | |
---|
822 | while (ed4w) { |
---|
823 | ed4w->aww->hide(); |
---|
824 | ed4w->cursor.invalidate_base_position(); |
---|
825 | ed4w = ed4w->next; |
---|
826 | } |
---|
827 | |
---|
828 | delete ED4_ROOT->main_manager; |
---|
829 | |
---|
830 | while (ED4_ROOT->first_window) |
---|
831 | ED4_ROOT->first_window->delete_window(ED4_ROOT->first_window); |
---|
832 | |
---|
833 | GBDATA *gb_main = GLOBAL_gb_main; |
---|
834 | GLOBAL_gb_main = NULL; |
---|
835 | #if defined(DEBUG) |
---|
836 | AWT_browser_forget_db(gb_main); |
---|
837 | #endif // DEBUG |
---|
838 | GB_close(gb_main); |
---|
839 | |
---|
840 | ::exit(0); |
---|
841 | } |
---|
842 | |
---|
843 | void ED4_quit_editor(AW_window *aww, AW_CL /*cd1*/, AW_CL /*cd2*/) { |
---|
844 | ED4_ROOT->use_window(aww); |
---|
845 | |
---|
846 | if (ED4_ROOT->first_window == ED4_ROOT->get_ed4w()) { // quit button has been pressed in first window |
---|
847 | ED4_exit(); |
---|
848 | } |
---|
849 | // case : in another window close has been pressed |
---|
850 | ED4_ROOT->get_aww()->hide(); |
---|
851 | ED4_ROOT->get_ed4w()->is_hidden = true; |
---|
852 | } |
---|
853 | |
---|
854 | void ED4_load_data( AW_window *aww, AW_CL cd1, AW_CL cd2 ) |
---|
855 | { |
---|
856 | ED4_ROOT->use_window(aww); |
---|
857 | |
---|
858 | AWUSE(aww); |
---|
859 | AWUSE(cd1); |
---|
860 | AWUSE(cd2); |
---|
861 | } |
---|
862 | |
---|
863 | void ED4_save_data( AW_window *aww, AW_CL cd1, AW_CL cd2 ) |
---|
864 | { |
---|
865 | ED4_ROOT->use_window(aww); |
---|
866 | |
---|
867 | AWUSE(aww); |
---|
868 | AWUSE(cd1); |
---|
869 | AWUSE(cd2); |
---|
870 | } |
---|
871 | |
---|
872 | void ED4_timer_refresh() |
---|
873 | { |
---|
874 | GB_begin_transaction(GLOBAL_gb_main); // for callbacks from database |
---|
875 | // ED4_ROOT->refresh_all_windows(0); |
---|
876 | GB_tell_server_dont_wait(GLOBAL_gb_main); |
---|
877 | GB_commit_transaction(GLOBAL_gb_main); |
---|
878 | } |
---|
879 | |
---|
880 | void ED4_timer(AW_root *, AW_CL cd1, AW_CL cd2 ) |
---|
881 | { |
---|
882 | // last_used_timestamp = GB_read_clock(gb_main); |
---|
883 | ED4_timer_refresh(); |
---|
884 | ED4_ROOT->aw_root->add_timed_callback(200,ED4_timer,cd1,cd2); |
---|
885 | } |
---|
886 | |
---|
887 | void ED4_refresh_window( AW_window *aww, AW_CL cd_called_from_menu, AW_CL /*cd2*/ ) |
---|
888 | { |
---|
889 | GB_transaction dummy(GLOBAL_gb_main); |
---|
890 | |
---|
891 | if (int(cd_called_from_menu)) { |
---|
892 | ED4_ROOT->use_window(aww); |
---|
893 | } |
---|
894 | |
---|
895 | ED4_main_manager *mainman = ED4_ROOT->main_manager; |
---|
896 | if (mainman) { // avoids a crash durin startup |
---|
897 | if (mainman->update_info.delete_requested) { |
---|
898 | mainman->delete_requested_childs(); |
---|
899 | } |
---|
900 | |
---|
901 | // ED4_ROOT->deselect_all(); |
---|
902 | mainman->update_info.set_clear_at_refresh(1); |
---|
903 | mainman->Show(1); |
---|
904 | } |
---|
905 | } |
---|
906 | |
---|
907 | void ED4_set_reference_species( AW_window *aww, AW_CL disable, AW_CL cd2 ){ |
---|
908 | GB_transaction dummy(GLOBAL_gb_main); |
---|
909 | |
---|
910 | if (disable) { |
---|
911 | ED4_ROOT->reference->init(); |
---|
912 | } |
---|
913 | else { |
---|
914 | ED4_cursor *cursor = &ED4_ROOT->get_ed4w()->cursor; |
---|
915 | |
---|
916 | if (cursor->owner_of_cursor) { |
---|
917 | ED4_terminal *terminal = cursor->owner_of_cursor->to_terminal(); |
---|
918 | ED4_manager *manager = terminal->parent->parent->to_manager(); |
---|
919 | |
---|
920 | if (manager->flag.is_consensus) { |
---|
921 | ED4_char_table *table = &terminal->get_parent(ED4_L_GROUP)->to_group_manager()->table(); |
---|
922 | char *consensus = table->build_consensus_string(); |
---|
923 | |
---|
924 | ED4_ROOT->reference->init("CONSENSUS", consensus, table->size()); |
---|
925 | } |
---|
926 | else if (manager->parent->flag.is_SAI) { |
---|
927 | char *name = GBT_read_string(GLOBAL_gb_main,AWAR_SPECIES_NAME); |
---|
928 | int datalen; |
---|
929 | char *data = terminal->resolve_pointer_to_string_copy(&datalen); |
---|
930 | |
---|
931 | ED4_ROOT->reference->init(name, data, datalen); |
---|
932 | |
---|
933 | free(data); |
---|
934 | free(name); |
---|
935 | } |
---|
936 | else { |
---|
937 | char *name = GBT_read_string(GLOBAL_gb_main,AWAR_SPECIES_NAME); |
---|
938 | |
---|
939 | ED4_ROOT->reference->init(name, ED4_ROOT->alignment_name); |
---|
940 | delete name; |
---|
941 | } |
---|
942 | } |
---|
943 | else { |
---|
944 | aw_message("First you have to place your cursor"); |
---|
945 | } |
---|
946 | } |
---|
947 | |
---|
948 | ED4_refresh_window(aww,0,cd2); |
---|
949 | } |
---|
950 | |
---|
951 | static void show_detailed_column_stats_activated(AW_window *aww) { |
---|
952 | ED4_ROOT->column_stat_initialized = 1; |
---|
953 | ED4_show_detailed_column_stats(aww, 0, 0); |
---|
954 | } |
---|
955 | |
---|
956 | double ED4_columnStat_terminal::threshold = -1; |
---|
957 | int ED4_columnStat_terminal::threshold_is_set() { |
---|
958 | return threshold>=0 && threshold<=100; |
---|
959 | } |
---|
960 | void ED4_columnStat_terminal::set_threshold(double aThreshold) { |
---|
961 | threshold = aThreshold; |
---|
962 | e4_assert(threshold_is_set()); |
---|
963 | } |
---|
964 | |
---|
965 | void ED4_set_col_stat_threshold(AW_window */*aww*/, AW_CL cl_do_refresh, AW_CL) { |
---|
966 | double default_threshold = 90.0; |
---|
967 | if (ED4_columnStat_terminal::threshold_is_set()) { |
---|
968 | default_threshold = ED4_columnStat_terminal::get_threshold(); |
---|
969 | } |
---|
970 | char default_input[40]; |
---|
971 | sprintf(default_input, "%6.2f", default_threshold); |
---|
972 | |
---|
973 | char *input = aw_input("Please insert threshold value for marking:", default_input); |
---|
974 | if (input) { |
---|
975 | double input_threshold = atof(input); |
---|
976 | |
---|
977 | if (input_threshold<0 || input_threshold>100) { |
---|
978 | aw_message("Illegal threshold value (allowed: 0..100)"); |
---|
979 | } |
---|
980 | else { |
---|
981 | ED4_columnStat_terminal::set_threshold(input_threshold); |
---|
982 | if (int(cl_do_refresh)) { |
---|
983 | ED4_ROOT->refresh_all_windows(1); |
---|
984 | } |
---|
985 | } |
---|
986 | free(input); |
---|
987 | } |
---|
988 | } |
---|
989 | |
---|
990 | void ED4_show_detailed_column_stats(AW_window *aww, AW_CL, AW_CL) |
---|
991 | { |
---|
992 | while (!ED4_columnStat_terminal::threshold_is_set()) { |
---|
993 | ED4_set_col_stat_threshold(aww, 0, 0); |
---|
994 | } |
---|
995 | |
---|
996 | ED4_cursor *cursor = &ED4_ROOT->get_ed4w()->cursor; |
---|
997 | if (!cursor->owner_of_cursor) { |
---|
998 | aw_message("First you have to place your cursor"); |
---|
999 | return; |
---|
1000 | } |
---|
1001 | |
---|
1002 | ED4_terminal *cursor_terminal = cursor->owner_of_cursor->to_terminal(); |
---|
1003 | ED4_manager *cursor_manager = cursor_terminal->parent->parent->to_manager(); |
---|
1004 | if (!cursor_terminal->is_sequence_terminal() || cursor_manager->flag.is_consensus || cursor_manager->parent->flag.is_SAI) { |
---|
1005 | aw_message("Display of column-statistic-details is only possible for species!"); |
---|
1006 | return; |
---|
1007 | } |
---|
1008 | |
---|
1009 | ED4_sequence_terminal *seq_term = cursor_terminal->to_sequence_terminal(); |
---|
1010 | if (!seq_term->st_ml_node && !(seq_term->st_ml_node=st_ml_convert_species_name_to_node(ED4_ROOT->st_ml, seq_term->species_name))) { |
---|
1011 | if (ED4_ROOT->column_stat_initialized) { |
---|
1012 | aw_message("Cannot display column statistics for this species (internal error?)"); |
---|
1013 | return; |
---|
1014 | } |
---|
1015 | AW_window *aww_st = st_create_main_window(ED4_ROOT->aw_root,ED4_ROOT->st_ml,(AW_CB0)show_detailed_column_stats_activated,(AW_window *)aww); |
---|
1016 | aww_st->show(); |
---|
1017 | return; |
---|
1018 | } |
---|
1019 | |
---|
1020 | ED4_multi_sequence_manager *multi_seq_man = cursor_manager->to_multi_sequence_manager(); |
---|
1021 | char buffer[35]; |
---|
1022 | int count = 1; |
---|
1023 | sprintf( buffer, "Sequence_Manager.%ld.%d", ED4_counter, count++); |
---|
1024 | |
---|
1025 | ED4_sequence_manager *new_seq_man = new ED4_sequence_manager(buffer, 0, 0, 0, 0, multi_seq_man); |
---|
1026 | new_seq_man->set_properties(ED4_P_MOVABLE); |
---|
1027 | multi_seq_man->children->append_member(new_seq_man); |
---|
1028 | |
---|
1029 | int pixel_length = max_seq_terminal_length; |
---|
1030 | #if defined(DEBUG) && 1 |
---|
1031 | printf("max_seq_terminal_length=%li\n", max_seq_terminal_length); |
---|
1032 | #endif |
---|
1033 | |
---|
1034 | AW_pos font_height = ED4_ROOT->font_group.get_height(ED4_G_SEQUENCES); |
---|
1035 | AW_pos columnStatHeight = ceil((COLUMN_STAT_ROWS+0.5/* reserve a bit more space*/)*COLUMN_STAT_ROW_HEIGHT(font_height)); |
---|
1036 | ED4_columnStat_terminal *ref_colStat_terminal = ED4_ROOT->ref_terminals.get_ref_column_stat(); |
---|
1037 | ref_colStat_terminal->extension.size[HEIGHT] = columnStatHeight; |
---|
1038 | ref_colStat_terminal->extension.size[WIDTH] = pixel_length; |
---|
1039 | |
---|
1040 | ED4_sequence_info_terminal *ref_colStat_info_terminal = ED4_ROOT->ref_terminals.get_ref_column_stat_info(); |
---|
1041 | ED4_sequence_info_terminal *new_colStat_info_term = new ED4_sequence_info_terminal("CStat", /*0,*/ 0, 0, SEQUENCEINFOSIZE, columnStatHeight, new_seq_man); |
---|
1042 | new_colStat_info_term->set_properties( (ED4_properties) (ED4_P_SELECTABLE | ED4_P_DRAGABLE | ED4_P_IS_HANDLE) ); |
---|
1043 | new_colStat_info_term->set_links(ref_colStat_info_terminal, ref_colStat_terminal); |
---|
1044 | new_seq_man->children->append_member(new_colStat_info_term); |
---|
1045 | |
---|
1046 | sprintf( buffer, "Column_Statistic_Terminal.%ld.%d", ED4_counter, count++); |
---|
1047 | ED4_columnStat_terminal *new_colStat_term = new ED4_columnStat_terminal(buffer, SEQUENCEINFOSIZE, 0, 0, columnStatHeight, new_seq_man); |
---|
1048 | new_colStat_term->set_properties(ED4_P_CURSOR_ALLOWED); |
---|
1049 | new_colStat_term->set_links(ref_colStat_terminal, ref_colStat_terminal); |
---|
1050 | // new_colStat_term->extension.size[WIDTH] = pixel_length; |
---|
1051 | new_seq_man->children->append_member(new_colStat_term); |
---|
1052 | |
---|
1053 | ED4_counter++; |
---|
1054 | |
---|
1055 | new_seq_man->resize_requested_by_child(); |
---|
1056 | ED4_ROOT->refresh_all_windows(0); |
---|
1057 | } |
---|
1058 | |
---|
1059 | ED4_returncode update_terminal_extension( void **/*arg1*/, void **/*arg2*/, ED4_base *this_object ) |
---|
1060 | { |
---|
1061 | if (this_object->is_terminal()){ |
---|
1062 | if (this_object->is_spacer_terminal()){ |
---|
1063 | if (this_object->parent->is_device_manager()) { // the rest is managed by reference links |
---|
1064 | ; |
---|
1065 | // this_object->extension.size[HEIGHT] = TERMINALHEIGHT / 2; // @@@ Zeilenabstand verringern hier? |
---|
1066 | } |
---|
1067 | } |
---|
1068 | else if (this_object->is_species_name_terminal()) { |
---|
1069 | this_object->extension.size[WIDTH] = MAXSPECIESWIDTH - BRACKETWIDTH * this_object->calc_group_depth(); |
---|
1070 | } |
---|
1071 | else if (this_object->is_sequence_info_terminal()) { |
---|
1072 | this_object->extension.size[WIDTH] = MAXINFOWIDTH; |
---|
1073 | } |
---|
1074 | else if (this_object->is_line_terminal()) { // thought for line terminals which are direct children of the device manager |
---|
1075 | this_object->extension.size[WIDTH] = |
---|
1076 | TREETERMINALSIZE + MAXSPECIESWIDTH + |
---|
1077 | ED4_ROOT->ref_terminals.get_ref_sequence_info()->extension.size[WIDTH] + |
---|
1078 | ED4_ROOT->ref_terminals.get_ref_sequence()->extension.size[WIDTH]; |
---|
1079 | } |
---|
1080 | } |
---|
1081 | |
---|
1082 | if (this_object->parent) { |
---|
1083 | this_object->parent->resize_requested_by_child(); |
---|
1084 | } |
---|
1085 | |
---|
1086 | return ED4_R_OK; |
---|
1087 | } |
---|
1088 | |
---|
1089 | #define SIGNIFICANT_FIELD_CHARS 30 // length used to compare field contents (in createGroupFromSelected) |
---|
1090 | |
---|
1091 | static void createGroupFromSelected(GB_CSTR group_name, GB_CSTR field_name, GB_CSTR field_content) |
---|
1092 | // creates a new group named group_name |
---|
1093 | // if field_name==0 -> all selected species & subgroups are moved to this new group |
---|
1094 | // if field_name!=0 -> all selected species containing field_content in field field_name are moved to this new group |
---|
1095 | { |
---|
1096 | ED4_group_manager *group_manager = NULL; |
---|
1097 | ED4_ROOT->main_manager->create_group(&group_manager, group_name); |
---|
1098 | ED4_manager *top_area = ED4_ROOT->main_manager->search_spec_child_rek(ED4_L_AREA)->to_manager(); |
---|
1099 | ED4_multi_species_manager *multi_species_manager = top_area->search_spec_child_rek( ED4_L_MULTI_SPECIES )->to_multi_species_manager(); |
---|
1100 | |
---|
1101 | group_manager->extension.position[Y_POS] = 2; |
---|
1102 | ED4_base::touch_world_cache(); |
---|
1103 | multi_species_manager->children->append_member( group_manager ); |
---|
1104 | group_manager->parent = (ED4_manager *) multi_species_manager; |
---|
1105 | |
---|
1106 | multi_species_manager = group_manager->get_defined_level( ED4_L_MULTI_SPECIES )->to_multi_species_manager(); |
---|
1107 | |
---|
1108 | ED4_list_elem *list_elem = ED4_ROOT->selected_objects.first(); |
---|
1109 | while (list_elem) { |
---|
1110 | ED4_base *object = ((ED4_selection_entry *) list_elem->elem())->object; |
---|
1111 | object = object->get_parent( ED4_L_SPECIES ); |
---|
1112 | int move_object = 1; |
---|
1113 | |
---|
1114 | if (object->flag.is_consensus) { |
---|
1115 | object = object->get_parent( ED4_L_GROUP ); |
---|
1116 | if (field_name) move_object = 0; // don't move groups if moving by field_name |
---|
1117 | } |
---|
1118 | else { |
---|
1119 | e4_assert(object->is_species_manager()); |
---|
1120 | if (field_name) { |
---|
1121 | GBDATA *gb_species = object->get_species_pointer(); |
---|
1122 | GBDATA *gb_field = GB_search(gb_species, field_name, GB_FIND); |
---|
1123 | |
---|
1124 | if (gb_field) { // field was found |
---|
1125 | int type = gb_field->flags.type; |
---|
1126 | if (type==GB_STRING) { |
---|
1127 | char *found_content = GB_read_as_string(gb_field); |
---|
1128 | move_object = strncmp(found_content, field_content, SIGNIFICANT_FIELD_CHARS)==0; |
---|
1129 | free(found_content); |
---|
1130 | } |
---|
1131 | else { |
---|
1132 | e4_assert(0); // field has to be string field |
---|
1133 | } |
---|
1134 | } |
---|
1135 | else { // field was NOT found |
---|
1136 | move_object = field_content==0 || field_content[0]==0; // move object if we search for no content |
---|
1137 | } |
---|
1138 | } |
---|
1139 | } |
---|
1140 | |
---|
1141 | if (move_object) { |
---|
1142 | object->parent->children->delete_member(object); |
---|
1143 | |
---|
1144 | ED4_base *base = object->get_parent(ED4_L_MULTI_SPECIES); |
---|
1145 | if (base && base->is_multi_species_manager()) { |
---|
1146 | ED4_multi_species_manager *old_multi = base->to_multi_species_manager(); |
---|
1147 | old_multi->invalidate_species_counters(); |
---|
1148 | } |
---|
1149 | multi_species_manager->children->append_member( object ); |
---|
1150 | |
---|
1151 | object->parent = ( ED4_manager * )multi_species_manager; |
---|
1152 | object->set_width(); |
---|
1153 | } |
---|
1154 | |
---|
1155 | list_elem = list_elem->next(); |
---|
1156 | } |
---|
1157 | |
---|
1158 | group_manager->create_consensus(group_manager); |
---|
1159 | group_manager->get_defined_level(ED4_L_MULTI_SPECIES)->to_multi_species_manager()->count_all_children_and_set_group_id(); |
---|
1160 | |
---|
1161 | { |
---|
1162 | ED4_bracket_terminal *bracket = group_manager->get_defined_level(ED4_L_BRACKET)->to_bracket_terminal(); |
---|
1163 | |
---|
1164 | if (bracket) { |
---|
1165 | group_manager->fold_group(bracket->id); |
---|
1166 | } |
---|
1167 | } |
---|
1168 | |
---|
1169 | multi_species_manager->resize_requested_by_child(); |
---|
1170 | |
---|
1171 | ED4_ROOT->get_ed4w()->update_scrolled_rectangle(); |
---|
1172 | ED4_ROOT->get_device()->reset(); |
---|
1173 | ED4_ROOT->refresh_all_windows(1); |
---|
1174 | } |
---|
1175 | |
---|
1176 | static void group_species(int use_field, AW_window *use_as_main_window) { |
---|
1177 | GB_ERROR error = 0; |
---|
1178 | GB_push_transaction(GLOBAL_gb_main); |
---|
1179 | |
---|
1180 | ED4_ROOT->use_window(use_as_main_window); |
---|
1181 | |
---|
1182 | if (!use_field) { |
---|
1183 | char *group_name = aw_input("Enter name for new group:"); |
---|
1184 | |
---|
1185 | if (group_name) { |
---|
1186 | if (strlen(group_name)>GB_GROUP_NAME_MAX) { |
---|
1187 | group_name[GB_GROUP_NAME_MAX] = 0; |
---|
1188 | aw_message("Truncated too long group name"); |
---|
1189 | } |
---|
1190 | createGroupFromSelected(group_name, 0, 0); |
---|
1191 | free(group_name); |
---|
1192 | } |
---|
1193 | } |
---|
1194 | else { |
---|
1195 | const char *field_name = ED4_ROOT->aw_root->awar(AWAR_FIELD_CHOSEN)->read_string(); |
---|
1196 | char *doneContents = strdup(";"); |
---|
1197 | size_t doneLen = 1; |
---|
1198 | |
---|
1199 | int tryAgain = 1; |
---|
1200 | int foundField = 0; |
---|
1201 | int foundSpecies = 0; |
---|
1202 | |
---|
1203 | while (tryAgain && !error) { |
---|
1204 | tryAgain = 0; |
---|
1205 | ED4_list_elem *list_elem = ED4_ROOT->selected_objects.first(); |
---|
1206 | while (list_elem && !error) { |
---|
1207 | ED4_base *object = ((ED4_selection_entry *) list_elem->elem())->object; |
---|
1208 | object = object->get_parent( ED4_L_SPECIES ); |
---|
1209 | if (!object->flag.is_consensus) { |
---|
1210 | GBDATA *gb_species = object->get_species_pointer(); |
---|
1211 | GBDATA *gb_field = GB_search(gb_species, field_name, GB_FIND); |
---|
1212 | |
---|
1213 | if (gb_species) { |
---|
1214 | foundSpecies = 1; |
---|
1215 | } |
---|
1216 | |
---|
1217 | if (gb_field) { |
---|
1218 | int type = gb_field->flags.type; |
---|
1219 | |
---|
1220 | if (type==GB_STRING) { |
---|
1221 | char *field_content = GB_read_as_string(gb_field); |
---|
1222 | size_t field_content_len = strlen(field_content); |
---|
1223 | |
---|
1224 | foundField = 1; |
---|
1225 | if (field_content_len>SIGNIFICANT_FIELD_CHARS) { |
---|
1226 | field_content[SIGNIFICANT_FIELD_CHARS] = 0; |
---|
1227 | field_content_len = SIGNIFICANT_FIELD_CHARS; |
---|
1228 | } |
---|
1229 | |
---|
1230 | char with_semi[SIGNIFICANT_FIELD_CHARS+2+1]; |
---|
1231 | sprintf(with_semi, ";%s;", field_content); |
---|
1232 | |
---|
1233 | if (strstr(doneContents, with_semi)==0) { // field_content was not used yet |
---|
1234 | createGroupFromSelected(field_content, field_name, field_content); |
---|
1235 | tryAgain = 1; |
---|
1236 | |
---|
1237 | int newlen = doneLen + field_content_len + 1; |
---|
1238 | char *newDone = (char*)malloc(newlen+1); |
---|
1239 | GBS_global_string_to_buffer(newDone, newlen, "%s%s;", doneContents, field_content); |
---|
1240 | freeset(doneContents, newDone); |
---|
1241 | doneLen = newlen; |
---|
1242 | } |
---|
1243 | free(field_content); |
---|
1244 | } |
---|
1245 | else { |
---|
1246 | error = "You have to use a string type field"; |
---|
1247 | } |
---|
1248 | } |
---|
1249 | } |
---|
1250 | list_elem = list_elem->next(); |
---|
1251 | } |
---|
1252 | } |
---|
1253 | |
---|
1254 | if (!foundSpecies) { |
---|
1255 | error = "Please select some species in order to insert them into new groups"; |
---|
1256 | } |
---|
1257 | else if (!foundField) { |
---|
1258 | error = GB_export_errorf("Field not found: '%s'", field_name); |
---|
1259 | } |
---|
1260 | } |
---|
1261 | |
---|
1262 | GB_end_transaction_show_error(GLOBAL_gb_main, error, aw_message); |
---|
1263 | } |
---|
1264 | |
---|
1265 | static void group_species2_cb(AW_window*, AW_CL cl_use_as_main_window, AW_CL cl_window_to_hide) { |
---|
1266 | group_species(1, (AW_window*)cl_use_as_main_window); |
---|
1267 | ((AW_window*)cl_window_to_hide)->hide(); |
---|
1268 | } |
---|
1269 | |
---|
1270 | static AW_window *create_group_species_by_field_window(AW_root *aw_root, AW_window *use_as_main_window) { |
---|
1271 | AW_window_simple *aws = new AW_window_simple; |
---|
1272 | |
---|
1273 | aws->init(aw_root, "CREATE_GROUP_USING_FIELD", "Create group using field"); |
---|
1274 | aws->load_xfig("edit4/choose_field.fig"); |
---|
1275 | |
---|
1276 | aws->button_length(20); |
---|
1277 | aws->at("doit"); |
---|
1278 | aws->callback(group_species2_cb, (AW_CL)use_as_main_window, (AW_CL)aws); |
---|
1279 | aws->create_button("USE_FIELD","Use selected field",""); |
---|
1280 | |
---|
1281 | aws->button_length(10); |
---|
1282 | aws->at("close"); |
---|
1283 | aws->callback( (AW_CB0)AW_POPDOWN); |
---|
1284 | aws->create_button("CLOSE", "CLOSE","C"); |
---|
1285 | |
---|
1286 | awt_create_selection_list_on_scandb(GLOBAL_gb_main, (AW_window*)aws, AWAR_FIELD_CHOSEN, -1, "source",0, &AWT_species_selector, 20, 10); |
---|
1287 | |
---|
1288 | return aws; |
---|
1289 | } |
---|
1290 | |
---|
1291 | void group_species_cb(AW_window *aww, AW_CL cl_use_fields, AW_CL) { |
---|
1292 | |
---|
1293 | int use_fields = int(cl_use_fields); |
---|
1294 | |
---|
1295 | if (!use_fields) { |
---|
1296 | group_species(0, aww); |
---|
1297 | } |
---|
1298 | else { |
---|
1299 | static AW_window *ask_field_window; |
---|
1300 | |
---|
1301 | if (!ask_field_window) ask_field_window = create_group_species_by_field_window(ED4_ROOT->aw_root, aww); |
---|
1302 | ask_field_window->activate(); |
---|
1303 | } |
---|
1304 | } |
---|
1305 | |
---|
1306 | void ED4_load_new_config(char *string) |
---|
1307 | { |
---|
1308 | char *config_data_top = NULL; |
---|
1309 | char *config_data_middle = NULL; |
---|
1310 | |
---|
1311 | ED4_window *window; |
---|
1312 | GB_transaction dummy(GLOBAL_gb_main); |
---|
1313 | |
---|
1314 | |
---|
1315 | ED4_ROOT->main_manager->clear_whole_background(); |
---|
1316 | ED4_calc_terminal_extentions(); |
---|
1317 | |
---|
1318 | max_seq_terminal_length = 0; |
---|
1319 | |
---|
1320 | ED4_init_notFoundMessage(); |
---|
1321 | |
---|
1322 | |
---|
1323 | if ( ED4_ROOT->selected_objects.no_of_entries() > 0 ) { |
---|
1324 | ED4_ROOT->deselect_all(); |
---|
1325 | } |
---|
1326 | |
---|
1327 | ED4_ROOT->scroll_picture.scroll = 0; |
---|
1328 | ED4_ROOT->scroll_picture.old_x = 0; |
---|
1329 | ED4_ROOT->scroll_picture.old_y = 0; |
---|
1330 | |
---|
1331 | ED4_ROOT->ref_terminals.clear(); |
---|
1332 | |
---|
1333 | for (window=ED4_ROOT->first_window; window; window=window->next) { |
---|
1334 | window->cursor.init(); |
---|
1335 | window->aww->set_horizontal_scrollbar_position ( 0 ); |
---|
1336 | window->aww->set_vertical_scrollbar_position ( 0 ); |
---|
1337 | } |
---|
1338 | |
---|
1339 | ED4_ROOT->scroll_links.link_for_hor_slider = NULL; |
---|
1340 | ED4_ROOT->scroll_links.link_for_ver_slider = NULL; |
---|
1341 | ED4_ROOT->middle_area_man = NULL; |
---|
1342 | ED4_ROOT->top_area_man = NULL; |
---|
1343 | |
---|
1344 | delete ED4_ROOT->main_manager; |
---|
1345 | ED4_ROOT->main_manager = NULL; |
---|
1346 | delete ED4_ROOT->ecoli_ref; |
---|
1347 | { |
---|
1348 | GB_push_transaction(GLOBAL_gb_main); |
---|
1349 | GBDATA *gb_configuration = GBT_find_configuration(GLOBAL_gb_main, string); |
---|
1350 | GBDATA *gb_middle_area = GB_search(gb_configuration, "middle_area", GB_FIND); |
---|
1351 | GBDATA *gb_top_area = GB_search(gb_configuration, "top_area", GB_FIND); |
---|
1352 | config_data_middle = GB_read_as_string(gb_middle_area); |
---|
1353 | config_data_top = GB_read_as_string(gb_top_area); |
---|
1354 | GB_pop_transaction(GLOBAL_gb_main); |
---|
1355 | } |
---|
1356 | |
---|
1357 | ED4_ROOT->first_window->reset_all_for_new_config(); |
---|
1358 | |
---|
1359 | ED4_ROOT->create_hierarchy( config_data_middle, config_data_top ); |
---|
1360 | ED4_ROOT->refresh_all_windows(1); |
---|
1361 | |
---|
1362 | free(config_data_middle); |
---|
1363 | free(config_data_top); |
---|
1364 | } |
---|
1365 | |
---|
1366 | static long ED4_get_edit_modus(AW_root *root) |
---|
1367 | { |
---|
1368 | if (!root->awar(AWAR_EDIT_MODE)->read_int()) { |
---|
1369 | return AD_ALIGN; |
---|
1370 | } |
---|
1371 | return root->awar(AWAR_INSERT_MODE)->read_int() ? AD_INSERT : AD_REPLACE; |
---|
1372 | } |
---|
1373 | |
---|
1374 | void ed4_changesecurity(AW_root *root, AW_CL /*cd1*/) |
---|
1375 | { |
---|
1376 | long mode = ED4_get_edit_modus(root); |
---|
1377 | long level; |
---|
1378 | const char *awar_name = 0; |
---|
1379 | |
---|
1380 | switch (mode){ |
---|
1381 | case AD_ALIGN: |
---|
1382 | awar_name = AWAR_EDIT_SECURITY_LEVEL_ALIGN; |
---|
1383 | break; |
---|
1384 | default: |
---|
1385 | awar_name = AWAR_EDIT_SECURITY_LEVEL_CHANGE; |
---|
1386 | } |
---|
1387 | |
---|
1388 | ED4_ROOT->aw_root->awar(AWAR_EDIT_SECURITY_LEVEL)->map(awar_name); |
---|
1389 | level = ED4_ROOT->aw_root->awar(awar_name)->read_int(); |
---|
1390 | GB_change_my_security (GLOBAL_gb_main, level, ""); |
---|
1391 | } |
---|
1392 | |
---|
1393 | void ed4_change_edit_mode(AW_root *root, AW_CL cd1) |
---|
1394 | { |
---|
1395 | awar_edit_modus = (ad_edit_modus)ED4_get_edit_modus(root); |
---|
1396 | ed4_changesecurity(root, cd1); |
---|
1397 | } |
---|
1398 | |
---|
1399 | ED4_returncode rebuild_consensus(void **/*arg1*/, void **/*arg2*/, ED4_base *object) // arg1 and arg2 are NULL-values !!! |
---|
1400 | { |
---|
1401 | if ( object->flag.is_consensus) { |
---|
1402 | ED4_species_manager *spec_man = object->to_species_manager(); |
---|
1403 | spec_man->do_callbacks(); |
---|
1404 | |
---|
1405 | ED4_base *sequence_data_terminal = object->search_spec_child_rek( ED4_L_SEQUENCE_STRING ); |
---|
1406 | |
---|
1407 | sequence_data_terminal->set_refresh(); |
---|
1408 | sequence_data_terminal->parent->refresh_requested_by_child(); |
---|
1409 | } |
---|
1410 | return ED4_R_OK; |
---|
1411 | } |
---|
1412 | |
---|
1413 | void ED4_new_editor_window( AW_window *aww, AW_CL /*cd1*/, AW_CL /*cd2*/ ) |
---|
1414 | { |
---|
1415 | ED4_ROOT->use_window(aww); |
---|
1416 | |
---|
1417 | AW_device *device; |
---|
1418 | ED4_window *new_window = 0; |
---|
1419 | |
---|
1420 | if (ED4_ROOT->generate_window( &device, &new_window) == ED4_R_BREAK) // don't open more then five windows |
---|
1421 | return; |
---|
1422 | |
---|
1423 | ED4_ROOT->use_window(new_window); |
---|
1424 | |
---|
1425 | new_window->set_scrolled_rectangle( 0, 0, 0, 0, ED4_ROOT->scroll_links.link_for_hor_slider, |
---|
1426 | ED4_ROOT->scroll_links.link_for_ver_slider, |
---|
1427 | ED4_ROOT->scroll_links.link_for_hor_slider, |
---|
1428 | ED4_ROOT->scroll_links.link_for_ver_slider ); |
---|
1429 | |
---|
1430 | new_window->aww->show(); |
---|
1431 | new_window->update_scrolled_rectangle(); |
---|
1432 | |
---|
1433 | ED4_ROOT->use_window(aww); |
---|
1434 | } |
---|
1435 | |
---|
1436 | |
---|
1437 | |
---|
1438 | void ED4_start_editor_on_configuration(AW_window *aww){ |
---|
1439 | aww->hide(); |
---|
1440 | char *cn = aww->get_root()->awar(AWAR_EDIT_CONFIGURATION)->read_string(); |
---|
1441 | |
---|
1442 | ED4_load_new_config(cn); |
---|
1443 | free(cn); |
---|
1444 | } |
---|
1445 | |
---|
1446 | void ED4_compression_changed_cb(AW_root *awr){ |
---|
1447 | ED4_remap_mode mode = (ED4_remap_mode)awr->awar(ED4_AWAR_COMPRESS_SEQUENCE_TYPE)->read_int(); |
---|
1448 | int percent = awr->awar(ED4_AWAR_COMPRESS_SEQUENCE_PERCENT)->read_int(); |
---|
1449 | GB_transaction transaction_var(GLOBAL_gb_main); |
---|
1450 | |
---|
1451 | if (ED4_ROOT->root_group_man) { |
---|
1452 | ED4_cursor& cursor = ED4_ROOT->get_ed4w()->cursor; |
---|
1453 | int rel_pos = cursor.get_screen_relative_pos(); |
---|
1454 | int seq_pos = cursor.get_sequence_pos(); |
---|
1455 | |
---|
1456 | AW_window *aww = ED4_ROOT->get_aww(); |
---|
1457 | AW_device *device = ED4_ROOT->get_device(); |
---|
1458 | |
---|
1459 | ED4_remap *remap = ED4_ROOT->root_group_man->remap(); |
---|
1460 | remap->set_mode(mode, percent); |
---|
1461 | |
---|
1462 | device->push_clip_scale(); |
---|
1463 | device->set_clipall(); // draw nothing |
---|
1464 | |
---|
1465 | ED4_expose_recalculations(); |
---|
1466 | |
---|
1467 | cursor.jump_sequence_pos(aww, seq_pos, ED4_JUMP_KEEP_POSITION); |
---|
1468 | cursor.set_screen_relative_pos(aww, rel_pos); |
---|
1469 | |
---|
1470 | ED4_expose_cb(aww, 0, 0); // does pop_clip_scale + refresh |
---|
1471 | } |
---|
1472 | } |
---|
1473 | |
---|
1474 | void ED4_compression_toggle_changed_cb(AW_root *root, AW_CL cd1, AW_CL /*cd2*/) |
---|
1475 | { |
---|
1476 | // static int cst_change_denied; |
---|
1477 | |
---|
1478 | int gaps = root->awar(ED4_AWAR_COMPRESS_SEQUENCE_GAPS)->read_int(); |
---|
1479 | int hide = root->awar(ED4_AWAR_COMPRESS_SEQUENCE_HIDE)->read_int(); |
---|
1480 | ED4_remap_mode mode = ED4_remap_mode(root->awar(ED4_AWAR_COMPRESS_SEQUENCE_TYPE)->read_int()); |
---|
1481 | |
---|
1482 | switch(int(cd1)) { |
---|
1483 | case 0: { // ED4_AWAR_COMPRESS_SEQUENCE_GAPS changed |
---|
1484 | if (gaps!=2 && hide!=0) { |
---|
1485 | root->awar(ED4_AWAR_COMPRESS_SEQUENCE_HIDE)->write_int(0); |
---|
1486 | return; |
---|
1487 | } |
---|
1488 | break; |
---|
1489 | } |
---|
1490 | case 1: { // ED4_AWAR_COMPRESS_SEQUENCE_HIDE changed |
---|
1491 | if (hide!=0 && gaps!=2) { |
---|
1492 | root->awar(ED4_AWAR_COMPRESS_SEQUENCE_GAPS)->write_int(2); |
---|
1493 | return; |
---|
1494 | } |
---|
1495 | break; |
---|
1496 | } |
---|
1497 | default: { |
---|
1498 | e4_assert(0); |
---|
1499 | break; |
---|
1500 | } |
---|
1501 | } |
---|
1502 | |
---|
1503 | mode = ED4_RM_NONE; |
---|
1504 | switch (gaps) { |
---|
1505 | case 0: mode = ED4_RM_NONE; break; |
---|
1506 | case 1: mode = ED4_RM_DYNAMIC_GAPS; break; |
---|
1507 | case 2: { |
---|
1508 | switch(hide) { |
---|
1509 | case 0: mode = ED4_RM_MAX_ALIGN; break; |
---|
1510 | case 1: mode = ED4_RM_SHOW_ABOVE; break; |
---|
1511 | default: e4_assert(0); break; |
---|
1512 | } |
---|
1513 | break; |
---|
1514 | } |
---|
1515 | default: e4_assert(0); break; |
---|
1516 | } |
---|
1517 | |
---|
1518 | root->awar(ED4_AWAR_COMPRESS_SEQUENCE_TYPE)->write_int(int(mode)); |
---|
1519 | } |
---|
1520 | |
---|
1521 | // ------------------------------------------------------------------- |
---|
1522 | // AW_window *ED4_create_level_1_options_window(AW_root *root) |
---|
1523 | // ------------------------------------------------------------------- |
---|
1524 | AW_window *ED4_create_level_1_options_window(AW_root *root){ |
---|
1525 | AW_window_simple *aws = new AW_window_simple; |
---|
1526 | |
---|
1527 | aws->init( root, "EDIT4_PROPS","EDIT4 Options"); |
---|
1528 | aws->load_xfig("edit4/options.fig"); |
---|
1529 | |
---|
1530 | aws->callback( (AW_CB0)AW_POPDOWN); |
---|
1531 | aws->at("close"); |
---|
1532 | aws->create_button("CLOSE", "CLOSE","C"); |
---|
1533 | |
---|
1534 | aws->callback( AW_POPUP_HELP,(AW_CL)"e4_options.hlp"); |
---|
1535 | aws->at("help"); |
---|
1536 | aws->create_button("HELP","HELP","H"); |
---|
1537 | |
---|
1538 | // ----------------------------------- |
---|
1539 | // Online Sequence Compression |
---|
1540 | |
---|
1541 | aws->at("gaps"); |
---|
1542 | aws->create_toggle_field(ED4_AWAR_COMPRESS_SEQUENCE_GAPS); |
---|
1543 | aws->insert_default_toggle("Show all gaps", "A", 0); |
---|
1544 | aws->insert_toggle("Show some gaps", "S", 1); |
---|
1545 | aws->insert_toggle("Hide all gaps", "H", 2); |
---|
1546 | aws->update_toggle_field(); |
---|
1547 | |
---|
1548 | aws->at("hide"); |
---|
1549 | aws->create_toggle_field(ED4_AWAR_COMPRESS_SEQUENCE_HIDE); |
---|
1550 | aws->insert_default_toggle("Hide no Nucleotides", "0", 0); |
---|
1551 | aws->insert_toggle("Hide columns with less than...", "1", 1); |
---|
1552 | aws->update_toggle_field(); |
---|
1553 | |
---|
1554 | aws->at("percent"); |
---|
1555 | aws->create_input_field(ED4_AWAR_COMPRESS_SEQUENCE_PERCENT); |
---|
1556 | |
---|
1557 | // -------------- |
---|
1558 | // Layout |
---|
1559 | |
---|
1560 | aws->at("seq_helix"); |
---|
1561 | aws->create_input_field(AWAR_EDIT_HELIX_SPACING); |
---|
1562 | |
---|
1563 | aws->at("seq_seq"); |
---|
1564 | aws->create_input_field(AWAR_EDIT_TERMINAL_SPACING); |
---|
1565 | |
---|
1566 | // -------------------- |
---|
1567 | // Scroll-Speed |
---|
1568 | |
---|
1569 | aws->at("scroll_x"); |
---|
1570 | aws->create_input_field(ED4_AWAR_SCROLL_SPEED_X); |
---|
1571 | |
---|
1572 | aws->at("scroll_y"); |
---|
1573 | aws->create_input_field(ED4_AWAR_SCROLL_SPEED_Y); |
---|
1574 | |
---|
1575 | aws->at("margin"); |
---|
1576 | aws->create_input_field(ED4_AWAR_SCROLL_MARGIN); |
---|
1577 | |
---|
1578 | // --------------- |
---|
1579 | // Editing |
---|
1580 | |
---|
1581 | aws->at("gapchars"); |
---|
1582 | aws->create_input_field(ED4_AWAR_GAP_CHARS); |
---|
1583 | |
---|
1584 | aws->at("repeat"); |
---|
1585 | aws->label("Use digits to repeat edit commands?"); |
---|
1586 | aws->create_toggle(ED4_AWAR_DIGITS_AS_REPEAT); |
---|
1587 | |
---|
1588 | aws->at("fast"); |
---|
1589 | aws->label("Should Ctrl-Cursor jump over next group?"); |
---|
1590 | aws->create_toggle(ED4_AWAR_FAST_CURSOR_JUMP); |
---|
1591 | |
---|
1592 | aws->at("checksum"); |
---|
1593 | aws->label("Announce all checksum changes\ncaused by editing commands."); |
---|
1594 | aws->create_toggle(ED4_AWAR_ANNOUNCE_CHECKSUM_CHANGES); |
---|
1595 | |
---|
1596 | return aws; |
---|
1597 | } |
---|
1598 | |
---|
1599 | /* Open window to show IUPAC tables */ |
---|
1600 | static AW_window * CON_showgroupswin_cb( AW_root *aw_root) |
---|
1601 | { |
---|
1602 | AW_window_simple *aws = new AW_window_simple; |
---|
1603 | aws->init( aw_root, "SHOW_IUPAC", "Show IUPAC"); |
---|
1604 | aws->load_xfig("consensus/groups.fig"); |
---|
1605 | aws->button_length( 7 ); |
---|
1606 | |
---|
1607 | aws->at("ok");aws->callback((AW_CB0)AW_POPDOWN); |
---|
1608 | aws->create_button("CLOSE","CLOSE","O"); |
---|
1609 | |
---|
1610 | return aws; |
---|
1611 | } |
---|
1612 | |
---|
1613 | |
---|
1614 | AW_window *ED4_create_consensus_definition_window(AW_root *root) { |
---|
1615 | static AW_window_simple *aws = 0; |
---|
1616 | |
---|
1617 | if (!aws) { |
---|
1618 | aws = new AW_window_simple; |
---|
1619 | |
---|
1620 | aws->init(root, "EDIT4_CONSENSUS", "EDIT4 Consensus Definition"); |
---|
1621 | aws->load_xfig("edit4/consensus.fig"); |
---|
1622 | |
---|
1623 | aws->callback((AW_CB0)AW_POPDOWN); |
---|
1624 | aws->at("close"); |
---|
1625 | aws->create_button("CLOSE", "CLOSE","C"); |
---|
1626 | |
---|
1627 | aws->callback( AW_POPUP_HELP,(AW_CL)"e4_consensus.hlp"); |
---|
1628 | aws->at("help"); |
---|
1629 | aws->create_button("HELP","HELP","H"); |
---|
1630 | |
---|
1631 | aws->button_length(10); |
---|
1632 | aws->at("showgroups");aws->callback(AW_POPUP,(AW_CL)CON_showgroupswin_cb,0); |
---|
1633 | aws->create_button("SHOW_IUPAC", "show\nIUPAC...","s"); |
---|
1634 | |
---|
1635 | aws->at("countgaps"); |
---|
1636 | aws->create_toggle_field(ED4_AWAR_CONSENSUS_COUNTGAPS); |
---|
1637 | aws->insert_toggle("on","1", 1); |
---|
1638 | aws->insert_default_toggle("off","0", 0); |
---|
1639 | aws->update_toggle_field(); |
---|
1640 | |
---|
1641 | aws->at("gapbound"); |
---|
1642 | aws->create_input_field(ED4_AWAR_CONSENSUS_GAPBOUND, 4); |
---|
1643 | |
---|
1644 | aws->at("group"); |
---|
1645 | aws->create_toggle_field(ED4_AWAR_CONSENSUS_GROUP); |
---|
1646 | aws->insert_toggle("on", "1", 1); |
---|
1647 | aws->insert_default_toggle("off", "0", 0); |
---|
1648 | aws->update_toggle_field(); |
---|
1649 | |
---|
1650 | aws->at("considbound"); |
---|
1651 | aws->create_input_field(ED4_AWAR_CONSENSUS_CONSIDBOUND, 4); |
---|
1652 | |
---|
1653 | aws->at("upper"); |
---|
1654 | aws->create_input_field(ED4_AWAR_CONSENSUS_UPPER, 4); |
---|
1655 | |
---|
1656 | aws->at("lower"); |
---|
1657 | aws->create_input_field(ED4_AWAR_CONSENSUS_LOWER, 4); |
---|
1658 | |
---|
1659 | aws->at("show"); |
---|
1660 | aws->label("Display consensus?"); |
---|
1661 | aws->create_toggle(ED4_AWAR_CONSENSUS_SHOW); |
---|
1662 | } |
---|
1663 | |
---|
1664 | return aws; |
---|
1665 | } |
---|
1666 | |
---|
1667 | void ED4_create_consensus_awars(AW_root *aw_root) |
---|
1668 | { |
---|
1669 | GB_transaction dummy(GLOBAL_gb_main); |
---|
1670 | |
---|
1671 | aw_root->awar_int(ED4_AWAR_CONSENSUS_COUNTGAPS, 1)->add_callback(ED4_consensus_definition_changed, 0, 0); |
---|
1672 | aw_root->awar_int(ED4_AWAR_CONSENSUS_GAPBOUND, 60)->add_callback(ED4_consensus_definition_changed, 0, 0); |
---|
1673 | aw_root->awar_int(ED4_AWAR_CONSENSUS_GROUP, 1)->add_callback(ED4_consensus_definition_changed, 0, 0); |
---|
1674 | aw_root->awar_int(ED4_AWAR_CONSENSUS_CONSIDBOUND, 30)->add_callback(ED4_consensus_definition_changed, 0, 0); |
---|
1675 | aw_root->awar_int(ED4_AWAR_CONSENSUS_UPPER, 95)->add_callback(ED4_consensus_definition_changed, 0, 0); |
---|
1676 | aw_root->awar_int(ED4_AWAR_CONSENSUS_LOWER, 70)->add_callback(ED4_consensus_definition_changed, 0, 0); |
---|
1677 | |
---|
1678 | AW_awar *cons_show = aw_root->awar_int(ED4_AWAR_CONSENSUS_SHOW, 1); |
---|
1679 | |
---|
1680 | cons_show->write_int(1); |
---|
1681 | cons_show->add_callback(ED4_consensus_display_changed, 0, 0); |
---|
1682 | } |
---|
1683 | |
---|
1684 | void ED4_restart_editor(AW_window *aww, AW_CL, AW_CL) |
---|
1685 | { |
---|
1686 | ED4_start_editor_on_configuration(aww); |
---|
1687 | } |
---|
1688 | |
---|
1689 | AW_window *ED4_start_editor_on_old_configuration(AW_root *awr) |
---|
1690 | { |
---|
1691 | static AW_window_simple *aws = 0; |
---|
1692 | |
---|
1693 | if (aws) return (AW_window *)aws; |
---|
1694 | aws = new AW_window_simple; |
---|
1695 | aws->init( awr, "LOAD_OLD_CONFIGURATION", "SELECT A CONFIGURATION"); |
---|
1696 | aws->at(10,10); |
---|
1697 | aws->auto_space(0,0); |
---|
1698 | awt_create_selection_list_on_configurations(GLOBAL_gb_main,(AW_window *)aws,AWAR_EDIT_CONFIGURATION); |
---|
1699 | aws->at_newline(); |
---|
1700 | |
---|
1701 | aws->callback((AW_CB0)ED4_start_editor_on_configuration); |
---|
1702 | aws->create_button("LOAD","LOAD"); |
---|
1703 | |
---|
1704 | aws->callback(AW_POPDOWN); |
---|
1705 | aws->create_button("CLOSE","CLOSE","C"); |
---|
1706 | |
---|
1707 | aws->window_fit(); |
---|
1708 | return (AW_window *)aws; |
---|
1709 | } |
---|
1710 | |
---|
1711 | void ED4_save_configuration(AW_window *aww,AW_CL close_flag){ |
---|
1712 | char *cn = aww->get_root()->awar(AWAR_EDIT_CONFIGURATION)->read_string(); |
---|
1713 | if (close_flag) aww->hide(); |
---|
1714 | |
---|
1715 | ED4_ROOT->database->generate_config_string( cn ); |
---|
1716 | |
---|
1717 | free(cn); |
---|
1718 | } |
---|
1719 | |
---|
1720 | AW_window *ED4_save_configuration_as_open_window(AW_root *awr){ |
---|
1721 | static AW_window_simple *aws = 0; |
---|
1722 | if (aws) return (AW_window *)aws; |
---|
1723 | aws = new AW_window_simple; |
---|
1724 | aws->init( awr, "SAVE_CONFIGURATION", "SAVE A CONFIGURATION"); |
---|
1725 | aws->load_xfig("edit4/save_config.fig"); |
---|
1726 | |
---|
1727 | aws->at("close"); |
---|
1728 | aws->callback(AW_POPDOWN); |
---|
1729 | aws->create_button("CLOSE","CLOSE"); |
---|
1730 | |
---|
1731 | aws->at("help"); |
---|
1732 | aws->callback(AW_POPUP_HELP,(AW_CL)"configuration.hlp"); |
---|
1733 | aws->create_button("HELP","HELP"); |
---|
1734 | |
---|
1735 | aws->at("save"); |
---|
1736 | aws->create_input_field(AWAR_EDIT_CONFIGURATION); |
---|
1737 | |
---|
1738 | aws->at("confs"); |
---|
1739 | awt_create_selection_list_on_configurations(GLOBAL_gb_main,aws,AWAR_EDIT_CONFIGURATION); |
---|
1740 | |
---|
1741 | aws->at("go"); |
---|
1742 | aws->callback(ED4_save_configuration, 1); |
---|
1743 | aws->create_button("SAVE","SAVE"); |
---|
1744 | |
---|
1745 | return aws; |
---|
1746 | } |
---|
1747 | |
---|
1748 | static GB_ERROR createDataFromConsensus(GBDATA *gb_species, ED4_group_manager *group_man) |
---|
1749 | { |
---|
1750 | GB_ERROR error = 0; |
---|
1751 | ED4_char_table *table = &group_man->table(); |
---|
1752 | char *consensus = table->build_consensus_string(); |
---|
1753 | int len = table->size(); |
---|
1754 | int p; |
---|
1755 | char *equal_to = ED4_ROOT->aw_root->awar(ED4_AWAR_CREATE_FROM_CONS_REPL_EQUAL)->read_string(); |
---|
1756 | char *point_to = ED4_ROOT->aw_root->awar(ED4_AWAR_CREATE_FROM_CONS_REPL_POINT)->read_string(); |
---|
1757 | int allUpper = ED4_ROOT->aw_root->awar(ED4_AWAR_CREATE_FROM_CONS_ALL_UPPER)->read_int(); |
---|
1758 | |
---|
1759 | for (p=0; p<len; p++) { |
---|
1760 | switch (consensus[p]) { |
---|
1761 | case '=': consensus[p] = equal_to[0]; break; |
---|
1762 | case '.': consensus[p] = point_to[0]; break; |
---|
1763 | default: { |
---|
1764 | if (allUpper) { |
---|
1765 | consensus[p] = toupper(consensus[p]); |
---|
1766 | } |
---|
1767 | break; |
---|
1768 | } |
---|
1769 | } |
---|
1770 | } |
---|
1771 | |
---|
1772 | if (ED4_ROOT->aw_root->awar(ED4_AWAR_CREATE_FROM_CONS_CREATE_POINTS)) { // points at start & end of sequence? |
---|
1773 | for (p=0; p<len; p++) { |
---|
1774 | if (!ADPP_IS_ALIGN_CHARACTER(consensus[p])) break; |
---|
1775 | consensus[p] = '.'; |
---|
1776 | } |
---|
1777 | for (p=len-1; p>=0; p--) { |
---|
1778 | if (!ADPP_IS_ALIGN_CHARACTER(consensus[p])) break; |
---|
1779 | consensus[p] = '.'; |
---|
1780 | } |
---|
1781 | } |
---|
1782 | |
---|
1783 | GB_CSTR ali = GBT_get_default_alignment(GLOBAL_gb_main); |
---|
1784 | GBDATA *gb_ali = GB_search(gb_species, ali, GB_DB); |
---|
1785 | if (gb_ali) { |
---|
1786 | GBDATA *gb_data = GB_search(gb_ali, "data", GB_STRING); |
---|
1787 | error = GB_write_pntr(gb_data, consensus, len+1, len); |
---|
1788 | } |
---|
1789 | else { |
---|
1790 | error = GB_export_errorf("Can't find alignment '%s'", ali); |
---|
1791 | } |
---|
1792 | free(consensus); |
---|
1793 | return error; |
---|
1794 | } |
---|
1795 | |
---|
1796 | // -------------------------------------------------------------------------------- |
---|
1797 | |
---|
1798 | struct S_SpeciesMergeList { |
---|
1799 | GBDATA *species; |
---|
1800 | char *species_name; |
---|
1801 | struct S_SpeciesMergeList *next; |
---|
1802 | |
---|
1803 | }; |
---|
1804 | typedef struct S_SpeciesMergeList *SpeciesMergeList; |
---|
1805 | |
---|
1806 | static ED4_returncode add_species_to_merge_list(void **SpeciesMergeListPtr, void **GBDATAPtr, ED4_base *base) |
---|
1807 | { |
---|
1808 | if (base->is_species_name_terminal()) { |
---|
1809 | ED4_species_name_terminal *name_term = base->to_species_name_terminal(); |
---|
1810 | char *species_name = name_term->resolve_pointer_to_string_copy(); |
---|
1811 | GBDATA *gb_species_data = (GBDATA*)GBDATAPtr; |
---|
1812 | GBDATA *gb_species = GBT_find_species_rel_species_data(gb_species_data, species_name); |
---|
1813 | |
---|
1814 | if (gb_species) { |
---|
1815 | SpeciesMergeList *smlp = (SpeciesMergeList*)SpeciesMergeListPtr; |
---|
1816 | SpeciesMergeList sml = new S_SpeciesMergeList; |
---|
1817 | sml->species = gb_species; |
---|
1818 | sml->species_name = strdup(species_name); |
---|
1819 | sml->next = *smlp; |
---|
1820 | *smlp = sml; |
---|
1821 | } |
---|
1822 | |
---|
1823 | free(species_name); |
---|
1824 | } |
---|
1825 | return ED4_R_OK; |
---|
1826 | } |
---|
1827 | static int SpeciesMergeListLength(SpeciesMergeList sml) |
---|
1828 | { |
---|
1829 | int length = 0; |
---|
1830 | |
---|
1831 | while (sml) { |
---|
1832 | length++; |
---|
1833 | sml = sml->next; |
---|
1834 | } |
---|
1835 | |
---|
1836 | return length; |
---|
1837 | } |
---|
1838 | static void freeSpeciesMergeList(SpeciesMergeList sml) { |
---|
1839 | while (sml) { |
---|
1840 | free(sml->species_name); |
---|
1841 | freeset(sml, sml->next); |
---|
1842 | } |
---|
1843 | } |
---|
1844 | |
---|
1845 | // -------------------------------------------------------------------------------- |
---|
1846 | |
---|
1847 | inline bool nameIsUnique(const char *short_name, GBDATA *gb_species_data) { |
---|
1848 | return GBT_find_species_rel_species_data(gb_species_data, short_name)==0; |
---|
1849 | } |
---|
1850 | |
---|
1851 | static void create_new_species(AW_window */*aww*/, AW_CL cl_creation_mode) |
---|
1852 | // creation_mode == 0 -> create new species |
---|
1853 | // 1 -> create new species from group konsensus |
---|
1854 | // 2 -> copy current species |
---|
1855 | { |
---|
1856 | enum e_creation_mode { CREATE_NEW_SPECIES, CREATE_FROM_CONSENSUS, COPY_SPECIES } creation_mode = (enum e_creation_mode)(cl_creation_mode); |
---|
1857 | GB_CSTR new_species_full_name = ED4_ROOT->aw_root->awar(ED4_AWAR_SPECIES_TO_CREATE)->read_string(); // this contains the full_name now! |
---|
1858 | GB_CSTR error = 0; |
---|
1859 | |
---|
1860 | e4_assert(creation_mode>=0 && creation_mode<=2); |
---|
1861 | |
---|
1862 | if (!new_species_full_name || new_species_full_name[0]==0) { |
---|
1863 | error = GB_export_error("Please enter a full_name for the new species"); |
---|
1864 | } |
---|
1865 | else { |
---|
1866 | error = GB_begin_transaction(GLOBAL_gb_main); |
---|
1867 | GBDATA *gb_species_data = GB_search(GLOBAL_gb_main, "species_data", GB_CREATE_CONTAINER); |
---|
1868 | char *new_species_name = 0; |
---|
1869 | char *acc = 0; |
---|
1870 | char *addid = 0; |
---|
1871 | |
---|
1872 | enum e_dataSource { MERGE_FIELDS, COPY_FIELDS } dataSource = (enum e_dataSource)ED4_ROOT->aw_root ->awar(ED4_AWAR_CREATE_FROM_CONS_DATA_SOURCE)->read_int(); |
---|
1873 | enum { NOWHERE, ON_SPECIES, ON_KONSENSUS } where_we_are = NOWHERE; |
---|
1874 | ED4_terminal *cursor_terminal = 0; |
---|
1875 | |
---|
1876 | if (!error) { |
---|
1877 | if (creation_mode==CREATE_FROM_CONSENSUS || creation_mode==COPY_SPECIES) { |
---|
1878 | ED4_cursor *cursor = &ED4_ROOT->get_ed4w()->cursor; |
---|
1879 | |
---|
1880 | if (cursor->owner_of_cursor) { |
---|
1881 | cursor_terminal = cursor->owner_of_cursor->to_terminal(); |
---|
1882 | |
---|
1883 | if (cursor_terminal->parent->parent->flag.is_consensus) { |
---|
1884 | where_we_are = ON_KONSENSUS; |
---|
1885 | } |
---|
1886 | else { |
---|
1887 | where_we_are = ON_SPECIES; |
---|
1888 | } |
---|
1889 | } |
---|
1890 | } |
---|
1891 | |
---|
1892 | if (creation_mode==COPY_SPECIES || (creation_mode==CREATE_FROM_CONSENSUS && dataSource==COPY_FIELDS)) { |
---|
1893 | if (where_we_are==ON_SPECIES) { |
---|
1894 | ED4_species_name_terminal *spec_name = cursor_terminal->to_sequence_terminal()->corresponding_species_name_terminal(); |
---|
1895 | const char *source_name = spec_name->resolve_pointer_to_char_pntr(); |
---|
1896 | GBDATA *gb_source = GBT_find_species_rel_species_data(gb_species_data, source_name); |
---|
1897 | |
---|
1898 | GBDATA *gb_acc = GB_search(gb_source, "acc", GB_FIND); |
---|
1899 | if (gb_acc) acc = GB_read_string(gb_acc); // if has accession |
---|
1900 | |
---|
1901 | const char *add_field = AW_get_nameserver_addid(GLOBAL_gb_main); |
---|
1902 | GBDATA *gb_addid = add_field[0] ? GB_search(gb_source, add_field, GB_FIND) : 0; |
---|
1903 | if (gb_addid) addid = GB_read_as_string(gb_addid); |
---|
1904 | } |
---|
1905 | else { |
---|
1906 | error = "Please place cursor on a species"; |
---|
1907 | } |
---|
1908 | } |
---|
1909 | } |
---|
1910 | |
---|
1911 | if (!error) { |
---|
1912 | UniqueNameDetector *existingNames = 0; |
---|
1913 | |
---|
1914 | if (creation_mode==0) { |
---|
1915 | error = "It's no good idea to create the short-name for a new species using the nameserver! (has no acc yet)"; |
---|
1916 | } |
---|
1917 | else { |
---|
1918 | error = AWTC_generate_one_name(GLOBAL_gb_main, new_species_full_name, acc, addid, new_species_name, true, true); |
---|
1919 | if (!error) { // name was created |
---|
1920 | if (!nameIsUnique(new_species_name, gb_species_data)) { |
---|
1921 | if (!existingNames) existingNames = new UniqueNameDetector(gb_species_data); |
---|
1922 | freeset(new_species_name, AWTC_makeUniqueShortName(new_species_name, *existingNames)); |
---|
1923 | if (!new_species_name) error = GB_await_error(); |
---|
1924 | } |
---|
1925 | } |
---|
1926 | } |
---|
1927 | |
---|
1928 | if (error) { // try to make a random name |
---|
1929 | const char *msg = GBS_global_string("%s\nGenerating a random name instead.", error); |
---|
1930 | aw_message(msg); |
---|
1931 | error = 0; |
---|
1932 | |
---|
1933 | if (!existingNames) existingNames = new UniqueNameDetector(gb_species_data); |
---|
1934 | new_species_name = AWTC_generate_random_name(*existingNames); |
---|
1935 | |
---|
1936 | if (!new_species_name) { |
---|
1937 | error = GBS_global_string("Failed to create a new name for '%s'", new_species_full_name); |
---|
1938 | } |
---|
1939 | } |
---|
1940 | |
---|
1941 | if (existingNames) delete existingNames; |
---|
1942 | } |
---|
1943 | |
---|
1944 | if (!error) { |
---|
1945 | GBDATA *gb_new_species = 0; |
---|
1946 | |
---|
1947 | if (!error) { |
---|
1948 | if (creation_mode==CREATE_NEW_SPECIES) { |
---|
1949 | GBDATA *gb_created_species = GBT_find_or_create_species(GLOBAL_gb_main, new_species_name); |
---|
1950 | if (!gb_created_species) { |
---|
1951 | error = GBS_global_string("Failed to create new species '%s'", new_species_name); |
---|
1952 | } |
---|
1953 | else { |
---|
1954 | GB_CSTR ali = GBT_get_default_alignment(GLOBAL_gb_main); |
---|
1955 | GBDATA *gb_ali = GB_search(gb_created_species, ali, GB_DB); |
---|
1956 | |
---|
1957 | if (gb_ali) error = GBT_write_string(gb_ali, "data", "......."); |
---|
1958 | else error = GBS_global_string("Can't create alignment '%s' (Reason: %s)", ali, GB_await_error()); |
---|
1959 | } |
---|
1960 | if (!error) error = GBT_write_string(gb_created_species, "full_name", new_species_full_name); |
---|
1961 | } |
---|
1962 | else if (creation_mode==CREATE_FROM_CONSENSUS && dataSource==MERGE_FIELDS) |
---|
1963 | { // create from consensus (merge fields from all species in container) |
---|
1964 | if (where_we_are==NOWHERE) { |
---|
1965 | error = "Please place cursor on any sequence/consensus of group"; |
---|
1966 | } |
---|
1967 | else { |
---|
1968 | ED4_group_manager *group_man = cursor_terminal->get_parent(ED4_L_GROUP)->to_group_manager(); |
---|
1969 | SpeciesMergeList sml = 0; // list of species in group |
---|
1970 | |
---|
1971 | group_man->route_down_hierarchy((void**)&sml, (void**)gb_species_data, add_species_to_merge_list); |
---|
1972 | if (sml==0) { |
---|
1973 | error = "Please choose a none empty group!"; |
---|
1974 | } |
---|
1975 | |
---|
1976 | if (!error) { |
---|
1977 | GBDATA *gb_source = sml->species; |
---|
1978 | gb_new_species = GB_create_container(gb_species_data, "species"); |
---|
1979 | error = GB_copy(gb_new_species, gb_source); // copy first found species to create a new species |
---|
1980 | } |
---|
1981 | if (!error) error = GBT_write_string(gb_new_species, "name", new_species_name); // insert new 'name' |
---|
1982 | if (!error) error = GBT_write_string(gb_new_species, "full_name", new_species_full_name); // insert new 'full_name' |
---|
1983 | if (!error) error = createDataFromConsensus(gb_new_species, group_man); // insert consensus as 'data' |
---|
1984 | |
---|
1985 | if (!error) { |
---|
1986 | char *doneFields = strdup(";name;"); // all fields which are already merged |
---|
1987 | int doneLen = strlen(doneFields); |
---|
1988 | SpeciesMergeList sl = sml; |
---|
1989 | int sl_length = SpeciesMergeListLength(sml); |
---|
1990 | int *fieldStat = new int[sl_length]; // 0 = not used yet ; -1 = don't has field ; |
---|
1991 | // 1..n = field content (same number means same content) |
---|
1992 | |
---|
1993 | while (sl && !error) { // with all species do.. |
---|
1994 | char *newFields = GB_get_subfields(sl->species); |
---|
1995 | char *fieldStart = newFields; // points to ; before next field |
---|
1996 | |
---|
1997 | while (fieldStart[1] && !error) { // with all subfields of the species do.. |
---|
1998 | char *fieldEnd = strchr(fieldStart+1, ';'); |
---|
1999 | |
---|
2000 | e4_assert(fieldEnd); |
---|
2001 | char behind = fieldEnd[1]; |
---|
2002 | fieldEnd[1] = 0; |
---|
2003 | |
---|
2004 | if (strstr(doneFields, fieldStart)==0) { // field is not merged yet |
---|
2005 | char *fieldName = fieldStart+1; |
---|
2006 | int fieldLen = int(fieldEnd-fieldName); |
---|
2007 | |
---|
2008 | e4_assert(fieldEnd[0]==';'); |
---|
2009 | fieldEnd[0] = 0; |
---|
2010 | |
---|
2011 | GBDATA *gb_field = GB_search(sl->species, fieldName, GB_FIND); |
---|
2012 | e4_assert(gb_field); // field has to exist, cause it was found before |
---|
2013 | int type = gb_field->flags.type; //GB_TYPE(gb_field); |
---|
2014 | if (type==GB_STRING) { // we only merge string fields |
---|
2015 | int i; |
---|
2016 | int doneSpecies = 0; |
---|
2017 | int nextStat = 1; |
---|
2018 | |
---|
2019 | for (i=0; i<sl_length; i++) { // clear field status |
---|
2020 | fieldStat[i] = 0; |
---|
2021 | } |
---|
2022 | |
---|
2023 | while (doneSpecies<sl_length) { // since all species in list were handled |
---|
2024 | SpeciesMergeList sl2 = sml; |
---|
2025 | i = 0; |
---|
2026 | |
---|
2027 | while (sl2) { |
---|
2028 | if (fieldStat[i]==0) { |
---|
2029 | gb_field = GB_search(sl2->species, fieldName, GB_FIND); |
---|
2030 | if (gb_field) { |
---|
2031 | char *content = GB_read_as_string(gb_field); |
---|
2032 | SpeciesMergeList sl3 = sl2->next; |
---|
2033 | |
---|
2034 | fieldStat[i] = nextStat; |
---|
2035 | doneSpecies++; |
---|
2036 | int j = i+1; |
---|
2037 | while (sl3) { |
---|
2038 | if (fieldStat[j]==0) { |
---|
2039 | gb_field = GB_search(sl3->species, fieldName, GB_FIND); |
---|
2040 | if (gb_field) { |
---|
2041 | char *content2 = GB_read_as_string(gb_field); |
---|
2042 | |
---|
2043 | if (strcmp(content, content2)==0) { // if contents are the same, they get the same status |
---|
2044 | fieldStat[j] = nextStat; |
---|
2045 | doneSpecies++; |
---|
2046 | } |
---|
2047 | free(content2); |
---|
2048 | } |
---|
2049 | else { |
---|
2050 | fieldStat[j] = -1; |
---|
2051 | doneSpecies++; |
---|
2052 | } |
---|
2053 | } |
---|
2054 | sl3 = sl3->next; |
---|
2055 | j++; |
---|
2056 | } |
---|
2057 | |
---|
2058 | free(content); |
---|
2059 | nextStat++; |
---|
2060 | } |
---|
2061 | else { |
---|
2062 | fieldStat[i] = -1; // field does not exist here |
---|
2063 | doneSpecies++; |
---|
2064 | } |
---|
2065 | } |
---|
2066 | sl2 = sl2->next; |
---|
2067 | i++; |
---|
2068 | } |
---|
2069 | } |
---|
2070 | |
---|
2071 | e4_assert(nextStat!=1); // this would mean that none of the species contained the field |
---|
2072 | |
---|
2073 | { |
---|
2074 | char *new_content = 0; |
---|
2075 | int new_content_len = 0; |
---|
2076 | |
---|
2077 | if (nextStat==2) { // all species contain same field content or do not have the field |
---|
2078 | SpeciesMergeList sl2 = sml; |
---|
2079 | |
---|
2080 | while (sl2) { |
---|
2081 | gb_field = GB_search(sl2->species, fieldName, GB_FIND); |
---|
2082 | if (gb_field) { |
---|
2083 | new_content = GB_read_as_string(gb_field); |
---|
2084 | new_content_len = strlen(new_content); |
---|
2085 | break; |
---|
2086 | } |
---|
2087 | sl2 = sl2->next; |
---|
2088 | } |
---|
2089 | } |
---|
2090 | else { // different field contents |
---|
2091 | int actualStat; |
---|
2092 | for (actualStat=1; actualStat<nextStat; actualStat++) { |
---|
2093 | int names_len = 1; // open bracket |
---|
2094 | SpeciesMergeList sl2 = sml; |
---|
2095 | i = 0; |
---|
2096 | char *content = 0; |
---|
2097 | |
---|
2098 | while (sl2) { |
---|
2099 | if (fieldStat[i]==actualStat) { |
---|
2100 | names_len += strlen(sl2->species_name)+1; |
---|
2101 | if (!content) { |
---|
2102 | gb_field = GB_search(sl2->species, fieldName, GB_FIND); |
---|
2103 | e4_assert(gb_field); |
---|
2104 | content = GB_read_as_string(gb_field); |
---|
2105 | } |
---|
2106 | } |
---|
2107 | sl2 = sl2->next; |
---|
2108 | i++; |
---|
2109 | } |
---|
2110 | |
---|
2111 | e4_assert(content); |
---|
2112 | int add_len = names_len+1+strlen(content); |
---|
2113 | char *whole = (char*)malloc(new_content_len+1+add_len+1); |
---|
2114 | e4_assert(whole); |
---|
2115 | char *add = new_content ? whole+sprintf(whole, "%s ", new_content) : whole; |
---|
2116 | sl2 = sml; |
---|
2117 | i = 0; |
---|
2118 | int first = 1; |
---|
2119 | while (sl2) { |
---|
2120 | if (fieldStat[i]==actualStat) { |
---|
2121 | add += sprintf(add, "%c%s", first ? '{' : ';', sl2->species_name); |
---|
2122 | first = 0; |
---|
2123 | } |
---|
2124 | sl2 = sl2->next; |
---|
2125 | i++; |
---|
2126 | } |
---|
2127 | add += sprintf(add, "} %s", content); |
---|
2128 | |
---|
2129 | free(content); |
---|
2130 | |
---|
2131 | freeset(new_content, whole); |
---|
2132 | new_content_len = strlen(new_content); |
---|
2133 | } |
---|
2134 | } |
---|
2135 | |
---|
2136 | if (new_content) { |
---|
2137 | error = GBT_write_string(gb_new_species, fieldName, new_content); |
---|
2138 | free(new_content); |
---|
2139 | } |
---|
2140 | } |
---|
2141 | } |
---|
2142 | |
---|
2143 | // mark field as done: |
---|
2144 | char *new_doneFields = (char*)malloc(doneLen+fieldLen+1+1); |
---|
2145 | sprintf(new_doneFields, "%s%s;", doneFields, fieldName); |
---|
2146 | doneLen += fieldLen+1; |
---|
2147 | freeset(doneFields, new_doneFields); |
---|
2148 | |
---|
2149 | fieldEnd[0] = ';'; |
---|
2150 | } |
---|
2151 | |
---|
2152 | fieldEnd[1] = behind; |
---|
2153 | fieldStart = fieldEnd; |
---|
2154 | } |
---|
2155 | free(newFields); |
---|
2156 | sl = sl->next; |
---|
2157 | } |
---|
2158 | free(doneFields); |
---|
2159 | free(fieldStat); |
---|
2160 | } |
---|
2161 | freeSpeciesMergeList(sml); sml = 0; |
---|
2162 | } |
---|
2163 | } |
---|
2164 | else { // copy species or create from consensus (copy fields from one species) |
---|
2165 | e4_assert(where_we_are==ON_SPECIES); |
---|
2166 | |
---|
2167 | ED4_species_name_terminal *spec_name = cursor_terminal->to_sequence_terminal()->corresponding_species_name_terminal(); |
---|
2168 | const char *source_name = spec_name->resolve_pointer_to_char_pntr(); |
---|
2169 | GBDATA *gb_source = GBT_find_species_rel_species_data(gb_species_data, source_name); |
---|
2170 | |
---|
2171 | if (gb_source) { |
---|
2172 | gb_new_species = GB_create_container(gb_species_data, "species"); |
---|
2173 | error = GB_copy(gb_new_species, gb_source); |
---|
2174 | if (!error) error = GBT_write_string(gb_new_species, "name", new_species_name); |
---|
2175 | if (!error) error = GBT_write_string(gb_new_species, "full_name", new_species_full_name); // insert new 'full_name' |
---|
2176 | if (!error && creation_mode==CREATE_FROM_CONSENSUS) { |
---|
2177 | ED4_group_manager *group_man = cursor_terminal->get_parent(ED4_L_GROUP)->to_group_manager(); |
---|
2178 | error = createDataFromConsensus(gb_new_species, group_man); |
---|
2179 | } |
---|
2180 | } |
---|
2181 | else { |
---|
2182 | error = GBS_global_string("Can't find species '%s'", source_name); |
---|
2183 | } |
---|
2184 | } |
---|
2185 | } |
---|
2186 | |
---|
2187 | if (error) { |
---|
2188 | GB_abort_transaction(GLOBAL_gb_main); |
---|
2189 | } |
---|
2190 | else { |
---|
2191 | GB_pop_transaction(GLOBAL_gb_main); |
---|
2192 | |
---|
2193 | ED4_get_and_jump_to_species(new_species_name); |
---|
2194 | ED4_ROOT->refresh_all_windows(1); |
---|
2195 | } |
---|
2196 | } |
---|
2197 | |
---|
2198 | free(addid); |
---|
2199 | free(acc); |
---|
2200 | free(new_species_name); |
---|
2201 | } |
---|
2202 | |
---|
2203 | if (error) aw_popup_ok(error); |
---|
2204 | } |
---|
2205 | |
---|
2206 | AW_window *ED4_create_new_seq_window(AW_root *root, AW_CL cl_creation_mode) |
---|
2207 | // creation_mode == 0 -> create new species |
---|
2208 | // 1 -> create new species from group konsensus |
---|
2209 | // 2 -> copy current species |
---|
2210 | { |
---|
2211 | AW_window_simple *aws = new AW_window_simple; |
---|
2212 | int creation_mode = int(cl_creation_mode); |
---|
2213 | switch (creation_mode) { |
---|
2214 | case 0: |
---|
2215 | aws->init( root, "create_species","Create species"); |
---|
2216 | break; |
---|
2217 | case 1: |
---|
2218 | aws->init( root, "create_species_from_consensus","Create species from consensus"); |
---|
2219 | break; |
---|
2220 | case 2: |
---|
2221 | aws->init( root, "copy_species","Copy current species"); |
---|
2222 | break; |
---|
2223 | default: |
---|
2224 | e4_assert(0); |
---|
2225 | return 0; |
---|
2226 | } |
---|
2227 | if (creation_mode==1) { // create from consensus |
---|
2228 | aws->load_xfig("edit4/create_seq_fc.fig"); |
---|
2229 | } |
---|
2230 | else { |
---|
2231 | aws->load_xfig("edit4/create_seq.fig"); |
---|
2232 | } |
---|
2233 | |
---|
2234 | aws->callback( (AW_CB0)AW_POPDOWN); |
---|
2235 | aws->at("close"); |
---|
2236 | aws->create_button("CLOSE", "CLOSE","C"); |
---|
2237 | |
---|
2238 | aws->at("label"); |
---|
2239 | aws->create_autosize_button(0,"Please enter the FULL_NAME\nof the new species"); |
---|
2240 | |
---|
2241 | aws->at("input"); |
---|
2242 | aws->create_input_field(ED4_AWAR_SPECIES_TO_CREATE, 30); |
---|
2243 | |
---|
2244 | aws->at("ok"); |
---|
2245 | aws->callback(create_new_species, cl_creation_mode); |
---|
2246 | aws->create_button("GO","GO","g"); |
---|
2247 | |
---|
2248 | if (creation_mode==1) { // create from consensus |
---|
2249 | aws->at("replace_equal"); |
---|
2250 | aws->label("Replace '=' by "); |
---|
2251 | aws->create_input_field(ED4_AWAR_CREATE_FROM_CONS_REPL_EQUAL, 1); |
---|
2252 | |
---|
2253 | aws->at("replace_point"); |
---|
2254 | aws->label("Replace '.' by "); |
---|
2255 | aws->create_input_field(ED4_AWAR_CREATE_FROM_CONS_REPL_POINT, 1); |
---|
2256 | |
---|
2257 | aws->at("replace_start_end"); |
---|
2258 | aws->label("Create ... at ends of sequence?"); |
---|
2259 | aws->create_toggle(ED4_AWAR_CREATE_FROM_CONS_CREATE_POINTS); |
---|
2260 | |
---|
2261 | aws->at("upper"); |
---|
2262 | aws->label("Convert all chars to upper?"); |
---|
2263 | aws->create_toggle(ED4_AWAR_CREATE_FROM_CONS_ALL_UPPER); |
---|
2264 | |
---|
2265 | aws->at("data"); |
---|
2266 | aws->create_option_menu(ED4_AWAR_CREATE_FROM_CONS_DATA_SOURCE, "Other fields", ""); |
---|
2267 | aws->insert_default_option("Merge from all in group", "", 0); |
---|
2268 | aws->insert_option("Copy from current species", "", 1); |
---|
2269 | aws->update_option_menu(); |
---|
2270 | } |
---|
2271 | |
---|
2272 | return (AW_window *)aws; |
---|
2273 | } |
---|
2274 | |
---|