Context Navigation

source: branches/profile/EDIT4/ED4_root.cxx

Visit:

Last change on this file was 12803, checked in by westram, 10 years ago
merge from 'alilink' into 'trunk' adds: log:branches/alilink@12801:12802
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 79.0 KB

Line
1	// =============================================================== //
2	// //
3	// File : ED4_root.cxx //
4	// Purpose : //
5	// //
6	// Institute of Microbiology (Technical University Munich) //
7	// http://www.arb-home.de/ //
8	// //
9	// =============================================================== //
10
11	#include "ed4_class.hxx"
12	#include "ed4_awars.hxx"
13	#include "ed4_tools.hxx"
14	#include "ed4_block.hxx"
15	#include "ed4_dots.hxx"
16	#include "ed4_nds.hxx"
17	#include "ed4_list.hxx"
18	#include "ed4_plugins.hxx"
19	#include "ed4_visualizeSAI.hxx"
20	#include "ed4_naligner.hxx"
21	#include "ed4_ProteinViewer.hxx"
22	#include "ed4_protein_2nd_structure.hxx"
23	#include "graph_aligner_gui.hxx"
24	#include "ed4_colStat.hxx"
25
26	#include <ed4_extern.hxx>
27	#include <fast_aligner.hxx>
28	#include <AW_helix.hxx>
29	#include <gde.hxx>
30	#include <awt.hxx>
31	#include <awt_seq_colors.hxx>
32	#include <awt_map_key.hxx>
33	#include <aw_awars.hxx>
34	#include <aw_preset.hxx>
35	#include <aw_msg.hxx>
36	#include <arb_progress.h>
37	#include <aw_root.hxx>
38	#include <aw_question.hxx>
39	#include <aw_advice.hxx>
40	#include "../WINDOW/aw_status.hxx" // @@@ hack - obsolete when EDIT4 status works like elsewhere
41	#include <arb_version.h>
42	#include <arb_file.h>
43	#include <arbdbt.h>
44	#include <ad_cb.h>
45	#include <macros.hxx>
46
47	#include <cctype>
48	#include <map>
49
50	AW_window AWTC_create_island_hopping_window(AW_root root, AW_CL);
51
52	ED4_WinContext ED4_WinContext::current_context;
53
54	void ED4_folding_line::warn_illegal_dimension() {
55	#if defined(DEBUG)
56	if (dimension<0.0) {
57	// e4_assert(0); // crashes gdb when called from scrollbar callback - so instead only dump backtrace
58	const char *msg = GBS_global_string("illegal dimension %f\n", dimension);
59	GBK_dump_backtrace(stderr, msg);
60	}
61	#endif
62	}
63
64	void ED4_WinContext::warn_missing_context() const {
65	e4_assert(0);
66	GBK_dump_backtrace(stderr, "Missing context");
67	aw_message("Missing context - please send information from console to devel@arb-home.de");
68	}
69
70	static ARB_ERROR request_terminal_refresh(ED4_base *base, AW_CL cl_level) {
71	ED4_level lev = ED4_level(cl_level);
72	if (lev == ED4_L_NO_LEVEL \|\| (base->spec.level&lev) != 0) {
73	if (base->is_terminal()) base->request_refresh();
74	}
75	return NULL;
76	}
77
78	void ED4_root::request_refresh_for_all_terminals() {
79	main_manager->route_down_hierarchy(request_terminal_refresh, ED4_L_NO_LEVEL).expect_no_error();
80	}
81
82	void ED4_root::request_refresh_for_specific_terminals(ED4_level lev) {
83	main_manager->route_down_hierarchy(request_terminal_refresh, lev).expect_no_error();
84	}
85
86
87	static ARB_ERROR request_sequence_refresh(ED4_base *base, AW_CL cl_consensi) {
88	ARB_ERROR error;
89	if (base->spec.level & ED4_L_SPECIES) {
90	bool consensi = bool(cl_consensi);
91	if (base->is_consensus_manager() == consensi) {
92	error = base->to_manager()->route_down_hierarchy(request_terminal_refresh, ED4_L_SEQUENCE_STRING);
93	}
94	}
95	return error;
96	}
97
98	// if you want to refresh consensi AND sequences you may use request_refresh_for_specific_terminals(ED4_L_SEQUENCE_STRING)
99	void ED4_root::request_refresh_for_consensus_terminals() {
100	main_manager->route_down_hierarchy(request_sequence_refresh, true).expect_no_error();
101	}
102	void ED4_root::request_refresh_for_sequence_terminals() {
103	if (main_manager) {
104	main_manager->route_down_hierarchy(request_sequence_refresh, false).expect_no_error();
105	}
106	}
107
108	void ED4_root::refresh_window_simple(bool redraw) {
109	// if 'redraw' -> update everything (ignoring refresh flag)
110	int refresh_all = 0;
111	if (redraw) {
112	#if defined(TRACE_REFRESH)
113	fprintf(stderr, "- clear display (refresh_window_simple(redraw=true) called)\n"); fflush(stderr);
114	#endif
115	main_manager->update_info.set_clear_at_refresh(1);
116	refresh_all = 1;
117	}
118
119	main_manager->Show(refresh_all, 0);
120	if (redraw) main_manager->update_info.set_clear_at_refresh(0);
121	}
122
123	void ED4_root::handle_update_requests(bool& redraw) {
124	if (main_manager->update_info.delete_requested) {
125	#if defined(TRACE_REFRESH)
126	fprintf(stderr, "- handling requested deletes\n"); fflush(stderr);
127	#endif
128	main_manager->delete_requested_children();
129	redraw = true;
130	}
131
132	if (main_manager->update_info.update_requested) {
133	#if defined(TRACE_REFRESH)
134	fprintf(stderr, "- handling requested updates\n"); fflush(stderr);
135	#endif
136	main_manager->update_requested_children();
137	redraw = true; // @@@ needed ?
138	}
139
140	while (main_manager->update_info.resize) {
141	#if defined(TRACE_REFRESH)
142	fprintf(stderr, "- handling requested resizes\n"); fflush(stderr);
143	#endif
144	main_manager->resize_requested_children();
145	redraw = true;
146	}
147
148	// make sure all update request have been handled:
149	e4_assert(!main_manager->update_info.delete_requested);
150	e4_assert(!main_manager->update_info.update_requested);
151	e4_assert(!main_manager->update_info.resize);
152	}
153
154	void ED4_root::special_window_refresh(bool handle_updates) {
155	// this function should only be used for window specific updates (e.g. cursor placement/deletion)
156	e4_assert(ED4_WinContext::have_context());
157
158	bool redraw = true;
159	if (handle_updates) handle_update_requests(redraw);
160	refresh_window_simple(redraw);
161	// do NOT clear_refresh_requests here!! this is no full refresh!
162	}
163
164	ED4_returncode ED4_root::refresh_all_windows(bool redraw) {
165	// if 'redraw' -> update everything (ignoring refresh flag)
166	GB_transaction ta(GLOBAL_gb_main);
167
168	handle_update_requests(redraw);
169
170	ED4_window *window = first_window;
171	while (window) {
172	ED4_LocalWinContext uses(window);
173	refresh_window_simple(redraw);
174	window = window->next;
175	}
176
177	if (main_manager->update_info.refresh) main_manager->clear_refresh();
178
179	return (ED4_R_OK);
180	}
181
182	// --------------------------------------------------------------------------------
183
184	#ifdef UNIT_TESTS
185	#ifndef TEST_UNIT_H
186	#include <test_unit.h>
187	#endif
188
189	static arb_test::match_expectation correct_win2world_calculation(ED4_foldable& foldable, int xwin_org, int ywin_org, int xwrld_expd, int ywrld_expd) {
190	using namespace arb_test;
191	match_expectation precondition(all().of(that(xwrld_expd).is_more_or_equal(xwin_org),
192	that(ywrld_expd).is_more_or_equal(ywin_org)));
193
194	AW_pos xwrld_calc = xwin_org;
195	AW_pos ywrld_calc = ywin_org;
196	foldable.win_to_world_coords(&xwrld_calc, &ywrld_calc);
197
198	match_expectation win_2_world_conversion(all().of(that(xwrld_calc).is_equal_to(xwrld_expd),
199	that(ywrld_calc).is_equal_to(ywrld_expd)));
200
201	AW_pos xwin_back = xwrld_calc;
202	AW_pos ywin_back = ywrld_calc;
203	foldable.world_to_win_coords(&xwin_back, &ywin_back);
204
205	match_expectation world_back2_win_conversion(all().of(that(xwin_back).is_equal_to(xwin_org),
206	that(ywin_back).is_equal_to(ywin_org)));
207
208	return all().of(precondition, win_2_world_conversion, world_back2_win_conversion);
209	}
210
211	static arb_test::match_expectation correct_world2win_calculation(ED4_foldable& foldable, int xwrld_org, int ywrld_org, int xwin_expd, int ywin_expd) {
212	using namespace arb_test;
213	match_expectation precondition(all().of(that(xwrld_org).is_more_or_equal(xwin_expd),
214	that(ywrld_org).is_more_or_equal(ywin_expd)));
215
216
217	AW_pos xwin_calc = xwrld_org;
218	AW_pos ywin_calc = ywrld_org;
219	foldable.world_to_win_coords(&xwin_calc, &ywin_calc);
220
221	match_expectation world_2_win_conversion(all().of(that(xwin_calc).is_equal_to(xwin_expd),
222	that(ywin_calc).is_equal_to(ywin_expd)));
223
224	return all().of(precondition, world_2_win_conversion);
225	}
226
227	#define TEST_EXPECT_WIN_UNFOLDED(xwi,ywi) TEST_EXPECTATION(correct_win2world_calculation(foldable, xwi, ywi, xwi, ywi))
228	#define TEST_EXPECT_WIN_WORLD_FOLDING(xwi,ywi,fx,fy) TEST_EXPECTATION(correct_win2world_calculation(foldable, xwi, ywi, (xwi)+(fx), (ywi)+(fy)))
229	#define TEST_EXPECT_WORLD_WIN_FOLDING(xwo,ywo,xwi,ywi) TEST_EXPECTATION(correct_world2win_calculation(foldable, xwo, ywo, xwi, ywi))
230
231	#define TEST_EXPECT_WIN_WORLD_FOLDING__BROKEN(xwi,ywi,fx,fy) TEST_EXPECTATION__BROKEN(correct_win2world_calculation(foldable, xwi, ywi, (xwi)+(fx), (ywi)+(fy)))
232	#define TEST_EXPECT_WIN_WORLD_FOLDING__BROKENIF(when,xwi,ywi,fx,fy) TEST_EXPECTATION__BROKENIF(when, correct_win2world_calculation(foldable, xwi, ywi, (xwi)+(fx), (ywi)+(fy)))
233
234	void TEST_win_2_world() {
235	ED4_foldable foldable;
236
237	const int X1 = 200;
238	const int X2 = 300;
239	const int Y1 = 100;
240	const int Y2 = 200;
241
242	ED4_folding_line *hor100 = foldable.insert_folding_line(Y1, 0, ED4_P_HORIZONTAL);
243	ED4_folding_line *ver200 = foldable.insert_folding_line(X1, 0, ED4_P_VERTICAL);
244	ED4_folding_line *hor200 = foldable.insert_folding_line(Y2, 0, ED4_P_HORIZONTAL);
245	ED4_folding_line *ver300 = foldable.insert_folding_line(X2, 0, ED4_P_VERTICAL);
246
247	// nothing folded yet
248
249	const int x01 = X1/2;
250	const int x12 = (X1+X2)/2;
251	const int x23 = X2+x01;
252
253	const int y01 = Y1/2;
254	const int y12 = (Y1+Y2)/2;
255	const int y23 = Y2+y01;
256
257	TEST_EXPECT_WIN_UNFOLDED(x01, y01);
258	TEST_EXPECT_WIN_UNFOLDED(x12, y01);
259	TEST_EXPECT_WIN_UNFOLDED(x23, y01);
260
261	TEST_EXPECT_WIN_UNFOLDED(x01, y12);
262	TEST_EXPECT_WIN_UNFOLDED(x12, y12);
263	TEST_EXPECT_WIN_UNFOLDED(x23, y12);
264
265	TEST_EXPECT_WIN_UNFOLDED(x01, y23);
266	TEST_EXPECT_WIN_UNFOLDED(x12, y23);
267	TEST_EXPECT_WIN_UNFOLDED(x23, y23);
268
269	for (int FACTOR = 1; FACTOR <= 100; FACTOR += 7) {
270	TEST_ANNOTATE(GBS_global_string("FACTOR=%i", FACTOR));
271	int H1 = FACTOR* 10;
272	int H2 = FACTOR* 40;
273	int V1 = FACTOR* 20;
274	int V2 = FACTOR* 80;
275
276	hor100->set_dimension(H1);
277	hor200->set_dimension(H2);
278	ver200->set_dimension(V1);
279	ver300->set_dimension(V2);
280
281	TEST_EXPECT_WIN_UNFOLDED (x01, y01); // always in unfolded range
282	TEST_EXPECT_WIN_WORLD_FOLDING(x12, y01, V1, 0);
283	TEST_EXPECT_WIN_WORLD_FOLDING(x23, y01, V1+V2, 0);
284
285	TEST_EXPECT_WIN_WORLD_FOLDING(x01, y12, 0, H1);
286	TEST_EXPECT_WIN_WORLD_FOLDING(x12, y12, V1, H1);
287	TEST_EXPECT_WIN_WORLD_FOLDING(x23, y12, V1+V2, H1);
288
289	TEST_EXPECT_WIN_WORLD_FOLDING(x01, y23, 0, H1+H2);
290	TEST_EXPECT_WIN_WORLD_FOLDING(x12, y23, V1, H1+H2);
291	TEST_EXPECT_WIN_WORLD_FOLDING(x23, y23, V1+V2, H1+H2);
292
293	// test "folded" world positions.
294	// they result in win positions lower than folding line!
295	TEST_EXPECT_WORLD_WIN_FOLDING(X1-1, Y1-1, X1-1, Y1-1); // left of/above folded range
296	TEST_EXPECT_WORLD_WIN_FOLDING(X1, Y1, X1-V1, Y1-H1); // left/upper end of folded range
297	TEST_EXPECT_WORLD_WIN_FOLDING(X1+5, Y1+5, X1+5-V1, Y1+5-H1); // in folded range
298	TEST_EXPECT_WORLD_WIN_FOLDING(X1+V1, Y1+H1, X1, Y1); // right/lower end of folded range
299	TEST_EXPECT_WORLD_WIN_FOLDING(X1+V1+1, Y1+H1+1, X1+1, Y1+1); // right of/below folded range
300	}
301	}
302
303	#endif // UNIT_TESTS
304
305	// --------------------------------------------------------------------------------
306
307	ED4_returncode ED4_root::deselect_all()
308	{
309	ED4_multi_species_manager *main_multi_man = middle_area_man->get_multi_species_manager();
310	main_multi_man->deselect_all_species_and_SAI();
311
312	main_multi_man = top_area_man->get_multi_species_manager();
313	main_multi_man->deselect_all_species_and_SAI();
314
315	return ED4_R_OK;
316	}
317
318	void ED4_root::remove_from_selected(ED4_species_name_terminal *name_term) { // @@@ change param to ED4_species_manager ?
319	if (name_term) {
320	if ((selected_objects->has_elem(name_term->selection_info))) {
321	selected_objects->remove_elem(name_term->selection_info);
322
323	delete name_term->selection_info;
324	name_term->selection_info = NULL;
325	name_term->containing_species_manager()->set_selected(false);
326	name_term->dragged = false; // @@@ caller shall do this
327
328	#ifdef DEBUG
329	GBDATA *gbd = name_term->get_species_pointer();
330
331	if (gbd) {
332	printf("removed term '%s'\n", GB_read_char_pntr(gbd));
333	}
334	else {
335	ED4_species_manager *spec_man = name_term->get_parent(ED4_L_SPECIES)->to_species_manager();
336
337	if (spec_man->is_consensus_manager()) {
338	printf("removed consensus '%s'\n", name_term->id);
339	}
340	else {
341	printf("removed unknown term '%s'\n", name_term->id ? name_term->id : "NULL");
342	}
343	}
344	#endif
345
346	name_term->request_refresh();
347	ED4_sequence_terminal *seq_term = name_term->corresponding_sequence_terminal();
348	if (seq_term) seq_term->request_refresh();
349
350	// ProtView: Refresh corresponding orf terminals
351	if (alignment_type == GB_AT_DNA) {
352	PV_CallBackFunction(this->aw_root);
353	}
354
355	ED4_multi_species_manager *multi_man = name_term->get_parent(ED4_L_MULTI_SPECIES)->to_multi_species_manager();
356	multi_man->invalidate_species_counters();
357	}
358	}
359	}
360
361	void ED4_root::announce_useraction_in(AW_window *aww) {
362	for (ED4_window *win = first_window; win; win = win->next) {
363	if (win->aww == aww) {
364	most_recently_used_window = win;
365	}
366	}
367	}
368
369	ED4_returncode ED4_root::add_to_selected(ED4_species_name_terminal *name_term) { // @@@ change param to ED4_species_manager ?
370	if (!name_term \|\| !(name_term->dynamic_prop & ED4_P_SELECTABLE)) { // check if object exists and may be selected
371	return (ED4_R_IMPOSSIBLE);
372	}
373
374	if (!(selected_objects->has_elem(name_term->selection_info))) { // object is really new to our list => calculate current extension and append it
375	ED4_selection_entry *sel_info = new ED4_selection_entry;
376	name_term->selection_info = sel_info;
377
378	if (name_term->dynamic_prop & ED4_P_IS_HANDLE) { // object is a handle for an object up in the hierarchy => search it
379	ED4_level mlevel = name_term->spec.handled_level;
380	ED4_base *tmp_object = name_term;
381
382	while ((tmp_object != NULL) && !(tmp_object->spec.level & mlevel)) {
383	tmp_object = tmp_object->parent;
384	}
385
386	if (!tmp_object) return (ED4_R_WARNING); // no target level found
387
388	sel_info->actual_width = tmp_object->extension.size[WIDTH];
389	sel_info->actual_height = tmp_object->extension.size[HEIGHT];
390	}
391	else // selected object is no handle => take it directly
392	{
393	sel_info->actual_width = name_term->extension.size[WIDTH];
394	sel_info->actual_height = name_term->extension.size[HEIGHT];
395	}
396
397	sel_info->drag_old_x = 0;
398	sel_info->drag_old_y = 0;
399	sel_info->drag_off_x = 0;
400	sel_info->drag_off_y = 0;
401	sel_info->old_event_y = 0;
402
403	sel_info->object = name_term;
404
405	selected_objects->prepend_elem(sel_info);
406
407	name_term->containing_species_manager()->set_selected(true);
408
409	#ifdef DEBUG
410	GBDATA *gbd = name_term->get_species_pointer();
411
412	if (gbd) {
413	printf("added term '%s'\n", GB_read_char_pntr(gbd));
414	}
415	else {
416	ED4_species_manager *spec_man = name_term->get_parent(ED4_L_SPECIES)->to_species_manager();
417	if (spec_man->is_consensus_manager()) {
418	printf("added consensus '%s'\n", name_term->id);
419	}
420	else {
421	printf("added unknown term '%s'\n", name_term->id ? name_term->id : "NULL");
422	}
423	}
424	#endif
425
426	name_term->request_refresh();
427	ED4_sequence_terminal *seq_term = name_term->corresponding_sequence_terminal();
428	if (seq_term) seq_term->request_refresh();
429
430	// ProtView: Refresh corresponding orf terminals
431	if (alignment_type == GB_AT_DNA) {
432	PV_CallBackFunction(this->aw_root);
433	}
434
435	ED4_multi_species_manager *multi_man = name_term->get_parent(ED4_L_MULTI_SPECIES)->to_multi_species_manager();
436	multi_man->invalidate_species_counters();
437
438	return (ED4_R_OK);
439	}
440
441	return (ED4_R_IMPOSSIBLE);
442	}
443
444	void ED4_root::resize_all() {
445	while (main_manager->update_info.resize) {
446	main_manager->resize_requested_children();
447	}
448	}
449
450	static ARB_ERROR change_char_table_length(ED4_base *base, AW_CL new_length) {
451	if (base->is_abstract_group_manager()) {
452	ED4_abstract_group_manager *group_man = base->to_abstract_group_manager();
453	group_man->table().change_table_length(new_length);
454	}
455	return NULL;
456	}
457
458	void ED4_alignment_length_changed(GBDATA *gb_alignment_len, GB_CB_TYPE IF_ASSERTION_USED(gbtype)) // callback from database
459	{
460	e4_assert(gbtype==GB_CB_CHANGED);
461	int new_length = GB_read_int(gb_alignment_len);
462
463	#if defined(DEBUG) && 1
464	printf("alignment_length_changed from %i to %i\n", MAXSEQUENCECHARACTERLENGTH, new_length);
465	#endif
466
467	if (MAXSEQUENCECHARACTERLENGTH!=new_length) { // otherwise we already did this (i.e. we were called by changed_by_database)
468	bool was_increased = new_length>MAXSEQUENCECHARACTERLENGTH;
469
470	MAXSEQUENCECHARACTERLENGTH = new_length;
471
472	{
473	const char *err = ED4_ROOT->helix->init(GLOBAL_gb_main); // reload helix
474	aw_message_if(err);
475	}
476	{
477	const char *err = ED4_ROOT->ecoli_ref->init(GLOBAL_gb_main); // reload ecoli
478	aw_message_if(err);
479	}
480
481	if (ED4_ROOT->alignment_type == GB_AT_AA) {
482	// TODO: is this needed here?
483	const char *err = ED4_pfold_set_SAI(&ED4_ROOT->protstruct, GLOBAL_gb_main, ED4_ROOT->alignment_name, &ED4_ROOT->protstruct_len); // reload protstruct
484	aw_message_if(err);
485	}
486
487	if (was_increased) {
488	ED4_ROOT->main_manager->route_down_hierarchy(change_char_table_length, new_length).expect_no_error();
489	ED4_ROOT->root_group_man->remap()->mark_compile_needed_force();
490	}
491	}
492	}
493
494	ARB_ERROR ED4_root::init_alignment() {
495	GB_transaction ta(GLOBAL_gb_main);
496
497	alignment_name = GBT_get_default_alignment(GLOBAL_gb_main);
498	alignment_type = GBT_get_alignment_type(GLOBAL_gb_main, alignment_name);
499	if (alignment_type==GB_AT_UNKNOWN) {
500	return GBS_global_string("You have to select a valid alignment before you can start ARB_EDIT4\n(%s)", GB_await_error());
501	}
502
503	GBDATA *gb_alignment = GBT_get_alignment(GLOBAL_gb_main, alignment_name);
504	if (!gb_alignment) {
505	return GBS_global_string("You can't edit without an existing alignment\n(%s)", GB_await_error());
506	}
507
508	GBDATA *gb_alignment_len = GB_search(gb_alignment, "alignment_len", GB_FIND);
509	int alignment_length = GB_read_int(gb_alignment_len);
510	MAXSEQUENCECHARACTERLENGTH = alignment_length;
511
512	GB_add_callback(gb_alignment_len, GB_CB_CHANGED, makeDatabaseCallback(ED4_alignment_length_changed));
513
514	aw_root->awar_string(AWAR_EDITOR_ALIGNMENT, alignment_name);
515
516	return NULL;
517	}
518
519	void ED4_root::recalc_font_group() {
520	font_group.unregisterAll();
521	for (int f=ED4_G_FIRST_FONT; f<=ED4_G_LAST_FONT; f++) {
522	ED4_MostRecentWinContext context;
523	font_group.registerFont(current_device(), f);
524	}
525	}
526
527	static ARB_ERROR force_group_update(ED4_base *base) {
528	if (base->is_multi_species_manager()) {
529	base->to_multi_species_manager()->update_requested_by_child();
530	}
531	return NULL;
532	}
533
534	ED4_returncode ED4_root::create_hierarchy(char area_string_middle, char area_string_top) {
535	// creates internal hierarchy of editor
536
537	long total_no_of_groups = 0;
538	long total_no_of_species = 0;
539	{
540	// count species and related info (e.g. helix) displayed in the top region (a == 0)
541	// count no of species and sais including groups in middle region (a == 1)
542
543	const char *area_string[2] = { area_string_top, area_string_middle };
544	for (int a = 0; a<2; ++a) {
545	long group_count;
546	long species_count;
547	database->calc_no_of_all(area_string[a], &group_count, &species_count);
548
549	total_no_of_groups += group_count;
550	total_no_of_species += species_count;
551	}
552	}
553
554	SmartPtr<arb_progress> startup_progress = new arb_progress("EDIT4 startup");
555
556	GB_push_transaction(GLOBAL_gb_main);
557
558	ecoli_ref = new BI_ecoli_ref;
559	ecoli_ref->init(GLOBAL_gb_main);
560
561	// [former position of ali-init-code]
562
563	main_manager = new ED4_main_manager("Main_Manager", 0, 0, 0, 0, NULL); // build a test hierarchy
564	root_group_man = new ED4_root_group_manager("Root_Group_Manager", 0, 0, 0, 0, main_manager);
565
566	main_manager->children->append_member(root_group_man);
567
568	ED4_device_manager *device_manager = new ED4_device_manager("Device_Manager", 0, 0, 0, 0, root_group_man);
569	root_group_man->children->append_member(device_manager);
570
571	ED4_calc_terminal_extentions();
572
573	{
574	int col_stat_term_height = 50; // @@@ Hoehe des ColumnStatistics Terminals ausrechnen
575
576	ref_terminals.init(new ED4_sequence_info_terminal("Reference_Sequence_Info_Terminal", /* NULL, */ 250, 0, MAXINFOWIDTH, TERMINALHEIGHT, NULL),
577	new ED4_sequence_terminal("Reference_Sequence_Terminal", 300, 0, 300, TERMINALHEIGHT, NULL, false),
578	new ED4_sequence_info_terminal("Reference_ColumnStatistics_Info_Terminal", /* NULL, */ 250, 0, MAXINFOWIDTH, col_stat_term_height, NULL),
579	new ED4_columnStat_terminal("Reference_ColumnStatistics_Terminal", 300, 0, 300, col_stat_term_height, NULL));
580	}
581
582
583	recalc_font_group();
584
585	ED4_index y = 0;
586
587	{
588	arb_progress species_progress("Loading species", total_no_of_species);
589
590	const int XPOS_MULTIMAN = 100;
591
592	// ******** Top Area beginning ********
593
594	ED4_multi_species_manager *top_multi_species_manager;
595	ED4_spacer_terminal *top_spacer_terminal;
596	ED4_spacer_terminal *top_mid_spacer_terminal;
597	ED4_spacer_terminal *top_multi_spacer_terminal_beg;
598	ED4_line_terminal *top_mid_line_terminal;
599	{
600	ED4_area_manager *top_area_manager = new ED4_area_manager("Top_Area_Manager", 0, y, 0, 0, device_manager);
601	device_manager->children->append_member(top_area_manager);
602	top_area_man = top_area_manager;
603
604	top_spacer_terminal = new ED4_spacer_terminal("Top_Spacer", true, 0, 0, 100, 10, top_area_manager);
605	top_area_manager->children->append_member(top_spacer_terminal);
606
607	top_multi_species_manager = new ED4_multi_species_manager("Top_MultiSpecies_Manager", XPOS_MULTIMAN, 0, 0, 0, top_area_manager);
608	top_area_manager->children->append_member(top_multi_species_manager);
609
610	top_multi_spacer_terminal_beg = new ED4_spacer_terminal("Top_Multi_Spacer_Terminal_Beg", true, 0, 0, 0, 3, top_multi_species_manager);
611	top_multi_species_manager->children->append_member(top_multi_spacer_terminal_beg);
612
613	y += 3;
614
615	reference = new AWT_reference(GLOBAL_gb_main);
616
617	int index = 0;
618	database->scan_string(top_multi_species_manager, ref_terminals.get_ref_sequence_info(), ref_terminals.get_ref_sequence(),
619	area_string_top, &index, &y, species_progress);
620	GB_pop_transaction(GLOBAL_gb_main);
621
622	const int TOP_MID_LINE_HEIGHT = 3;
623	int TOP_MID_SPACER_HEIGHT = font_group.get_max_height()-TOP_MID_LINE_HEIGHT;
624
625	top_mid_line_terminal = new ED4_line_terminal("Top_Mid_Line_Terminal", 0, y, 0, TOP_MID_LINE_HEIGHT, device_manager); // width will be set below
626	device_manager->children->append_member(top_mid_line_terminal);
627
628	y += TOP_MID_LINE_HEIGHT;
629
630
631	top_mid_spacer_terminal = new ED4_spacer_terminal("Top_Middle_Spacer", true, 0, y, 880, TOP_MID_SPACER_HEIGHT, device_manager);
632	device_manager->children->append_member(top_mid_spacer_terminal);
633
634	// needed to avoid text-clipping problems:
635	main_manager->set_top_middle_spacer_terminal(top_mid_spacer_terminal);
636	main_manager->set_top_middle_line_terminal(top_mid_line_terminal);
637
638	y += TOP_MID_SPACER_HEIGHT; // add top-mid_spacer_terminal height
639	}
640
641	// ******** Middle Area beginning ********
642
643	ED4_area_manager *middle_area_manager;
644	ED4_tree_terminal *tree_terminal;
645	ED4_multi_species_manager *mid_multi_species_manager;
646	ED4_spacer_terminal *mid_multi_spacer_terminal_beg;
647	ED4_line_terminal *mid_bot_line_terminal;
648	ED4_spacer_terminal *total_bottom_spacer;
649	{
650	middle_area_manager = new ED4_area_manager("Middle_Area_Manager", 0, y, 0, 0, device_manager);
651	device_manager->children->append_member(middle_area_manager);
652	middle_area_man = middle_area_manager;
653
654	tree_terminal = new ED4_tree_terminal("Tree", 0, 0, 2, 0, middle_area_manager);
655	middle_area_manager->children->append_member(tree_terminal);
656
657	mid_multi_species_manager = new ED4_multi_species_manager("Middle_MultiSpecies_Manager", XPOS_MULTIMAN, 0, 0, 0, middle_area_manager);
658	middle_area_manager->children->append_member(mid_multi_species_manager);
659
660	mid_multi_spacer_terminal_beg = new ED4_spacer_terminal("Mid_Multi_Spacer_Terminal_Beg", true, 0, 0, 0, 3, mid_multi_species_manager);
661	mid_multi_species_manager->children->append_member(mid_multi_spacer_terminal_beg);
662
663	y+=3; // dummy height, to create a dummy layout ( to preserve order of objects )
664
665	scroll_links.link_for_ver_slider = middle_area_manager;
666
667	ED4_index help = y;
668	{
669	GB_transaction ta(GLOBAL_gb_main);
670	int index = 0;
671	database->scan_string(mid_multi_species_manager, ref_terminals.get_ref_sequence_info(), ref_terminals.get_ref_sequence(),
672	area_string_middle, &index, &y, species_progress);
673	}
674
675	{
676	ED4_spacer_terminal *mid_bot_spacer_terminal = new ED4_spacer_terminal("Middle_Bot_Spacer_Terminal", true, 0, y, 880, 10, device_manager);
677	device_manager->children->append_member(mid_bot_spacer_terminal);
678	}
679
680	tree_terminal->extension.size[HEIGHT] = y - help;
681
682	y += 10; // add top-mid_spacer_terminal height
683
684	mid_bot_line_terminal = new ED4_line_terminal("Mid_Bot_Line_Terminal", 0, y, 0, 3, device_manager); // width will be set below
685	device_manager->children->append_member(mid_bot_line_terminal);
686	y += 3;
687
688	total_bottom_spacer = new ED4_spacer_terminal("Total_Bottom_Spacer_terminal", true, 0, y, 0, 10000, device_manager);
689	device_manager->children->append_member(total_bottom_spacer);
690	y += 10000;
691	}
692
693	if (scroll_links.link_for_hor_slider) {
694	long ext_width = long(scroll_links.link_for_hor_slider->extension.size[WIDTH]);
695
696	top_multi_spacer_terminal_beg->extension.size[WIDTH] = ext_width + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
697	mid_multi_spacer_terminal_beg->extension.size[WIDTH] = ext_width + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
698	total_bottom_spacer->extension.size[WIDTH] = ext_width + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
699
700	top_mid_line_terminal->extension.size[WIDTH] = ext_width + TREETERMINALSIZE + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
701	mid_bot_line_terminal->extension.size[WIDTH] = ext_width + TREETERMINALSIZE + MAXSPECIESWIDTH + SEQUENCEINFOSIZE;
702
703	}
704
705	tree_terminal->set_links(NULL, mid_multi_species_manager); // set links
706	top_spacer_terminal->set_links(tree_terminal, top_multi_species_manager);
707	top_mid_spacer_terminal->set_links(middle_area_manager, NULL);
708	total_bottom_spacer->set_links(mid_bot_line_terminal, 0);
709
710	species_progress.done();
711	}
712
713	first_window->update_window_coords();
714	resize_all();
715
716	main_manager->route_down_hierarchy(force_group_update).expect_no_error();
717
718	if (!scroll_links.link_for_hor_slider) { // happens when no species AND no SAI has data
719	startup_progress->done();
720	startup_progress.SetNull(); // make progress disappear (otherwise prompter below is often behind progress window)
721	GB_pop_transaction(GLOBAL_gb_main);
722
723	aw_popup_ok(GBS_global_string("No species/SAI contains data in '%s'\nARB_EDIT4 will terminate", alignment_name));
724	ED4_exit();
725	}
726
727	// build consensi
728	{
729	arb_progress consensi_progress("Initializing consensi", total_no_of_species+total_no_of_groups+1); // 1 is root_group_man
730
731	root_group_man->create_consensus(root_group_man, &consensi_progress);
732	e4_assert(root_group_man->table().ok());
733	consensi_progress.done(); // if there is a "top"-group, progress increment is one to low
734	}
735
736	root_group_man->remap()->mark_compile_needed_force();
737	root_group_man->update_remap();
738
739	// calc size and display:
740
741	resize_all();
742
743	e4_assert(main_manager);
744
745	{
746	ED4_base *x_link = scroll_links.link_for_hor_slider;
747	ED4_base *y_link = scroll_links.link_for_ver_slider;
748	ED4_base *width_link = x_link;
749	ED4_base *height_link = y_link;
750
751	ED4_window *win = first_window;
752	while (win) {
753	win->set_scrolled_rectangle(x_link, y_link, width_link, height_link);
754	win->aww->show();
755	win->update_scrolled_rectangle();
756	win = win->next;
757	}
758	}
759
760	ED4_trigger_instant_refresh();
761	ED4_finish_and_show_notFoundMessage();
762
763	return ED4_R_OK;
764	}
765
766	ED4_returncode ED4_root::get_area_rectangle(AW_screen_area *rect, AW_pos x, AW_pos y) {
767	// returns win-coordinates of area (defined by folding lines) which contains position x/y
768	int x1, x2, y1, y2;
769	const AW_screen_area& area_rect = current_device()->get_area_size();
770
771	x1 = area_rect.l;
772	for (const ED4_folding_line *flv=current_ed4w()->get_vertical_folding(); ; flv = flv->get_next()) {
773	if (flv) {
774	x2 = int(flv->get_pos()); // @@@ use AW_INT ?
775	}
776	else {
777	x2 = area_rect.r;
778	if (x1==x2) {
779	break;
780	}
781	}
782
783	y1 = area_rect.t;
784	for (const ED4_folding_line *flh=current_ed4w()->get_horizontal_folding(); ; flh = flh->get_next()) {
785	if (flh) {
786	y2 = int(flh->get_pos()); // @@@ use AW_INT ?
787	}
788	else {
789	y2 = area_rect.b;
790	if (y1==y2) {
791	break;
792	}
793	}
794
795	if (x1<=x && x<=x2 && y1<=y && y<=y2) {
796	rect->t = y1;
797	rect->b = y2;
798	rect->l = x1;
799	rect->r = x2;
800	return ED4_R_OK;
801	}
802	y1 = y2;
803	if (!flh) break;
804	}
805	x1 = x2;
806	if (!flv) break;
807	}
808	return ED4_R_IMPOSSIBLE; // no area contains x/y :-(
809	}
810
811	void ED4_root::copy_window_struct(ED4_window source, ED4_window destination)
812	{
813	destination->slider_pos_horizontal = source->slider_pos_horizontal;
814	destination->slider_pos_vertical = source->slider_pos_vertical;
815	destination->coords = source->coords;
816	}
817
818
819	static void reload_helix_cb() {
820	const char *err = ED4_ROOT->helix->init(GLOBAL_gb_main);
821	if (err) aw_message(err);
822	ED4_request_full_refresh();
823	}
824
825
826	static void reload_ecoli_cb() {
827	const char *err = ED4_ROOT->ecoli_ref->init(GLOBAL_gb_main);
828	if (err) aw_message(err);
829	ED4_request_full_refresh();
830	}
831
832	// ---------------------------------------
833	// recursion through all species
834
835	typedef ARB_ERROR (ED4_Species_Callback)(GBDATA, AW_CL);
836
837	static ARB_ERROR do_sth_with_species(ED4_base *base, AW_CL cl_spec_cb, AW_CL cd) {
838	ARB_ERROR error = NULL;
839
840	if (base->is_species_manager()) {
841	ED4_Species_Callback cb = (ED4_Species_Callback)cl_spec_cb;
842	ED4_species_manager *species_manager = base->to_species_manager();
843	ED4_species_name_terminal *species_name_terminal = species_manager->search_spec_child_rek(ED4_L_SPECIES_NAME)->to_species_name_terminal();
844
845	if (species_name_terminal->get_species_pointer()) {
846	char *species_name = GB_read_as_string(species_name_terminal->get_species_pointer());
847
848	e4_assert(species_name);
849	GBDATA *species = GBT_find_species(GLOBAL_gb_main, species_name);
850
851	error = species
852	? cb(species, cd)
853	: GB_append_exportedError(GBS_global_string("can't find species '%s'", species_name));
854
855	free(species_name);
856	}
857	}
858
859	return error;
860	}
861
862
863	static ARB_ERROR ED4_with_all_loaded_species(ED4_Species_Callback cb, AW_CL cd) {
864	return ED4_ROOT->root_group_man->route_down_hierarchy(do_sth_with_species, (AW_CL)cb, cd);
865	}
866
867	static bool has_species_name(ED4_base *base, AW_CL cl_species_name) {
868	ED4_species_name_terminal *name_term = base->to_species_name_terminal();
869	GBDATA *gbd = name_term->get_species_pointer();
870
871	if (gbd) {
872	const char *name = GB_read_char_pntr(gbd);
873	e4_assert(name);
874	return strcmp(name, (const char*)cl_species_name)==0;
875	}
876
877	return false;
878	}
879
880	ED4_species_name_terminal ED4_find_species_name_terminal(const char species_name)
881	{
882	ED4_base *base = ED4_ROOT->root_group_man->find_first_that(ED4_L_SPECIES_NAME, has_species_name, (AW_CL)species_name);
883
884	return base ? base->to_species_name_terminal() : 0;
885	}
886
887	static char get_group_consensus(const char species_name, PosRange range) {
888	ED4_species_name_terminal *name_term = ED4_find_species_name_terminal(species_name);
889	char *consensus = 0;
890
891	if (name_term) {
892	ED4_abstract_group_manager *group_man = name_term->get_parent(ED4_level(ED4_L_GROUP\|ED4_L_ROOTGROUP))->to_abstract_group_manager();
893	if (group_man) {
894	consensus = group_man->table().build_consensus_string(range);
895	}
896	}
897
898	return consensus;
899	}
900
901	static bool get_selected_range(PosRange& range) {
902	ED4_selected_elem *listElem = ED4_ROOT->selected_objects->head();
903	if (listElem) {
904	ED4_sequence_terminal *seqTerm = listElem->elem()->object->corresponding_sequence_terminal();
905	return ED4_get_selected_range(seqTerm, range);
906	}
907	return false;
908	}
909
910	static ED4_selected_elem *curr_aligner_elem = 0;
911
912	static GBDATA *get_next_selected_species() {
913	if (!curr_aligner_elem) return 0;
914
915	ED4_species_manager *specMan = curr_aligner_elem->elem()->object->containing_species_manager();
916	curr_aligner_elem = curr_aligner_elem->next();
917	return specMan->get_species_pointer();
918	}
919
920	static GBDATA get_first_selected_species(int total_no_of_selected_species)
921	{
922	int selected = ED4_ROOT->selected_objects->size();
923
924	if (total_no_of_selected_species) {
925	*total_no_of_selected_species = selected;
926	}
927
928	if (selected) {
929	curr_aligner_elem = ED4_ROOT->selected_objects->head();
930	}
931	else {
932	curr_aligner_elem = 0;
933	}
934
935	return get_next_selected_species();
936	}
937
938	struct AlignDataAccess dataAccess_4_aligner = {
939	1, // default is to do a refresh
940	ED4_trigger_instant_refresh, // with this function
941	get_group_consensus, // aligner fetches consensus of group of species via this function
942	get_selected_range, // aligner fetches column range of selection via this function
943	get_first_selected_species, // aligner fetches first and..
944	get_next_selected_species, // .. following selected species via this functions
945	0, // AW_helix (needed for island_hopping)
946	NULL, // gb_main
947	};
948	static ARB_ERROR ED4_delete_temp_entries(GBDATA *species, AW_CL cl_alignment_name) {
949	return FastAligner_delete_temp_entries(species, (GB_CSTR)cl_alignment_name);
950	}
951
952	static void ED4_remove_faligner_entries(AW_window *, AW_CL, AW_CL) {
953	ARB_ERROR error = GB_begin_transaction(GLOBAL_gb_main);
954	if (!error) error = ED4_with_all_loaded_species(ED4_delete_temp_entries, (AW_CL)ED4_ROOT->alignment_name);
955	GB_end_transaction_show_error(GLOBAL_gb_main, error, aw_message);
956	}
957
958	#if defined(DEBUG) && 0
959
960	void ED4_testSplitNMerge(AW_window *aw, AW_CL, AW_CL)
961	{
962	AW_root *root = aw->get_root();
963	char *name;
964	GBDATA *species;
965	GBDATA *gbd;
966	char *data;
967	long length;
968
969	GB_ERROR error = GB_begin_transaction(gb_main);
970	char *ali = ED4_ROOT->alignment_name;
971
972	if (!error)
973	{
974	name = root->awar(AWAR_SPECIES_NAME)->read_string();
975	species = GBT_find_species(gb_main, name);
976	gbd = species ? GBT_find_sequence(species, ali) : NULL;
977	data = gbd ? GB_read_string(gbd) : NULL;
978	length = gbd ? GB_read_string_count(gbd) : NULL;
979
980	if (data)
981	{
982	char *newData = AWTC_testConstructSequence(data);
983
984	if (newData)
985	{
986	error = GB_write_string(gbd, newData);
987	delete [] newData;
988	}
989	}
990	else
991	{
992	error = GB_get_error();
993	if (!error) error = GB_export_error("Can't read data of '%s'", name);
994	}
995
996	delete name;
997	delete data;
998	}
999
1000	GB_end_transaction_show_error(gb_main, error, aw_message);
1001	}
1002
1003	#endif
1004
1005	static void toggle_helix_for_SAI(AW_window *aww, AW_CL, AW_CL) {
1006	ED4_LocalWinContext uses(aww);
1007	ED4_cursor *cursor = &current_cursor();
1008
1009	if (cursor->in_SAI_terminal()) {
1010	ED4_sequence_terminal *sai_term = cursor->owner_of_cursor->to_sequence_terminal();
1011	ED4_sequence_info_terminal *sai_info_term = sai_term->parent->search_spec_child_rek(ED4_L_SEQUENCE_INFO)->to_sequence_info_terminal();
1012
1013	GBDATA *gb_sai_data = sai_info_term->data();
1014	GB_transaction ta(gb_sai_data);
1015
1016	GBDATA *gb_sai = GB_get_grandfather(gb_sai_data);
1017	GBDATA *gb_disp_sec = GB_searchOrCreate_int(gb_sai, "showsec", 0);
1018
1019	bool show_sec = 1-bool(GB_read_int(gb_disp_sec));
1020	GB_ERROR error = GB_write_int(gb_disp_sec, show_sec);
1021	if (!error) {
1022	sai_term->set_secstruct_display(show_sec);
1023	sai_term->request_refresh();
1024	}
1025	if (error) aw_message(error);
1026	}
1027	else {
1028	aw_message("Please select an SAI");
1029	}
1030	}
1031
1032	static void title_mode_changed(AW_root aw_root, AW_window aww)
1033	{
1034	int title_mode = aw_root->awar(AWAR_EDIT_TITLE_MODE)->read_int();
1035
1036	if (title_mode==0) {
1037	aww->set_info_area_height(57);
1038	}
1039	else {
1040	aww->set_info_area_height(170);
1041	}
1042	}
1043
1044	static void ED4_undo_redo(AW_window *aww, AW_CL undo_type) {
1045	ED4_LocalWinContext uses(aww);
1046	GB_ERROR error = GB_undo(GLOBAL_gb_main, (GB_UNDO_TYPE)undo_type);
1047
1048	if (error) {
1049	aw_message(error);
1050	}
1051	else {
1052	GB_begin_transaction(GLOBAL_gb_main);
1053	GB_commit_transaction(GLOBAL_gb_main);
1054	ED4_cursor *cursor = &current_cursor();
1055	if (cursor->owner_of_cursor) cursor->owner_of_cursor->request_refresh();
1056	}
1057	}
1058
1059	static void ED4_clear_errors(AW_window *aww, AW_CL) {
1060	aw_clear_message_cb(aww);
1061	}
1062
1063	static AW_window ED4_zoom_message_window(AW_root root, AW_CL)
1064	{
1065	AW_window_simple *aws = new AW_window_simple;
1066
1067	aws->init(root, "ZOOM_ERR_MSG", "Errors and warnings");
1068	aws->load_xfig("edit4/message.fig");
1069
1070	aws->callback((AW_CB0)AW_POPDOWN);
1071	aws->at("hide");
1072	aws->create_button("HIDE", "HIDE");
1073
1074	aws->callback(ED4_clear_errors, (AW_CL)0);
1075	aws->at("clear");
1076	aws->create_button("CLEAR", "CLEAR");
1077
1078	aws->at("errortext");
1079	aws->create_text_field(AWAR_ERROR_MESSAGES);
1080
1081	return (AW_window *)aws;
1082	}
1083
1084
1085	static char cat(char toBuf, const char s1, const char s2)
1086	{
1087	char *buf = toBuf;
1088
1089	while ((buf++=s1++)!=0) ;
1090	buf--;
1091	while ((buf++=s2++)!=0) ;
1092
1093	return toBuf;
1094	}
1095
1096	static void insert_search_fields(AW_window_menu_modes *awmm,
1097	const char label_prefix, const char macro_prefix,
1098	const char pattern_awar_name, const char show_awar_name,
1099	int short_form, ED4_SearchPositionType type, ED4_window *ed4w)
1100	{
1101	char buf[200];
1102
1103	if (!short_form) {
1104	awmm->at(cat(buf, label_prefix, "search"));
1105	awmm->create_input_field(pattern_awar_name, 30);
1106	}
1107
1108	awmm->at(cat(buf, label_prefix, "n"));
1109	awmm->callback(ED4_search_cb, ED4_encodeSearchDescriptor(+1, type), (AW_CL)ed4w);
1110	awmm->create_button(cat(buf, macro_prefix, "_SEARCH_NEXT"), "#edit/next.xpm");
1111
1112	awmm->at(cat(buf, label_prefix, "l"));
1113	awmm->callback(ED4_search_cb, ED4_encodeSearchDescriptor(-1, type), (AW_CL)ed4w);
1114	awmm->create_button(cat(buf, macro_prefix, "_SEARCH_LAST"), "#edit/last.xpm");
1115
1116	awmm->at(cat(buf, label_prefix, "d"));
1117	awmm->callback(ED4_popup_search_window, (AW_CL)type);
1118	awmm->create_button(cat(buf, macro_prefix, "_SEARCH_DETAIL"), "#edit/detail.xpm");
1119
1120	awmm->at(cat(buf, label_prefix, "s"));
1121	awmm->create_toggle(show_awar_name);
1122	}
1123
1124	static void ED4_set_protection(AW_window aww, AW_CL cd1, AW_CL / cd2 */) {
1125	ED4_LocalWinContext uses(aww);
1126	ED4_cursor *cursor = &current_cursor();
1127	GB_ERROR error = 0;
1128
1129	if (cursor->owner_of_cursor) {
1130	int wanted_protection = int(cd1);
1131	ED4_sequence_terminal *seq_term = cursor->owner_of_cursor->to_sequence_terminal();
1132	ED4_sequence_info_terminal *seq_info_term = seq_term->parent->search_spec_child_rek(ED4_L_SEQUENCE_INFO)->to_sequence_info_terminal();
1133	GBDATA *gbd = seq_info_term->data();
1134
1135	GB_push_transaction(gbd);
1136
1137	GB_push_my_security(gbd);
1138	error = GB_write_security_write(gbd, wanted_protection);
1139	GB_pop_my_security(gbd);
1140
1141	error = GB_end_transaction(gbd, error);
1142	}
1143	else {
1144	error = "No species selected";
1145	}
1146
1147	if (error) aw_message(error);
1148	}
1149
1150	enum MenuSelectType {
1151	ED4_MS_NONE,
1152	ED4_MS_ALL,
1153	ED4_MS_INVERT,
1154	ED4_MS_INVERT_GROUP,
1155	ED4_MS_UNMARK_ALL,
1156	ED4_MS_MARK_SELECTED,
1157	ED4_MS_UNMARK_SELECTED,
1158	ED4_MS_SELECT_MARKED,
1159	ED4_MS_DESELECT_MARKED,
1160	ED4_MS_TOGGLE_BLOCKTYPE
1161	};
1162
1163	static void ED4_menu_select(AW_window *aww, AW_CL type, AW_CL) {
1164	GB_transaction ta(GLOBAL_gb_main);
1165	MenuSelectType select = MenuSelectType(type);
1166	ED4_multi_species_manager *middle_multi_man = ED4_ROOT->middle_area_man->get_multi_species_manager();
1167
1168	e4_assert(middle_multi_man);
1169
1170	switch (select) {
1171	case ED4_MS_NONE: {
1172	if (ED4_getBlocktype()!=ED4_BT_NOBLOCK) {
1173	ED4_ROOT->deselect_all();
1174	ED4_setBlocktype(ED4_BT_NOBLOCK);
1175	}
1176	break;
1177	}
1178	case ED4_MS_ALL: {
1179	middle_multi_man->select_all(true); // only species
1180	ED4_correctBlocktypeAfterSelection();
1181	break;
1182	}
1183	case ED4_MS_INVERT: {
1184	middle_multi_man->invert_selection_of_all_species();
1185	ED4_correctBlocktypeAfterSelection();
1186	break;
1187	}
1188	case ED4_MS_SELECT_MARKED: {
1189	middle_multi_man->marked_species_select(true);
1190	ED4_correctBlocktypeAfterSelection();
1191	break;
1192	}
1193	case ED4_MS_DESELECT_MARKED: {
1194	middle_multi_man->marked_species_select(false);
1195	ED4_correctBlocktypeAfterSelection();
1196	break;
1197	}
1198	case ED4_MS_UNMARK_ALL: {
1199	GBT_mark_all(GLOBAL_gb_main, 0);
1200	break;
1201	}
1202	case ED4_MS_MARK_SELECTED: {
1203	middle_multi_man->selected_species_mark(true);
1204	ED4_correctBlocktypeAfterSelection();
1205	break;
1206	}
1207	case ED4_MS_UNMARK_SELECTED: {
1208	middle_multi_man->selected_species_mark(false);
1209	ED4_correctBlocktypeAfterSelection();
1210	break;
1211	}
1212	case ED4_MS_INVERT_GROUP: {
1213	ED4_cursor *cursor = &ED4_ROOT->first_window->get_matching_ed4w(aww)->cursor;
1214	int done = 0;
1215
1216	if (cursor->owner_of_cursor) {
1217	ED4_multi_species_manager *multi_man = cursor->owner_of_cursor->get_parent(ED4_L_MULTI_SPECIES)->to_multi_species_manager();
1218
1219	multi_man->invert_selection_of_all_species();
1220	ED4_correctBlocktypeAfterSelection();
1221	done = 1;
1222	}
1223
1224	if (!done) {
1225	aw_message("Place cursor into group");
1226	}
1227	break;
1228	}
1229	case ED4_MS_TOGGLE_BLOCKTYPE: {
1230	ED4_toggle_block_type();
1231	break;
1232	}
1233	default: {
1234	e4_assert(0);
1235	break;
1236	}
1237	}
1238
1239	ED4_request_full_refresh();
1240	}
1241
1242	static void ED4_menu_perform_block_operation(AW_window /aww*/, AW_CL type, AW_CL) {
1243	ED4_perform_block_operation(ED4_blockoperation_type(type));
1244	}
1245
1246	static void modes_cb(AW_window*, ED4_species_mode smode) {
1247	ED4_ROOT->species_mode = smode;
1248	for (ED4_window *win = ED4_ROOT->first_window; win; win = win->next) {
1249	win->aww->select_mode(smode);
1250	}
1251	}
1252
1253	void ED4_no_dangerous_modes() {
1254	if (ED4_ROOT->species_mode == ED4_SM_KILL) {
1255	modes_cb(NULL, ED4_SM_MOVE);
1256	}
1257	}
1258
1259	void ED4_init_aligner_data_access(AlignDataAccess *data_access) {
1260	GB_ERROR error = GB_push_transaction(GLOBAL_gb_main);
1261	char *alignment_name = GBT_get_default_alignment(GLOBAL_gb_main);
1262	long alilen = GBT_get_alignment_len(GLOBAL_gb_main, alignment_name);
1263
1264	data_access->gb_main = GLOBAL_gb_main;
1265
1266	if (alilen<=0) error = GB_await_error();
1267	else {
1268	char *helix_string = 0;
1269	char *helix_name = GBT_get_default_helix(GLOBAL_gb_main);
1270	GBDATA *gb_helix_con = GBT_find_SAI(GLOBAL_gb_main, helix_name);
1271	if (gb_helix_con) {
1272	GBDATA *gb_helix = GBT_find_sequence(gb_helix_con, alignment_name);
1273	if (gb_helix) helix_string = GB_read_string(gb_helix);
1274	}
1275	free(helix_name);
1276	freeset(data_access->helix_string, helix_string);
1277	}
1278
1279	free(alignment_name);
1280	error = GB_end_transaction(GLOBAL_gb_main, error);
1281	if (error) aw_message(error);
1282	}
1283
1284	static AW_window ED4_create_faligner_window(AW_root awr, AW_CL cl_AlignDataAccess) {
1285	AlignDataAccess data_access = (AlignDataAccess)cl_AlignDataAccess;
1286
1287	#if defined(DEBUG)
1288	static AlignDataAccess *last_data_access = NULL;
1289
1290	e4_assert(!last_data_access \|\| (last_data_access == data_access)); // there shall be only one AlignDataAccess
1291	last_data_access = data_access;
1292	#endif
1293
1294	static AW_window *aws = NULL;
1295	if (!aws) {
1296	ED4_init_aligner_data_access(data_access);
1297	aws = FastAligner_create_window(awr, data_access);
1298	}
1299	return aws;
1300	}
1301
1302	static void ED4_save_properties(AW_window *aw, AW_CL cl_mode, AW_CL) {
1303	int mode = (int)cl_mode;
1304
1305	AW_save_specific_properties(aw, ED4_propertyName(mode));
1306	}
1307
1308	void ED4_popup_gc_window(AW_window *awp, AW_gc_manager gcman) {
1309	typedef std::map<AW_gc_manager, AW_window*> gcwin;
1310	static gcwin win;
1311
1312	gcwin::iterator found = win.find(gcman);
1313
1314	AW_window *aww = NULL;
1315	if (found == win.end()) {
1316	aww = AW_create_gc_window(awp->get_root(), gcman);
1317	win[gcman] = aww;
1318	}
1319	else {
1320	aww = win[gcman];
1321	}
1322	aww->activate();
1323	}
1324
1325	static void refresh_on_gc_change_cb() {
1326	ED4_expose_recalculations();
1327	ED4_request_full_instant_refresh();
1328	}
1329
1330	ED4_returncode ED4_root::generate_window(AW_device device, ED4_window new_window) {
1331	{
1332	ED4_window *ed4w = first_window;
1333
1334	while (ed4w) { // before creating a window look for a hidden window
1335	if (ed4w->is_hidden) {
1336	ed4w->aww->show();
1337	ed4w->is_hidden = false;
1338	return ED4_R_BREAK;
1339	}
1340	ed4w = ed4w->next;
1341	}
1342	}
1343
1344	if (ED4_window::no_of_windows == MAXWINDOWS) // no more than 5 windows allowed
1345	{
1346	aw_message(GBS_global_string("Restricted to %i windows", MAXWINDOWS));
1347	return ED4_R_BREAK;
1348	}
1349
1350	AW_window_menu_modes *awmm = new AW_window_menu_modes;
1351	{
1352	int winNum = ED4_window::no_of_windows+1;
1353	char *winName = winNum>1 ? GBS_global_string_copy("ARB_EDIT4_%i", winNum) : strdup("ARB_EDIT4");
1354	char winTitle = GBS_global_string_copy("ARB_EDIT4 %d* [%s]", winNum, alignment_name);
1355
1356	awmm->init(aw_root, winName, winTitle, 800, 450);
1357
1358	free(winTitle);
1359	free(winName);
1360	}
1361
1362	*device = awmm->get_device(AW_MIDDLE_AREA); // points to Middle Area device
1363	*new_window = ED4_window::insert_window(awmm); // append to window list
1364
1365	e4_assert(ED4_window::no_of_windows >= 1);
1366	bool clone = ED4_window::no_of_windows>1;
1367	if (!clone) { // this is the first window
1368	AW_init_color_group_defaults("arb_edit4");
1369	}
1370	else { // additional edit windows
1371	copy_window_struct(first_window, *new_window);
1372	}
1373
1374	ED4_LocalWinContext uses(*new_window);
1375
1376	// each window has its own gc-manager
1377	gc_manager = AW_manage_GC(awmm,
1378	"ARB_EDIT4", // but all gc-managers use the same colors
1379	*device,
1380	ED4_G_STANDARD, // GC_Standard configuration
1381	ED4_G_DRAG,
1382	AW_GCM_DATA_AREA,
1383	makeWindowCallback(refresh_on_gc_change_cb), // callback triggering refresh on gc-change
1384	true, // use color groups
1385
1386	"#f8f8f8",
1387	"STANDARD$black", // Standard Color showing sequences
1388	"#SEQUENCES (0)$#505050", // default color for sequences (color 0)
1389	"+-HELIX (1)$#8E0000", "+-COLOR 2$#0000dd", "-COLOR 3$#00AA55",
1390	"+-COLOR 4$#80f", "+-COLOR 5$#c0a020", "-COLOR 6$grey",
1391	"+-COLOR 7$#ff0000", "+-COLOR 8$#44aaff", "-COLOR 9$#ffaa00",
1392
1393	"+-RANGE 0$#FFFFFF", "+-RANGE 1$#F0F0F0", "-RANGE 2$#E0E0E0",
1394	"+-RANGE 3$#D8D8D8", "+-RANGE 4$#D0D0D0", "-RANGE 5$#C8C8C8",
1395	"+-RANGE 6$#C0C0C0", "+-RANGE 7$#B8B8B8", "-RANGE 8$#B0B0B0",
1396	"-RANGE 9$#A0A0A0",
1397
1398	// colors used to Paint search patterns
1399	// (do not change the names of these gcs)
1400	"+-User1$#B8E2F8", "+-User2$#B8E2F8", "-Probe$#B8E2F8", // see also SEC_graphic::init_devices
1401	"+-Primer(l)$#A9FE54", "+-Primer(r)$#A9FE54", "-Primer(g)$#A9FE54",
1402	"+-Sig(l)$#DBB0FF", "+-Sig(r)$#DBB0FF", "-Sig(g)$#DBB0FF",
1403
1404	"+-MISMATCHES$#FF9AFF", "-CURSOR$#FF0080",
1405	"+-MARKED$#f4f8e0", "-SELECTED$#FFFF80",
1406
1407	NULL);
1408
1409	// since the gc-managers of all EDIT4-windows point to the same window properties,
1410	// changing fonts and colors is always done on first gc-manager
1411	static AW_gc_manager first_gc_manager = 0;
1412	if (!first_gc_manager) first_gc_manager = gc_manager;
1413
1414	// --------------
1415	// File
1416
1417	#if defined(DEBUG)
1418	AWT_create_debug_menu(awmm);
1419	#endif // DEBUG
1420
1421	awmm->create_menu("File", "F", AWM_ALL);
1422
1423	awmm->insert_menu_topic("new_win", "New Editor Window", "W", 0, AWM_ALL, ED4_new_editor_window);
1424	awmm->insert_menu_topic("save_config", "Save Configuration", "S", 0, AWM_ALL, makeWindowCallback(ED4_save_configuration, false));
1425	awmm->insert_menu_topic("save_config_as", "Save Configuration As", "A", 0, AWM_ALL, AW_POPUP, (AW_CL) ED4_save_configuration_as_open_window, (int)0);
1426	awmm->sep______________();
1427	awmm->insert_menu_topic("load_config", "Load Configuration", "L", 0, AWM_ALL, AW_POPUP, (AW_CL)ED4_start_editor_on_old_configuration, 0);
1428	awmm->insert_menu_topic("reload_config", "Reload Configuration", "R", 0, AWM_ALL, ED4_restart_editor, 0, 0);
1429	insert_macro_menu_entry(awmm, true);
1430	awmm->sep______________();
1431	GDE_load_menu(awmm, AWM_ALL, "Print");
1432	awmm->sep______________();
1433
1434	if (clone) awmm->insert_menu_topic("close", "CLOSE", "C", 0, AWM_ALL, ED4_quit_editor);
1435	else awmm->insert_menu_topic("quit", "QUIT", "Q", 0, AWM_ALL, ED4_quit_editor);
1436
1437	// ----------------
1438	// Create
1439
1440	awmm->create_menu("Create", "C", AWM_ALL);
1441	awmm->insert_menu_topic("create_species", "Create new species", "n", 0, AWM_ALL, makeCreateWindowCallback(ED4_create_new_seq_window, CREATE_NEW_SPECIES));
1442	awmm->insert_menu_topic("create_species_from_consensus", "Create new species from consensus", "u", 0, AWM_ALL, makeCreateWindowCallback(ED4_create_new_seq_window, CREATE_FROM_CONSENSUS));
1443	awmm->insert_menu_topic("copy_species", "Copy current species", "C", 0, AWM_ALL, makeCreateWindowCallback(ED4_create_new_seq_window, COPY_SPECIES));
1444	awmm->sep______________();
1445	awmm->insert_menu_topic("create_group", "Create new Group", "G", 0, AWM_ALL, group_species_cb, 0, 0);
1446	awmm->insert_menu_topic("create_groups_by_field", "Create new groups using Field", "F", 0, AWM_ALL, group_species_cb, 1, 0);
1447
1448	// --------------
1449	// Edit
1450
1451	awmm->create_menu("Edit", "E", AWM_ALL);
1452	awmm->insert_menu_topic("refresh", "Refresh [Ctrl-L]", "f", 0, AWM_ALL, (AW_CB)ED4_request_full_refresh, 0, 0);
1453	awmm->insert_menu_topic("load_current", "Load current species [GET]", "G", 0, AWM_ALL, ED4_get_and_jump_to_current_from_menu, 0, 0);
1454	awmm->insert_menu_topic("load_marked", "Load marked species", "m", 0, AWM_ALL, ED4_get_marked_from_menu, 0, 0);
1455	awmm->sep______________();
1456	awmm->insert_menu_topic("refresh_ecoli", "Reload Ecoli sequence", "E", "ecoliref.hlp", AWM_ALL, (AW_CB)reload_ecoli_cb, 0, 0);
1457	awmm->insert_menu_topic("refresh_helix", "Reload Helix", "H", "helix.hlp", AWM_ALL, (AW_CB)reload_helix_cb, 0, 0);
1458	awmm->insert_menu_topic("helix_jump_opposite", "Jump helix opposite [Ctrl-J]", "J", 0, AWM_ALL, ED4_helix_jump_opposite);
1459	awmm->sep______________();
1460
1461	awmm->insert_sub_menu("Set protection of current ", "p");
1462	{
1463	char macro[] = "to_0",
1464	topic[] = ".. to 0",
1465	hotkey[] = "0";
1466
1467	for (char i='0'; i<='6'; i++) {
1468	macro[3] = topic[6] = hotkey[0] = i;
1469	awmm->insert_menu_topic(macro, topic, hotkey, "security.hlp", AWM_ALL, ED4_set_protection, AW_CL(i-'0'), 0);
1470	}
1471	}
1472	awmm->close_sub_menu();
1473
1474	#if !defined(NDEBUG) && 0
1475	awmm->insert_menu_topic(0, "Test (test split & merge)", "T", 0, AWM_ALL, ED4_testSplitNMerge, 1, 0);
1476	#endif
1477
1478	awmm->sep______________();
1479	awmm->insert_menu_topic("fast_aligner", INTEGRATED_ALIGNERS_TITLE, "I", "faligner.hlp", AWM_ALL, AW_POPUP, (AW_CL)ED4_create_faligner_window, (AW_CL)&dataAccess_4_aligner);
1480	awmm->insert_menu_topic("fast_align_set_ref", "Set aligner reference [Ctrl-R]", "R", "faligner.hlp", AWM_ALL, (AW_CB)FastAligner_set_reference_species, (AW_CL)aw_root, 0);
1481	awmm->insert_menu_topic("align_sequence", "Old aligner from ARB_EDIT [broken]", "O", "ne_align_seq.hlp", AWM_DISABLED, AW_POPUP, (AW_CL)create_naligner_window, 0);
1482	awmm->insert_menu_topic("sina", "SINA (SILVA Incremental Aligner)", "S", "sina_main.hlp", sina_mask(aw_root), show_sina_window, (AW_CL)&dataAccess_4_aligner, 0);
1483	awmm->insert_menu_topic("del_ali_tmp", "Remove all aligner Entries", "v", 0, AWM_ALL, ED4_remove_faligner_entries, 1, 0);
1484	awmm->sep______________();
1485	awmm->insert_menu_topic("missing_bases", "Dot potentially missing bases", "D", "missbase.hlp", AWM_EXP, ED4_popup_dot_missing_bases_window, 0, 0);
1486
1487	if (alignment_type == GB_AT_RNA) { // if the database contains valid alignment of rRNA sequences
1488	awmm->sep______________();
1489	awmm->insert_menu_topic("sec_edit", "Edit secondary structure", "c", "arb_secedit.hlp", AWM_ALL, ED4_start_plugin, (AW_CL)GLOBAL_gb_main, (AW_CL)"SECEDIT");
1490	#if defined(ARB_OPENGL)
1491	awmm->insert_menu_topic("rna3d", "View 3D molecule", "3", "rna3d_general.hlp", AWM_ALL, ED4_start_plugin, (AW_CL)GLOBAL_gb_main, (AW_CL)"RNA3D");
1492	#endif // ARB_OPENGL
1493	#if defined(DEBUG)
1494	awmm->insert_menu_topic("noplugin", "DEBUG: call unknown plugin", "u", 0, AWM_ALL, ED4_start_plugin, (AW_CL)GLOBAL_gb_main, (AW_CL)"testplugin");
1495	#endif // DEBUG
1496	}
1497
1498	// --------------
1499	// View
1500
1501	awmm->create_menu("View", "V", AWM_ALL);
1502	awmm->insert_sub_menu("Search", "S");
1503	{
1504	int s;
1505	const char *hotkeys = "12Poiclrg";
1506	char hotkey[] = "_";
1507
1508	e4_assert(strlen(hotkeys) == SEARCH_PATTERNS);
1509
1510	for (s=0; s<SEARCH_PATTERNS; s++) {
1511	ED4_SearchPositionType type = ED4_SearchPositionType(s);
1512	const char *id = ED4_SearchPositionTypeId[type];
1513	int len = strlen(id);
1514	char macro_name = GB_give_buffer(2(len+8));
1515	char *menu_entry_name = macro_name+(len+8);
1516
1517	#ifndef NDEBUG
1518	memset(macro_name, 0, 2*(len+8)); // to avoid memchk-warning
1519	#endif
1520	sprintf(macro_name, "%s_SEARCH", id);
1521	char *p = macro_name;
1522	while (1) {
1523	char c = *p++;
1524	if (!c) break;
1525	p[-1] = toupper(c);
1526	}
1527	sprintf(menu_entry_name, "%s Search", id);
1528
1529	hotkey[0] = hotkeys[s];
1530	awmm->insert_menu_topic(awmm->local_id(macro_name), menu_entry_name, hotkey, "e4_search.hlp", AWM_ALL, ED4_popup_search_window, AW_CL(type));
1531	}
1532	}
1533	awmm->close_sub_menu();
1534	awmm->sep______________();
1535	awmm->insert_sub_menu("Cursor position ", "p");
1536	awmm->insert_menu_topic("store_curpos", "Store cursor position", "S", 0, AWM_ALL, ED4_store_curpos);
1537	awmm->insert_menu_topic("restore_curpos", "Restore cursor position ", "R", 0, AWM_ALL, ED4_restore_curpos);
1538	awmm->insert_menu_topic("clear_curpos", "Clear stored positions", "C", 0, AWM_ALL, makeWindowCallback(ED4_clear_stored_curpos));
1539	awmm->close_sub_menu();
1540
1541	awmm->sep______________();
1542	awmm->insert_menu_topic("change_cursor", "Change cursor type", "t", 0, AWM_ALL, ED4_change_cursor);
1543	awmm->insert_menu_topic("show_all", "Show all bases ", "a", "set_reference.hlp", AWM_ALL, ED4_set_reference_species, 1, 0);
1544	awmm->insert_menu_topic("show_diff", "Show only differences to selected", "d", "set_reference.hlp", AWM_ALL, ED4_set_reference_species, 0, 0);
1545	awmm->sep______________();
1546	awmm->insert_menu_topic("enable_col_stat", "Activate column statistics", "v", "st_ml.hlp", AWM_EXP, ED4_activate_col_stat, 0, 0);
1547	awmm->insert_menu_topic("disable_col_stat", "Disable column statistics", "i", "st_ml.hlp", AWM_EXP, ED4_disable_col_stat, 0, 0);
1548	awmm->insert_menu_topic("detail_col_stat", "Toggle detailed Col.-Stat.", "C", "st_ml.hlp", AWM_EXP, ED4_toggle_detailed_column_stats, 0, 0);
1549	awmm->insert_menu_topic("dcs_threshold", "Set threshold for D.c.s.", "f", "st_ml.hlp", AWM_EXP, ED4_set_col_stat_threshold, 0, 0);
1550	awmm->sep______________();
1551	awmm->insert_menu_topic("visualize_SAI", "Visualize SAIs", "z", "visualizeSAI.hlp", AWM_ALL, AW_POPUP, (AW_CL)ED4_createVisualizeSAI_window, 0);
1552	awmm->insert_menu_topic("toggle_saisec", "Toggle secondary info for SAI", "o", "toggle_secinfo.hlp", AWM_ALL, toggle_helix_for_SAI, 0, 0);
1553
1554	// Enable ProteinViewer only for DNA sequence type
1555	if (alignment_type == GB_AT_DNA) {
1556	awmm->insert_menu_topic("Protein_Viewer", "Protein Viewer", "w", "proteinViewer.hlp", AWM_ALL, AW_POPUP, (AW_CL)ED4_CreateProteinViewer_window, 0);
1557	}
1558
1559	// ---------------
1560	// Block
1561
1562	awmm->create_menu("Block", "B", AWM_ALL);
1563
1564	awmm->insert_menu_topic("select_marked", "Select marked species", "e", "e4_block.hlp", AWM_ALL, ED4_menu_select, AW_CL(ED4_MS_SELECT_MARKED), 0);
1565	awmm->insert_menu_topic("deselect_marked", "Deselect marked species", "k", "e4_block.hlp", AWM_ALL, ED4_menu_select, AW_CL(ED4_MS_DESELECT_MARKED), 0);
1566	awmm->insert_menu_topic("select_all", "Select all species", "S", "e4_block.hlp", AWM_ALL, ED4_menu_select, AW_CL(ED4_MS_ALL), 0);
1567	awmm->insert_menu_topic("deselect_all", "Deselect all", "D", "e4_block.hlp", AWM_ALL, ED4_menu_select, AW_CL(ED4_MS_NONE), 0);
1568	awmm->sep______________();
1569	awmm->insert_menu_topic("mark_selected", "Mark selected species", "M", "e4_block.hlp", AWM_ALL, ED4_menu_select, AW_CL(ED4_MS_MARK_SELECTED), 0);
1570	awmm->insert_menu_topic("unmark_selected", "Unmark selected species", "n", "e4_block.hlp", AWM_ALL, ED4_menu_select, AW_CL(ED4_MS_UNMARK_SELECTED), 0);
1571	awmm->insert_menu_topic("unmark_all", "Unmark all species", "U", "e4_block.hlp", AWM_ALL, ED4_menu_select, AW_CL(ED4_MS_UNMARK_ALL), 0);
1572	awmm->sep______________();
1573	awmm->insert_menu_topic("invert_all", "Invert selected species", "I", "e4_block.hlp", AWM_ALL, ED4_menu_select, AW_CL(ED4_MS_INVERT), 0);
1574	awmm->insert_menu_topic("invert_group", "Invert group", "g", "e4_block.hlp", AWM_ALL, ED4_menu_select, AW_CL(ED4_MS_INVERT_GROUP), 0);
1575	awmm->sep______________();
1576	awmm->insert_menu_topic("lowcase", "Change to lower case ", "w", "e4_block.hlp", AWM_ALL, ED4_menu_perform_block_operation, AW_CL(ED4_BO_LOWER_CASE), 0);
1577	awmm->insert_menu_topic("upcase", "Change to upper case", "p", "e4_block.hlp", AWM_ALL, ED4_menu_perform_block_operation, AW_CL(ED4_BO_UPPER_CASE), 0);
1578	awmm->sep______________();
1579	awmm->insert_menu_topic("reverse", "Reverse selection ", "v", "e4_block.hlp", AWM_ALL, ED4_menu_perform_block_operation, AW_CL(ED4_BO_REVERSE), 0);
1580	awmm->insert_menu_topic("complement", "Complement selection ", "o", "e4_block.hlp", AWM_ALL, ED4_menu_perform_block_operation, AW_CL(ED4_BO_COMPLEMENT), 0);
1581	awmm->insert_menu_topic("reverse_complement", "Reverse complement", "t", "e4_block.hlp", AWM_ALL, ED4_menu_perform_block_operation, AW_CL(ED4_BO_REVERSE_COMPLEMENT), 0);
1582	awmm->sep______________();
1583	awmm->insert_menu_topic("unalignBlockLeft", "Unalign block left", "a", "e4_block.hlp", AWM_ALL, ED4_menu_perform_block_operation, AW_CL(ED4_BO_UNALIGN_LEFT), 0);
1584	awmm->insert_menu_topic("unalignBlockCenter", "Unalign block center", "c", "e4_block.hlp", AWM_ALL, ED4_menu_perform_block_operation, AW_CL(ED4_BO_UNALIGN_CENTER), 0);
1585	awmm->insert_menu_topic("unalignBlockRight", "Unalign block right", "b", "e4_block.hlp", AWM_ALL, ED4_menu_perform_block_operation, AW_CL(ED4_BO_UNALIGN_RIGHT), 0);
1586	awmm->sep______________();
1587	awmm->insert_menu_topic("replace", "Search & Replace ", "h", "e4_replace.hlp", AWM_ALL, AW_POPUP, AW_CL(ED4_create_replace_window), 0);
1588	awmm->insert_menu_topic("setsai", "Modify SAI ", "y", "e4_modsai.hlp", AWM_ALL, AW_POPUP, AW_CL(ED4_create_modsai_window), 0);
1589	awmm->sep______________();
1590	awmm->insert_menu_topic("toggle_block_type", "Exchange: Line<->Column", "x", "e4_block.hlp", AWM_ALL, ED4_menu_select, AW_CL(ED4_MS_TOGGLE_BLOCKTYPE), 0);
1591	awmm->insert_menu_topic("shift_left", "Shift block left ", "l", "e4_block.hlp", AWM_ALL, ED4_menu_perform_block_operation, AW_CL(ED4_BO_SHIFT_LEFT), 0);
1592	awmm->insert_menu_topic("shift_right", "Shift block right", "r", "e4_block.hlp", AWM_ALL, ED4_menu_perform_block_operation, AW_CL(ED4_BO_SHIFT_RIGHT), 0);
1593
1594	// --------------------
1595	// Properties
1596
1597	awmm->create_menu("Properties", "P", AWM_ALL);
1598
1599	#ifdef ARB_MOTIF
1600	awmm->insert_menu_topic("props_frame", "Frame Settings ", "F", 0, AWM_ALL, AW_preset_window);
1601	#endif
1602
1603	awmm->insert_menu_topic("props_options", "Editor Options ", "O", "e4_options.hlp", AWM_ALL, ED4_create_level_1_options_window);
1604	awmm->insert_menu_topic("props_consensus", "Consensus Definition ", "u", "e4_consensus.hlp", AWM_ALL, ED4_create_consensus_definition_window);
1605	awmm->sep______________();
1606
1607	awmm->insert_menu_topic("props_data", "Change Colors & Fonts ", "C", 0, AWM_ALL, makeWindowCallback(ED4_popup_gc_window, first_gc_manager));
1608	awmm->insert_menu_topic("props_seq_colors", "Sequence color mapping", "S", "sequence_colors.hlp", AWM_ALL, AW_POPUP, (AW_CL)create_seq_colors_window, (AW_CL)sequence_colors);
1609
1610	awmm->sep______________();
1611
1612	if (alignment_type == GB_AT_AA) awmm->insert_menu_topic("props_pfold", "Protein Match Settings ", "P", "pfold_props.hlp", AWM_ALL, AW_POPUP, (AW_CL)ED4_pfold_create_props_window, (AW_CL)ED4_request_relayout);
1613	else awmm->insert_menu_topic("props_helix_sym", "Helix Settings ", "H", "helixsym.hlp", AWM_ALL, AW_POPUP, (AW_CL)create_helix_props_window, (AW_CL)ED4_request_relayout);
1614
1615	awmm->insert_menu_topic("props_key_map", "Key Mappings ", "K", "nekey_map.hlp", AWM_ALL, AW_POPUP, (AW_CL)create_key_map_window, 0);
1616	awmm->insert_menu_topic("props_nds", "Select visible info (NDS) ", "D", "ed4_nds.hlp", AWM_ALL, AW_POPUP, (AW_CL)ED4_create_nds_window, 0);
1617	awmm->sep______________();
1618	AW_insert_common_property_menu_entries(awmm);
1619	awmm->sep______________();
1620	awmm->insert_sub_menu("Save properties ...", "a");
1621	{
1622	static const char * const tag[] = { "save_alispecific_props", "save_alitype_props", "save_props" };
1623	static const char * const entry_type[] = { "alignment specific ", "ali-type specific ", "" };
1624
1625	// check what is the default mode
1626	int default_mode = -1;
1627	for (int mode = 0; mode <= 2; ++mode) {
1628	if (strcmp(GB_path_in_arbprop(ED4_propertyName(mode)), db_name) == 0) {
1629	default_mode = mode;
1630	break;
1631	}
1632	}
1633	if (default_mode == -1) default_mode = 2; // no properties yet -> use 'edit4.arb'
1634
1635	const char *entry = GBS_global_string("Save loaded Properties (%s)", ED4_propertyName(default_mode));
1636	awmm->insert_menu_topic("save_loaded_props", entry, "l", "e4_defaults.hlp", AWM_ALL, ED4_save_properties, (AW_CL)default_mode, 0);
1637	awmm->sep______________();
1638
1639	for (int mode = 2; mode >= 0; --mode) {
1640	char hotkey[] = "x";
1641	hotkey[0] = "Pta"[mode];
1642	entry = GBS_global_string("Save %sProperties (%s)", entry_type[mode], ED4_propertyName(mode));
1643	awmm->insert_menu_topic(tag[mode], entry, hotkey, "e4_defaults.hlp", AWM_ALL, ED4_save_properties, (AW_CL)mode, 0);
1644	}
1645	}
1646	awmm->close_sub_menu();
1647
1648	awmm->insert_help_topic("ARB_EDIT4 help", "E", "e4.hlp", AWM_ALL, makeHelpCallback("e4.hlp"));
1649
1650	// ----------------------------------------------------------------------------------------------------
1651
1652	aw_root->awar_int(AWAR_EDIT_TITLE_MODE)->add_callback((AW_RCB1)title_mode_changed, (AW_CL)awmm);
1653	awmm->set_bottom_area_height(0); // No bottom area
1654
1655	awmm->auto_space(5, -2);
1656	awmm->shadow_width(3);
1657
1658	int db_pathx, db_pathy;
1659	awmm->get_at_position(&db_pathx, &db_pathy);
1660
1661	awmm->shadow_width(1);
1662	awmm->load_xfig("edit4/editmenu.fig", false);
1663
1664	// --------------------------
1665	// help /quit /fold
1666
1667	awmm->button_length(0);
1668
1669	awmm->at("quit");
1670	awmm->callback(ED4_quit_editor);
1671	awmm->help_text("quit.hlp");
1672
1673	if (clone) {
1674	awmm->create_button("CLOSE", "#close.xpm");
1675	#if defined(ARB_GTK)
1676	awmm->set_close_action("CLOSE");
1677	#endif
1678	}
1679	else {
1680	awmm->create_button("QUIT", "#quit.xpm");
1681	#if defined(ARB_GTK)
1682	awmm->set_close_action("QUIT");
1683	#endif
1684	}
1685
1686	awmm->at("help");
1687	awmm->callback(AW_help_entry_pressed);
1688	awmm->help_text("e4.hlp");
1689	awmm->create_button("HELP", "#help.xpm");
1690
1691	awmm->at("fold");
1692	awmm->help_text("e4.hlp");
1693	awmm->create_toggle(AWAR_EDIT_TITLE_MODE, "#more.xpm", "#less.xpm");
1694
1695	// -------------------
1696	// positions
1697
1698	awmm->button_length(0);
1699
1700	awmm->at("posTxt"); awmm->create_button(0, "Position");
1701
1702	awmm->button_length(6+1);
1703
1704	awmm->at("ecoliTxt"); awmm->create_button(0, ED4_AWAR_NDS_ECOLI_NAME, 0, "+");
1705
1706	awmm->button_length(0);
1707
1708	awmm->at("baseTxt"); awmm->create_button(0, "Base");
1709	awmm->at("iupacTxt"); awmm->create_button(0, "IUPAC");
1710	awmm->at("helixnrTxt"); awmm->create_button(0, "Helix#");
1711
1712	awmm->at("pos");
1713	awmm->callback((AW_CB)ED4_jump_to_cursor_position, (AW_CL) current_ed4w()->awar_path_for_cursor, AW_CL(ED4_POS_SEQUENCE));
1714	awmm->create_input_field(current_ed4w()->awar_path_for_cursor, 7);
1715
1716	awmm->at("ecoli");
1717	awmm->callback((AW_CB)ED4_jump_to_cursor_position, (AW_CL) current_ed4w()->awar_path_for_Ecoli, AW_CL(ED4_POS_ECOLI));
1718	awmm->create_input_field(current_ed4w()->awar_path_for_Ecoli, 6);
1719
1720	awmm->at("base");
1721	awmm->callback((AW_CB)ED4_jump_to_cursor_position, (AW_CL) current_ed4w()->awar_path_for_basePos, AW_CL(ED4_POS_BASE));
1722	awmm->create_input_field(current_ed4w()->awar_path_for_basePos, 6);
1723
1724	awmm->at("iupac");
1725	awmm->callback((AW_CB)ED4_set_iupac, (AW_CL) current_ed4w()->awar_path_for_IUPAC, AW_CL(0));
1726	awmm->create_input_field(current_ed4w()->awar_path_for_IUPAC, 4);
1727
1728	awmm->at("helixnr");
1729	awmm->callback((AW_CB)ED4_set_helixnr, (AW_CL) current_ed4w()->awar_path_for_helixNr, AW_CL(0));
1730	awmm->create_input_field(current_ed4w()->awar_path_for_helixNr, 5);
1731
1732	// ----------------------------
1733	// jump/get/undo/redo
1734
1735	awmm->button_length(4);
1736
1737	awmm->at("jump");
1738	awmm->callback(ED4_jump_to_current_species, 0);
1739	awmm->help_text("e4.hlp");
1740	awmm->create_button("JUMP", "Jump");
1741
1742	awmm->at("get");
1743	awmm->callback(ED4_get_and_jump_to_current, 0);
1744	awmm->help_text("e4.hlp");
1745	awmm->create_button("GET", "Get");
1746
1747	awmm->button_length(0);
1748
1749	awmm->at("undo");
1750	awmm->callback(ED4_undo_redo, GB_UNDO_UNDO);
1751	awmm->help_text("undo.hlp");
1752	awmm->create_button("UNDO", "#undo.xpm");
1753
1754	awmm->at("redo");
1755	awmm->callback(ED4_undo_redo, GB_UNDO_REDO);
1756	awmm->help_text("undo.hlp");
1757	awmm->create_button("REDO", "#redo.xpm");
1758
1759	// --------------------------
1760	// aligner / SAIviz
1761
1762	awmm->button_length(7);
1763
1764	awmm->at("aligner");
1765	awmm->callback(AW_POPUP, (AW_CL)ED4_create_faligner_window, (AW_CL)&dataAccess_4_aligner);
1766	awmm->help_text("faligner.hlp");
1767	awmm->create_button("ALIGNER", "Aligner");
1768
1769	awmm->at("saiviz");
1770	awmm->callback(AW_POPUP, (AW_CL)ED4_createVisualizeSAI_window, 0);
1771	awmm->help_text("visualizeSAI.hlp");
1772	awmm->create_button("SAIVIZ", "SAIviz");
1773
1774	// -------------------------------------------
1775	// align/insert/protection/direction
1776
1777	awmm->button_length(0);
1778
1779	awmm->at("protect");
1780	awmm->create_option_menu(AWAR_EDIT_SECURITY_LEVEL, true);
1781	awmm->insert_option("0", 0, 0);
1782	awmm->insert_option("1", 0, 1);
1783	awmm->insert_option("2", 0, 2);
1784	awmm->insert_option("3", 0, 3);
1785	awmm->insert_option("4", 0, 4);
1786	awmm->insert_option("5", 0, 5);
1787	awmm->insert_default_option("6", 0, 6);
1788	awmm->update_option_menu();
1789
1790	// draw protection icon AFTER protection!!
1791	awmm->at("pico");
1792	awmm->create_button(NULL, "#protect.xpm");
1793
1794	// draw align/edit-button AFTER protection!!
1795	awmm->at("edit");
1796	awmm->create_toggle(AWAR_EDIT_MODE, "#edit/align.xpm", "#edit/editseq.xpm", 7);
1797
1798	awmm->at("insert");
1799	awmm->create_text_toggle(AWAR_INSERT_MODE, "Replace", "Insert", 7);
1800
1801	awmm->at("direct");
1802	awmm->create_toggle(AWAR_EDIT_RIGHTWARD, "#edit/3to5.xpm", "#edit/5to3.xpm", 7);
1803
1804	// -------------------------
1805	// secedit / rna3d
1806
1807	int xoffset = 0;
1808
1809	if (alignment_type == GB_AT_RNA) { // if the database contains valid alignment of rRNA sequences
1810	// add buttons for RNA3D and SECEDIT plugins
1811
1812	awmm->button_length(0);
1813
1814	awmm->at("secedit");
1815	awmm->callback(ED4_start_plugin, (AW_CL)GLOBAL_gb_main, (AW_CL)"SECEDIT");
1816	awmm->help_text("arb_secedit.hlp");
1817	awmm->create_button("SECEDIT", "#edit/secedit.xpm");
1818
1819	#if defined(ARB_OPENGL)
1820	awmm->at("rna3d");
1821	awmm->callback(ED4_start_plugin, (AW_CL)GLOBAL_gb_main, (AW_CL)"RNA3D");
1822	awmm->help_text("rna3d_general.hlp");
1823	awmm->create_button("RNA3D", "#edit/rna3d.xpm");
1824	#endif // ARB_OPENGL
1825	}
1826	else {
1827	awmm->at("secedit");
1828	int xsecedit = awmm->get_at_xposition();
1829	awmm->at("zoom");
1830	int xzoom = awmm->get_at_xposition();
1831	xoffset = xsecedit-xzoom; // shift message stuff to the left by xoffset
1832	}
1833
1834	{
1835	int x, y;
1836
1837	awmm->at("zoom");
1838	if (xoffset) { awmm->get_at_position(&x, &y); awmm->at(x+xoffset, y); }
1839	awmm->callback(AW_POPUP, (AW_CL)ED4_zoom_message_window, (AW_CL)0);
1840	awmm->create_button("ZOOM", "#edit/zoom.xpm");
1841
1842	awmm->at("clear");
1843	if (xoffset) { awmm->get_at_position(&x, &y); awmm->at(x+xoffset, y); }
1844	awmm->callback(ED4_clear_errors, (AW_CL)0);
1845	awmm->create_button("CLEAR", "#edit/clear.xpm");
1846
1847	awmm->at("errortext");
1848	if (xoffset) { awmm->get_at_position(&x, &y); awmm->at(x+xoffset, y); }
1849	aw_root->awar_string(AWAR_ERROR_MESSAGES, "This is ARB Edit4 [Build " ARB_VERSION "]");
1850	awmm->create_text_field(AWAR_ERROR_MESSAGES);
1851	aw_set_local_message();
1852	}
1853
1854	// ---------------------
1855	// 'more' area
1856
1857	awmm->at("cons");
1858	awmm->create_toggle(ED4_AWAR_CONSENSUS_SHOW, "#edit/nocons.xpm", "#edit/cons.xpm");
1859
1860	awmm->at("num");
1861	awmm->create_toggle(ED4_AWAR_DIGITS_AS_REPEAT, "#edit/norepeat.xpm", "#edit/repeat.xpm");
1862
1863	awmm->at("key");
1864	awmm->create_toggle("key_mapping/enable", "#edit/nokeymap.xpm", "#edit/keymap.xpm");
1865
1866	// search
1867
1868	awmm->button_length(0);
1869	#define INSERT_SEARCH_FIELDS(Short, label_prefix, prefix) \
1870	insert_search_fields(awmm, \
1871	#label_prefix, \
1872	#prefix, \
1873	ED4_AWAR_##prefix##_SEARCH_PATTERN, \
1874	ED4_AWAR_##prefix##_SEARCH_SHOW, \
1875	Short, \
1876	ED4_##prefix##_PATTERN, \
1877	current_ed4w() \
1878	)
1879
1880	INSERT_SEARCH_FIELDS(0, u1, USER1);
1881	INSERT_SEARCH_FIELDS(0, u2, USER2);
1882	INSERT_SEARCH_FIELDS(0, pro, PROBE);
1883	INSERT_SEARCH_FIELDS(1, pri1, PRIMER1);
1884	INSERT_SEARCH_FIELDS(1, pri2, PRIMER2);
1885	INSERT_SEARCH_FIELDS(1, pri3, PRIMER3);
1886	INSERT_SEARCH_FIELDS(1, sig1, SIG1);
1887	INSERT_SEARCH_FIELDS(1, sig2, SIG2);
1888	INSERT_SEARCH_FIELDS(1, sig3, SIG3);
1889
1890	#undef INSERT_SEARCH_FIELDS
1891
1892	awmm->at("alast");
1893	awmm->callback(ED4_search_cb, ED4_encodeSearchDescriptor(-1, ED4_ANY_PATTERN), (AW_CL)current_ed4w());
1894	awmm->create_button("ALL_SEARCH_LAST", "#edit/last.xpm");
1895
1896	awmm->at("anext");
1897	awmm->callback(ED4_search_cb, ED4_encodeSearchDescriptor(+1, ED4_ANY_PATTERN), (AW_CL)current_ed4w());
1898	awmm->create_button("ALL_SEARCH_NEXT", "#edit/next.xpm");
1899
1900	title_mode_changed(aw_root, awmm);
1901
1902	// Buttons at left window border
1903
1904	awmm->create_mode("edit/arrow.xpm", "normal.hlp", AWM_ALL, makeWindowCallback(modes_cb, ED4_SM_MOVE));
1905	awmm->create_mode("edit/kill.xpm", "kill.hlp", AWM_ALL, makeWindowCallback(modes_cb, ED4_SM_KILL));
1906	awmm->create_mode("edit/mark.xpm", "mark.hlp", AWM_ALL, makeWindowCallback(modes_cb, ED4_SM_MARK));
1907
1908	FastAligner_create_variables(awmm->get_root(), props_db);
1909
1910	#if defined(DEBUG)
1911	AWT_check_action_ids(awmm->get_root(), "");
1912	#endif
1913
1914	announce_useraction_in(awmm);
1915
1916	return (ED4_R_OK);
1917	}
1918
1919	AW_window *ED4_root::create_new_window() {
1920	// only the first window, other windows are generated by generate_window
1921	AW_device *device = NULL;
1922	ED4_window *new_window = NULL;
1923
1924	generate_window(&device, &new_window);
1925
1926	ED4_LocalWinContext uses(new_window);
1927
1928	ED4_calc_terminal_extentions();
1929
1930	DRAW = 1;
1931	move_cursor = 0;
1932	max_seq_terminal_length = 0;
1933
1934	ED4_init_notFoundMessage();
1935
1936	return new_window->aww;
1937	}
1938
1939	ED4_index ED4_root::pixel2pos(AW_pos click_x) {
1940	// 'click_x' is the x-offset into the terminal in pixels
1941	// returns the x-offset into the terminal in base positions (clipped to max. allowed position)
1942
1943	int length_of_char = font_group.get_width(ED4_G_SEQUENCES);
1944	ED4_index scr_pos = int((click_x-CHARACTEROFFSET) / length_of_char);
1945	int max_scrpos = root_group_man->remap()->get_max_screen_pos();
1946
1947	if (scr_pos>max_scrpos) scr_pos = max_scrpos;
1948
1949	return scr_pos;
1950	}
1951
1952	static char *detectProperties() {
1953	char *propname = NULL;
1954
1955	// check if edit4_?na.arb / edit4_ali_???.arb exist in $ARB_PROP
1956	for (int mode = 0; !propname && mode <= 1; ++mode) {
1957	const char *fullprop = GB_path_in_arbprop(ED4_propertyName(mode));
1958	if (GB_is_regularfile(fullprop)) {
1959	freedup(propname, fullprop);
1960	}
1961	}
1962
1963	// if not, use 'mode 2', i.e. "edit4.arb"
1964	// (no full path, we want to load default from arb_defaults)
1965	if (!propname) propname = strdup(ED4_propertyName(2));
1966
1967	return propname;
1968	}
1969
1970	ED4_root::ED4_root(int* argc, char*** argv)
1971	: most_recently_used_window(0),
1972	db_name(detectProperties()),
1973	aw_root(AWT_create_root(db_name, "ARB_EDIT4", need_macro_ability(), argc, argv)),
1974	props_db(AW_ROOT_DEFAULT),
1975	first_window(0),
1976	main_manager(0),
1977	middle_area_man(0),
1978	top_area_man(0),
1979	root_group_man(0),
1980	database(0),
1981	selected_objects(new ED4_selected_list),
1982	folding_action(0),
1983	species_mode(ED4_SM_MOVE),
1984	ecoli_ref(0),
1985	alignment_name(0),
1986	alignment_type(GB_AT_UNKNOWN),
1987	reference(0),
1988	sequence_colors(0),
1989	gc_manager(0),
1990	st_ml(0),
1991	helix(0),
1992	helix_spacing(0),
1993	helix_add_spacing(0),
1994	terminal_add_spacing(0),
1995	protstruct(0),
1996	protstruct_len(0),
1997	edk(0),
1998	edit_string(0),
1999	column_stat_activated(false),
2000	column_stat_initialized(false),
2001	visualizeSAI(false),
2002	visualizeSAI_allSpecies(false),
2003	temp_gc(0)
2004	{}
2005
2006
2007	ED4_root::~ED4_root() {
2008	delete aw_root;
2009	delete first_window;
2010	delete main_manager;
2011	delete middle_area_man;
2012	delete top_area_man;
2013	delete database;
2014	delete ecoli_ref;
2015	delete selected_objects;
2016
2017	free(protstruct);
2018	free(db_name);
2019	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: