Context Navigation

source: tags/ms_ra2q34/MERGE/MG_species.cxx

Visit:

Last change on this file was 18092, checked in by westram, 5 years ago
full update from child 'fts' into 'trunk' implements #562 adds: [18091/branches/fts] log:branches/gui@17754:17924,17926:18090
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 52.7 KB

Line
1	// =============================================================== //
2	// //
3	// File : MG_species.cxx //
4	// Purpose : //
5	// //
6	// Institute of Microbiology (Technical University Munich) //
7	// http://www.arb-home.de/ //
8	// //
9	// =============================================================== //
10
11	#include "merge.hxx"
12	#include "MG_adapt_ali.hxx"
13
14	#include <AW_rename.hxx>
15	#include <db_query.h>
16	#include <db_scanner.hxx>
17	#include <item_sel_list.h>
18
19	#include <xfergui.h>
20	#include <xferset.h>
21
22	#include <aw_awars.hxx>
23	#include <aw_msg.hxx>
24	#include <arb_progress.h>
25	#include <aw_root.hxx>
26	#include <aw_question.hxx>
27
28	#include <arb_str.h>
29	#include <arb_strbuf.h>
30	#include <arb_global_defs.h>
31
32
33	#define AWAR_SPECIES_SRC AWAR_MERGE_TMP_SRC "name"
34	#define AWAR_FIELD_SRC AWAR_MERGE_TMP_SRC "field"
35	#define AWAR_TAG_SRC AWAR_MERGE_TMP_SRC "tag"
36
37	#define AWAR_SPECIES_DST AWAR_MERGE_TMP_DST "name"
38	#define AWAR_FIELD_DST AWAR_MERGE_TMP_DST "field"
39	#define AWAR_TAG_DST AWAR_MERGE_TMP_DST "tag"
40
41	#define AWAR_TAG_DEL AWAR_MERGE_TMP "tagdel"
42	#define AWAR_APPEND AWAR_MERGE_TMP "append"
43
44	#define AWAR_SPECIES_XFER_TYPE AWAR_MERGE_SAV "xferType"
45	#define AWAR_SPECIES_XFER_SCOPE AWAR_MERGE_SAV "xferScope"
46	#define AWAR_SPECIES_XFER_FTS AWAR_MERGE_SAV "fts"
47
48	static DbScanner *scanner_src = NULp;
49	static DbScanner *scanner_dst = NULp;
50
51	enum SpeciesXferType {
52	SXT_WHOLE_SPECIES,
53	SXT_SINGLE_FIELD,
54	SXT_USING_FTS, // field transfer set
55	};
56
57	enum SpeciesXferScope {
58	SXS_SELECTED_SPECIES,
59	SXS_LISTED_SPECIES,
60	};
61
62	const char *MG_left_AWAR_SPECIES_NAME() { return AWAR_SPECIES_SRC; }
63
64	void MG_create_species_awars(AW_root *aw_root, AW_default aw_def) {
65	aw_root->awar_string(AWAR_SPECIES_SRC, "", aw_def);
66	aw_root->awar_string(AWAR_SPECIES_DST, "", aw_def);
67
68	aw_root->awar_string(AWAR_FIELD_SRC, NO_FIELD_SELECTED, aw_def);
69	aw_root->awar_string(AWAR_FIELD_DST, NO_FIELD_SELECTED, aw_def);
70
71	aw_root->awar_int(AWAR_APPEND, 0, aw_def);
72
73	aw_root->awar_int(AWAR_SPECIES_XFER_TYPE, SXT_WHOLE_SPECIES, aw_def);
74	aw_root->awar_int(AWAR_SPECIES_XFER_SCOPE, SXS_LISTED_SPECIES, aw_def);
75
76	aw_root->awar_string(AWAR_SPECIES_XFER_FTS, "", aw_def);
77	}
78
79	static void MG_map_species(AW_root *aw_root, DbSel db) {
80	GBDATA *gb_main = get_gb_main(db);
81	const char *awar_name = db == SRC_DB ? AWAR_SPECIES_SRC : AWAR_SPECIES_DST;
82	DbScanner *scanner = db == SRC_DB ? scanner_src : scanner_dst;
83
84	GB_transaction ta(gb_main);
85	char *selected_species = aw_root->awar(awar_name)->read_string();
86	GBDATA *gb_species = GBT_find_species(gb_main, selected_species);
87	if (gb_species) {
88	scanner->Map(gb_species, awar_name); // @@@ why is awar_name passed here? (normally a changekey-path is used)
89	// @@@ undocumented feature in DbScanner or bug?
90	}
91	free(selected_species);
92	}
93
94	static GB_ERROR MG_transfer_fields_info(char *fieldname = NULp) {
95	GBDATA *gb_key_data = GB_search(GLOBAL_gb_src, CHANGE_KEY_PATH, GB_CREATE_CONTAINER);
96	GB_ERROR error = NULp;
97
98	if (!gb_key_data) error = GB_await_error();
99	else {
100	if (!GB_search(GLOBAL_gb_dst, CHANGE_KEY_PATH, GB_CREATE_CONTAINER)) error = GB_await_error();
101	else {
102	for (GBDATA *gb_key = GB_entry(gb_key_data, CHANGEKEY);
103	gb_key && !error;
104	gb_key = GB_nextEntry(gb_key))
105	{
106	GBDATA *gb_key_name = GB_entry(gb_key, CHANGEKEY_NAME);
107	if (gb_key_name) {
108	GBDATA *gb_key_type = GB_entry(gb_key, CHANGEKEY_TYPE);
109	if (gb_key_type) {
110	char *name = GB_read_string(gb_key_name);
111
112	if (!fieldname \|\| strcmp(fieldname, name) == 0) {
113	error = GBT_add_new_changekey(GLOBAL_gb_dst, name, (int)GB_read_int(gb_key_type));
114	}
115	free(name);
116	}
117	}
118	}
119	}
120	}
121	return error;
122	}
123
124	static GB_ERROR MG_transfer_one_species(AW_root *aw_root, MG_remaps& remap,
125	GBDATA gb_src_species, GBDATA gb_dst_species_data,
126	bool src_is_genome, bool dst_is_genome,
127	GB_HASH source_organism_hash, GB_HASH dest_species_hash,
128	GB_HASH *error_suppressor)
129	{
130	// copies species 'gb_src_species' from source to destination DB.
131	//
132	// 'source_organism_hash' may be NULp, otherwise it's used to search for source organisms (when merging from genome DB)
133	// 'dest_species_hash' may be NULp, otherwise created species is stored there
134
135	mg_assert(gb_src_species);
136
137	GB_ERROR error = NULp;
138	const char *src_name = GBT_get_name(gb_src_species);
139	bool transfer_fields = false;
140
141	if (!src_name) {
142	error = "refused to transfer unnamed species";
143	}
144	else {
145	if (src_is_genome) {
146	if (dst_is_genome) { // genome -> genome
147	if (GEN_is_pseudo_gene_species(gb_src_species)) {
148	const char *origin = GEN_origin_organism(gb_src_species);
149	GBDATA *dest_organism = dest_species_hash
150	? (GBDATA*)GBS_read_hash(dest_species_hash, origin)
151	: GEN_find_organism(GLOBAL_gb_dst, origin);
152
153	if (dest_organism) transfer_fields = true;
154	else {
155	error = GBS_global_string("Destination DB does not contain '%s's origin-organism '%s'",
156	src_name, origin);
157	}
158	}
159	// else: merge organism ok
160	}
161	else { // genome -> non-genome
162	if (GEN_is_pseudo_gene_species(gb_src_species)) transfer_fields = true;
163	else {
164	error = GBS_global_string("You can't merge organisms (%s) into a non-genome DB.\n"
165	"Only pseudo-species are possible", src_name);
166	}
167	}
168	}
169	else {
170	if (dst_is_genome) { // non-genome -> genome
171	error = GBS_global_string("You can't merge non-genome species (%s) into a genome DB", src_name);
172	}
173	// else: non-genome -> non-genome ok
174	}
175	}
176
177	GBDATA *gb_dst_species = NULp;
178	if (!error) {
179	gb_dst_species = dest_species_hash
180	? (GBDATA*)GBS_read_hash(dest_species_hash, src_name)
181	: GBT_find_species_rel_species_data(gb_dst_species_data, src_name);
182
183	if (gb_dst_species) error = GB_delete(gb_dst_species);
184	}
185	if (!error) {
186	gb_dst_species = GB_create_container(gb_dst_species_data, "species");
187	if (!gb_dst_species) error = GB_await_error();
188	}
189	if (!error) error = GB_copy_dropProtectMarksAndTempstate(gb_dst_species, gb_src_species);
190	if (!error && transfer_fields) {
191	mg_assert(src_is_genome);
192	error = MG_export_fields(aw_root, gb_src_species, gb_dst_species, error_suppressor, source_organism_hash);
193	}
194	if (!error) GB_write_flag(gb_dst_species, 1);
195	if (!error) error = MG_adaptAllCopiedAlignments(remap, gb_src_species, gb_dst_species);
196	if (!error && dest_species_hash) GBS_write_hash(dest_species_hash, src_name, (long)gb_dst_species);
197
198	return error;
199	}
200
201	static const char get_reference_species_names(AW_root awr) {
202	return awr->awar(AWAR_REMAP_SPECIES_LIST)->read_char_pntr();
203	}
204	static bool adaption_enabled(AW_root *awr) {
205	return awr->awar(AWAR_REMAP_ENABLE)->read_int() != 0;
206	}
207
208	static void mg_transfer_selected_species(AW_window *aww) {
209	if (MG_copy_and_check_alignments() != 0) return;
210
211	AW_root *aw_root = aww->get_root();
212	char *src_name = aw_root->awar(AWAR_SPECIES_SRC)->read_string();
213	GB_ERROR error = NULp;
214
215	if (!src_name \|\| !src_name[0]) {
216	error = "Please select a species in the left list";
217	}
218	else {
219	arb_progress progress("Transferring selected species");
220
221	error = GB_begin_transaction(GLOBAL_gb_src);
222	if (!error) error = GB_begin_transaction(GLOBAL_gb_dst);
223
224	if (!error) {
225	MG_remaps rm(GLOBAL_gb_src, GLOBAL_gb_dst, adaption_enabled(aw_root), get_reference_species_names(aw_root));
226
227	GBDATA *gb_src_species_data = GBT_get_species_data(GLOBAL_gb_src);
228	GBDATA *gb_dst_species_data = GBT_get_species_data(GLOBAL_gb_dst);
229
230	bool src_is_genome = GEN_is_genome_db(GLOBAL_gb_src, -1);
231	bool dst_is_genome = GEN_is_genome_db(GLOBAL_gb_dst, -1);
232
233	GBDATA *gb_src_species = GBT_find_species_rel_species_data(gb_src_species_data, src_name);
234	if (!gb_src_species) {
235	error = GBS_global_string("Could not find species '%s' in source database", src_name);
236	}
237	else {
238	error = MG_transfer_one_species(aw_root, rm,
239	gb_src_species, gb_dst_species_data,
240	src_is_genome, dst_is_genome,
241	NULp, NULp,
242	NULp);
243	}
244	}
245
246	if (!error) error = MG_transfer_fields_info();
247
248	error = GB_end_transaction(GLOBAL_gb_src, error);
249	error = GB_end_transaction(GLOBAL_gb_dst, error);
250	}
251
252	if (error) aw_message(error);
253	}
254
255	static void mg_transfer_listed_species(AW_window *aww) {
256	if (MG_copy_and_check_alignments() != 0) return;
257
258	GB_ERROR error = NULp;
259	GB_begin_transaction(GLOBAL_gb_src);
260	GB_begin_transaction(GLOBAL_gb_dst);
261
262	bool src_is_genome = GEN_is_genome_db(GLOBAL_gb_src, -1);
263	bool dst_is_genome = GEN_is_genome_db(GLOBAL_gb_dst, -1);
264
265	GB_HASH *error_suppressor = GBS_create_hash(50, GB_IGNORE_CASE);
266	GB_HASH *dest_species_hash = GBT_create_species_hash(GLOBAL_gb_dst);
267	GB_HASH *source_organism_hash = src_is_genome ? GBT_create_organism_hash(GLOBAL_gb_src) : NULp;
268
269	AW_root *aw_root = aww->get_root();
270	MG_remaps rm(GLOBAL_gb_src, GLOBAL_gb_dst, adaption_enabled(aw_root), get_reference_species_names(aw_root));
271
272	GBDATA *gb_src_species;
273	arb_progress progress("Transferring listed species", mg_count_queried(GLOBAL_gb_src));
274
275	for (gb_src_species = GBT_first_species(GLOBAL_gb_src);
276	gb_src_species;
277	gb_src_species = GBT_next_species(gb_src_species))
278	{
279	if (IS_QUERIED_SPECIES(gb_src_species)) {
280	GBDATA *gb_dst_species_data = GBT_get_species_data(GLOBAL_gb_dst);
281
282	error = MG_transfer_one_species(aw_root, rm,
283	gb_src_species, gb_dst_species_data,
284	src_is_genome, dst_is_genome,
285	source_organism_hash, dest_species_hash,
286	error_suppressor);
287
288	progress.inc_and_check_user_abort(error);
289	}
290	}
291
292	GBS_free_hash(dest_species_hash);
293	if (source_organism_hash) GBS_free_hash(source_organism_hash);
294	GBS_free_hash(error_suppressor);
295
296	if (!error) error = MG_transfer_fields_info();
297
298	error = GB_end_transaction(GLOBAL_gb_src, error);
299	GB_end_transaction_show_error(GLOBAL_gb_dst, error, aw_message);
300	}
301
302	static GB_ERROR transfer_single_field(GBDATA const gb_src_species, GBDATA const gb_dst_species, const char const field, GBDATA const gb_src_field, const bool append, const bool transfer_of_alignment, const MG_remaps& rm) {
303	GBDATA *gb_dst_field = GB_search(gb_dst_species, field, GB_FIND);
304	GB_TYPES src_type = GB_read_type(gb_src_field);
305	GB_TYPES dst_type = gb_dst_field ? GB_read_type(gb_dst_field) : src_type;
306
307	bool use_copy = true;
308	GB_ERROR error = NULp;
309
310	if (append) {
311	if (src_type != GB_STRING \|\| dst_type != GB_STRING) {
312	error = "You can use 'Append data' with text fields only!";
313	}
314	else if (gb_dst_field) { // append possible (otherwise use_copy!)
315	char *src_val = GB_read_string(gb_src_field);
316	char *dst_val = GB_read_string(gb_dst_field);
317
318	if (!src_val \|\| !dst_val) error = GB_await_error();
319	else {
320	if (!GBS_find_string(dst_val, src_val, 0)) { // do not append if dst_val contains src_val
321	error = GB_write_string(gb_dst_field, GBS_global_string("%s %s", dst_val, src_val));
322	if (!error) GB_write_flag(gb_dst_species, 1);
323	}
324	}
325
326	free(src_val);
327	free(dst_val);
328
329	use_copy = false;
330	}
331	}
332
333	if (!error && use_copy) {
334	if (dst_type != src_type) error = "type mismatch"; // abort early (previously failed in call to MG_transfer_fields_info below)
335	if (!error && src_type == GB_DB && gb_dst_field) {
336	// if type is container -> delete before copy
337	// (otherwise it would generate a mix of both containers; if wanted provide optionally)
338	error = GB_delete(gb_dst_field);
339	gb_dst_field = NULp; // trigger recreation+copy
340	}
341	if (!error && !gb_dst_field) { // create missing target field (otherwise simply overwrite)
342	gb_dst_field = GB_search(gb_dst_species, field, src_type);
343	if (!gb_dst_field) error = GB_await_error(); // failed to create?
344	}
345	if (!error) error = GB_copy_dropProtectMarksAndTempstate(gb_dst_field, gb_src_field); // [Note: if transfer_of_alignment -> copies 'data' field of one alignment]
346	if (!error && transfer_of_alignment) error = MG_adaptAllCopiedAlignments(rm, gb_src_species, gb_dst_species); // [Note: adapts all copied alignments, if adapt toggle is checked]
347	if (!error) GB_write_flag(gb_dst_species, 1);
348	}
349	return error;
350	}
351
352	inline bool fieldContainsAlignment(const char *field) {
353	return GBS_string_matches(field, "ali_*", GB_MIND_CASE);
354	}
355
356	static void transfer_field_of_listed_cb(AW_window *aww) {
357	if (MG_copy_and_check_alignments() != 0) return;
358
359	AW_root *aw_root = aww->get_root();
360	char *field = aw_root->awar(AWAR_FIELD_SRC)->read_string();
361	const bool append = aw_root->awar(AWAR_APPEND)->read_int();
362	GB_ERROR error = NULp;
363
364	if (strcmp(field, NO_FIELD_SELECTED) == 0) {
365	error = "Please select the field you like to transfer";
366	}
367	else if (strcmp(field, "name") == 0) {
368	error = "Transferring the 'name' field is forbidden";
369	}
370	else {
371	const bool transfer_of_alignment = fieldContainsAlignment(field);
372
373	if (transfer_of_alignment && append) {
374	error = "Appending alignment data is not permitted\n"
375	"(please refer to ARB_NT/Sequence/Concatenate.. to do so)";
376	}
377	else {
378	error = GB_begin_transaction(GLOBAL_gb_src);
379	if (!error) error = GB_begin_transaction(GLOBAL_gb_dst);
380
381	if (!error) {
382	arb_progress progress("Transferring fields of listed", mg_count_queried(GLOBAL_gb_src));
383
384	MG_remaps rm(GLOBAL_gb_src, GLOBAL_gb_dst, adaption_enabled(aw_root), get_reference_species_names(aw_root)); // @@@ unused if transfer_of_alignment == false
385
386	GBDATA *gb_dest_species_data = GBT_get_species_data(GLOBAL_gb_dst);
387	if (!gb_dest_species_data) error = GB_await_error();
388
389	for (GBDATA *gb_src_species = GBT_first_species(GLOBAL_gb_src);
390	gb_src_species && !error;
391	gb_src_species = GBT_next_species(gb_src_species))
392	{
393	if (IS_QUERIED_SPECIES(gb_src_species)) {
394	const char *src_name = GBT_read_name(gb_src_species);
395	GBDATA *gb_dst_species = GB_find_string(gb_dest_species_data, "name", src_name, GB_IGNORE_CASE, SEARCH_GRANDCHILD);
396
397	if (!gb_dst_species) {
398	gb_dst_species = GB_create_container(gb_dest_species_data, "species");
399	if (!gb_dst_species) error = GB_await_error();
400	else error = GBT_write_string(gb_dst_species, "name", src_name);
401	}
402	else {
403	gb_dst_species = GB_get_father(gb_dst_species);
404	}
405
406	if (!error) {
407	// @@@ DRY vs inner part of body of transfer_field_of_selected_cb .@DRY_TRANSFER_FIELD
408	GBDATA *gb_src_field = GB_search(gb_src_species, field, GB_FIND);
409
410	if (gb_src_field) {
411	error = transfer_single_field(gb_src_species, gb_dst_species, field, gb_src_field, append, transfer_of_alignment, rm);
412	}
413	}
414	if (error) error = GBS_global_string("%s (species=%s)", error, src_name); // mention name of species in error message
415
416	progress.inc_and_check_user_abort(error);
417	}
418	}
419	}
420
421	if (!error) error = MG_transfer_fields_info(field);
422
423	error = GB_end_transaction(GLOBAL_gb_src, error);
424	error = GB_end_transaction(GLOBAL_gb_dst, error);
425	}
426	}
427
428	if (error) aw_message(error);
429	free(field);
430	}
431
432	static void transfer_field_of_selected_cb(AW_window *aww) {
433	if (MG_copy_and_check_alignments() != 0) return;
434
435	AW_root *aw_root = aww->get_root();
436	char *field = aw_root->awar(AWAR_FIELD_SRC)->read_string();
437	const bool append = false; // @@@ provide via GUI?
438	GB_ERROR error = NULp;
439
440	if (strcmp(field, NO_FIELD_SELECTED) == 0) {
441	error = "Please select the field you like to transfer";
442	}
443	else if (strcmp(field, "name") == 0) {
444	error = "Transferring the 'name' field is forbidden";
445	}
446	else {
447	const bool transfer_of_alignment = fieldContainsAlignment(field);
448
449	if (transfer_of_alignment && append) { // @@@ append always false (see above)
450	error = "Appending alignment data is not permitted\n"
451	"(please refer to ARB_NT/Sequence/Concatenate.. to do so)";
452	}
453	else {
454	error = GB_begin_transaction(GLOBAL_gb_src);
455	if (!error) error = GB_begin_transaction(GLOBAL_gb_dst);
456
457	if (!error) {
458	arb_progress progress("Cross copy field");
459
460	MG_remaps rm(GLOBAL_gb_src, GLOBAL_gb_dst, adaption_enabled(aw_root), get_reference_species_names(aw_root)); // @@@ unused if transfer_of_alignment == false
461
462	GBDATA *gb_src_species;
463	GBDATA *gb_dst_species;
464	{
465	char *src_name = aw_root->awar(AWAR_SPECIES_SRC)->read_string();
466	char *dst_name = aw_root->awar(AWAR_SPECIES_DST)->read_string();
467
468	gb_src_species = GBT_find_species(GLOBAL_gb_src, src_name);
469	gb_dst_species = GBT_find_species(GLOBAL_gb_dst, dst_name);
470
471	free(dst_name);
472	free(src_name);
473	}
474
475	if (!gb_src_species) error = "Please select a species in left hitlist";
476	if (!gb_dst_species) error = "Please select a species in right hitlist";
477
478	if (!error) {
479	// @@@ DRY vs loop-body of transfer_field_of_listed_cb .@DRY_TRANSFER_FIELD
480	GBDATA *gb_src_field = GB_search(gb_src_species, field, GB_FIND);
481	if (!gb_src_field) error = GBS_global_string("Source species has no field '%s'", field);
482
483	if (!error) {
484	error = transfer_single_field(gb_src_species, gb_dst_species, field, gb_src_field, append, transfer_of_alignment, rm);
485	}
486	}
487	}
488	if (!error) error = MG_transfer_fields_info(field);
489
490	error = GB_end_transaction(GLOBAL_gb_src, error);
491	error = GB_end_transaction(GLOBAL_gb_dst, error);
492	}
493	}
494
495	if (error) aw_message(error);
496
497	free(field);
498	}
499
500	static void popup_single_field_transfer_window(AW_root *aw_root, SpeciesXferScope scope) {
501	static AW_window *aww[2] = { NULp, NULp };
502
503	if (!aww[scope]) {
504	GB_transaction ta(GLOBAL_gb_src);
505	AW_window_simple *aws = new AW_window_simple;
506
507	bool listed = scope == SXS_LISTED_SPECIES;
508	mg_assert(implicated(!listed, scope == SXS_SELECTED_SPECIES));
509
510	if (listed) aws->init(aw_root, "MERGE_XFER_FIELD_OF_LISTED", "Transfer field of listed");
511	else aws->init(aw_root, "MERGE_XFER_SINGLE_FIELD", "Transfer field of selected");
512
513	aws->load_xfig("merge/mg_transfield.fig");
514	aws->button_length(10);
515
516	aws->callback(AW_POPDOWN);
517	aws->at("close");
518	aws->create_button("CLOSE", "CLOSE", "C");
519
520	aws->at("help");
521	aws->callback(makeHelpCallback(listed ? "mg_xfer_field_of_listed.hlp" : "mg_xfer_field_of_sel.hlp"));
522	aws->create_button("HELP", "HELP");
523
524	if (listed) {
525	aws->at("append");
526	aws->label("Append data?");
527	aws->create_toggle(AWAR_APPEND);
528	}
529
530	long typeFilter = listed ? FIELD_FILTER_ANY_FIELD : FIELD_UNFILTERED;
531	create_itemfield_selection_button(aws, FieldSelDef(AWAR_FIELD_SRC, GLOBAL_gb_src, SPECIES_get_selector(), typeFilter, "source/target field"), "scandb");
532
533	aws->at("go");
534	aws->callback(listed ? transfer_field_of_listed_cb : transfer_field_of_selected_cb);
535	aws->create_button("GO", "GO");
536
537	aww[scope] = aws;
538	}
539	aww[scope]->activate();
540	}
541
542	static void MG_merge_tagged_field_cb(AW_window *aww) {
543	GB_transaction ta_merge(GLOBAL_gb_src);
544	GB_ERROR error = GB_begin_transaction(GLOBAL_gb_dst);
545
546	if (!error) {
547	AW_root *awr = aww->get_root();
548
549	char *src_field = awr->awar(AWAR_FIELD_SRC)->read_string();
550	char *dst_field = awr->awar(AWAR_FIELD_DST)->read_string();
551
552	if (strcmp(src_field, NO_FIELD_SELECTED) == 0 \|\|
553	strcmp(dst_field, NO_FIELD_SELECTED) == 0)
554	{
555	error = "Please select source- and target-fields.";
556	}
557
558	if (!error) {
559	char *src_tag = awr->awar(AWAR_TAG_SRC)->read_string();
560	char *dst_tag = awr->awar(AWAR_TAG_DST)->read_string();
561	char *del_tag = awr->awar(AWAR_TAG_DEL)->read_string();
562
563	arb_progress progress("Merging tagged fields", mg_count_queried(GLOBAL_gb_src));
564
565	GBDATA *gb_dest_species_data = GBT_get_species_data(GLOBAL_gb_dst);
566	if (!gb_dest_species_data) error = GB_await_error();
567	else {
568	for (GBDATA *gb_src_species = GBT_first_species(GLOBAL_gb_src);
569	gb_src_species && !error;
570	gb_src_species = GBT_next_species(gb_src_species))
571	{
572	if (IS_QUERIED_SPECIES(gb_src_species)) {
573	char *name = GBT_read_string(gb_src_species, "name");
574	if (!name) error = GB_await_error();
575	else {
576	GBDATA *gb_dst_species = GBT_find_or_create_species_rel_species_data(gb_dest_species_data, name, true);
577	if (!gb_dst_species) error = GB_await_error();
578	else {
579	char *src_val = GBT_readOrCreate_string(gb_src_species, src_field, "");
580	char *dst_val = GBT_readOrCreate_string(gb_dst_species, dst_field, "");
581
582	if (!src_val \|\| !dst_val) error = GB_await_error();
583	else {
584	char *sum = GBS_merge_tagged_strings(src_val, src_tag, del_tag,
585	dst_val, dst_tag, del_tag);
586
587	if (!sum) error = GB_await_error();
588	else error = GBT_write_string(gb_dst_species, dst_field, sum);
589	free(sum);
590	}
591	free(dst_val);
592	free(src_val);
593	}
594	}
595	free(name);
596	progress.inc_and_check_user_abort(error);
597	}
598	}
599	}
600
601	if (error) progress.done();
602
603	free(del_tag);
604	free(dst_tag);
605	free(src_tag);
606	}
607	free(dst_field);
608	free(src_field);
609	}
610	GB_end_transaction_show_error(GLOBAL_gb_dst, error, aw_message);
611	}
612
613	static AW_window create_mg_merge_tagged_fields_window(AW_root aw_root) {
614	static AW_window_simple *aws = NULp;
615	if (aws) return aws;
616
617	GB_transaction ta(GLOBAL_gb_src);
618
619	aw_root->awar_string(AWAR_TAG_SRC, "S");
620	aw_root->awar_string(AWAR_TAG_DST, "D");
621
622	aw_root->awar_string(AWAR_TAG_DEL, "S*");
623
624	aws = new AW_window_simple;
625	aws->init(aw_root, "MERGE_TAGGED_FIELD", "Merge tagged field");
626	aws->load_xfig("merge/mg_mergetaggedfield.fig");
627	aws->button_length(13);
628
629	aws->callback(AW_POPDOWN);
630	aws->at("close");
631	aws->create_button("CLOSE", "CLOSE", "C");
632
633	aws->at("go");
634	aws->callback(MG_merge_tagged_field_cb);
635	aws->create_button("GO", "GO");
636
637	aws->at("help");
638	aws->callback(makeHelpCallback("mergetaggedfield.hlp"));
639	aws->create_button("HELP", "HELP");
640
641	aws->at("tag1"); aws->create_input_field(AWAR_TAG_SRC, 5);
642	aws->at("tag2"); aws->create_input_field(AWAR_TAG_DST, 5);
643
644	aws->at("del1"); aws->create_input_field(AWAR_TAG_DEL, 5);
645
646	create_itemfield_selection_button(aws, FieldSelDef(AWAR_FIELD_SRC, GLOBAL_gb_src, SPECIES_get_selector(), FIELD_FILTER_STRING, "source-field"), "fields1");
647	create_itemfield_selection_button(aws, FieldSelDef(AWAR_FIELD_DST, GLOBAL_gb_dst, SPECIES_get_selector(), FIELD_FILTER_STRING, "target-field"), "fields2");
648
649	return aws;
650	}
651
652	static GB_ERROR MG_equal_alignments(bool autoselect_equal_alignment_name) {
653	//! Make the alignment names equal
654	ConstStrArray S_alignment_names;
655	ConstStrArray D_alignment_names;
656	GBT_get_alignment_names(S_alignment_names, GLOBAL_gb_src);
657	GBT_get_alignment_names(D_alignment_names, GLOBAL_gb_dst);
658
659	GB_ERROR error = NULp;
660	if (!S_alignment_names[0]) {
661	error = GB_export_error("No source sequences found");
662	}
663	else {
664	char *src_type = GBT_get_alignment_type_string(GLOBAL_gb_src, S_alignment_names[0]);
665	const char *dest = NULp;
666
667	for (int d = D_alignment_names.size()-1; d>0; --d) {
668	char *dst_type = GBT_get_alignment_type_string(GLOBAL_gb_dst, D_alignment_names[d]);
669	if (strcmp(src_type, dst_type) != 0) D_alignment_names.remove(d--);
670	free(dst_type);
671	}
672
673	int d = D_alignment_names.size();
674	switch (d) {
675	case 0:
676	error = GB_export_errorf("Cannot find a target alignment with a type of '%s'\n"
677	"You should create one first or select a different alignment type\n"
678	"during sequence import", src_type);
679	break;
680	case 1:
681	dest = D_alignment_names[0];
682	break;
683
684	default:
685	if (autoselect_equal_alignment_name) {
686	for (int i = 0; i<d; ++i) {
687	if (ARB_stricmp(S_alignment_names[0], D_alignment_names[i]) == 0) {
688	dest = D_alignment_names[i];
689	break;
690	}
691	}
692	}
693
694	if (!dest) {
695	GBS_strstruct buttonstr(100);
696
697	for (int i=0; i<d; i++) {
698	buttonstr.cat(D_alignment_names[i]);
699	buttonstr.put(',');
700	}
701	buttonstr.cat("ABORT");
702
703	int aliid = aw_question(NULp,
704	"There are more than one possible alignment targets\n"
705	"Choose one destination alignment or ABORT",
706	buttonstr.get_data());
707
708	if (aliid >= d) {
709	error = "Operation Aborted";
710	break;
711	}
712	dest = D_alignment_names[aliid];
713	}
714	break;
715	}
716	if (!error && dest && strcmp(S_alignment_names[0], dest) != 0) {
717	error = GBT_rename_alignment(GLOBAL_gb_src, S_alignment_names[0], dest, 1, 1);
718	if (error) {
719	error = GBS_global_string("Failed to rename alignment '%s' to '%s' (Reason: %s)",
720	S_alignment_names[0], dest, error);
721	}
722	else {
723	GBT_add_new_changekey(GLOBAL_gb_src, GBS_global_string("%s/data", dest), GB_STRING);
724	}
725	}
726	free(src_type);
727	}
728
729	return error;
730	}
731
732	GB_ERROR MERGE_sequences_simple(AW_root *awr) {
733	//! Merge the sequences of two databases
734
735	static char *s_name = NULp;
736
737	GB_HASH *D_species_hash = NULp;
738
739	GB_topSecurityLevel srcUnsecured(GLOBAL_gb_src);
740	GB_topSecurityLevel dstUnsecured(GLOBAL_gb_dst);
741	GB_transaction taSrc(GLOBAL_gb_src);
742	GB_transaction taDst(GLOBAL_gb_dst);
743
744	GB_ERROR error = MG_equal_alignments(true);
745	if (!error) {
746	GBDATA *S_species_data = GBT_get_species_data(GLOBAL_gb_src);
747	GBDATA *D_species_data = GBT_get_species_data(GLOBAL_gb_dst);
748
749	freenull(s_name);
750
751	{
752	long S_species_count = GB_number_of_subentries(S_species_data);
753	long D_species_count = GB_number_of_subentries(D_species_data);
754
755	// create hash containing all species from gb_dst,
756	// but sized to hold all species from both DBs:
757	D_species_hash = GBT_create_species_hash_sized(GLOBAL_gb_dst, S_species_count+D_species_count);
758	}
759
760	bool overwriteall = false;
761	bool autorenameall = false;
762
763	for (GBDATA *S_species = GB_entry(S_species_data, "species"); S_species; S_species = GB_nextEntry(S_species)) {
764	GBDATA *S_name = GB_search(S_species, "name", GB_STRING);
765
766	freeset(s_name, GB_read_string(S_name));
767
768	int count = 1;
769	bool retry;
770	do {
771	retry = false;
772	count++;
773
774	GBDATA D_species = (GBDATA)GBS_read_hash(D_species_hash, s_name);
775	if (D_species) {
776	if (overwriteall) {
777	error = GB_delete(D_species);
778	}
779	else if (autorenameall) {
780	GB_ERROR dummy;
781	char *newname = AWTC_create_numbered_suffix(D_species_hash, s_name, dummy);
782
783	mg_assert(newname);
784	freeset(s_name, newname);
785	}
786	else {
787	switch (aw_question("merge_existing_species",
788	GBS_global_string("Warning: There is an ID conflict for species '%s'\n"
789	" You may:\n"
790	" - Overwrite existing species\n"
791	" - Overwrite all species with ID conflicts\n"
792	" - Not import species\n"
793	" - Enter ID for imported species\n"
794	" - Automatically create unique species IDs (append .NUM)\n"
795	" - Abort everything", s_name),
796	"overwrite, overwrite all, don't import, create ID, auto-create IDs, abort")) {
797	case 1:
798	overwriteall = true;
799	FALLTHROUGH;
800	case 0:
801	GB_delete(D_species);
802	break;
803
804	case 2:
805	continue;
806
807	case 3: {
808	GB_ERROR warning; // duplicated species warning (does not apply here)
809	char *autoname = AWTC_create_numbered_suffix(D_species_hash, s_name, warning);
810
811	if (!autoname) autoname = ARB_strdup(s_name);
812	freeset(s_name, aw_input("Species ID", "Enter new species ID", autoname));
813	free(autoname);
814	retry = true;
815	break;
816	}
817	case 4:
818	autorenameall = true;
819	retry = true;
820	break;
821
822	case 5:
823	error = "Operation aborted";
824	break;
825	}
826	}
827	}
828	} while (retry);
829
830	if (!error) {
831	GBDATA *D_species = GB_create_container(D_species_data, "species");
832	if (!D_species) error = GB_await_error();
833	else {
834	error = GB_copy_dropMarksAndTempstate(D_species, S_species);
835
836	if (!error) {
837	GB_write_flag(D_species, 1); // mark species
838	GB_raise_user_flag(D_species, GB_USERFLAG_QUERY); // put in search&query hitlist
839	error = GBT_write_string(D_species, "name", s_name);
840	}
841	}
842
843	GBS_write_hash(D_species_hash, s_name, (long)D_species);
844	}
845
846	if (error) break;
847	}
848	}
849
850	if (D_species_hash) GBS_free_hash(D_species_hash);
851
852	if (!error) error = MG_transfer_fields_info();
853	if (!error) awr->awar(AWAR_SPECIES_NAME)->write_string(s_name);
854
855	error = taSrc.close(error);
856	error = taDst.close(error);
857
858	aw_message_if(error);
859	return error;
860	}
861
862	// -----------------------------
863	// MG_species_selector
864
865	static void mg_select_species1(GBDATA, AW_root aw_root, const char *item_name) {
866	aw_root->awar(AWAR_SPECIES_SRC)->write_string(item_name);
867	}
868	static void mg_select_species2(GBDATA, AW_root aw_root, const char *item_name) {
869	aw_root->awar(AWAR_SPECIES_DST)->write_string(item_name);
870	}
871
872	static GBDATA mg_get_first_species_data1(GBDATA , AW_root *, QUERY_RANGE) {
873	return GBT_get_species_data(GLOBAL_gb_src);
874	}
875	static GBDATA mg_get_first_species_data2(GBDATA , AW_root *, QUERY_RANGE) {
876	return GBT_get_species_data(GLOBAL_gb_dst);
877	}
878
879	static GBDATA mg_get_selected_species1(GBDATA /* gb_main /, AW_root aw_root) {
880	GB_transaction ta(GLOBAL_gb_src);
881	char *species_name = aw_root->awar(AWAR_SPECIES_SRC)->read_string();
882	GBDATA *gb_species = NULp;
883	if (species_name[0]) gb_species = GBT_find_species(GLOBAL_gb_src, species_name);
884	free(species_name);
885	return gb_species;
886	}
887	static GBDATA mg_get_selected_species2(GBDATA /* gb_main /, AW_root aw_root) {
888	GB_transaction ta(GLOBAL_gb_dst);
889	char *species_name = aw_root->awar(AWAR_SPECIES_DST)->read_string();
890	GBDATA *gb_species = NULp;
891	if (species_name[0]) gb_species = GBT_find_species(GLOBAL_gb_dst, species_name);
892	free(species_name);
893	return gb_species;
894	}
895
896	static MutableItemSelector MG_species_selector[2];
897
898	static void mg_initialize_species_selectors() {
899	static int initialized = 0;
900	if (!initialized) {
901	MG_species_selector[0] = MG_species_selector[1] = SPECIES_get_selector();
902
903	for (int s = 0; s <= 1; ++s) {
904	MutableItemSelector& sel = MG_species_selector[s];
905
906	sel.update_item_awars = s ? mg_select_species2 : mg_select_species1;
907	sel.get_first_item_container = s ? mg_get_first_species_data2 : mg_get_first_species_data1;
908	sel.get_selected_item = s ? mg_get_selected_species2 : mg_get_selected_species1;
909	}
910
911	initialized = 1;
912	}
913	}
914
915	class ScopedTransporter { // @@@ later also use for old merge types (SXT_WHOLE_SPECIES + SXT_SINGLE_FIELD)
916	static QUERY::DbQuery *query2update;
917
918	GBDATA expect_selected_species(GBDATA gb_main, const char awarname_selected, const char species_role, const char *listLocation, GB_ERROR& error, bool acceptNone) {
919	GBDATA *gb_species = NULp;
920	if (!error) {
921	const char *species_name = AW_root::SINGLETON->awar(awarname_selected)->read_char_pntr();
922	if (species_name[0]) {
923	gb_species = GBT_expect_species(gb_main, species_name);
924	if (!gb_species) {
925	error = GBS_global_string("%s (selected in %s hitlist)", GB_await_error(), listLocation);
926	}
927	}
928	else {
929	if (!acceptNone) {
930	error = GBS_global_string("Please select a %s species in %s hitlist", species_role, listLocation);
931	}
932	}
933	}
934
935	mg_assert(implicated(!acceptNone, contradicted(error, gb_species)));
936	mg_assert(!(error && gb_species));
937
938	return gb_species;
939	}
940
941	GB_ERROR transferExistingOrNew(GBDATA gb_src_item, GBDATA gb_dst_item_container) {
942	GB_ERROR error = NULp;
943	const char *name = GBT_get_name(gb_src_item);
944	mg_assert(name);
945
946	GBDATA *gb_dst_item = GBT_find_species_rel_species_data(gb_dst_item_container, name);
947	if (gb_dst_item) { // found existing species
948	error = transferOne(gb_src_item, gb_dst_item, NULp); // use it as target
949	}
950	else { // not found
951	if (GB_have_error()) { // due to error
952	error = GB_await_error();
953	}
954	else { // otherwise create new species
955	error = transferOne(gb_src_item, NULp, gb_dst_item_container);
956	}
957	}
958	return error;
959	}
960
961	protected:
962	static void markTarget(GBDATA *gb_dst_item) {
963	mg_assert(GB_is_ancestor_of(GLOBAL_gb_dst, gb_dst_item)); // only modify userflag of destination(!) database
964
965	GB_write_flag(gb_dst_item, 1); // mark species
966	GB_raise_user_flag(gb_dst_item, GB_USERFLAG_QUERY); // put in search&query (destination) hitlist
967	}
968
969	public:
970	virtual ~ScopedTransporter() {}
971
972	static void set_query_to_update(QUERY::DbQuery *query) { query2update = query; }
973
974	virtual GB_ERROR transferOne(GBDATA gb_src_item, GBDATA gb_dst_item, GBDATA *gb_dst_item_container) = 0;
975	/*! transfer one species (used when transferring selected/listed species)
976	* @param gb_src_item source of transfer
977	* @param gb_dst_item target of transfer (if not NULp)
978	* @param gb_dst_item_container transfer target will be created inside this container (if gb_dst_item == NULp)
979	*/
980
981	GB_ERROR transferAllIn(SpeciesXferScope scope, const char *progressTitle) {
982	GB_ERROR error = GB_begin_transaction(GLOBAL_gb_src);
983	error = GB_begin_transaction(GLOBAL_gb_dst);
984
985	{
986	unsigned long scopeSize = 0;
987	switch (scope) {
988	case SXS_SELECTED_SPECIES: scopeSize = 1; break;
989	case SXS_LISTED_SPECIES: scopeSize = mg_count_queried(GLOBAL_gb_src); break;
990	}
991
992	arb_progress progress(progressTitle, scopeSize);
993
994	GBDATA *gb_dst_species_container = GBT_get_species_data(GLOBAL_gb_dst);
995	if (!error) {
996	switch (scope) {
997	case SXS_SELECTED_SPECIES: {
998	GBDATA *gb_src_species = expect_selected_species(GLOBAL_gb_src, AWAR_SPECIES_SRC, "source", "left", error, false);
999	GBDATA *gb_dst_species = expect_selected_species(GLOBAL_gb_dst, AWAR_SPECIES_DST, "target", "right", error, true);
1000
1001	if (!error) {
1002	if (gb_dst_species) { // source and target explicitely selected
1003	error = transferOne(gb_src_species, gb_dst_species, NULp);
1004	}
1005	else {
1006	error = transferExistingOrNew(gb_src_species, gb_dst_species_container);
1007	}
1008	progress.inc_and_check_user_abort(error);
1009	}
1010	break;
1011	}
1012
1013	case SXS_LISTED_SPECIES: {
1014	for (GBDATA *gb_src_species = GBT_first_species(GLOBAL_gb_src);
1015	gb_src_species && !error;
1016	gb_src_species = GBT_next_species(gb_src_species))
1017	{
1018	if (IS_QUERIED_SPECIES(gb_src_species)) {
1019	error = transferExistingOrNew(gb_src_species, gb_dst_species_container);
1020	if (error) { // mention name of species in error message:
1021	error = GBS_global_string("%s (species=%s)", error, GBT_read_name(gb_src_species));
1022	}
1023	progress.inc_and_check_user_abort(error);
1024	}
1025	}
1026	break;
1027	}
1028	}
1029	}
1030
1031	if (error) progress.done();
1032	}
1033	error = GB_end_transaction(GLOBAL_gb_src, error);
1034	error = GB_end_transaction(GLOBAL_gb_dst, error);
1035
1036	if (!error && query2update) DbQuery_update_list(query2update); // no need to update in case of error
1037
1038	return error;
1039	}
1040	};
1041
1042	QUERY::DbQuery *ScopedTransporter::query2update = NULp;
1043
1044	using namespace FieldTransfer;
1045
1046	typedef SmartPtr<MG_remaps> MG_remapsPtr;
1047
1048	class AdaptedAlignmentTransporter : public AlignmentTransporter {
1049	MG_remapsPtr remaps;
1050
1051	public:
1052	AdaptedAlignmentTransporter(MG_remapsPtr remaps_) : remaps(remaps_) {}
1053	bool shallCopyBefore() const OVERRIDE {
1054	return true; // ItemClonedByRuleSet::copyAlignments() shall be called b4 calling transport()
1055	}
1056	GB_ERROR transport(GBDATAgb_src_item, GBDATA gb_dst_item) const OVERRIDE {
1057	return MG_adaptAllCopiedAlignments(*remaps, gb_src_item, gb_dst_item);
1058	}
1059	};
1060
1061	class ViaFtsTransporter : public ScopedTransporter {
1062	RuleSetPtr fts;
1063	AdaptedAlignmentTransporter aliTransporter;
1064
1065	public:
1066	ViaFtsTransporter(RuleSetPtr fts_, MG_remapsPtr remaps) :
1067	fts(fts_),
1068	aliTransporter(remaps)
1069	{}
1070	GB_ERROR transferOne(GBDATA gb_src_item, GBDATA gb_dst_item, GBDATA *gb_dst_item_container) OVERRIDE {
1071	mg_assert(fts.isSet());
1072	mg_assert(contradicted(gb_dst_item, gb_dst_item_container)); // exactly one of both shall be set
1073
1074	GB_ERROR error = NULp;
1075	GBDATA *gb_transferred = NULp;
1076	{
1077	ItemClonedByRuleSet transfer(gb_src_item, CLONE_ITEM_SPECIES, fts,
1078	gb_dst_item ? CLONE_INTO_EXISTING : REAL_CLONE,
1079	gb_dst_item ? gb_dst_item : gb_dst_item_container,
1080	&aliTransporter);
1081
1082	if (transfer.has_error()) {
1083	error = transfer.get_error();
1084	}
1085	else {
1086	gb_transferred = transfer.get_clone();
1087	}
1088	}
1089
1090	mg_assert(contradicted(error, gb_transferred));
1091	if (!error) markTarget(gb_transferred);
1092
1093	return error;
1094	}
1095	};
1096
1097	static void mg_xfer_via_fts(AW_root *aw_root, SpeciesXferScope scope) {
1098	GB_ERROR error = NULp;
1099	const char *ftsname = XFER_getFullFTS(aw_root->awar(AWAR_SPECIES_XFER_FTS)->read_char_pntr());
1100
1101	if (!ftsname[0]) {
1102	error = "No FTS selected";
1103	}
1104	else {
1105	ErrorOrRuleSetPtr loaded = RuleSet::loadFrom(ftsname);
1106	if (loaded.hasError()) {
1107	ARB_ERROR lerror = loaded.getError();
1108	error = lerror.deliver();
1109	}
1110	else {
1111	MG_remapsPtr remaps;
1112	{
1113	GB_transaction ta_src(GLOBAL_gb_src);
1114	GB_transaction ta_dst(GLOBAL_gb_dst);
1115	remaps = new MG_remaps(GLOBAL_gb_src, GLOBAL_gb_dst, adaption_enabled(aw_root), get_reference_species_names(aw_root)); // @@@ use factory to make MG_remaps / MG_remapsPtr
1116	// @@@ can MG_remaps report error (e.g. if wrong SAI/species specified as reference)
1117	}
1118
1119	ViaFtsTransporter transporter(loaded.getValue(), remaps);
1120	error = transporter.transferAllIn(scope, "Transfer using FTS");
1121	}
1122	}
1123	aw_message_if(error);
1124	}
1125
1126	struct MergeFieldScanner : public AvailableFieldScanner {
1127	void scanFields(StrArray& fields, FieldsToScan whatToScan) const OVERRIDE {
1128	if (whatToScan & SCAN_INPUT_FIELDS) {
1129	collectKeysRegisteredInDatabase(fields, GLOBAL_gb_src, SPECIES_get_selector(), true, false);
1130	}
1131	if (whatToScan & SCAN_OUTPUT_FIELDS) {
1132	collectKeysRegisteredInDatabase(fields, GLOBAL_gb_dst, SPECIES_get_selector(), true, false);
1133	}
1134	}
1135	};
1136
1137	static MergeFieldScanner fieldScanner;
1138
1139	static void MG_transfer_species(AW_window *aww) {
1140	AW_root *awr = aww->get_root();
1141
1142	SpeciesXferType type = SpeciesXferType (awr->awar(AWAR_SPECIES_XFER_TYPE) ->read_int());
1143	SpeciesXferScope scope = SpeciesXferScope(awr->awar(AWAR_SPECIES_XFER_SCOPE)->read_int());
1144
1145	switch (type) {
1146	case SXT_WHOLE_SPECIES:
1147	switch (scope) {
1148	case SXS_LISTED_SPECIES: mg_transfer_listed_species(aww); break;
1149	case SXS_SELECTED_SPECIES: mg_transfer_selected_species(aww); break;
1150	}
1151	break;
1152
1153	case SXT_SINGLE_FIELD:
1154	popup_single_field_transfer_window(awr, scope);
1155	break;
1156
1157	case SXT_USING_FTS:
1158	mg_xfer_via_fts(awr, scope);
1159	break;
1160	}
1161	}
1162
1163	AW_window MG_create_merge_species_window(AW_root awr, bool dst_is_new) {
1164	GB_ERROR error = MG_expect_renamed();
1165	if (error) {
1166	aw_message(error);
1167	return NULp; // deny to open window before user has renamed species
1168	}
1169
1170	awr->awar_string(AWAR_REMAP_SPECIES_LIST, "ecoli", GLOBAL_gb_dst);
1171	awr->awar_int(AWAR_REMAP_ENABLE, 0, GLOBAL_gb_dst);
1172
1173	AW_window_simple_menu *aws = new AW_window_simple_menu;
1174	aws->init(awr, "MERGE_TRANSFER_SPECIES", "TRANSFER SPECIES");
1175	aws->load_xfig("merge/species.fig");
1176
1177	aws->at("close");
1178	aws->callback(AW_POPDOWN);
1179	aws->create_button("CLOSE", "CLOSE", "C");
1180
1181	aws->at("help");
1182	aws->callback(makeHelpCallback("mg_species.hlp"));
1183	aws->create_button("HELP", "HELP", "H");
1184
1185	mg_initialize_species_selectors();
1186
1187	{
1188	QUERY::query_spec awtqs(MG_species_selector[0]);
1189	aws->create_menu("Source-DB", "S");
1190
1191	awtqs.gb_main = GLOBAL_gb_src;
1192	awtqs.gb_ref = GLOBAL_gb_dst;
1193	awtqs.expect_hit_in_ref_list = false;
1194	awtqs.species_name = AWAR_SPECIES_SRC;
1195	awtqs.tree_name = NULp; // no selected tree here -> can't use tree related ACI commands without specifying a tree
1196	awtqs.select_bit = GB_USERFLAG_QUERY;
1197	awtqs.ere_pos_fig = "ere1";
1198	awtqs.by_pos_fig = "by1";
1199	awtqs.qbox_pos_fig = "qbox1";
1200	awtqs.key_pos_fig = NULp;
1201	awtqs.query_pos_fig = "content1";
1202	awtqs.result_pos_fig = "result1";
1203	awtqs.count_pos_fig = "count1";
1204	awtqs.do_query_pos_fig = "doquery1";
1205	awtqs.config_pos_fig = "doconfig1";
1206	awtqs.do_mark_pos_fig = NULp;
1207	awtqs.do_unmark_pos_fig = NULp;
1208	awtqs.do_delete_pos_fig = "dodelete1";
1209	awtqs.do_set_pos_fig = "doset1";
1210	awtqs.do_refresh_pos_fig = "dorefresh1";
1211	awtqs.open_parser_pos_fig = "openparser1";
1212	awtqs.use_menu = 1;
1213
1214	create_query_box(aws, &awtqs, "db1");
1215
1216	DbScanner *scanner = DbScanner::create(GLOBAL_gb_src, "merge_spec1", aws, "box1", NULp, NULp, DB_SCANNER, NULp, awtqs.get_queried_itemtype());
1217	scanner_src = scanner;
1218	aws->get_root()->awar(AWAR_SPECIES_SRC)->add_callback(makeRootCallback(MG_map_species, SRC_DB));
1219	}
1220	{
1221	QUERY::query_spec awtqs(MG_species_selector[1]);
1222	aws->create_menu("Target-DB", "T");
1223
1224	awtqs.gb_main = GLOBAL_gb_dst;
1225	awtqs.gb_ref = GLOBAL_gb_src;
1226	awtqs.expect_hit_in_ref_list = true;
1227	awtqs.species_name = AWAR_SPECIES_DST;
1228	awtqs.select_bit = GB_USERFLAG_QUERY;
1229	awtqs.ere_pos_fig = "ere2";
1230	awtqs.by_pos_fig = "by2";
1231	awtqs.qbox_pos_fig = "qbox2";
1232	awtqs.key_pos_fig = NULp;
1233	awtqs.query_pos_fig = "content2";
1234	awtqs.result_pos_fig = "result2";
1235	awtqs.count_pos_fig = "count2";
1236	awtqs.do_query_pos_fig = "doquery2";
1237	awtqs.config_pos_fig = "doconfig2";
1238	awtqs.do_mark_pos_fig = NULp;
1239	awtqs.do_unmark_pos_fig = NULp;
1240	awtqs.do_delete_pos_fig = "dodelete2";
1241	awtqs.do_set_pos_fig = "doset2";
1242	awtqs.do_refresh_pos_fig = "dorefresh2";
1243	awtqs.open_parser_pos_fig = "openparser2";
1244	awtqs.use_menu = 1;
1245
1246	ScopedTransporter::set_query_to_update(create_query_box(aws, &awtqs, "db2"));
1247
1248	DbScanner *scanner = DbScanner::create(GLOBAL_gb_dst, "merge_spec2", aws, "box2", NULp, NULp, DB_SCANNER, NULp, awtqs.get_queried_itemtype());
1249	scanner_dst = scanner;
1250	aws->get_root()->awar(AWAR_SPECIES_DST)->add_callback(makeRootCallback(MG_map_species, DST_DB));
1251	}
1252
1253	// ---------------------
1254	// middle area
1255
1256	// top icon
1257	aws->button_length(0);
1258	aws->at("icon");
1259	aws->callback(makeHelpCallback("mg_species.hlp"));
1260	aws->create_button("HELP_MERGE", "#merge/icon.xpm");
1261
1262	// adapt alignments
1263	{
1264	if (dst_is_new) {
1265	aws->sens_mask(AWM_DISABLED); // if dest DB is new = > adaption impossible
1266	awr->awar(AWAR_REMAP_ENABLE)->write_int(0); // disable adaption
1267	}
1268
1269	aws->at("adapt");
1270	aws->create_toggle(AWAR_REMAP_ENABLE);
1271
1272	aws->at("reference");
1273	aws->create_text_field(AWAR_REMAP_SPECIES_LIST);
1274
1275	aws->at("pres_sel");
1276	aws->callback(MG_create_preserves_selection_window);
1277	aws->create_autosize_button("SELECT", "SELECT", "S");
1278
1279	aws->sens_mask(AWM_ALL);
1280	}
1281
1282	// transfer options:
1283	aws->at("xferType");
1284	aws->create_option_menu(AWAR_SPECIES_XFER_TYPE, false);
1285	aws->insert_option("whole species", "w", SXT_WHOLE_SPECIES);
1286	aws->insert_option("single field", "s", SXT_SINGLE_FIELD);
1287	aws->insert_option("using FTS", "F", SXT_USING_FTS);
1288	aws->update_option_menu();
1289
1290	aws->at("fts");
1291	aws->callback(makeWindowCallback(XFER_select_RuleSet, AWAR_SPECIES_XFER_FTS, static_cast<AvailableFieldScanner*>(&fieldScanner)));
1292	aws->create_button("SELECT_FTS", AWAR_SPECIES_XFER_FTS);
1293
1294	aws->at("xferWhat");
1295	aws->create_option_menu(AWAR_SPECIES_XFER_SCOPE, false);
1296	aws->insert_option("listed species", "l", SXS_LISTED_SPECIES);
1297	aws->insert_option("selected species", "s", SXS_SELECTED_SPECIES);
1298	aws->update_option_menu();
1299
1300	{
1301	aws->shadow_width(3);
1302
1303	aws->at("transfer");
1304	aws->callback(MG_transfer_species);
1305	aws->create_button("TRANSFER", "Transfer species");
1306
1307	aws->shadow_width(1);
1308	}
1309
1310	aws->create_menu("Source->Target", "g");
1311	aws->insert_menu_topic("compare_field_of_listed", "Compare a field of listed species ...", "C", "checkfield.hlp", AWM_ALL, create_mg_check_fields_window);
1312	aws->insert_menu_topic("merge_field_of_listed_to_new_field", "Merge tagged field ...", "D", "mergetaggedfield.hlp", AWM_ALL, create_mg_merge_tagged_fields_window);
1313	aws->sep______________();
1314	aws->insert_menu_topic("def_gene_species_field_xfer", "Define field transfer for gene-species", "g", "gene_species_field_transfer.hlp", AWM_ALL, MG_gene_species_create_field_transfer_def_window);
1315
1316
1317	return aws;
1318	}
1319

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

Download in other formats: