source: tags/ms_r18q1/AWTI/AWTI_export.cxx

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

#include "awti_export.hxx"
#include "awti_exp_local.hxx"

#include <FileWatch.h>
#include <seqio.hxx>
#include <awt_filter.hxx>
#include <AP_filter.hxx>

#include <aw_awars.hxx>
#include <aw_file.hxx>
#include <aw_window.hxx>
#include <aw_msg.hxx>

#include <arbdbt.h>

#include <arb_progress.h>
#include <arb_str.h>
#include <arb_strbuf.h>
#include "awti_edit.hxx"

using namespace SEQIO;

static void export_go_cb(AW_window *aww, GBDATA *gb_main, adfiltercbstruct *acbs) {
    awti_assert(!GB_have_error());

    GB_transaction ta(gb_main);
    arb_progress   progress("Exporting data");

    AW_root     *awr            = aww->get_root();
    char        *formname       = awr->awar(AWAR_EXPORT_FORMATNAME)->read_string();
    int          multiple       = awr->awar(AWAR_EXPORT_MULTIPLE_FILES)->read_int();
    ExportWhich  which          = ExportWhich(awr->awar(AWAR_EXPORT_MARKED)->read_int());
    int          cut_stop_codon = awr->awar(AWAR_EXPORT_CUTSTOP)->read_int();
    int          compress       = awr->awar(AWAR_EXPORT_COMPRESS)->read_int();
    GB_ERROR     error          = NULp;

    char *outname      = awr->awar(AWAR_EXPORT_FILENAME)->read_string();
    char *real_outname = NULp; // with suffix (name of first file if multiple)

    AP_filter *filter = awt_get_filter(acbs);
    char *db_name = awr->awar(AWAR_DB_NAME)->read_string();

    error = export_by_format(gb_main, which, NULp, filter, cut_stop_codon, compress,
                             db_name, formname, outname, multiple, &real_outname);
    free(db_name);
    if (error) aw_message(error);

    if (real_outname) awr->awar(AWAR_EXPORT_FILENAME)->write_string(real_outname);

    AW_refresh_fileselection(awr, AWAR_EXPORT_FILEBASE);

    free(real_outname);
    free(outname);
    free(formname);

}

static void avoid_empty_target_name(char*& nameOnly) {
    static char *last_used_name = strdup("noname");
    if (nameOnly) freedup(last_used_name, nameOnly);
    else          nameOnly = strdup(last_used_name); // if name was lost (by changing directory) -> reuse last_used_name
}

static bool in_export_filename_changed_cb = false;
static void export_filename_changed_cb(AW_root *aw_root) {
    if (!in_export_filename_changed_cb) {
        LocallyModify<bool> dont_recurse(in_export_filename_changed_cb, true);

        AW_awar *awar_export = aw_root->awar(AWAR_EXPORT_FILENAME);
        char    *exportname  = awar_export->read_string();

        if (!GB_is_directory(exportname)) {
            char *path, *nameOnly, *suffix;
            GB_split_full_path(exportname, &path, NULp, &nameOnly, &suffix);

            avoid_empty_target_name(nameOnly);

            const char *new_exportname = GB_concat_path(path, GB_append_suffix(nameOnly, suffix));
            if (new_exportname) awar_export->write_string(new_exportname);
        }
        free(exportname);
    }
}

static void create_export_awars(AW_root *awr, AW_default def) {
    {
        GBS_strstruct path(500);
        path.cat(GB_path_in_arbprop("filter"));
        path.put(':');
        path.cat(GB_path_in_ARBLIB("export"));

        AW_create_fileselection_awars(awr, AWAR_EXPORT_FORMATBASE, path.get_data(), ".eft", "*");
        AW_create_fileselection_awars(awr, AWAR_EXPORT_FILEBASE,   "",              "",     "noname");
    }

    awr->awar_string(AWAR_EXPORT_FORMAT_DESC, "<no format selected>", def);

    awr->awar_int(AWAR_EXPORT_MULTIPLE_FILES, 0,          def);
    awr->awar_int(AWAR_EXPORT_MARKED,         EBF_MARKED, def);
    awr->awar_int(AWAR_EXPORT_COMPRESS,       1,          def); // vertical gaps

    awt_create_filter_awars(awr, def, AWAR_EXPORT_FILTER_NAME, AWAR_DEFAULT_ALIGNMENT);

    awr->awar_int(AWAR_EXPORT_CUTSTOP, 0, def); // don't cut stop-codon

    awr->awar(AWAR_EXPORT_FILENAME)->add_callback(export_filename_changed_cb);
}

