// =============================================================== // // // // File : graph_aligner_gui.cxx // // Purpose : // // // // Coded by Elmar Pruesse in October 2008 // // Institute of Microbiology (Technical University Munich) // // http://www.arb-home.de/ // // // // =============================================================== // #include "graph_aligner_gui.hxx" #include "ed4_defs.hxx" // need to use AlignDataAccess defined here to get selected species #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using std::cerr; using std::cout; using std::endl; #define ga_assert(cond) arb_assert(cond) #define GA_AWAR_ROOT "sina/" #define GA_AWAR_TEMP "tmp/" GA_AWAR_ROOT #define GA_AWAR_CMD GA_AWAR_ROOT "cmd" #define GA_AWAR_TGT GA_AWAR_ROOT "target" #define GA_AWAR_SAI GA_AWAR_ROOT "sai" #define GA_AWAR_ALIGNMENT GA_AWAR_ROOT "alignment" #define GA_AWAR_PROTECTION GA_AWAR_ROOT "protection" #define GA_AWAR_TURN_CHECK GA_AWAR_ROOT "turncheck" #define GA_AWAR_REALIGN GA_AWAR_ROOT "realign" #define GA_AWAR_MATCH_SCORE GA_AWAR_ROOT "match_score" #define GA_AWAR_MISMATCH_SCORE GA_AWAR_ROOT "mismatch_score" #define GA_AWAR_GAP_PEN GA_AWAR_ROOT "gap_pen" #define GA_AWAR_GAP_EXT GA_AWAR_ROOT "gap_ext" #define GA_AWAR_ADVANCED GA_AWAR_ROOT "advanced" #define GA_AWAR_FS_MIN GA_AWAR_ROOT "fs_min" #define GA_AWAR_FS_MAX GA_AWAR_ROOT "fs_max" #define GA_AWAR_FS_MSC GA_AWAR_ROOT "fs_msc" #define GA_AWAR_MIN_FULL GA_AWAR_ROOT "min_full" #define GA_AWAR_FULL_MINLEN GA_AWAR_ROOT "full_minlen" #define GA_AWAR_OVERHANG GA_AWAR_ROOT "overhang" #define GA_AWAR_THREADS GA_AWAR_ROOT "threads" #define GA_AWAR_QSIZE GA_AWAR_ROOT "qsize" #define GA_AWAR_KMER_LEN GA_AWAR_ROOT "kmer_len" #define GA_AWAR_KMER_MM GA_AWAR_ROOT "kmer_mm" #define GA_AWAR_MIN_LEN GA_AWAR_ROOT "min_len" #define GA_AWAR_WEIGHT GA_AWAR_ROOT "weight" #define GA_AWAR_INSERT GA_AWAR_ROOT "insert" #define GA_AWAR_LOWERCASE GA_AWAR_ROOT "lowercase" #define GA_AWAR_AUTOFILTER GA_AWAR_ROOT "autofilter" #define GA_AWAR_KMER_NOREL GA_AWAR_ROOT "kmer_norel" #define GA_AWAR_KMER_NOFAST GA_AWAR_ROOT "kmer_nofast" #define GA_AWAR_SHOW_DIST GA_AWAR_ROOT "show_dist" #define GA_AWAR_SHOW_DIFF GA_AWAR_ROOT "show_diff" #define GA_AWAR_COLOR GA_AWAR_ROOT "color" #define GA_AWAR_GENE_START GA_AWAR_ROOT "gene_start" #define GA_AWAR_GENE_END GA_AWAR_ROOT "gene_end" #define GA_AWAR_FS_COVER_GENE GA_AWAR_ROOT "fs_cover_gene" #define GA_AWAR_USED_RELS GA_AWAR_ROOT "write_used_rels" #define GA_AWAR_CALC_IDENTITY GA_AWAR_ROOT "calc_idty" #define GA_AWAR_NOWARN_START GA_AWAR_ROOT "nowarn_start" #define GA_AWAR_REFDB_MODE GA_AWAR_ROOT "refdb_mode" #define GA_AWAR_REFDB GA_AWAR_ROOT "refdb" #define GA_AWAR_REFDB_SELECT GA_AWAR_TEMP "refdb" enum RefDbMode { REF_EXPLICIT, // use explicitly specified database REF_LAST_SAVE, // use last saved state of loaded database REF_CURRENT, // use current state of loaded database }; static void refDbModeChanged_cb(AW_root *root) { RefDbMode mode = RefDbMode(root->awar(GA_AWAR_REFDB_MODE)->read_int()); AW_awar *awar_refdb = root->awar(GA_AWAR_REFDB); switch (mode) { case REF_EXPLICIT: { const char *refdb = awar_refdb->read_char_pntr(); if (!GB_is_readablefile(refdb)) { const char *refdb_sel = root->awar(GA_AWAR_REFDB_SELECT)->read_char_pntr(); if (GB_is_readablefile(refdb_sel)) { awar_refdb->write_string(refdb_sel); } else { aw_message("Please select a reference database"); } } break; } case REF_LAST_SAVE: { const char *db_name = root->awar(AWAR_SAVED_DB_PATH)->read_char_pntr(); if (db_name[0] == 0) { // happens when editor runs standalone aw_message("Failed to detect name of current database - please select manually"); } awar_refdb->write_string(db_name); break; } case REF_CURRENT: { awar_refdb->write_string(":"); break; } } } static void newRefDbSelected_cb(AW_root *root) { const char *refdb_sel = root->awar(GA_AWAR_REFDB_SELECT)->read_char_pntr(); if (GB_is_readablefile(refdb_sel)) { root->awar(GA_AWAR_REFDB_MODE)->write_int(REF_EXPLICIT); root->awar(GA_AWAR_REFDB)->write_string(refdb_sel); } else { root->awar(GA_AWAR_REFDB_MODE)->write_int(REF_CURRENT); } } void create_sina_variables(AW_root *root, AW_default db1) { const char *sinaCmd = "arb_sina.sh"; root->awar_string(GA_AWAR_CMD, sinaCmd, db1); root->awar_int (GA_AWAR_TGT, 2, db1); root->awar_int (AWAR_PT_SERVER, 0, db1); root->awar_string(GA_AWAR_SAI, "", db1); root->awar_int (GA_AWAR_PROTECTION, 0, db1); root->awar_int (GA_AWAR_TURN_CHECK, 1, db1); root->awar_int (GA_AWAR_REALIGN, 1, db1); root->awar_float (GA_AWAR_GAP_PEN, 5.0, db1); root->awar_float (GA_AWAR_GAP_EXT, 2.0, db1); root->awar_float (GA_AWAR_MATCH_SCORE, 2.0, db1); root->awar_float (GA_AWAR_MISMATCH_SCORE, -1.0, db1); root->awar_int (GA_AWAR_ADVANCED, 0, db1); root->awar_int (GA_AWAR_FS_MIN, 40, db1); root->awar_int (GA_AWAR_FS_MAX, 40, db1); root->awar_float (GA_AWAR_FS_MSC, .7, db1); root->awar_int (GA_AWAR_MIN_FULL, 1, db1); root->awar_int (GA_AWAR_FULL_MINLEN, 1400, db1); root->awar_string(GA_AWAR_OVERHANG, "attach", db1); root->awar_int (GA_AWAR_THREADS, 1, db1); root->awar_int (GA_AWAR_QSIZE, 1, db1); root->awar_int (GA_AWAR_KMER_LEN, 10, db1); root->awar_int (GA_AWAR_KMER_MM, 0, db1); root->awar_int (GA_AWAR_MIN_LEN, 150, db1); root->awar_float (GA_AWAR_WEIGHT, 1, db1); root->awar_string(GA_AWAR_INSERT, "shift", db1); root->awar_string(GA_AWAR_LOWERCASE, "none", db1); root->awar_string(GA_AWAR_AUTOFILTER, "", db1); root->awar_int (GA_AWAR_KMER_NOREL, 0, db1); root->awar_int (GA_AWAR_KMER_NOFAST, 0, db1); root->awar_int (GA_AWAR_SHOW_DIST, 0, db1); root->awar_int (GA_AWAR_SHOW_DIFF, 0, db1); root->awar_int (GA_AWAR_COLOR, 1, db1); root->awar_int (GA_AWAR_GENE_START, 0, db1); root->awar_int (GA_AWAR_GENE_END, 0, db1); root->awar_int (GA_AWAR_FS_COVER_GENE, 0, db1); root->awar_int (GA_AWAR_USED_RELS, 0, db1); root->awar_int (GA_AWAR_CALC_IDENTITY, 0, db1); root->awar_int (GA_AWAR_NOWARN_START, 0, db1); AW_awar *awar_mode = root->awar_int (GA_AWAR_REFDB_MODE, REF_CURRENT, db1); root->awar_string (GA_AWAR_REFDB, ":", db1); AW_awar *awar_select = root->awar_string(GA_AWAR_REFDB_SELECT, "", db1); awar_mode->add_callback(makeRootCallback(refDbModeChanged_cb)); awar_select->add_callback(makeRootCallback(newRefDbSelected_cb)); } enum SinaArbInterfaceVersion { ARB_5_99, ARB_7_1, }; const SinaArbInterfaceVersion NO_INTERFACE = SinaArbInterfaceVersion(-1); struct sina_arb_interface_def { SinaArbInterfaceVersion version; const char *id; // as define by SINA }; static sina_arb_interface_def supported_sina_versions[] = { // order matters: first supported version will be used. { ARB_7_1, "ARB7.1" }, // only defined in patched version delivered with arb { ARB_5_99, "ARB5.99" }, // supported at least by sina 1.3 up to 1.7.2 { NO_INTERFACE, "" }, // version=sentinel }; static const char *get_interface_id(SinaArbInterfaceVersion version) { for (int v = 0; ; ++v) { const sina_arb_interface_def& sina_interface = supported_sina_versions[v]; if (sina_interface.version == version) { return sina_interface.id; } } return get_interface_id(NO_INTERFACE); } static SinaArbInterfaceVersion used_sina_interface = NO_INTERFACE; static GB_ERROR detect_sina_version(AW_root *awr) { const char *sinaName = awr->awar(GA_AWAR_CMD)->read_char_pntr(); char *sina = ARB_executable(sinaName, GB_getenv("PATH")); const char *fail_reason = NULp; std::string tested_interfaces = ""; used_sina_interface = NO_INTERFACE; if (sina) { if (ARB_path_contains_unwanted_chars(sina)) { char *description = GBS_global_string_copy("the sina executable derived from\n" "- gui property '%s' and\n" "- environment variable PATH", sinaName); ARB_warn_about_unwanted_chars(sina, description); free(description); } for (int v = 0; ; ++v) { const sina_arb_interface_def& sina_interface = supported_sina_versions[v]; if (sina_interface.version == NO_INTERFACE) { if (fail_reason) fail_reason = GBS_global_string("%s (this ARB supports these interface versions: %s)", fail_reason, tested_interfaces.c_str()); break; } int exitstatus = system(GBS_global_string("%s --has-cli-vers %s", sina, sina_interface.id)); exitstatus = WEXITSTATUS(exitstatus); if (exitstatus == EXIT_FAILURE) { fail_reason = "Incompatible SINA and ARB versions"; if (!tested_interfaces.empty()) tested_interfaces += ' '; tested_interfaces += sina_interface.id; } else { if (exitstatus == EXIT_SUCCESS) { used_sina_interface = sina_interface.version; fail_reason = NULp; fprintf(stdout, "Using SINA-ARB interface version '%s'%s\n", sina_interface.id, v>0 ? " (old)" : ""); } else { fail_reason = GBS_global_string("Could not execute SINA binary '%s' (exitstatus was %i)", sinaName, exitstatus); } break; // either found compatible version or failed completely -> stop } } free(sina); } else { fail_reason = GBS_global_string("'%s' not found", sinaName); } return fail_reason; } AW_active sina_mask(AW_root *awr) { GB_ERROR fail_reason = detect_sina_version(awr); if (fail_reason) { fprintf(stderr, "Note: SINA (SILVA Aligner) disabled (Reason: %s)\n", fail_reason); } return fail_reason ? AWM_DISABLED : AWM_ALL; } inline const char *stream2static(const std::stringstream& str) { return GBS_static_string(str.str().c_str()); } inline const char *empty_as_none(const char *sainame) { // see http://bugs.arb-home.de/ticket/519 if (sainame && !sainame[0]) sainame = "none"; return sainame; } static void sina_start(AW_window *window, const AlignDataAccess *data_access) { cerr << "Starting SINA..." << endl; AW_root *root = window->get_root(); GB_ERROR gb_error = NULp; // make string from pt server selection const char *pt_server = NULp; { int pt = root->awar(AWAR_PT_SERVER)->read_int(); if (pt == -1) { // do NOT use ptserver (aka "use sina internal family search") if (used_sina_interface == ARB_5_99) { gb_error = "internal SINA family search is not available with your SINA version"; } } else { std::stringstream ptnam; ptnam << "ARB_PT_SERVER" << pt; pt_server = GBS_read_arb_tcp(ptnam.str().c_str()); if (!pt_server) { gb_error = GBS_global_string("Unable to find definition for chosen PT-server\n(Reason: %s)", GB_await_error()); } else { const char *pt_db = pt_server + strlen(pt_server) + 1; pt_db += strlen(pt_db)+3; // start pt server if necessary gb_error = arb_look_and_start_server(AISC_MAGIC_NUMBER, ptnam.str().c_str()); if (gb_error) { std::stringstream tmp; tmp << "Cannot contact PT server. Aborting" << endl << " ID: \"" << tmp.str().c_str() << "\" PORT: \"" << pt_server << "\" DB: \"" << pt_db << endl << "\" GBERROR: \"" << gb_error << "\"" << endl; gb_error = stream2static(tmp); } } } } if (!gb_error) { // create temporary file char* tmpfile; FILE* tmpfile_F; { char* tmpfile_tpl = GB_unique_filename("sina_select", "tmp"); tmpfile_F = GB_fopen_tempfile(tmpfile_tpl, "w", &tmpfile); free(tmpfile_tpl); } if (!tmpfile_F) { std::stringstream tmp; tmp << "Error: Unable to create temporary file \"" << tmpfile << "\"!"; gb_error = stream2static(tmp); } else { GB_remove_on_exit(tmpfile); GBDATA *gb_main = data_access->gb_main; std::vector spec_names; switch (root->awar(GA_AWAR_TGT)->read_int()) { case 0: { // current char *spec_name = root->awar(AWAR_SPECIES_NAME)->read_string(); if (spec_name) { fwrite(spec_name, strlen(spec_name), 1, tmpfile_F); fwrite("\n", 1, 1, tmpfile_F); } else { gb_error = "Unable to get name of currently active species"; } free(spec_name); break; } case 1: { // selected GB_begin_transaction(gb_main); int num_selected = 0; for (GBDATA *gb_spec = data_access->get_first_selected_species(&num_selected); gb_spec; gb_spec = data_access->get_next_selected_species()) { GBDATA *gbd_name = GB_find(gb_spec, "name", SEARCH_CHILD); if (gbd_name) { const char *str = GB_read_char_pntr(gbd_name); fwrite(str, strlen(str), 1, tmpfile_F); fwrite("\n", 1, 1, tmpfile_F); } } GB_commit_transaction(gb_main); break; } case 2: { // marked GB_begin_transaction(gb_main); for (GBDATA *gb_spec = GBT_first_marked_species(gb_main); gb_spec; gb_spec = GBT_next_marked_species(gb_spec)) { GBDATA *gbd_name = GB_find(gb_spec, "name", SEARCH_CHILD); if (gbd_name) { const char *str = GB_read_char_pntr(gbd_name); fwrite(str, strlen(str), 1, tmpfile_F); fwrite("\n", 1, 1, tmpfile_F); } } GB_commit_transaction(gb_main); break; } } fclose(tmpfile_F); if (!gb_error) { // build command line GBS_strstruct cl(2000); cl.cat(root->awar(GA_AWAR_CMD)->read_char_pntr()); cl.cat(" -i :"); switch (used_sina_interface) { case ARB_5_99: cl.cat(" --ptdb :"); break; case ARB_7_1: cl.cat(" --out :"); cl.cat(" --db "); cl.cat(root->awar(GA_AWAR_REFDB)->read_char_pntr()); if (root->awar(GA_AWAR_NOWARN_START)->read_int()) cl.cat(" --dont-expect-start"); if (root->awar(GA_AWAR_CALC_IDENTITY)->read_int()) cl.cat(" --calc-idty"); cl.cat(" --default-alignment "); cl.cat(data_access->alignment_name.c_str()); // always use alignment used in editor break; } if (pt_server) { cl.cat(" --ptport "); cl.cat(pt_server); if (used_sina_interface == ARB_7_1) { cl.cat(" --fs-engine "); cl.cat("pt-server"); } } else { // use sina internal search ga_assert(used_sina_interface == ARB_7_1); cl.cat(" --fs-engine "); cl.cat("internal"); } cl.cat(" --turn "); cl.cat(root->awar(GA_AWAR_TURN_CHECK)->read_int() ? "all" : "none"); cl.cat(" --overhang "); cl.cat(root->awar(GA_AWAR_OVERHANG)->read_char_pntr()); cl.cat(" --filter "); cl.cat(empty_as_none(root->awar(GA_AWAR_SAI)->read_char_pntr())); cl.cat(" --fs-min "); cl.putlong(root->awar(GA_AWAR_FS_MIN)->read_int()); cl.cat(" --fs-msc "); cl.putfloat(root->awar(GA_AWAR_FS_MSC)->read_float()); cl.cat(" --fs-max "); cl.putlong(root->awar(GA_AWAR_FS_MAX)->read_int()); cl.cat(" --fs-req 1"); // hardcoded to 1 - uses stricter requirement for full-length sequences cl.cat(" --fs-req-full "); cl.putlong(root->awar(GA_AWAR_MIN_FULL)->read_int()); cl.cat(" --fs-full-len "); cl.putlong(root->awar(GA_AWAR_FULL_MINLEN)->read_int()); cl.cat(" --fs-kmer-len "); cl.putlong(root->awar(GA_AWAR_KMER_LEN)->read_int()); cl.cat(" --fs-kmer-mm "); cl.putlong(root->awar(GA_AWAR_KMER_MM)->read_int()); // @@@ only with ptserver -> document + add 2 gui cl.cat(" --fs-min-len "); cl.putlong(root->awar(GA_AWAR_MIN_LEN)->read_int()); cl.cat(" --fs-weight "); cl.putfloat(root->awar(GA_AWAR_WEIGHT)->read_float()); cl.cat(" --pen-gap "); cl.putfloat(root->awar(GA_AWAR_GAP_PEN)->read_float()); cl.cat(" --pen-gapext "); cl.putfloat(root->awar(GA_AWAR_GAP_EXT)->read_float()); cl.cat(" --match-score "); cl.putfloat(root->awar(GA_AWAR_MATCH_SCORE)->read_float()); cl.cat(" --mismatch-score "); cl.putfloat(root->awar(GA_AWAR_MISMATCH_SCORE)->read_float()); cl.cat(" --prot-level "); cl.putlong(root->awar(GA_AWAR_PROTECTION)->read_int()); cl.cat(" --select-file "); cl.cat(tmpfile); cl.cat(" --insertion "); cl.cat(root->awar(GA_AWAR_INSERT)->read_char_pntr()); cl.cat(" --lowercase "); cl.cat(root->awar(GA_AWAR_LOWERCASE)->read_char_pntr()); cl.cat(" --auto-filter-field "); cl.cat_sQuoted(root->awar(GA_AWAR_AUTOFILTER)->read_char_pntr()); // note: default value passed to sina 1.3 was 'none' (w/o quotes) cl.cat(" --gene-start "); cl.putlong(root->awar(GA_AWAR_GENE_START)->read_int()); cl.cat(" --gene-end "); cl.putlong(root->awar(GA_AWAR_GENE_END)->read_int()); cl.cat(" --fs-cover-gene "); cl.putlong(root->awar(GA_AWAR_FS_COVER_GENE)->read_int()); if (root->awar(GA_AWAR_KMER_NOREL)->read_int()) cl.cat(" --fs-kmer-norel "); if (root->awar(GA_AWAR_KMER_NOFAST)->read_int()) cl.cat(" --fs-kmer-no-fast "); if (root->awar(GA_AWAR_SHOW_DIST)->read_int()) cl.cat(" --show-dist "); if (root->awar(GA_AWAR_SHOW_DIFF)->read_int()) cl.cat(" --show-diff "); if (root->awar(GA_AWAR_COLOR)->read_int()) cl.cat(" --color"); if (root->awar(GA_AWAR_REALIGN)->read_int()) cl.cat(" --realign"); if (root->awar(GA_AWAR_USED_RELS)->read_int()) cl.cat(" --write-used-rels"); gb_error = ARB_system(cl.get_data(), XCmdType(XCMD_SERVSYNC_WAIT_ON_ERROR, gb_main)); } if (!gb_error) aw_message("SINA finished aligning."); } free(tmpfile); } aw_message_if(gb_error); } static char* filter_posvar_SAI_for_ali(GBDATA *gb_extended, const char *ali_name) { char *result = NULp; char *typePath = GBS_global_string_copy("%s/_TYPE", ali_name); GBDATA *gbd = GB_search(gb_extended, typePath, GB_FIND); if (gbd) { const char* type = GB_read_char_pntr(gbd); if (type && strncmp("PV", type, 2) == 0) { gbd = GB_find(gb_extended, "name", SEARCH_CHILD); result = GB_read_string(gbd); } } free(typePath); return result; } static AWT_config_mapping_def sina_config_mapping[] = { // both { GA_AWAR_TGT, "target" }, { GA_AWAR_OVERHANG, "overhang" }, { GA_AWAR_INSERT, "insertions" }, { GA_AWAR_LOWERCASE, "lowercase" }, { GA_AWAR_WEIGHT, "weight" }, { GA_AWAR_FULL_MINLEN, "fullminlen" }, // advanced only { GA_AWAR_SAI, "sai" }, { GA_AWAR_AUTOFILTER, "autofilter" }, { GA_AWAR_TURN_CHECK, "turncheck" }, { GA_AWAR_REALIGN, "realign" }, { GA_AWAR_GAP_PEN, "gappen" }, { GA_AWAR_GAP_EXT, "gapext" }, { GA_AWAR_MATCH_SCORE, "matchscore" }, { GA_AWAR_MISMATCH_SCORE, "mismatchscore" }, { GA_AWAR_FS_MIN, "fs_min" }, { GA_AWAR_FS_MSC, "fs_minscore" }, { GA_AWAR_FS_MAX, "fs_min" }, { GA_AWAR_MIN_FULL, "minfull" }, { GA_AWAR_KMER_LEN, "kmerlen" }, { GA_AWAR_KMER_MM, "kmermm" }, { GA_AWAR_MIN_LEN, "refminlen" }, { GA_AWAR_GENE_START, "genestart" }, { GA_AWAR_GENE_END, "geneend" }, { GA_AWAR_FS_COVER_GENE, "fs_covergene" }, { GA_AWAR_USED_RELS, "write_used_rels" }, { GA_AWAR_CALC_IDENTITY, "calc_identity" }, { GA_AWAR_KMER_NOFAST, "kmernofast" }, { GA_AWAR_KMER_NOREL, "kmernorel" }, // both { GA_AWAR_SHOW_DIFF, "showdiff" }, { GA_AWAR_COLOR, "color" }, { GA_AWAR_SHOW_DIST, "showdist" }, { NULp, NULp } }; static void accept_selected_ref_db(AW_window *aww, const char * const *awar_filename) { AW_root *root = aww->get_root(); char *filename = root->awar(*awar_filename)->read_string(); if (GB_is_readablefile(filename)) { AW_awar *awar_refdb_sel = root->awar(GA_AWAR_REFDB_SELECT); awar_refdb_sel->write_string(filename); aww->hide(); } free(filename); } static AW_window *create_ref_db_selection_window(AW_root *aw_root) { static char *awar_name = NULp; // do not free, bound to callback return awt_create_load_box(aw_root, "Select", "SINA reference database", ".", "arb", &awar_name, makeWindowCallback(accept_selected_ref_db, (const char*const*)&awar_name)); } static void sina_select_ref_db(AW_window *aww) { static AW_window *aw_ref_db_selection = NULL; if (!aw_ref_db_selection) { AW_root *root = aww->get_root(); aw_ref_db_selection = create_ref_db_selection_window(root); } aw_ref_db_selection->activate(); } static SinaArbInterfaceVersion gui_sina_interface = NO_INTERFACE; // interface used in GUI static void sina_cmd_changed_cb(AW_root *awr) { GB_ERROR fail_reason = detect_sina_version(awr); if (fail_reason) { aw_message(fail_reason); } else { if (used_sina_interface != gui_sina_interface) { aw_message("The GUI does not match the used sina version!\n" "Please save properties and restart the editor."); } aw_message(GBS_global_string("Using sina-arb interface '%s'", get_interface_id(used_sina_interface))); } } static AW_window_simple* new_sina_simple(AW_root *root, const AlignDataAccess *alignData, bool adv) { const int hgap = 10; AW_window_simple *aws = new AW_window_simple; if (gui_sina_interface == NO_INTERFACE) { gui_sina_interface = used_sina_interface; root->awar(GA_AWAR_CMD)->add_callback(sina_cmd_changed_cb); } aws->reset_layout("20220422"); aws->init(root, adv ? "XSINA" : "SINA", "SINA (SILVA Incremental Aligner)"); aws->button_length(12); aws->at(10, 10); aws->auto_space(5, 5); int closex, closey; aws->get_at_position(&closex, &closey); aws->callback(AW_POPDOWN); aws->create_button("CLOSE", "CLOSE", "O"); int closex2 = aws->get_at_xposition(); if (gui_sina_interface == NO_INTERFACE) { // happens when no sina detected + menu entry is triggered via macro // @@@ would be nice to globally avoid callbacks for inactive menu entries aws->at_newline(); aws->label_length(0); aws->label("SINA command\nError: Failed to find or identify sina version!"); aws->create_input_field(GA_AWAR_CMD, 20); return aws; } aws->at_shift(10, 0); aws->label_length(0); aws->label("Show advanced options"); aws->create_toggle(GA_AWAR_ADVANCED); bool cbInstalled = false; if (!cbInstalled) { root->awar(GA_AWAR_ADVANCED)->add_callback(makeRootCallback(show_sina_window, alignData)); cbInstalled = true; } aws->at_newline(); aws->at_shift(0, hgap); int y_col2 = aws->get_at_yposition(); aws->label_length(15); aws->create_toggle_field(GA_AWAR_TGT, "Align what?"); aws->insert_toggle("Current Species:", "C", 0); aws->insert_toggle("Selected Species", "S", 1); aws->insert_default_toggle("Marked Species", "M", 2); aws->update_toggle_field(); aws->at_shift(0, 3); aws->create_input_field(AWAR_SPECIES_NAME, 20); aws->at_newline(); aws->at_shift(0, hgap); aws->button_length(24); if (used_sina_interface == ARB_5_99) { aws->label("PT Server:"); } else { aws->label_length(20); aws->label("PT Server\n" "undefined => sina kmer"); } awt_create_PTSERVER_selection_button(aws, AWAR_PT_SERVER); aws->label_length(0); if (gui_sina_interface == ARB_7_1) { aws->at_newline(); aws->create_toggle_field(GA_AWAR_REFDB_MODE, "Reference database"); aws->insert_toggle("Explicit as ", "E", REF_EXPLICIT); aws->insert_toggle("Last saved", "s", REF_LAST_SAVE); aws->insert_default_toggle("Current", "C", REF_CURRENT); aws->update_toggle_field(); aws->at_shift(0, 3); aws->callback(makeWindowCallback(sina_select_ref_db)); aws->create_autosize_button("selected", "selected", "s"); aws->at_newline(); aws->create_input_field(GA_AWAR_REFDB, 40); } aws->at_newline(); aws->label("Overhang placement"); aws->create_option_menu(GA_AWAR_OVERHANG); aws->insert_option("keep attached", NULp, "attach"); aws->insert_option("move to edge", NULp, "edge"); aws->insert_option("remove", NULp, "remove"); aws->update_option_menu(); aws->at_newline(); aws->label("Handling of unmappable insertions"); aws->create_option_menu(GA_AWAR_INSERT); aws->insert_option("Shift surrounding bases", NULp, "shift"); aws->insert_option("Forbid during DP alignment", NULp, "forbid"); aws->insert_option("Delete bases", NULp, "remove"); aws->update_option_menu(); int x_col2 = aws->get_at_xposition(); aws->at_newline(); aws->label("Character Case"); aws->create_option_menu(GA_AWAR_LOWERCASE); aws->insert_option("Do not modify", NULp, "original"); aws->insert_option("Show unaligned bases as lower case", NULp, "unaligned"); aws->insert_option("Uppercase all", NULp, "none"); aws->update_option_menu(); aws->at_newline(); aws->label("Family conservation weight (0-1)"); aws->create_input_field(GA_AWAR_WEIGHT, 3); aws->at_newline(); aws->label("Size of full-length sequences"); aws->create_input_field(GA_AWAR_FULL_MINLEN, 5); aws->at_newline(); aws->label_length(17); aws->label("Protection Level"); aws->create_option_menu(GA_AWAR_PROTECTION); aws->insert_option("0", NULp, 0); aws->insert_option("1", NULp, 1); aws->insert_option("2", NULp, 2); aws->insert_option("3", NULp, 3); aws->insert_option("4", NULp, 4); aws->insert_option("5", NULp, 5); aws->insert_option("6", NULp, 6); aws->update_option_menu(); aws->at_newline(); aws->label_length(21); aws->label("Show changed sections"); aws->create_toggle(GA_AWAR_SHOW_DIFF); aws->label_length(11); aws->label("color bases"); aws->create_toggle(GA_AWAR_COLOR); aws->at_newline(); aws->label_length(21); aws->label("Show statistics"); aws->create_toggle(GA_AWAR_SHOW_DIST); aws->at_newline(); int startx, starty; aws->get_at_position(&startx, &starty); aws->button_length(12); aws->at(closex, starty); aws->callback(makeWindowCallback(sina_start, alignData)); aws->highlight(); aws->create_button("Start", "Start", "S"); aws->at(closex2+200, starty-10); AWT_insert_config_manager(aws, AW_ROOT_DEFAULT, "sina", sina_config_mapping); if (adv) { aws->at(x_col2, y_col2); aws->auto_space(5, 5); // resets position for at_newline aws->label_length(0); aws->label("Pos. Var.:"); awt_create_SAI_selection_button(alignData->gb_main, aws, GA_AWAR_SAI, makeSaiSelectionlistFilterCallback(filter_posvar_SAI_for_ali, alignData->alignment_name.c_str())); aws->at_newline(); aws->label("Field used for automatic\nfilter selection"); aws->create_input_field(GA_AWAR_AUTOFILTER, 20); aws->at_newline(); aws->label("Turn check"); aws->create_toggle(GA_AWAR_TURN_CHECK); aws->label("Realign"); aws->create_toggle(GA_AWAR_REALIGN); aws->at_newline(); aws->at_shift(0, hgap); aws->label("Gap insertion/extension penalties"); aws->create_input_field(GA_AWAR_GAP_PEN, 5); aws->create_input_field(GA_AWAR_GAP_EXT, 5); aws->at_newline(); aws->label("Match score"); aws->create_input_field(GA_AWAR_MATCH_SCORE, 3); aws->label("Mismatch score"); aws->create_input_field(GA_AWAR_MISMATCH_SCORE, 3); aws->at_newline(); aws->label("Family search min/min_score/max"); aws->create_input_field(GA_AWAR_FS_MIN, 3); aws->create_input_field(GA_AWAR_FS_MSC, 3); aws->create_input_field(GA_AWAR_FS_MAX, 3); aws->at_newline(); aws->label("Minimal number of full length sequences"); aws->create_input_field(GA_AWAR_MIN_FULL, 3); aws->at_newline(); aws->label("Family search oligo length / mismatches"); aws->create_input_field(GA_AWAR_KMER_LEN, 3); aws->create_input_field(GA_AWAR_KMER_MM, 3); aws->at_newline(); aws->label("Minimal reference sequence length"); aws->create_input_field(GA_AWAR_MIN_LEN, 5); aws->at_newline(); aws->label("Alignment bounds: start"); aws->create_input_field(GA_AWAR_GENE_START, 6); aws->label("end"); aws->create_input_field(GA_AWAR_GENE_END, 6); aws->at_newline(); aws->label("Number of references required to touch bounds"); aws->create_input_field(GA_AWAR_FS_COVER_GENE, 3); aws->at_newline(); aws->label("Save used references in 'used_rels'"); aws->create_toggle(GA_AWAR_USED_RELS); aws->at_newline(); aws->label("Store highest identity in 'align_ident_slv'"); aws->create_toggle(GA_AWAR_CALC_IDENTITY); aws->at_newline(); aws->label("Disable fast search"); aws->create_toggle(GA_AWAR_KMER_NOFAST); aws->at_newline(); aws->label("Score search results by absolute oligo match count"); aws->create_toggle(GA_AWAR_KMER_NOREL); if (gui_sina_interface == ARB_7_1) { aws->at_newline(); aws->label("Suppress warnings about missing 'start' field"); aws->create_toggle(GA_AWAR_NOWARN_START); } aws->at_newline(); aws->label("SINA command"); aws->create_input_field(GA_AWAR_CMD, 20); } int winx, winy; aws->get_window_size(winx, winy); aws->button_length(12); aws->at(winx-closex2+5, closey); aws->callback(makeHelpCallback("sina_main.hlp")); aws->create_button("HELP", "HELP"); return aws; } void show_sina_window(UNFIXED, const AlignDataAccess *alignData) { AW_root *root = AW_root::SINGLETON; static AW_window_simple *ga_aws = NULp; static AW_window_simple *ga_aws_adv = NULp; if (root->awar(GA_AWAR_ADVANCED)->read_int()) { if (!ga_aws_adv) ga_aws_adv = new_sina_simple(root, alignData, true); ga_aws_adv->show(); if (ga_aws) ga_aws->hide(); } else { if (!ga_aws) ga_aws = new_sina_simple(root, alignData, false); ga_aws->show(); if (ga_aws_adv) ga_aws_adv->hide(); } static bool refdb_mode_refreshed = false; if (!refdb_mode_refreshed) { AW_awar *awar_mode = root->awar(GA_AWAR_REFDB_MODE); if (awar_mode->read_int() != REF_EXPLICIT) awar_mode->touch(); // trigger callback refdb_mode_refreshed = true; } }