MG_species.cxx

Go to the documentation of this file.

// =============================================================== //
//                                                                 //
//   File      : MG_species.cxx                                    //
//   Purpose   :                                                   //
//                                                                 //
//   Institute of Microbiology (Technical University Munich)       //
//   http://www.arb-home.de/                                       //
//                                                                 //
// =============================================================== //

#include "merge.hxx"
#include "MG_adapt_ali.hxx"

#include <AW_rename.hxx>
#include <db_query.h>
#include <db_scanner.hxx>
#include <item_sel_list.h>

#include <xfergui.h>
#include <xferset.h>

#include <aw_awars.hxx>
#include <aw_msg.hxx>
#include <arb_progress.h>
#include <aw_root.hxx>
#include <aw_question.hxx>

#include <arb_str.h>
#include <arb_strbuf.h>
#include <arb_global_defs.h>


#define AWAR_SPECIES_SRC AWAR_MERGE_TMP_SRC "name"
#define AWAR_FIELD_SRC   AWAR_MERGE_TMP_SRC "field"
#define AWAR_TAG_SRC     AWAR_MERGE_TMP_SRC "tag"

#define AWAR_SPECIES_DST AWAR_MERGE_TMP_DST "name"
#define AWAR_FIELD_DST   AWAR_MERGE_TMP_DST "field"
#define AWAR_TAG_DST     AWAR_MERGE_TMP_DST "tag"

#define AWAR_TAG_DEL AWAR_MERGE_TMP "tagdel"
#define AWAR_APPEND  AWAR_MERGE_TMP "append"

#define AWAR_SPECIES_XFER_TYPE  AWAR_MERGE_SAV "xferType"
#define AWAR_SPECIES_XFER_SCOPE AWAR_MERGE_SAV "xferScope"
#define AWAR_SPECIES_XFER_FTS   AWAR_MERGE_SAV "fts"

static DbScanner *scanner_src = NULp;
static DbScanner *scanner_dst = NULp;

enum SpeciesXferType {
    SXT_WHOLE_SPECIES,
    SXT_SINGLE_FIELD,       // (skips alignment data)
    SXT_USING_FTS,          // field transfer set
    SXT_USING_FTS_SKIP_ALI, // field transfer set (skips alignment data)
};

enum SpeciesXferScope {
    SXS_SELECTED_SPECIES,
    SXS_LISTED_SPECIES,
};

const char *MG_left_AWAR_SPECIES_NAME() { return AWAR_SPECIES_SRC; }

void MG_create_species_awars(AW_root *aw_root, AW_default aw_def) {
    aw_root->awar_string(AWAR_SPECIES_SRC, "", aw_def);
    aw_root->awar_string(AWAR_SPECIES_DST, "", aw_def);

    aw_root->awar_string(AWAR_FIELD_SRC, NO_FIELD_SELECTED, aw_def);
    aw_root->awar_string(AWAR_FIELD_DST, NO_FIELD_SELECTED, aw_def);

    aw_root->awar_int(AWAR_APPEND, 0, aw_def);

    aw_root->awar_int(AWAR_SPECIES_XFER_TYPE,  SXT_WHOLE_SPECIES,  aw_def);
    aw_root->awar_int(AWAR_SPECIES_XFER_SCOPE, SXS_LISTED_SPECIES, aw_def);

    aw_root->awar_string(AWAR_SPECIES_XFER_FTS, "", aw_def);
}

static void MG_map_species(AW_root *aw_root, DbSel db) {
    GBDATA     *gb_main   = get_gb_main(db);
    const char *awar_name = db == SRC_DB ? AWAR_SPECIES_SRC : AWAR_SPECIES_DST;
    DbScanner  *scanner   = db == SRC_DB ? scanner_src : scanner_dst;

    GB_transaction ta(gb_main);
    char   *selected_species = aw_root->awar(awar_name)->read_string();
    GBDATA *gb_species       = GBT_find_species(gb_main, selected_species);
    if (gb_species) {
        scanner->Map(gb_species, awar_name); // @@@ why is awar_name passed here? (normally a changekey-path is used)
                                             // @@@ undocumented feature in DbScanner or bug?
    }
    free(selected_species);
}

static GB_ERROR MG_transfer_fields_info(char *fieldname = NULp) {
    GBDATA   *gb_key_data = GB_search(GLOBAL_gb_src, CHANGE_KEY_PATH, GB_CREATE_CONTAINER);
    GB_ERROR  error       = NULp;

    if (!gb_key_data) error = GB_await_error();
    else {
        if (!GB_search(GLOBAL_gb_dst, CHANGE_KEY_PATH, GB_CREATE_CONTAINER)) error = GB_await_error();
        else {
            for (GBDATA *gb_key = GB_entry(gb_key_data, CHANGEKEY);
                 gb_key && !error;
                 gb_key = GB_nextEntry(gb_key))
            {
                GBDATA *gb_key_name = GB_entry(gb_key, CHANGEKEY_NAME);
                if (gb_key_name) {
                    GBDATA *gb_key_type = GB_entry(gb_key, CHANGEKEY_TYPE);
                    if (gb_key_type) {
                        char *name = GB_read_string(gb_key_name);

                        if (!fieldname || strcmp(fieldname, name) == 0) {
                            error = GBT_add_new_species_changekey(GLOBAL_gb_dst, name, GB_TYPES(GB_read_int(gb_key_type)));
                        }
                        free(name);
                    }
                }
            }
        }
    }
    return error;
}