static void update_format_description_and_suffix(const char *eft) {
    // called when export format has changed (filter content or selected filter)
    // -> automatically correct filename suffix
    // -> restrict view to suffix
    // -> update description

    ExportFormatInfo eft_info;
    GB_ERROR         error = get_exportFormat_information(eft, eft_info);

    AW_root *aw_root   = AW_root::SINGLETON;
    AW_awar *awar_desc = aw_root->awar(AWAR_EXPORT_FORMAT_DESC);

    if (error) awar_desc->write_string(error); // display format-errors in description field
    else {
        const char  *current_suffix  = eft_info.suffix.content(); // Note: current_suffix may be NULp.. is that ok?
        static char *previous_suffix = NULp;

        // modify export filename and view
        AW_awar *awar_filter = aw_root->awar(AWAR_EXPORT_FILESUFFIX);
        AW_awar *awar_export = aw_root->awar(AWAR_EXPORT_FILENAME);

        awar_filter->write_string("");

        char *exportname = awar_export->read_string();

        {
            LocallyModify<bool> dont_recurse(in_export_filename_changed_cb, true);

            char *path, *nameOnly, *suffix;
            GB_split_full_path(exportname, &path, NULp, &nameOnly, &suffix);

            avoid_empty_target_name(nameOnly);

            if (suffix) {
                if (previous_suffix && ARB_stricmp(suffix, previous_suffix) == 0) freedup(suffix, current_suffix); // remove old suffix
                else freedup(suffix, GB_append_suffix(suffix, current_suffix)); // don't know existing suffix -> append
            }
            else suffix = ARB_strdup(current_suffix);

            const char *new_exportname = GB_concat_path(path, GB_append_suffix(nameOnly, suffix));
            if (new_exportname) awar_export->write_string(new_exportname);

            free(suffix);
            free(nameOnly);
            free(path);
        }

        free(exportname);

        awar_filter->write_string(current_suffix);

        // remember last applied suffix
        freedup(previous_suffix, current_suffix);

        // update description
        if (eft_info.description.isSet()) awar_desc->write_string(&*eft_info.description);
        else                              awar_desc->write_string("<no description>");
    }
}

AW_window *create_AWTC_export_window(AW_root *awr, GBDATA *gb_main) {
    static AW_window_simple *aws = NULp;

    if (!aws) {
        create_export_awars(awr, AW_ROOT_DEFAULT);

        aws = new AW_window_simple;

        aws->init(awr, "ARB_EXPORT", "ARB EXPORT");
        aws->load_xfig("awt/export_db.fig");

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

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

        AW_create_fileselection(aws, AWAR_EXPORT_FILEBASE,   "f", "PWD",     ANY_DIR,    false); // select export filename
        AW_create_fileselection(aws, AWAR_EXPORT_FORMATBASE, "",  "ARBHOME", MULTI_DIRS, false); // select export filter

        aws->at("allmarked");
        aws->create_option_menu(AWAR_EXPORT_MARKED, true);
        aws->insert_option("all",    "a", EBF_ALL);
        aws->insert_option("marked", "m", EBF_MARKED);
        aws->update_option_menu();

        aws->at("compress");
        aws->create_option_menu(AWAR_EXPORT_COMPRESS, true);
        aws->insert_option("no", "n", 0);
        aws->insert_option("vertical gaps", "v", 1);
        aws->insert_option("all gaps", "a", 2);
        aws->update_option_menu();

        aws->at("seqfilter");
        adfiltercbstruct *filtercd = awt_create_select_filter(awr, gb_main, AWAR_EXPORT_FILTER_NAME);
        aws->callback(makeCreateWindowCallback(awt_create_select_filter_win, filtercd));
        aws->create_button("SELECT_FILTER", AWAR_EXPORT_FILTER_NAME);

        aws->at("cutstop");
        aws->create_toggle(AWAR_EXPORT_CUTSTOP);

        aws->at("multiple");
        aws->create_toggle(AWAR_EXPORT_MULTIPLE_FILES);

        aws->at("desc");
        aws->create_text_field(AWAR_EXPORT_FORMAT_DESC);

        aws->at("go");
        aws->highlight();
        aws->callback(makeWindowCallback(export_go_cb, gb_main, filtercd));
        aws->create_button("GO", "GO", "G", "+");

        aws->at("test");
        aws->callback(makeWindowCallback(AWTI_activate_export_test_window, gb_main, filtercd));
        aws->create_button("TEST", "Test", "T");

        static FileWatch fwatch(AWAR_EXPORT_FORMATNAME, makeFileChangedCallback(update_format_description_and_suffix));
    }

    return aws;
}