static GB_ERROR MG_transfer_one_species(AW_root *aw_root, MG_remaps& remap,
                                        GBDATA *gb_src_species, GBDATA *gb_dst_species_data,
                                        bool src_is_genome, bool dst_is_genome,
                                        GB_HASH *source_organism_hash, GB_HASH *dest_species_hash,
                                        GB_HASH *error_suppressor)
{
    // copies species 'gb_src_species' from source to destination DB.
    //
    // 'source_organism_hash' may be NULp, otherwise it's used to search for source organisms (when merging from genome DB)
    // 'dest_species_hash' may be NULp, otherwise created species is stored there

    mg_assert(gb_src_species);

    GB_ERROR    error           = NULp;
    const char *src_name        = GBT_get_name(gb_src_species);
    bool        transfer_fields = false;

    if (!src_name) {
        error = "refused to transfer unnamed species";
    }
    else {
        if (src_is_genome) {
            if (dst_is_genome) { // genome -> genome
                if (GEN_is_pseudo_gene_species(gb_src_species)) {
                    const char *origin        = GEN_origin_organism(gb_src_species);
                    GBDATA     *dest_organism = dest_species_hash
                        ? (GBDATA*)GBS_read_hash(dest_species_hash, origin)
                        : GEN_find_organism(GLOBAL_gb_dst, origin);

                    if (dest_organism) transfer_fields = true;
                    else {
                        error = GBS_global_string("Destination DB does not contain '%s's origin-organism '%s'",
                                                  src_name, origin);
                    }
                }
                // else: merge organism ok
            }
            else { // genome -> non-genome
                if (GEN_is_pseudo_gene_species(gb_src_species)) transfer_fields = true;
                else {
                    error = GBS_global_string("You can't merge organisms (%s) into a non-genome DB.\n"
                                              "Only pseudo-species are possible", src_name);
                }
            }
        }
        else {
            if (dst_is_genome) { // non-genome -> genome
                error = GBS_global_string("You can't merge non-genome species (%s) into a genome DB", src_name);
            }
            // else: non-genome -> non-genome ok
        }
    }

    GBDATA *gb_dst_species = NULp;
    if (!error) {
        gb_dst_species = dest_species_hash
            ? (GBDATA*)GBS_read_hash(dest_species_hash, src_name)
            : GBT_find_species_rel_species_data(gb_dst_species_data, src_name);

        if (gb_dst_species) error = GB_delete(gb_dst_species);
    }
    if (!error) {
        gb_dst_species = GB_create_container(gb_dst_species_data, "species");
        if (!gb_dst_species) error = GB_await_error();
    }
    if (!error) error = GB_copy_dropProtectMarksAndTempstate(gb_dst_species, gb_src_species);
    if (!error && transfer_fields) {
        mg_assert(src_is_genome);
        error = MG_export_fields(aw_root, gb_src_species, gb_dst_species, error_suppressor, source_organism_hash);
    }
    if (!error) GB_write_flag(gb_dst_species, 1);
    if (!error) error = MG_adaptAllCopiedAlignments(remap, gb_src_species, gb_dst_species);
    if (!error && dest_species_hash) GBS_write_hash(dest_species_hash, src_name, (long)gb_dst_species);

    return error;
}

static const char *get_reference_species_names(AW_root *awr) {
    return awr->awar(AWAR_REMAP_SPECIES_LIST)->read_char_pntr();
}
static bool adaption_enabled(AW_root *awr) {
    return awr->awar(AWAR_REMAP_ENABLE)->read_int() != 0;
}

static void mg_transfer_selected_species(AW_window *aww) {
    if (MG_copy_and_check_alignments() != 0) return;

    AW_root  *aw_root  = aww->get_root();
    char     *src_name = aw_root->awar(AWAR_SPECIES_SRC)->read_string();
    GB_ERROR  error    = NULp;

    if (!src_name || !src_name[0]) {
        error = "Please select a species in the left list";
    }
    else {
        arb_progress progress("Transferring selected species");

        error             = GB_begin_transaction(GLOBAL_gb_src);
        if (!error) error = GB_begin_transaction(GLOBAL_gb_dst);

        if (!error) {
            MG_remaps rm(GLOBAL_gb_src, GLOBAL_gb_dst, adaption_enabled(aw_root), get_reference_species_names(aw_root));

            GBDATA *gb_src_species_data = GBT_get_species_data(GLOBAL_gb_src);
            GBDATA *gb_dst_species_data = GBT_get_species_data(GLOBAL_gb_dst);

            bool src_is_genome = GEN_is_genome_db(GLOBAL_gb_src, -1);
            bool dst_is_genome = GEN_is_genome_db(GLOBAL_gb_dst, -1);

            GBDATA *gb_src_species = GBT_find_species_rel_species_data(gb_src_species_data, src_name);
            if (!gb_src_species) {
                error = GBS_global_string("Could not find species '%s' in source database", src_name);
            }
            else {
                error = MG_transfer_one_species(aw_root, rm,
                                                gb_src_species, gb_dst_species_data,
                                                src_is_genome, dst_is_genome,
                                                NULp, NULp,
                                                NULp);
            }
        }

        if (!error) error = MG_transfer_fields_info();

        error = GB_end_transaction(GLOBAL_gb_src, error);
        error = GB_end_transaction(GLOBAL_gb_dst, error);
    }

    if (error) aw_message(error);
}

static void mg_transfer_listed_species(AW_window *aww) {
    if (MG_copy_and_check_alignments() != 0) return;

    GB_ERROR error = NULp;
    GB_begin_transaction(GLOBAL_gb_src);
    GB_begin_transaction(GLOBAL_gb_dst);

    bool src_is_genome = GEN_is_genome_db(GLOBAL_gb_src, -1);
    bool dst_is_genome = GEN_is_genome_db(GLOBAL_gb_dst, -1);

    GB_HASH *error_suppressor     = GBS_create_hash(50, GB_IGNORE_CASE);
    GB_HASH *dest_species_hash    = GBT_create_species_hash(GLOBAL_gb_dst);
    GB_HASH *source_organism_hash = src_is_genome ? GBT_create_organism_hash(GLOBAL_gb_src) : NULp;

    AW_root   *aw_root = aww->get_root();
    MG_remaps  rm(GLOBAL_gb_src, GLOBAL_gb_dst, adaption_enabled(aw_root), get_reference_species_names(aw_root));

    GBDATA *gb_src_species;
    arb_progress progress("Transferring listed species", mg_count_queried(GLOBAL_gb_src));

    for (gb_src_species = GBT_first_species(GLOBAL_gb_src);
         gb_src_species;
         gb_src_species = GBT_next_species(gb_src_species))
    {
        if (IS_QUERIED_SPECIES(gb_src_species)) {
            GBDATA *gb_dst_species_data = GBT_get_species_data(GLOBAL_gb_dst);

            error = MG_transfer_one_species(aw_root, rm,
                                            gb_src_species, gb_dst_species_data,
                                            src_is_genome, dst_is_genome,
                                            source_organism_hash, dest_species_hash,
                                            error_suppressor);

            progress.inc_and_check_user_abort(error);
        }
    }

    GBS_free_hash(dest_species_hash);
    if (source_organism_hash) GBS_free_hash(source_organism_hash);
    GBS_free_hash(error_suppressor);

    if (!error) error = MG_transfer_fields_info();

    error = GB_end_transaction(GLOBAL_gb_src, error);
    GB_end_transaction_show_error(GLOBAL_gb_dst, error, aw_message);
}

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) {
    GBDATA   *gb_dst_field = GB_search(gb_dst_species, field, GB_FIND);
    GB_TYPES  src_type     = GB_read_type(gb_src_field);
    GB_TYPES  dst_type     = gb_dst_field ? GB_read_type(gb_dst_field) : src_type;

    bool     use_copy = true;
    GB_ERROR error    = NULp;

    if (append) {
        if (src_type != GB_STRING || dst_type != GB_STRING) {
            error = "You can use 'Append data' with text fields only!";
        }
        else if (gb_dst_field) { // append possible (otherwise use_copy!)
            char *src_val = GB_read_string(gb_src_field);
            char *dst_val = GB_read_string(gb_dst_field);

            if (!src_val || !dst_val) error = GB_await_error();
            else {
                if (!GBS_find_string(dst_val, src_val, 0)) { // do not append if dst_val contains src_val
                    error = GB_write_string(gb_dst_field, GBS_global_string("%s %s", dst_val, src_val));
                    if (!error) GB_write_flag(gb_dst_species, 1);
                }
            }

            free(src_val);
            free(dst_val);

            use_copy = false;
        }
    }

    if (!error && use_copy) {
        if (dst_type != src_type) error = "type mismatch"; // abort early (previously failed in call to MG_transfer_fields_info below)
        if (!error && src_type == GB_DB && gb_dst_field) {
            // if type is container -> delete before copy
            // (otherwise it would generate a mix of both containers; if wanted provide optionally)
            error        = GB_delete(gb_dst_field);
            gb_dst_field = NULp; // trigger recreation+copy
        }
        if (!error && !gb_dst_field) { // create missing target field (otherwise simply overwrite)
            gb_dst_field             = GB_search(gb_dst_species, field, src_type);
            if (!gb_dst_field) error = GB_await_error(); // failed to create?
        }
        if (!error) error = GB_copy_dropProtectMarksAndTempstate(gb_dst_field, gb_src_field); // [Note: if transfer_of_alignment -> copies 'data' field of one alignment]
        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]
        if (!error) GB_write_flag(gb_dst_species, 1);
    }
    return error;
}

inline bool fieldContainsAlignment(const char *field) {
    return GBS_string_matches(field, "ali_*", GB_MIND_CASE);
}

static void transfer_field_of_listed_cb(AW_window *aww) {
    if (MG_copy_and_check_alignments() != 0) return;

    AW_root    *aw_root = aww->get_root();
    char       *field   = aw_root->awar(AWAR_FIELD_SRC)->read_string();
    const bool  append  = aw_root->awar(AWAR_APPEND)->read_int();
    GB_ERROR    error   = NULp;

    if (strcmp(field, NO_FIELD_SELECTED) == 0) {
        error = "Please select the field you like to transfer";
    }
    else if (strcmp(field, "name") == 0) {
        error = "Transferring the 'name' field is forbidden";
    }
    else {
        const bool transfer_of_alignment = fieldContainsAlignment(field);

        if (transfer_of_alignment && append) {
            error = "Appending alignment data is not permitted\n"
                "(please refer to ARB_NT/Sequence/Concatenate.. to do so)";
        }
        else {
            error             = GB_begin_transaction(GLOBAL_gb_src);
            if (!error) error = GB_begin_transaction(GLOBAL_gb_dst);

            if (!error) {
                arb_progress progress("Transferring fields of listed", mg_count_queried(GLOBAL_gb_src));

                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

                GBDATA *gb_dest_species_data     = GBT_get_species_data(GLOBAL_gb_dst);
                if (!gb_dest_species_data) error = GB_await_error();

                for (GBDATA *gb_src_species = GBT_first_species(GLOBAL_gb_src);
                     gb_src_species && !error;
                     gb_src_species = GBT_next_species(gb_src_species))
                {
                    if (IS_QUERIED_SPECIES(gb_src_species)) {
                        const char *src_name = GBT_get_name(gb_src_species);
                        if (src_name) {
                            GBDATA *gb_dst_species = GB_find_string(gb_dest_species_data, "name", src_name, GB_IGNORE_CASE, SEARCH_GRANDCHILD);

                            if (!gb_dst_species) {
                                gb_dst_species             = GB_create_container(gb_dest_species_data, "species");
                                if (!gb_dst_species) error = GB_await_error();
                                else error                 = GBT_write_string(gb_dst_species, "name", src_name);
                            }
                            else {
                                gb_dst_species = GB_get_father(gb_dst_species);
                            }

                            if (!error) {
                                // @@@ DRY vs inner part of body of transfer_field_of_selected_cb .@DRY_TRANSFER_FIELD
                                GBDATA *gb_src_field = GB_search(gb_src_species, field, GB_FIND);

                                if (gb_src_field) {
                                    error = transfer_single_field(gb_src_species, gb_dst_species, field, gb_src_field, append, transfer_of_alignment, rm);
                                }
                            }
                            if (error) error = GBS_global_string("%s (species=%s)", error, src_name); // mention name of species in error message
                        }
                        else {
                            error = "refusing to transfer from unnamed species";
                        }

                        progress.inc_and_check_user_abort(error);
                    }
                }
            }

            if (!error) error = MG_transfer_fields_info(field);

            error = GB_end_transaction(GLOBAL_gb_src, error);
            error = GB_end_transaction(GLOBAL_gb_dst, error);
        }
    }

    if (error) aw_message(error);
    free(field);
}

static void transfer_field_of_selected_cb(AW_window *aww) {
    if (MG_copy_and_check_alignments() != 0) return;

    AW_root    *aw_root = aww->get_root();
    char       *field   = aw_root->awar(AWAR_FIELD_SRC)->read_string();
    const bool  append  = false; // @@@ provide via GUI?
    GB_ERROR    error   = NULp;

    if (strcmp(field, NO_FIELD_SELECTED) == 0) {
        error = "Please select the field you like to transfer";
    }
    else if (strcmp(field, "name") == 0) {
        error = "Transferring the 'name' field is forbidden";
    }
    else {
        const bool transfer_of_alignment = fieldContainsAlignment(field);

        if (transfer_of_alignment && append) { // @@@ append always false (see above)
            error = "Appending alignment data is not permitted\n"
                "(please refer to ARB_NT/Sequence/Concatenate.. to do so)";
        }
        else {
            error             = GB_begin_transaction(GLOBAL_gb_src);
            if (!error) error = GB_begin_transaction(GLOBAL_gb_dst);

            if (!error) {
                arb_progress progress("Cross copy field");

                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

                GBDATA *gb_src_species;
                GBDATA *gb_dst_species;
                {
                    char *src_name = aw_root->awar(AWAR_SPECIES_SRC)->read_string();
                    char *dst_name = aw_root->awar(AWAR_SPECIES_DST)->read_string();

                    gb_src_species = GBT_find_species(GLOBAL_gb_src, src_name);
                    gb_dst_species = GBT_find_species(GLOBAL_gb_dst, dst_name);

                    free(dst_name);
                    free(src_name);
                }

                if (!gb_src_species) error = "Please select a species in left hitlist";
                if (!gb_dst_species) error = "Please select a species in right hitlist";

                if (!error) {
                    // @@@ DRY vs loop-body of transfer_field_of_listed_cb .@DRY_TRANSFER_FIELD
                    GBDATA *gb_src_field     = GB_search(gb_src_species, field, GB_FIND);
                    if (!gb_src_field) error = GBS_global_string("Source species has no field '%s'", field);

                    if (!error) {
                        error = transfer_single_field(gb_src_species, gb_dst_species, field, gb_src_field, append, transfer_of_alignment, rm);
                    }
                }
            }
            if (!error) error = MG_transfer_fields_info(field);

            error = GB_end_transaction(GLOBAL_gb_src, error);
            error = GB_end_transaction(GLOBAL_gb_dst, error);
        }
    }

    if (error) aw_message(error);

    free(field);
}

static void popup_single_field_transfer_window(AW_root *aw_root, SpeciesXferScope scope) {
    static AW_window *aww[2] = { NULp, NULp };

    if (!aww[scope]) {
        GB_transaction    ta(GLOBAL_gb_src);
        AW_window_simple *aws = new AW_window_simple;

        bool listed = scope == SXS_LISTED_SPECIES;
        mg_assert(implicated(!listed, scope == SXS_SELECTED_SPECIES));

        if (listed) aws->init(aw_root, "MERGE_XFER_FIELD_OF_LISTED", "Transfer field of listed");
        else        aws->init(aw_root, "MERGE_XFER_SINGLE_FIELD",    "Transfer field of selected");

        aws->load_xfig("merge/mg_transfield.fig");
        aws->button_length(10);

        aws->callback(AW_POPDOWN);
        aws->at("close");
        aws->create_button("CLOSE", "CLOSE", "C");

        aws->at("help");
        aws->callback(makeHelpCallback(listed ? "mg_xfer_field_of_listed.hlp" : "mg_xfer_field_of_sel.hlp"));
        aws->create_button("HELP", "HELP");

        if (listed) {
            aws->at("append");
            aws->label("Append data?");
            aws->create_toggle(AWAR_APPEND);
        }

        long typeFilter = listed ? FIELD_FILTER_ANY_FIELD : FIELD_UNFILTERED;
        create_itemfield_selection_button(aws, FieldSelDef(AWAR_FIELD_SRC, GLOBAL_gb_src, SPECIES_get_selector(), typeFilter, "source/target field"), "scandb");

        aws->at("go");
        aws->callback(listed ? transfer_field_of_listed_cb : transfer_field_of_selected_cb);
        aws->create_button("GO", "GO");

        aww[scope] = aws;
    }
    aww[scope]->activate();
}

static void MG_merge_tagged_field_cb(AW_window *aww) {
    GB_transaction ta_merge(GLOBAL_gb_src);
    GB_ERROR       error = GB_begin_transaction(GLOBAL_gb_dst);

    if (!error) {
        AW_root *awr = aww->get_root();

        char *src_field = awr->awar(AWAR_FIELD_SRC)->read_string();
        char *dst_field = awr->awar(AWAR_FIELD_DST)->read_string();

        if (strcmp(src_field, NO_FIELD_SELECTED) == 0 ||
            strcmp(dst_field, NO_FIELD_SELECTED) == 0)
        {
            error = "Please select source- and target-fields.";
        }

        if (!error) {
            char *src_tag = awr->awar(AWAR_TAG_SRC)->read_string();
            char *dst_tag = awr->awar(AWAR_TAG_DST)->read_string();
            char *del_tag = awr->awar(AWAR_TAG_DEL)->read_string();

            arb_progress progress("Merging tagged fields", mg_count_queried(GLOBAL_gb_src));

            GBDATA *gb_dest_species_data     = GBT_get_species_data(GLOBAL_gb_dst);
            if (!gb_dest_species_data) error = GB_await_error();
            else {
                for (GBDATA *gb_src_species = GBT_first_species(GLOBAL_gb_src);
                     gb_src_species && !error;
                     gb_src_species = GBT_next_species(gb_src_species))
                {
                    if (IS_QUERIED_SPECIES(gb_src_species)) {
                        char *name       = GBT_read_string(gb_src_species, "name");
                        if (!name) error = GB_await_error();
                        else {
                            GBDATA *gb_dst_species     = GBT_find_or_create_species_rel_species_data(gb_dest_species_data, name, true);
                            if (!gb_dst_species) error = GB_await_error();
                            else {
                                char *src_val = GBT_readOrCreate_string(gb_src_species, src_field, "");
                                char *dst_val = GBT_readOrCreate_string(gb_dst_species, dst_field, "");

                                if (!src_val || !dst_val) error = GB_await_error();
                                else {
                                    char *sum = GBS_merge_tagged_strings(src_val, src_tag, del_tag,
                                                                         dst_val, dst_tag, del_tag);

                                    if (!sum) error = GB_await_error();
                                    else error      = GBT_write_string(gb_dst_species, dst_field, sum);
                                    free(sum);
                                }
                                free(dst_val);
                                free(src_val);
                            }
                        }
                        free(name);
                        progress.inc_and_check_user_abort(error);
                    }
                }
            }

            if (error) progress.done();

            free(del_tag);
            free(dst_tag);
            free(src_tag);
        }
        free(dst_field);
        free(src_field);
    }
    GB_end_transaction_show_error(GLOBAL_gb_dst, error, aw_message);
}

static AW_window *create_mg_merge_tagged_fields_window(AW_root *aw_root) {
    static AW_window_simple *aws = NULp;
    if (aws) return aws;

    GB_transaction ta(GLOBAL_gb_src);

    aw_root->awar_string(AWAR_TAG_SRC, "S");
    aw_root->awar_string(AWAR_TAG_DST, "D");

    aw_root->awar_string(AWAR_TAG_DEL, "S*");

    aws = new AW_window_simple;
    aws->init(aw_root, "MERGE_TAGGED_FIELD", "Merge tagged field");
    aws->load_xfig("merge/mg_mergetaggedfield.fig");
    aws->button_length(13);

    aws->callback(AW_POPDOWN);
    aws->at("close");
    aws->create_button("CLOSE", "CLOSE", "C");

    aws->at("go");
    aws->callback(MG_merge_tagged_field_cb);
    aws->create_button("GO", "GO");

    aws->at("help");
    aws->callback(makeHelpCallback("mergetaggedfield.hlp"));
    aws->create_button("HELP", "HELP");

    aws->at("tag1");    aws->create_input_field(AWAR_TAG_SRC, 5);
    aws->at("tag2");    aws->create_input_field(AWAR_TAG_DST, 5);

    aws->at("del1");    aws->create_input_field(AWAR_TAG_DEL, 5);

    create_itemfield_selection_button(aws, FieldSelDef(AWAR_FIELD_SRC, GLOBAL_gb_src, SPECIES_get_selector(), FIELD_FILTER_STRING, "source-field"), "fields1");
    create_itemfield_selection_button(aws, FieldSelDef(AWAR_FIELD_DST, GLOBAL_gb_dst, SPECIES_get_selector(), FIELD_FILTER_STRING, "target-field"), "fields2");

    return aws;
}

static GB_ERROR MG_equal_alignments(bool autoselect_equal_alignment_name) {
    ConstStrArray S_alignment_names;
    ConstStrArray D_alignment_names;
    GBT_get_alignment_names(S_alignment_names, GLOBAL_gb_src);
    GBT_get_alignment_names(D_alignment_names, GLOBAL_gb_dst);

    GB_ERROR error = NULp;
    if (!S_alignment_names[0]) {
        error =  GB_export_error("No source sequences found");
    }
    else {
        char       *src_type = GBT_get_alignment_type_string(GLOBAL_gb_src, S_alignment_names[0]);
        const char *dest     = NULp;

        for (int d = D_alignment_names.size()-1; d>0; --d) {
            char *dst_type = GBT_get_alignment_type_string(GLOBAL_gb_dst, D_alignment_names[d]);
            if (strcmp(src_type, dst_type) != 0) D_alignment_names.remove(d--);
            free(dst_type);
        }

        int d = D_alignment_names.size();
        switch (d) {
            case 0:
                error = GB_export_errorf("Cannot find a target alignment with a type of '%s'\n"
                                         "You should create one first or select a different alignment type\n"
                                         "during sequence import", src_type);
                break;
            case 1:
                dest = D_alignment_names[0];
                break;

            default:
                if (autoselect_equal_alignment_name) {
                    for (int i = 0; i<d; ++i) {
                        if (ARB_stricmp(S_alignment_names[0], D_alignment_names[i]) == 0) {
                            dest = D_alignment_names[i];
                            break;
                        }
                    }
                }

                if (!dest) {
                    GBS_strstruct buttonstr(100);

                    for (int i=0; i<d; i++) {
                        buttonstr.cat(D_alignment_names[i]);
                        buttonstr.put(',');
                    }
                    buttonstr.cat("ABORT");

                    int aliid = aw_question(NULp,
                                            "There are more than one possible alignment targets\n"
                                            "Choose one destination alignment or ABORT",
                                            buttonstr.get_data());

                    if (aliid >= d) {
                        error = "Operation Aborted";
                        break;
                    }
                    dest = D_alignment_names[aliid];
                }
                break;
        }
        if (!error && dest && strcmp(S_alignment_names[0], dest) != 0) {
            error = GBT_rename_alignment(GLOBAL_gb_src, S_alignment_names[0], dest);
            if (error) {
                error = GBS_global_string("Failed to rename alignment '%s' to '%s' (Reason: %s)",
                                          S_alignment_names[0], dest, error);
            }
            else {
                error = GBT_add_alignment_changekeys(GLOBAL_gb_src, dest);
            }
        }
        free(src_type);
    }

    return error;
}

GB_ERROR MERGE_sequences_simple(AW_root *awr) {

    static char *s_name = NULp;

    GB_HASH *D_species_hash = NULp;

    GB_topSecurityLevel srcUnsecured(GLOBAL_gb_src);
    GB_topSecurityLevel dstUnsecured(GLOBAL_gb_dst);
    GB_transaction taSrc(GLOBAL_gb_src);
    GB_transaction taDst(GLOBAL_gb_dst);

    GB_ERROR error = MG_equal_alignments(true);
    if (!error) {
        GBDATA *S_species_data = GBT_get_species_data(GLOBAL_gb_src);
        GBDATA *D_species_data = GBT_get_species_data(GLOBAL_gb_dst);

        freenull(s_name);

        {
            long S_species_count = GB_number_of_subentries(S_species_data);
            long D_species_count = GB_number_of_subentries(D_species_data);

            // create hash containing all species from gb_dst,
            // but sized to hold all species from both DBs:
            D_species_hash = GBT_create_species_hash_sized(GLOBAL_gb_dst, S_species_count+D_species_count);
        }

        bool overwriteall  = false;
        bool autorenameall = false;

        for (GBDATA *S_species = GB_entry(S_species_data, "species"); S_species; S_species = GB_nextEntry(S_species)) {
            GBDATA *S_name = GB_search(S_species, "name", GB_STRING);

            freeset(s_name, GB_read_string(S_name));

            int  count = 1;
            bool retry;
            do {
                retry = false;
                count++;

                GBDATA *D_species = (GBDATA*)GBS_read_hash(D_species_hash, s_name);
                if (D_species) {
                    if (overwriteall) {
                        error = GB_delete(D_species);
                    }
                    else if (autorenameall) {
                        GB_ERROR  dummy;
                        char     *newname = AWTC_create_numbered_suffix(D_species_hash, s_name, dummy);

                        mg_assert(newname);
                        freeset(s_name, newname);
                    }
                    else {
                        switch (aw_question("merge_existing_species",
                                            GBS_global_string("Warning: There is an ID conflict for species '%s'\n"
                                                              "  You may:\n"
                                                              "  - Overwrite existing species\n"
                                                              "  - Overwrite all species with ID conflicts\n"
                                                              "  - Not import species\n"
                                                              "  - Enter ID for imported species\n"
                                                              "  - Automatically create unique species IDs (append .NUM)\n"
                                                              "  - Abort everything", s_name),
                                            "overwrite, overwrite all, don't import, create ID, auto-create IDs, abort")) {
                            case 1:
                                overwriteall = true;
                                FALLTHROUGH;
                            case 0:
                                GB_delete(D_species);
                                break;

                            case 2:
                                continue;

                            case 3: {
                                GB_ERROR  warning;          // duplicated species warning (does not apply here)
                                char     *autoname = AWTC_create_numbered_suffix(D_species_hash, s_name, warning);

                                if (!autoname) autoname = ARB_strdup(s_name);
                                freeset(s_name, aw_input("Species ID", "Enter new species ID", autoname));
                                free(autoname);
                                retry = true;
                                break;
                            }
                            case 4:
                                autorenameall = true;
                                retry = true;
                                break;

                            case 5:
                                error = "Operation aborted";
                                break;
                        }
                    }
                }
            } while (retry);

            if (!error) {
                GBDATA *D_species     = GB_create_container(D_species_data, "species");
                if (!D_species) error = GB_await_error();
                else {
                    error = GB_copy_dropMarksAndTempstate(D_species, S_species);

                    if (!error) {
                        GB_write_flag(D_species, 1);          // mark species
                        GB_raise_user_flag(D_species, GB_USERFLAG_QUERY); // put in search&query hitlist
                        error = GBT_write_string(D_species, "name", s_name);
                    }
                }

                GBS_write_hash(D_species_hash, s_name, (long)D_species);
            }

            if (error) break;
        }
    }

    if (D_species_hash) GBS_free_hash(D_species_hash);

    if (!error) error = MG_transfer_fields_info();
    if (!error) awr->awar(AWAR_SPECIES_NAME)->write_string(s_name);

    error = taSrc.close(error);
    error = taDst.close(error);

    aw_message_if(error);
    return error;
}

// -----------------------------
//      MG_species_selector

static void mg_select_species1(GBDATA*,  AW_root *aw_root, const char *item_name) {
    aw_root->awar(AWAR_SPECIES_SRC)->write_string(item_name);
}
static void mg_select_species2(GBDATA*,  AW_root *aw_root, const char *item_name) {
    aw_root->awar(AWAR_SPECIES_DST)->write_string(item_name);
}

static GBDATA *mg_get_first_species_data1(GBDATA*, AW_root*, QUERY_RANGE) {
    return GBT_get_species_data(GLOBAL_gb_src);
}
static GBDATA *mg_get_first_species_data2(GBDATA*, AW_root*, QUERY_RANGE) {
    return GBT_get_species_data(GLOBAL_gb_dst);
}

static GBDATA *mg_get_selected_species1(GBDATA*, AW_root *aw_root) {
    GB_transaction  ta(GLOBAL_gb_src);
    const char     *species_name = aw_root->awar(AWAR_SPECIES_SRC)->read_char_pntr();
    return species_name[0] ? GBT_find_species(GLOBAL_gb_src, species_name) : NULp;
}
static GBDATA *mg_get_selected_species2(GBDATA*, AW_root *aw_root) {
    GB_transaction  ta(GLOBAL_gb_dst);
    const char     *species_name = aw_root->awar(AWAR_SPECIES_DST)->read_char_pntr();
    return species_name[0] ? GBT_find_species(GLOBAL_gb_dst, species_name) : NULp;
}

static MutableItemSelector MG_species_selector[2];

static void mg_initialize_species_selectors() {
    static bool initialized = false;
    if (!initialized) {
        MG_species_selector[0] = MG_species_selector[1] = SPECIES_get_selector();

        for (int s = 0; s <= 1; ++s) {
            MutableItemSelector& sel = MG_species_selector[s];

            sel.update_item_awars        = s ? mg_select_species2 : mg_select_species1;
            sel.get_first_item_container = s ? mg_get_first_species_data2 : mg_get_first_species_data1;
            sel.get_selected_item = s ? mg_get_selected_species2 : mg_get_selected_species1;
        }

        initialized = true;
    }
}

class ScopedTransporter { // @@@ later also use for old merge types (SXT_WHOLE_SPECIES + SXT_SINGLE_FIELD)
    static QUERY::DbQuery *query2update;

    GBDATA *expect_selected_species(GBDATA *gb_main, const char *awarname_selected, const char *species_role, const char *listLocation, GB_ERROR& error, bool acceptNone) {
        GBDATA *gb_species = NULp;
        if (!error) {
            const char *species_name = AW_root::SINGLETON->awar(awarname_selected)->read_char_pntr();
            if (species_name[0]) {
                gb_species = GBT_expect_species(gb_main, species_name);
                if (!gb_species) {
                    error = GBS_global_string("%s (selected in %s hitlist)", GB_await_error(), listLocation);
                }
            }
            else {
                if (!acceptNone) {
                    error = GBS_global_string("Please select a %s species in %s hitlist", species_role, listLocation);
                }
            }
        }

        mg_assert(implicated(!acceptNone, contradicted(error, gb_species)));
        mg_assert(!(error && gb_species));

        return gb_species;
    }

    GB_ERROR transferExistingOrNew(GBDATA *gb_src_item, GBDATA *gb_dst_item_container) {
        GB_ERROR    error = NULp;
        const char *name  = GBT_get_name(gb_src_item);

        if (!name) {
            error = "unnamed item";
        }
        else {
            GBDATA *gb_dst_item = GBT_find_species_rel_species_data(gb_dst_item_container, name);
            if (gb_dst_item) { // found existing species
                error = transferOne(gb_src_item, gb_dst_item, NULp); // use it as target
            }
            else { // not found
                if (GB_have_error()) { // due to error
                    error = GB_await_error();
                }
                else { // otherwise create new species
                    error = transferOne(gb_src_item, NULp, gb_dst_item_container);
                }
            }
        }
        return error;
    }

protected:
    static void markTarget(GBDATA *gb_dst_item) {
        mg_assert(GB_is_ancestor_of(GLOBAL_gb_dst, gb_dst_item)); // only modify userflag of destination(!) database

        GB_write_flag(gb_dst_item, 1);                      // mark species
        GB_raise_user_flag(gb_dst_item, GB_USERFLAG_QUERY); // put in search&query (destination) hitlist
    }

public:
    virtual ~ScopedTransporter() {}

    static void set_query_to_update(QUERY::DbQuery *query) { query2update = query; }

    virtual GB_ERROR transferOne(GBDATA *gb_src_item, GBDATA *gb_dst_item, GBDATA *gb_dst_item_container) = 0;
    GB_ERROR transferAllIn(SpeciesXferScope scope, const char *progressTitle) {
        GB_ERROR error = GB_begin_transaction(GLOBAL_gb_src);
        error          = GB_begin_transaction(GLOBAL_gb_dst);

        {
            unsigned long scopeSize = 0;
            switch (scope) {
                case SXS_SELECTED_SPECIES: scopeSize = 1;                               break;
                case SXS_LISTED_SPECIES:   scopeSize = mg_count_queried(GLOBAL_gb_src); break;
            }

            arb_progress progress(progressTitle, scopeSize);

            GBDATA *gb_dst_species_container = GBT_get_species_data(GLOBAL_gb_dst);
            if (!error) {
                switch (scope) {
                    case SXS_SELECTED_SPECIES: {
                        GBDATA *gb_src_species = expect_selected_species(GLOBAL_gb_src, AWAR_SPECIES_SRC, "source", "left",  error, false);
                        GBDATA *gb_dst_species = expect_selected_species(GLOBAL_gb_dst, AWAR_SPECIES_DST, "target", "right", error, true);

                        if (!error) {
                            if (gb_dst_species) { // source and target explicitely selected
                                error = transferOne(gb_src_species, gb_dst_species, NULp);
                            }
                            else {
                                error = transferExistingOrNew(gb_src_species, gb_dst_species_container);
                            }
                            progress.inc_and_check_user_abort(error);
                        }
                        break;
                    }

                    case SXS_LISTED_SPECIES: {
                        for (GBDATA *gb_src_species = GBT_first_species(GLOBAL_gb_src);
                             gb_src_species && !error;
                             gb_src_species = GBT_next_species(gb_src_species))
                        {
                            if (IS_QUERIED_SPECIES(gb_src_species)) {
                                error = transferExistingOrNew(gb_src_species, gb_dst_species_container);
                                if (error) { // mention name of species in error message:
                                    error = GBS_global_string("%s (species=%s)", error, GBT_get_name_or_description(gb_src_species));
                                }
                                progress.inc_and_check_user_abort(error);
                            }
                        }
                        break;
                    }
                }
            }

            if (error) progress.done();
        }
        error = GB_end_transaction(GLOBAL_gb_src, error);
        error = GB_end_transaction(GLOBAL_gb_dst, error);

        if (!error && query2update) DbQuery_update_list(query2update); // no need to update in case of error

        return error;
    }
};

QUERY::DbQuery *ScopedTransporter::query2update = NULp;

using namespace FieldTransfer;

typedef SmartPtr<MG_remaps> MG_remapsPtr;

class AdaptedAlignmentTransporter : public AlignmentTransporter {
    MG_remapsPtr remaps;

public:
    AdaptedAlignmentTransporter(MG_remapsPtr remaps_) : remaps(remaps_) {}
    bool shallCopyBefore() const OVERRIDE {
        return true; // ItemClonedByRuleSet::copyAlignments() shall be called b4 calling transport()
    }
    GB_ERROR transport(GBDATA *gb_src_item, GBDATA *gb_dst_item) const OVERRIDE {
        return MG_adaptAllCopiedAlignments(*remaps, gb_src_item, gb_dst_item);
    }
};

struct DontTransportAlignment : public AlignmentTransporter {
    // this AlignmentTransporter simply does not transport anything
    bool shallCopyBefore() const OVERRIDE { return false; } // do not call copyAlignments() b4 calling transport()
    GB_ERROR transport(GBDATA *, GBDATA *) const OVERRIDE { return NULp; } // do not transport alignment data
};



class ViaFtsTransporter : public ScopedTransporter {
    RuleSetPtr              fts;
    AlignmentTransporterPtr aliTransporter;

public:
    ViaFtsTransporter(RuleSetPtr fts_, AlignmentTransporterPtr transp) :
        fts(fts_),
        aliTransporter(transp)
    {}
    GB_ERROR transferOne(GBDATA *gb_src_item, GBDATA *gb_dst_item, GBDATA *gb_dst_item_container) OVERRIDE {
        mg_assert(fts.isSet());
        mg_assert(contradicted(gb_dst_item, gb_dst_item_container)); // exactly one of both shall be set

        GB_ERROR  error          = NULp;
        GBDATA   *gb_transferred = NULp;
        {
            ItemClonedByRuleSet transfer(gb_src_item, CLONE_ITEM_SPECIES, fts,
                                         gb_dst_item ? CLONE_INTO_EXISTING : REAL_CLONE,
                                         gb_dst_item ? gb_dst_item         : gb_dst_item_container,
                                         &*aliTransporter);

            if (transfer.has_error()) {
                error = transfer.get_error();
            }
            else {
                gb_transferred = transfer.get_clone();
            }
        }

        mg_assert(contradicted(error, gb_transferred));
        if (!error) markTarget(gb_transferred);

        return error;
    }
};

static void mg_xfer_via_fts(AW_root *aw_root, SpeciesXferScope scope, bool xfer_seq_data) {
    if (MG_copy_and_check_alignments() != 0) return;

    GB_ERROR    error   = NULp;
    const char *ftsname = XFER_getFullFTS(aw_root->awar(AWAR_SPECIES_XFER_FTS)->read_char_pntr());

    if (!ftsname[0]) {
        error = "No FTS selected";
    }
    else {
        ErrorOrRuleSetPtr loaded = RuleSet::loadFrom(ftsname);
        if (loaded.hasError()) {
            ARB_ERROR lerror = loaded.getError();
            error            = lerror.deliver();
        }
        else {
            AlignmentTransporterPtr transport_ali;
            if (xfer_seq_data) {
                MG_remapsPtr remaps;
                {
                    GB_transaction ta_src(GLOBAL_gb_src);
                    GB_transaction ta_dst(GLOBAL_gb_dst);
                    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
                    // @@@ can MG_remaps report error? (e.g. if wrong SAI/species specified as reference)
                }

                transport_ali = new AdaptedAlignmentTransporter(remaps);
            }
            else {
                transport_ali = new DontTransportAlignment;
            }

            ViaFtsTransporter transporter(loaded.getValue(), transport_ali);
            error = transporter.transferAllIn(scope, "Transfer using FTS");
        }
    }
    aw_message_if(error);
}

struct MergeFieldScanner : public AvailableFieldScanner {
    void scanFields(StrArray& fields, FieldsToScan whatToScan) const OVERRIDE {
        if (whatToScan & SCAN_INPUT_FIELDS) {
            collectKeysRegisteredInDatabase(fields, GLOBAL_gb_src, SPECIES_get_selector(), true, false);
        }
        if (whatToScan & SCAN_OUTPUT_FIELDS) {
            collectKeysRegisteredInDatabase(fields, GLOBAL_gb_dst, SPECIES_get_selector(), true, false);
        }
    }
};

static MergeFieldScanner fieldScanner;

static void MG_transfer_species(AW_window *aww) {
    AW_root *awr = aww->get_root();

    SpeciesXferType  type  = SpeciesXferType (awr->awar(AWAR_SPECIES_XFER_TYPE) ->read_int());
    SpeciesXferScope scope = SpeciesXferScope(awr->awar(AWAR_SPECIES_XFER_SCOPE)->read_int());

    switch (type) {
        case SXT_WHOLE_SPECIES:
            switch (scope) {
                case SXS_LISTED_SPECIES:   mg_transfer_listed_species(aww);   break;
                case SXS_SELECTED_SPECIES: mg_transfer_selected_species(aww); break;
            }
            break;

        case SXT_SINGLE_FIELD:
            popup_single_field_transfer_window(awr, scope);
            break;

        case SXT_USING_FTS:
        case SXT_USING_FTS_SKIP_ALI: {
            bool xfer_seq_data = (type == SXT_USING_FTS);
            mg_xfer_via_fts(awr, scope, xfer_seq_data);
            break;
        }
    }
}

AW_window *MG_create_merge_species_window(AW_root *awr, bool dst_is_new) {
    GB_ERROR error = MG_expect_renamed();
    if (error) {
        aw_message(error);
        return NULp; // deny to open window before user has renamed species
    }

    awr->awar_string(AWAR_REMAP_SPECIES_LIST, "ecoli", GLOBAL_gb_dst);
    awr->awar_int(AWAR_REMAP_ENABLE, 0, GLOBAL_gb_dst);

    AW_window_simple_menu *aws = new AW_window_simple_menu;
    aws->init(awr, "MERGE_TRANSFER_SPECIES", "TRANSFER SPECIES");
    aws->load_xfig("merge/species.fig");

    aws->at("close");
    aws->callback(AW_POPDOWN);
    aws->create_button("CLOSE", "CLOSE", "C");

    aws->at("help");
    aws->callback(makeHelpCallback("mg_species.hlp"));
    aws->create_button("HELP", "HELP", "H");

    mg_initialize_species_selectors();

    {
        QUERY::query_spec awtqs(MG_species_selector[0]);
        aws->create_menu("Source-DB", "S");

        awtqs.gb_main                = GLOBAL_gb_src;
        awtqs.gb_ref                 = GLOBAL_gb_dst;
        awtqs.expect_hit_in_ref_list = false;
        awtqs.species_name           = AWAR_SPECIES_SRC;
        awtqs.tree_name              = NULp; // no selected tree here -> can't use tree related ACI commands without specifying a tree
        awtqs.select_bit             = GB_USERFLAG_QUERY;
        awtqs.ere_pos_fig            = "ere1";
        awtqs.by_pos_fig             = "by1";
        awtqs.qbox_pos_fig           = "qbox1";
        awtqs.key_pos_fig            = NULp;
        awtqs.query_pos_fig          = "content1";
        awtqs.result_pos_fig         = "result1";
        awtqs.count_pos_fig          = "count1";
        awtqs.do_query_pos_fig       = "doquery1";
        awtqs.config_pos_fig         = "doconfig1";
        awtqs.do_mark_pos_fig        = NULp;
        awtqs.do_unmark_pos_fig      = NULp;
        awtqs.do_delete_pos_fig      = "dodelete1";
        awtqs.do_set_pos_fig         = "doset1";
        awtqs.do_refresh_pos_fig     = "dorefresh1";
        awtqs.open_parser_pos_fig    = "openparser1";
        awtqs.use_menu               = 1;

        create_query_box(aws, &awtqs, "db1");

        DbScanner *scanner = DbScanner::create(GLOBAL_gb_src, "merge_spec1", aws, "box1", NULp, NULp, DB_SCANNER, NULp, awtqs.get_queried_itemtype());
        scanner_src = scanner;
        aws->get_root()->awar(AWAR_SPECIES_SRC)->add_callback(makeRootCallback(MG_map_species, SRC_DB));
    }
    {
        QUERY::query_spec awtqs(MG_species_selector[1]);
        aws->create_menu("Target-DB", "T");

        awtqs.gb_main                = GLOBAL_gb_dst;
        awtqs.gb_ref                 = GLOBAL_gb_src;
        awtqs.expect_hit_in_ref_list = true;
        awtqs.species_name           = AWAR_SPECIES_DST;
        awtqs.select_bit             = GB_USERFLAG_QUERY;
        awtqs.ere_pos_fig            = "ere2";
        awtqs.by_pos_fig             = "by2";
        awtqs.qbox_pos_fig           = "qbox2";
        awtqs.key_pos_fig            = NULp;
        awtqs.query_pos_fig          = "content2";
        awtqs.result_pos_fig         = "result2";
        awtqs.count_pos_fig          = "count2";
        awtqs.do_query_pos_fig       = "doquery2";
        awtqs.config_pos_fig         = "doconfig2";
        awtqs.do_mark_pos_fig        = NULp;
        awtqs.do_unmark_pos_fig      = NULp;
        awtqs.do_delete_pos_fig      = "dodelete2";
        awtqs.do_set_pos_fig         = "doset2";
        awtqs.do_refresh_pos_fig     = "dorefresh2";
        awtqs.open_parser_pos_fig    = "openparser2";
        awtqs.use_menu               = 1;

        ScopedTransporter::set_query_to_update(create_query_box(aws, &awtqs, "db2"));

        DbScanner *scanner = DbScanner::create(GLOBAL_gb_dst, "merge_spec2", aws, "box2", NULp, NULp, DB_SCANNER, NULp, awtqs.get_queried_itemtype());
        scanner_dst = scanner;
        aws->get_root()->awar(AWAR_SPECIES_DST)->add_callback(makeRootCallback(MG_map_species, DST_DB));
    }

    // ---------------------
    //      middle area

    // top icon
    aws->button_length(0);
    aws->at("icon");
    aws->callback(makeHelpCallback("mg_species.hlp"));
    aws->create_button("HELP_MERGE", "#merge/icon.xpm");

    // adapt alignments
    {
        if (dst_is_new) {
            aws->sens_mask(AWM_DISABLED); // if dest DB is new = > adaption impossible
            awr->awar(AWAR_REMAP_ENABLE)->write_int(0); // disable adaption
        }

        aws->at("adapt");
        aws->create_toggle(AWAR_REMAP_ENABLE);

        aws->at("reference");
        aws->create_text_field(AWAR_REMAP_SPECIES_LIST);

        aws->at("pres_sel");
        aws->callback(MG_create_preserves_selection_window);
        aws->create_autosize_button("SELECT", "SELECT", "S");

        aws->sens_mask(AWM_ALL);
    }

    // transfer options:
    aws->at("xferType");
    aws->create_option_menu(AWAR_SPECIES_XFER_TYPE);
    aws->insert_option("whole species",        "w", SXT_WHOLE_SPECIES);
    aws->insert_option("single field",         "s", SXT_SINGLE_FIELD);
    aws->insert_option("using FTS (with seq)", "F", SXT_USING_FTS);
    aws->insert_option("using FTS (w/o seq)",  "o", SXT_USING_FTS_SKIP_ALI);
    aws->update_option_menu();

    aws->at("fts");
    aws->callback(makeWindowCallback(XFER_select_RuleSet, AWAR_SPECIES_XFER_FTS, static_cast<AvailableFieldScanner*>(&fieldScanner)));
    aws->create_button("SELECT_FTS", AWAR_SPECIES_XFER_FTS);

    aws->at("xferWhat");
    aws->create_option_menu(AWAR_SPECIES_XFER_SCOPE);
    aws->insert_option("listed species",   "l", SXS_LISTED_SPECIES);
    aws->insert_option("selected species", "s", SXS_SELECTED_SPECIES);
    aws->update_option_menu();

    {
        aws->shadow_width(3);

        aws->at("transfer");
        aws->callback(MG_transfer_species);
        aws->create_button("TRANSFER", "Transfer species");

        aws->shadow_width(1);
    }

    aws->create_menu("Source->Target", "g");
    aws->insert_menu_topic("compare_field_of_listed",            "Compare a field of listed species ...", "C", "checkfield.hlp",       AWM_ALL, create_mg_check_fields_window);
    aws->insert_menu_topic("merge_field_of_listed_to_new_field", "Merge tagged field ...",                "M", "mergetaggedfield.hlp", AWM_ALL, create_mg_merge_tagged_fields_window);
    aws->sep______________();
    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);


    return aws;
}