// =============================================================== // // // // File : ui_species.cxx // // Purpose : // // // // Institute of Microbiology (Technical University Munich) // // http://www.arb-home.de/ // // // // =============================================================== // #include "dbui.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace DBUI; using namespace QUERY; #define ui_assert(cond) arb_assert(cond) // awars shared between different itemtypes: #define AWAR_FIELD_REORDER_ORDER "tmp/adreorder/order" // separate awars for different itemtypes: #define AWAR_FIELD_REORDER_SOURCE_TMPL "tmp/adreorder/%s/source" #define AWAR_FIELD_REORDER_DEST_TMPL "tmp/adreorder/%s/dest" #define AWAR_FIELD_CREATE_NAME_TMPL "tmp/adfield/%s/name" #define AWAR_FIELD_CREATE_TYPE_TMPL "tmp/adfield/%s/type" #define AWAR_FIELD_DELETE_TMPL "tmp/adfield/%s/source" #define AWAR_FIELD_CONVERT_SOURCE_TMPL "tmp/adconvert/%s/source" #define AWAR_FIELD_CONVERT_TYPE_TMPL "tmp/adconvert/%s/type" // next neighbours of listed and selected: // more defined in ../../AWTC/awtc_next_neighbours.hxx@AWAR_NN_BASE #define AWAR_NN_COMPLEMENT AWAR_NN_BASE "complement" #define AWAR_NN_RANGE_START AWAR_NN_BASE "range_start" #define AWAR_NN_RANGE_END AWAR_NN_BASE "range_end" #define AWAR_NN_MIN_SCORE AWAR_NN_BASE "min_scored" #define AWAR_NN_MAX_HITS AWAR_NN_BASE "max_hits" // next neighbours of selected only: #define AWAR_NN_BASE_SELECTED AWAR_NN_BASE "selected/" #define AWAR_NN_SELECTED_HIT_COUNT "tmp/" AWAR_NN_BASE_SELECTED "hit_count" #define AWAR_NN_SELECTED_AUTO_SEARCH "tmp/" AWAR_NN_BASE_SELECTED "auto_search" #define AWAR_NN_SELECTED_AUTO_MARK "tmp/" AWAR_NN_BASE_SELECTED "auto_mark" // next neighbours of listed only: #define AWAR_NN_BASE_LISTED AWAR_NN_BASE "listed/" #define AWAR_NN_LISTED_DEST_FIELD AWAR_NN_BASE_LISTED "dest_field" #define AWAR_NN_LISTED_SCORED_ENTRIES AWAR_NN_BASE_LISTED "scored_entries" enum ReorderMode { // real orders ORDER_ALPHA, ORDER_TYPE, ORDER_FREQ, // special modes RIGHT_BEHIND_LEFT, REVERSE_ORDER, }; void DBUI::create_dbui_awars(AW_root *aw_root) { aw_root->awar_int(AWAR_FIELD_REORDER_ORDER, ORDER_ALPHA, AW_ROOT_DEFAULT); } inline const char *itemAwar(const char *name_template, ItemSelector& itype) { return GBS_global_string(name_template, itype.item_name); } static void init_itemtype_specific_DBUI_awars(AW_root *aw_root, ItemSelector& itype) { static bool initialized[QUERY_ITEM_TYPES] = { false }; if (!initialized[itype.type]) { aw_root->awar_string(itemAwar(AWAR_FIELD_REORDER_SOURCE_TMPL, itype), "", AW_ROOT_DEFAULT); aw_root->awar_string(itemAwar(AWAR_FIELD_REORDER_DEST_TMPL, itype), "", AW_ROOT_DEFAULT); aw_root->awar_string(itemAwar(AWAR_FIELD_CREATE_NAME_TMPL, itype), "", AW_ROOT_DEFAULT); aw_root->awar_int (itemAwar(AWAR_FIELD_CREATE_TYPE_TMPL, itype), GB_STRING, AW_ROOT_DEFAULT); aw_root->awar_string(itemAwar(AWAR_FIELD_DELETE_TMPL, itype), "", AW_ROOT_DEFAULT); aw_root->awar_string(itemAwar(AWAR_FIELD_CONVERT_SOURCE_TMPL, itype), "", AW_ROOT_DEFAULT); aw_root->awar_int (itemAwar(AWAR_FIELD_CONVERT_TYPE_TMPL, itype), GB_STRING, AW_ROOT_DEFAULT); initialized[itype.type] = true; } } static void move_species_to_extended(AW_window *aww, GBDATA *gb_main) { char *source = aww->get_root()->awar(AWAR_SPECIES_NAME)->read_string(); GB_ERROR error = GB_begin_transaction(gb_main); if (!error) { GBDATA *gb_sai_data = GBT_get_SAI_data(gb_main); if (!gb_sai_data) error = GB_await_error(); else { GBDATA *gb_species = GBT_find_species(gb_main, source); GBDATA *gb_dest = GBT_find_SAI_rel_SAI_data(gb_sai_data, source); if (gb_dest) error = GBS_global_string("SAI '%s' already exists", source); else if (gb_species) { gb_dest = GB_create_container(gb_sai_data, "extended"); if (!gb_dest) error = GB_await_error(); else { error = GB_copy_dropProtectMarksAndTempstate(gb_dest, gb_species); if (!error) { error = GB_delete(gb_species); if (!error) aww->get_root()->awar(AWAR_SPECIES_NAME)->write_string(""); } } } else error = "Please select a species"; } } GB_end_transaction_show_error(gb_main, error, aw_message); free(source); } static GB_ERROR species_create_handler(const char *dest, GBDATA *gb_main) { GB_ERROR error = NULp; if (dest[0]) { error = GB_begin_transaction(gb_main); if (!error) { GBDATA *gb_species_data = GBT_get_species_data(gb_main); if (!gb_species_data) error = GB_await_error(); else { GBDATA *gb_dest = GBT_find_species_rel_species_data(gb_species_data, dest); if (gb_dest) error = GBS_global_string("Species '%s' already exists", dest); else { gb_dest = GBT_find_or_create_species_rel_species_data(gb_species_data, dest, true); if (!gb_dest) error = GB_await_error(); else AW_root::SINGLETON->awar(AWAR_SPECIES_NAME)->write_string(dest); } } } error = GB_end_transaction(gb_main, error); } else { error = "Please enter a name for the new species"; } return error; } static void species_create_cb(AW_window *, GBDATA *gb_main) { AWT_activate_prompt("Create new species", "Enter shortname (ID) of new species:", "", "Create", makeResultHandler(species_create_handler, gb_main), "spa_create.hlp"); } static GBDATA *expect_species_selected(AW_root *aw_root, GBDATA *gb_main, char **give_name = NULp) { GB_transaction ta(gb_main); char *name = aw_root->awar(AWAR_SPECIES_NAME)->read_string(); GBDATA *gb_species = GBT_find_species(gb_main, name); if (!gb_species) { if (name && name[0]) aw_message(GBS_global_string("Species '%s' does not exist.", name)); else aw_message("Please select a species first"); } if (give_name) *give_name = name; else free(name); return gb_species; } static void species_copy_cb(AW_window *aww, GBDATA *gb_main) { AW_root *aw_root = aww->get_root(); char *name; GBDATA *gb_species = expect_species_selected(aw_root, gb_main, &name); if (gb_species) { GB_transaction ta(gb_main); GBDATA *gb_species_data = GB_get_father(gb_species); UniqueNameDetector und(gb_species_data); GB_ERROR error = NULp; char *copy_name = AWTC_makeUniqueShortName(GBS_global_string("c%s", name), und); if (!copy_name) error = GB_await_error(); else { GBDATA *gb_new_species = GB_create_container(gb_species_data, "species"); if (!gb_new_species) error = GB_await_error(); else { error = GB_copy_dropProtectMarksAndTempstate(gb_new_species, gb_species); if (!error) { error = GBT_write_string(gb_new_species, "name", copy_name); if (!error) aw_root->awar(AWAR_SPECIES_NAME)->write_string(copy_name); // set focus } } free(copy_name); } if (error) { error = ta.close(error); aw_message(error); } } } static GB_ERROR species_rename_handler(const char *new_fullname, GBDATA *gb_species) { GB_transaction ta(gb_species); GBDATA *gb_full_name = GB_search(gb_species, "full_name", GB_STRING); const char *old_fullname = GB_read_char_pntr(gb_full_name); GB_ERROR error = NULp; if (strcmp(old_fullname, new_fullname) == 0) { error = "[nothing changed]"; } else { error = GB_write_string(gb_full_name, new_fullname); } if (!error) { AW_root *awr = AW_root::SINGLETON; bool recreateID = ARB_in_expert_mode(awr) && // never re-create ID in novice mode aw_ask_sure("recreate_name_field", "Regenerate species identifier ('name')?\n" "(only do this if you know what you're doing)"); if (recreateID) { arb_progress progress("Regenerating species ID", 1L); error = AWTC_recreate_name(gb_species); if (!error) awr->awar(AWAR_SPECIES_NAME)->write_string(null2empty(GBT_get_name(gb_species))); // set focus } } error = ta.close(error); return error; } static void species_rename_cb(AW_window *aww, GBDATA *gb_main) { AW_root *aw_root = aww->get_root(); GBDATA *gb_species = expect_species_selected(aw_root, gb_main); if (gb_species) { const char *full_name; { GB_transaction ta(gb_main); GBDATA *gb_full_name = GB_search(gb_species, "full_name", GB_STRING); full_name = gb_full_name ? GB_read_char_pntr(gb_full_name) : ""; } AWT_activate_prompt("Rename species", "Modify 'full_name' of species:", full_name, "Rename", makeResultHandler(species_rename_handler, gb_species), "spa_rename.hlp"); } } static void species_delete_cb(AW_window *aww, GBDATA *gb_main) { AW_root *aw_root = aww->get_root(); char *name; GBDATA *gb_species = expect_species_selected(aw_root, gb_main, &name); GB_ERROR error = NULp; if (!gb_species) { error = "Please select a species first"; } else if (aw_ask_sure("info_delete_species", GBS_global_string("Are you sure to delete the species '%s'?", name))) { GB_transaction ta(gb_main); error = GB_delete(gb_species); error = ta.close(error); if (!error) aw_root->awar(AWAR_SPECIES_NAME)->write_string(""); } if (error) aw_message(error); free(name); } static long count_field_occurrence(BoundItemSel *bsel, const char *field_name) { QUERY_RANGE RANGE = QUERY_ALL_ITEMS; long count = 0; ItemSelector& sel = bsel->selector; for (GBDATA *gb_container = sel.get_first_item_container(bsel->gb_main, NULp, RANGE); gb_container; gb_container = sel.get_next_item_container(gb_container, RANGE)) { for (GBDATA *gb_item = sel.get_first_item(gb_container, RANGE); gb_item; gb_item = sel.get_next_item(gb_item, RANGE)) { GBDATA *gb_field = GB_entry(gb_item, field_name); if (gb_field) ++count; } } return count; } class KeySorter : virtual Noncopyable { int key_count; GBDATA **key; int field_count; // = key_count - container_count bool order_changed; // helper variables for sorting static GB_HASH *order_hash; static BoundItemSel *bitem_selector; static arb_progress *sort_progress; bool legal_pos(int p) { return p >= 0 && p= 0 && pinc(); } return freq; } int compare(int p1, int p2, ReorderMode mode) { switch (mode) { case RIGHT_BEHIND_LEFT: case REVERSE_ORDER: ui_assert(0); // illegal ReorderMode break; case ORDER_TYPE: return field_type(p2)-field_type(p1); case ORDER_ALPHA: return strcasecmp(field_name(p1), field_name(p2)); case ORDER_FREQ: return field_freq(p2)-field_freq(p1); } return p2-p1; // keep order } public: KeySorter(GBDATA *gb_key_data) { key_count = 0; field_count = 0; key = NULp; for (GBDATA *gb_key = GB_child(gb_key_data); gb_key; gb_key = GB_nextChild(gb_key)) { key_count++; } if (key_count) { ARB_alloc(key, key_count); int container_count = 0; for (GBDATA *gb_key = GB_child(gb_key_data); gb_key; gb_key = GB_nextChild(gb_key)) { GBDATA *gb_type = GB_entry(gb_key, CHANGEKEY_TYPE); GB_TYPES type = GB_TYPES(GB_read_int(gb_type)); if (type == GB_DB) { // move containers behind fields key[key_count-1-container_count++] = gb_key; } else { key[field_count++] = gb_key; } } ui_assert((container_count+field_count) == key_count); reverse_order(field_count, key_count-1); // of containers } order_changed = false; } ~KeySorter() { ui_assert(!order_changed); // order changed but not written free(key); } int get_field_count() const { return field_count; } void bubble_sort(int p1, int p2, ReorderMode mode, BoundItemSel *selector) { if (p1>p2) std::swap(p1, p2); if (legal_field_pos(p1, p2)) { if (mode == ORDER_FREQ) { sort_progress = new arb_progress("Calculating field frequencies", long(p2-p1+1)); } bitem_selector = selector; while (p1p1) { if (compare(i-1, i, mode)>0) { swap(i-1, i); changed = true; } --i; } if (!changed) break; ++p1; } if (order_hash) { GBS_free_hash(order_hash); order_hash = NULp; } if (sort_progress) { delete sort_progress; sort_progress = NULp; } } } void reverse_order(int p1, int p2) { if (p1>p2) std::swap(p1, p2); if (legal_field_pos(p1, p2)) while (p1wanted_position) { swap(to_move, to_move-1); to_move--; } } } __ATTR__USERESULT GB_ERROR save_changes() { GB_ERROR warning = NULp; if (order_changed) { if (key_count) { GBDATA *gb_main = GB_get_root(key[0]); warning = GB_resort_data_base(gb_main, key, key_count); } order_changed = false; } return warning; } }; GB_HASH *KeySorter::order_hash = NULp; BoundItemSel *KeySorter::bitem_selector = NULp; arb_progress *KeySorter::sort_progress = NULp; static void reorder_keys(AW_window *aws, ReorderMode mode, Itemfield_Selection *sel_left, Itemfield_Selection *sel_right) { ItemSelector& selector = sel_left->get_selector(); ui_assert(&selector == &sel_right->get_selector()); int left_index = sel_left->get_sellist()->get_index_of_selected(); int right_index = sel_right->get_sellist()->get_index_of_selected(); GB_ERROR warning = NULp; GBDATA *gb_main = sel_left->get_gb_main(); AW_root *awr = aws->get_root(); init_itemtype_specific_DBUI_awars(awr, selector); GB_begin_transaction(gb_main); GBDATA *gb_left_field = GBT_get_changekey(gb_main, awr->awar(itemAwar(AWAR_FIELD_REORDER_SOURCE_TMPL, selector))->read_char_pntr(), selector.change_key_path); GBDATA *gb_right_field = GBT_get_changekey(gb_main, awr->awar(itemAwar(AWAR_FIELD_REORDER_DEST_TMPL, selector))->read_char_pntr(), selector.change_key_path); if (!gb_left_field || !gb_right_field || gb_left_field == gb_right_field) { warning = "Please select different fields in both list"; } else { GBDATA *gb_key_data = GB_search(gb_main, selector.change_key_path, GB_CREATE_CONTAINER); KeySorter sorter(gb_key_data); int left_key_idx = sorter.index_of(gb_left_field); int right_key_idx = sorter.index_of(gb_right_field); switch (mode) { case RIGHT_BEHIND_LEFT: sorter.move_to(right_key_idx, left_key_idx+(left_key_idxleft_index) { left_index++; right_index++; } // make it simple to move several consecutive keys break; case REVERSE_ORDER: sorter.reverse_order(left_key_idx, right_key_idx); std::swap(left_index, right_index); break; default: { BoundItemSel bis(gb_main, selector); sorter.bubble_sort(left_key_idx, right_key_idx, mode, &bis); break; } } warning = sorter.save_changes(); } GB_commit_transaction(gb_main); if (warning) { aw_message(warning); } else { sel_left->get_sellist()->select_element_at(left_index); sel_right->get_sellist()->select_element_at(right_index); } } static void reorder_right_behind_left(AW_window *aws, Itemfield_Selection *selleft, Itemfield_Selection *selright) { reorder_keys(aws, RIGHT_BEHIND_LEFT, selleft, selright); } static void reverse_key_order (AW_window *aws, Itemfield_Selection *selleft, Itemfield_Selection *selright) { reorder_keys(aws, REVERSE_ORDER, selleft, selright); } static void sort_keys(AW_window *aws, Itemfield_Selection *selleft, Itemfield_Selection *selright) { ReorderMode mode = ReorderMode(aws->get_root()->awar(AWAR_FIELD_REORDER_ORDER)->read_int()); reorder_keys(aws, mode, selleft, selright); } static void reorder_up_down(AW_window *aws, Itemfield_Selection *sel_right, int dir) { GBDATA *gb_main = sel_right->get_gb_main(); GB_begin_transaction(gb_main); ItemSelector& selector = sel_right->get_selector(); int list_index = sel_right->get_sellist()->get_index_of_selected(); const char *field_name = aws->get_root()->awar(itemAwar(AWAR_FIELD_REORDER_DEST_TMPL, selector))->read_char_pntr(); GBDATA *gb_field = GBT_get_changekey(gb_main, field_name, selector.change_key_path); GB_ERROR warning = NULp; if (!gb_field) { warning = "Please select the item to move in the right box"; } else { GBDATA *gb_key_data = GB_search(gb_main, selector.change_key_path, GB_CREATE_CONTAINER); KeySorter sorter(gb_key_data); int curr_index = sorter.index_of(gb_field); int dest_index = -1; if (abs(dir) == 1) { dest_index = curr_index+dir; list_index = -1; } else { dest_index = dir<0 ? 0 : sorter.get_field_count()-1; } sorter.move_to(curr_index, dest_index); warning = sorter.save_changes(); } GB_commit_transaction(gb_main); if (list_index >= 0) sel_right->get_sellist()->select_element_at(list_index); if (warning) aw_message(warning); } AW_window *DBUI::create_fields_reorder_window(AW_root *root, BoundItemSel *bound_selector) { ItemSelector& selector = bound_selector->selector; AW_window_simple *aws = new AW_window_simple; init_itemtype_specific_DBUI_awars(root, selector); init_itemType_specific_window(root, aws, selector, "REORDER_FIELDS", "Reorder %s fields", false); aws->load_xfig("ad_kreo.fig"); aws->at("close"); aws->callback(AW_POPDOWN); aws->create_button("CLOSE", "Close", "C"); aws->at("help"); const char *HELPFILE = "spaf_reorder.hlp"; aws->callback(makeHelpCallback(HELPFILE)); aws->create_button("HELP", "Help", "H"); Itemfield_Selection *sel1 = create_itemfield_selection_list(aws, FieldSelDef(itemAwar(AWAR_FIELD_REORDER_SOURCE_TMPL, selector), bound_selector->gb_main, selector, FIELD_UNFILTERED), "source"); Itemfield_Selection *sel2 = create_itemfield_selection_list(aws, FieldSelDef(itemAwar(AWAR_FIELD_REORDER_DEST_TMPL, selector), bound_selector->gb_main, selector, FIELD_UNFILTERED), "dest"); aws->button_length(8); aws->at("sort"); aws->callback(makeWindowCallback(sort_keys, sel1, sel2)); aws->help_text(HELPFILE); aws->create_button("SORT", "Sort by"); aws->at("sorttype"); aws->create_option_menu(AWAR_FIELD_REORDER_ORDER); aws->insert_option("name", "a", ORDER_ALPHA); aws->insert_option("type", "t", ORDER_TYPE); aws->insert_option("frequency", "f", ORDER_FREQ); aws->update_option_menu(); aws->at("leftright"); aws->callback(makeWindowCallback(reorder_right_behind_left, sel1, sel2)); aws->help_text(HELPFILE); aws->create_autosize_button("MOVE_RIGHT_BEHIND_LEFT", "Move right\nbehind left"); aws->at("reverse"); aws->callback(makeWindowCallback(reverse_key_order, sel1, sel2)); aws->help_text(HELPFILE); aws->create_autosize_button("REVERSE", "Reverse"); aws->button_length(6); struct { const char *tag; const char *macro; int dir; } reorder[4] = { { "Top", "MOVE_TOP_RIGHT", -2 }, { "Up", "MOVE_UP_RIGHT", -1 }, { "Down", "MOVE_DOWN_RIGHT", +1 }, { "Bottom", "MOVE_BOT_RIGHT", +2 }, }; for (int i = 0; i<4; ++i) { aws->at(reorder[i].tag); aws->callback(makeWindowCallback(reorder_up_down, sel2, reorder[i].dir)); aws->help_text(HELPFILE); aws->create_button(reorder[i].macro, reorder[i].tag); } return aws; } static void hide_field_cb(AW_window *aws, Itemfield_Selection *item_sel, int hide) { GBDATA *gb_main = item_sel->get_gb_main(); GB_ERROR error = GB_begin_transaction(gb_main); if (!error) { ItemSelector& selector = item_sel->get_selector(); char *source = aws->get_root()->awar(itemAwar(AWAR_FIELD_DELETE_TMPL, selector))->read_string(); GBDATA *gb_source = GBT_get_changekey(gb_main, source, selector.change_key_path); if (!gb_source) error = "Please select the field you want to (un)hide"; else error = GBT_write_int(gb_source, CHANGEKEY_HIDDEN, hide); free(source); } GB_end_transaction_show_error(gb_main, error, aw_message); if (!error) item_sel->get_sellist()->move_selection(1); } static void field_delete_cb(AW_window *aws, Itemfield_Selection *item_sel) { GBDATA *gb_main = item_sel->get_gb_main(); GB_ERROR error = GB_begin_transaction(gb_main); if (!error) { ItemSelector& selector = item_sel->get_selector(); char *source = aws->get_root()->awar(itemAwar(AWAR_FIELD_DELETE_TMPL, selector))->read_string(); AW_selection_list *sellist = item_sel->get_sellist(); int curr_index = sellist->get_index_of_selected(); GBDATA *gb_source = GBT_get_changekey(gb_main, source, selector.change_key_path); if (!gb_source) error = "Please select the field you want to delete"; else error = GB_delete(gb_source); for (GBDATA *gb_item_container = selector.get_first_item_container(gb_main, aws->get_root(), QUERY_ALL_ITEMS); !error && gb_item_container; gb_item_container = selector.get_next_item_container(gb_item_container, QUERY_ALL_ITEMS)) { for (GBDATA * gb_item = selector.get_first_item(gb_item_container, QUERY_ALL_ITEMS); !error && gb_item; gb_item = selector.get_next_item(gb_item, QUERY_ALL_ITEMS)) { GBDATA *gbd = GB_search(gb_item, source, GB_FIND); if (gbd) { error = GB_delete(gbd); if (!error) { // item has disappeared, this selects the next one: sellist->select_element_at(curr_index); } } } } free(source); } GB_end_transaction_show_error(gb_main, error, aw_message); } AW_window *DBUI::create_field_delete_window(AW_root *root, BoundItemSel *bound_selector) { ItemSelector& selector = bound_selector->selector; AW_window_simple *aws = new AW_window_simple; init_itemtype_specific_DBUI_awars(root, selector); init_itemType_specific_window(root, aws, selector, "DELETE_FIELD", "Delete %s field", false); aws->load_xfig("ad_delof.fig"); aws->button_length(6); aws->at("close"); aws->callback(AW_POPDOWN); aws->create_button("CLOSE", "Close", "C"); aws->at("help"); aws->callback(makeHelpCallback("spaf_delete.hlp")); aws->create_button("HELP", "Help", "H"); Itemfield_Selection *item_sel = create_itemfield_selection_list(aws, FieldSelDef(itemAwar(AWAR_FIELD_DELETE_TMPL, selector), bound_selector->gb_main, selector, FIELD_UNFILTERED, "field", SF_HIDDEN), "source"); aws->button_length(13); aws->at("hide"); aws->callback(makeWindowCallback(hide_field_cb, item_sel, 1)); aws->create_button("HIDE_FIELD", "Hide field", "H"); aws->at("unhide"); aws->callback(makeWindowCallback(hide_field_cb, item_sel, 0)); aws->create_button("UNHIDE_FIELD", "Unhide field", "U"); aws->at("delf"); aws->callback(makeWindowCallback(field_delete_cb, item_sel)); aws->create_button("DELETE_FIELD", "Delete field\n(data deleted)", "C"); return aws; } static void field_create_cb(AW_window *aws, BoundItemSel *bound_selector) { ItemSelector& selector = bound_selector->selector; GB_push_transaction(bound_selector->gb_main); char *name = aws->get_root()->awar(itemAwar(AWAR_FIELD_CREATE_NAME_TMPL, selector))->read_string(); GB_ERROR error = GB_check_key(name); GB_ERROR error2 = GB_check_hkey(name); if (error && !error2) { aw_message("Warning: Your key contain a '/' character,\n" " that means it is a hierarchical key"); error = NULp; } GB_TYPES type = GB_TYPES(aws->get_root()->awar(itemAwar(AWAR_FIELD_CREATE_TYPE_TMPL, selector))->read_int()); if (!error) error = GBT_add_new_changekey_to_keypath(bound_selector->gb_main, name, type, selector.change_key_path); aws->hide_or_notify(error); free(name); GB_pop_transaction(bound_selector->gb_main); } inline void insert_fieldtype_toggles(AW_window *aws) { aws->insert_toggle("Ascii text", "s", (int)GB_STRING); aws->insert_toggle("Rounded numerical", "i", (int)GB_INT); aws->insert_toggle("Floating-point n.", "F", (int)GB_FLOAT); aws->insert_toggle("Bitmask (0/1)", "B", (int)GB_BITS); // keep in sync with ../ITEMS/item_sel_list.cxx@FIELD_TYPE_DESCRIPTIONS } AW_window *DBUI::create_field_create_window(AW_root *root, BoundItemSel *bound_selector) { ItemSelector& selector = bound_selector->selector; AW_window_simple *aws = new AW_window_simple; init_itemtype_specific_DBUI_awars(root, selector); init_itemType_specific_window(root, aws, selector, "CREATE_FIELD", "Create new %s field", false); aws->load_xfig("ad_fcrea.fig"); aws->at("close"); aws->callback(AW_POPDOWN); aws->create_button("CLOSE", "Close", "C"); aws->at("input"); aws->label("FIELD NAME"); aws->create_input_field(itemAwar(AWAR_FIELD_CREATE_NAME_TMPL, selector), 15); aws->at("type"); aws->create_toggle_field(itemAwar(AWAR_FIELD_CREATE_TYPE_TMPL, selector), "FIELD TYPE"); insert_fieldtype_toggles(aws); aws->update_toggle_field(); aws->at("ok"); aws->callback(makeWindowCallback(field_create_cb, bound_selector)); aws->create_button("CREATE", "Create", "C"); return aws; } static void field_convert_commit_cb(AW_window *aws, BoundItemSel *bound_selector) { AW_root *root = aws->get_root(); GBDATA *gb_main = bound_selector->gb_main; GB_push_transaction(gb_main); ItemSelector& selector = bound_selector->selector; // @@@ GBT_convert_changekey currently only works for species fields, make it work with genes/exp/... as well => pass selector into GBT_convert_changekey GB_ERROR error = GBT_convert_changekey(gb_main, root->awar(itemAwar(AWAR_FIELD_CONVERT_SOURCE_TMPL, selector))->read_char_pntr(), (GB_TYPES)root->awar(itemAwar(AWAR_FIELD_CONVERT_TYPE_TMPL, selector))->read_int()); GB_end_transaction_show_error(gb_main, error, aw_message); } static void field_convert_update_typesel_cb(AW_root *root, BoundItemSel *bound_selector) { ItemSelector& selector = bound_selector->selector; int type; { GBDATA *gb_main = bound_selector->gb_main; GB_transaction ta(gb_main); type = GBT_get_type_of_changekey(gb_main, root->awar(itemAwar(AWAR_FIELD_CONVERT_SOURCE_TMPL, selector))->read_char_pntr(), selector.change_key_path); } root->awar(itemAwar(AWAR_FIELD_CONVERT_TYPE_TMPL, selector))->write_int(type); } static AW_window *create_field_convert_window(AW_root *root, BoundItemSel *bound_selector) { ItemSelector& selector = bound_selector->selector; AW_window_simple *aws = new AW_window_simple; init_itemtype_specific_DBUI_awars(root, selector); init_itemType_specific_window(root, aws, selector, "CONVERT_FIELD", "Convert %s field", false); aws->load_xfig("ad_conv.fig"); aws->at("close"); aws->callback(AW_POPDOWN); aws->create_button("CLOSE", "Close", "C"); aws->at("help"); aws->callback(makeHelpCallback("spaf_convert.hlp")); aws->create_button("HELP", "Help", "H"); const char *awarname_field = itemAwar(AWAR_FIELD_CONVERT_SOURCE_TMPL, selector); root->awar(awarname_field)->add_callback(makeRootCallback(field_convert_update_typesel_cb, bound_selector)); create_itemfield_selection_list(aws, FieldSelDef(awarname_field, bound_selector->gb_main, selector, FIELD_FILTER_STRING_READABLE, "field", SF_SHOW_TYPE), "source"); aws->at("typesel"); aws->create_toggle_field(itemAwar(AWAR_FIELD_CONVERT_TYPE_TMPL, selector)); insert_fieldtype_toggles(aws); aws->update_toggle_field(); aws->at("convert"); aws->callback(makeWindowCallback(field_convert_commit_cb, bound_selector)); aws->create_button("CONVERT", "Convert", "T"); return aws; } void DBUI::insert_field_admin_menuitems(AW_window *aws, GBDATA *gb_main) { static BoundItemSel *bis = new BoundItemSel(gb_main, SPECIES_get_selector()); ui_assert(bis->gb_main == gb_main); aws->insert_menu_topic(aws->local_id("spec_reorder_fields"), "Reorder fields ...", "R", "spaf_reorder.hlp", AWM_ALL, makeCreateWindowCallback(create_fields_reorder_window, bis)); aws->insert_menu_topic(aws->local_id("spec_delete_field"), "Delete/Hide fields ...", "D", "spaf_delete.hlp", AWM_EXP, makeCreateWindowCallback(create_field_delete_window, bis)); aws->insert_menu_topic(aws->local_id("spec_create_field"), "Create fields ...", "C", "spaf_create.hlp", AWM_ALL, makeCreateWindowCallback(create_field_create_window, bis)); aws->insert_menu_topic(aws->local_id("spec_convert_field"), "Convert fields ...", "t", "spaf_convert.hlp", AWM_EXP, makeCreateWindowCallback(create_field_convert_window, bis)); aws->sep______________(); aws->insert_menu_topic("spec_unhide_fields", "Show all hidden fields", "S", "scandb.hlp", AWM_ALL, makeWindowCallback(species_field_selection_list_unhide_all_cb, gb_main)); aws->insert_menu_topic("spec_refresh_fields", "Refresh fields", "f", "scandb.hlp", AWM_ALL, makeWindowCallback(species_field_selection_list_update_cb, gb_main)); } inline int get_and_fix_range_from_awar(AW_awar *awar) { const char *input = awar->read_char_pntr(); int bpos = atoi(input); int ipos; if (bpos>0) { awar->write_string(GBS_global_string("%i", bpos)); ipos = bio2info(bpos); } else { ipos = -1; awar->write_string(""); } return ipos; } class NN_GlobalData { DbQuery *query; AW_selection_list *resultList; // result list from create_next_neighbours_selected_window() public: NN_GlobalData() : query(NULp), resultList(NULp) {} void set_query(DbQuery *new_query) { if (new_query != query) { ui_assert(!query); // need redesign b4 changing query works query = new_query; } } void set_result_list(AW_selection_list *new_resultList) { if (new_resultList != resultList) { ui_assert(!resultList); // need redesign b4 changing query works resultList = new_resultList; } } DbQuery *get_query() const { ui_assert(query); return query; } AW_selection_list *get_result_list() const { ui_assert(resultList); return resultList; } GBDATA *get_gb_main() const { return query_get_gb_main(get_query()); } }; static NN_GlobalData NN_GLOBAL; static PosRange get_nn_range_from_awars(AW_root *aw_root) { int start = get_and_fix_range_from_awar(aw_root->awar(AWAR_NN_RANGE_START)); int end = get_and_fix_range_from_awar(aw_root->awar(AWAR_NN_RANGE_END)); return PosRange(start, end); } inline char *read_sequence_region(GBDATA *gb_data, const PosRange& range) { return range.dup_corresponding_part(GB_read_char_pntr(gb_data), GB_read_count(gb_data)); } static void awtc_nn_search_all_listed(AW_window *aww) { DbQuery *query = NN_GLOBAL.get_query(); GBDATA *gb_main = query_get_gb_main(query); ui_assert(speciesOrOrganism(get_queried_itemtype(query).type)); GB_begin_transaction(gb_main); long queriedCount = count_queried_items(query, QUERY_ALL_ITEMS); GB_ERROR error = queriedCount ? NULp : "No species listed in query"; const char *dest_field = NULp; AW_root *aw_root = aww->get_root(); if (!error) { dest_field = prepare_and_get_selected_itemfield(aw_root, AWAR_NN_LISTED_DEST_FIELD, gb_main, get_queried_itemtype(query)); error = dest_field ? NULp : GB_await_error(); } if (!error) { arb_progress progress("Searching next neighbours", queriedCount); progress.auto_subtitles("Species"); int pts = aw_root->awar(AWAR_PROBE_ADMIN_PT_SERVER)->read_int(); char *ali_name = aw_root->awar(AWAR_DEFAULT_ALIGNMENT)->read_string(); int oligo_len = aw_root->awar(AWAR_NN_OLIGO_LEN)->read_int(); int mismatches = aw_root->awar(AWAR_NN_MISMATCHES)->read_int(); bool fast_mode = aw_root->awar(AWAR_NN_FAST_MODE)->read_int(); bool rel_matches = aw_root->awar(AWAR_NN_REL_MATCHES)->read_int(); int wanted_entries = aw_root->awar(AWAR_NN_MAX_HITS)->read_int(); bool scored_entries = aw_root->awar(AWAR_NN_LISTED_SCORED_ENTRIES)->read_int(); float min_score = aw_root->awar(AWAR_NN_MIN_SCORE)->read_float(); FF_complement compl_mode = static_cast(aw_root->awar(AWAR_NN_COMPLEMENT)->read_int()); RelativeScoreScaling rel_scaling = static_cast(aw_root->awar(AWAR_NN_REL_SCALING)->read_int()); PosRange org_range = get_nn_range_from_awars(aw_root); for (GBDATA *gb_species = GBT_first_species(gb_main); !error && gb_species; gb_species = GBT_next_species(gb_species)) { if (!IS_QUERIED(gb_species, query)) continue; GBDATA *gb_data = GBT_find_sequence(gb_species, ali_name); if (gb_data) { PosRange range = org_range; // modified by read_sequence_region char *sequence = read_sequence_region(gb_data, range); PT_FamilyFinder ff(gb_main, pts, oligo_len, mismatches, fast_mode, rel_matches, rel_scaling); ff.restrict_2_region(range); error = ff.searchFamily(sequence, compl_mode, wanted_entries, min_score); if (!error) { const FamilyList *fm = ff.getFamilyList(); GBS_strstruct *value = NULp; while (fm) { const char *thisValue = NULp; if (rel_matches) { ui_assert((fm->rel_matches*100) >= min_score); // filtered by ptserver thisValue = scored_entries ? GBS_global_string("%.1f%%:%s", fm->rel_matches*100, fm->name) : fm->name; } else { ui_assert(fm->matches >= min_score); // filtered by ptserver thisValue = scored_entries ? GBS_global_string("%li:%s", fm->matches, fm->name) : fm->name; } if (thisValue) { if (!value) { // first entry value = new GBS_strstruct(1000); } else { value->put(';'); } value->cat(thisValue); } fm = fm->next; } if (value) { ui_assert(GBT_get_type_of_changekey(gb_main, dest_field, CHANGE_KEY_PATH) == GB_STRING); GBDATA *gb_dest = GB_search(gb_species, dest_field, GB_STRING); error = GB_write_string(gb_dest, value->get_data()); delete value; } else { GBDATA *gb_dest = GB_search(gb_species, dest_field, GB_FIND); if (gb_dest) error = GB_delete(gb_dest); } } free(sequence); } progress.inc_and_check_user_abort(error); } free(ali_name); } GB_end_transaction_show_error(gb_main, error, aw_message); } static void awtc_mark_hits(AW_window *) { AW_selection_list *resultList = NN_GLOBAL.get_result_list(); GB_HASH *list_hash = resultList->to_hash(false); GBDATA *gb_main = NN_GLOBAL.get_gb_main(); GB_transaction ta(gb_main); for (GBDATA *gb_species = GBT_first_species(gb_main); gb_species; gb_species = GBT_next_species(gb_species)) { int hit = GBS_read_hash(list_hash, GBT_get_name_or_description(gb_species)); GB_write_flag(gb_species, hit); } } static void awtc_nn_search(AW_window *) { AW_root *aw_root = AW_root::SINGLETON; GBDATA *gb_main = NN_GLOBAL.get_gb_main(); GB_ERROR error = NULp; PosRange range = get_nn_range_from_awars(aw_root); char *sequence = NULp; { GB_transaction ta(gb_main); char *sel_species = aw_root->awar(AWAR_SPECIES_NAME)->read_string(); GBDATA *gb_species = GBT_find_species(gb_main, sel_species); if (!gb_species) { error = "Select a species first"; } else { char *ali_name = aw_root->awar(AWAR_DEFAULT_ALIGNMENT)->read_string(); GBDATA *gb_data = GBT_find_sequence(gb_species, ali_name); if (gb_data) { sequence = read_sequence_region(gb_data, range); } else { error = GBS_global_string("Species '%s' has no sequence '%s'", sel_species, ali_name); } free(ali_name); } free(sel_species); } int pts = aw_root->awar(AWAR_PROBE_ADMIN_PT_SERVER)->read_int(); int oligo_len = aw_root->awar(AWAR_NN_OLIGO_LEN)->read_int(); int mismatches = aw_root->awar(AWAR_NN_MISMATCHES)->read_int(); bool fast_mode = aw_root->awar(AWAR_NN_FAST_MODE)->read_int(); bool rel_matches = aw_root->awar(AWAR_NN_REL_MATCHES)->read_int(); float min_score = aw_root->awar(AWAR_NN_MIN_SCORE)->read_float(); RelativeScoreScaling rel_scaling = static_cast(aw_root->awar(AWAR_NN_REL_SCALING)->read_int()); PT_FamilyFinder ff(gb_main, pts, oligo_len, mismatches, fast_mode, rel_matches, rel_scaling); ff.restrict_2_region(range); int max_hits = 0; // max wanted hits if (!error) { FF_complement compl_mode = static_cast(aw_root->awar(AWAR_NN_COMPLEMENT)->read_int()); max_hits = aw_root->awar(AWAR_NN_MAX_HITS)->read_int(); error = ff.searchFamily(sequence, compl_mode, max_hits, min_score); } // update result list { AW_selection_list* sel = NN_GLOBAL.get_result_list(); sel->clear(); int hits = 0; if (error) { aw_message(error); sel->insert_default("", ""); } else { int count = 1; int shownHits = max_hits>0 ? max_hits : ff.getRealHits(); int numWidth = log(shownHits)/log(10)+1; for (const FamilyList *fm = ff.getFamilyList(); fm; fm = fm->next) { const char *dis; if (rel_matches) { dis = GBS_global_string("#%0*i %-12s Rel.hits: %5.1f%%", numWidth, count, fm->name, fm->rel_matches*100); } else { dis = GBS_global_string("#%0*i %-12s Hits: %4li", numWidth, count, fm->name, fm->matches); } sel->insert(dis, fm->name); count++; } sel->insert_default(ff.hits_were_truncated() ? "" : "", ""); hits = ff.getRealHits(); } aw_root->awar(AWAR_NN_SELECTED_HIT_COUNT)->write_int(hits); if (aw_root->awar(AWAR_NN_SELECTED_AUTO_MARK)->read_int()) { awtc_mark_hits(NULp); aw_root->awar(AWAR_TREE_REFRESH)->touch(); } sel->update(); } free(sequence); } static void awtc_move_hits(AW_window *aww) { AW_root *aw_root = aww->get_root(); char *current_species = aw_root->awar(AWAR_SPECIES_NAME)->read_string(); if (!current_species) current_species = strdup(""); char *hit_description = GBS_global_string_copy("", current_species); copy_selection_list_2_query_box(NN_GLOBAL.get_query(), NN_GLOBAL.get_result_list(), hit_description); free(hit_description); free(current_species); } static bool autosearch_triggered = false; static unsigned nn_perform_delayed_autosearch_cb(AW_root*) { awtc_nn_search(NULp); autosearch_triggered = false; return 0; } static void nn_trigger_delayed_autosearch_cb(AW_root *awr) { // automatic search is triggered delayed to make sure // dependencies between involved awars have propagated. if (!autosearch_triggered) { // ignore multiple triggers (happens when multiple awars change, e.g. when loading config) autosearch_triggered = true; awr->add_timed_callback(200, makeTimedCallback(nn_perform_delayed_autosearch_cb)); } } static void nn_auto_search_changed_cb(AW_root *awr) { int auto_search = awr->awar(AWAR_NN_SELECTED_AUTO_SEARCH)->read_int(); AW_awar *awar_sel_species = awr->awar(AWAR_SPECIES_NAME); if (auto_search) { awar_sel_species->add_callback(nn_trigger_delayed_autosearch_cb); nn_trigger_delayed_autosearch_cb(awr); } else { awar_sel_species->remove_callback(nn_trigger_delayed_autosearch_cb); } } static AW_window *nn_of_sel_win = NULp; static void nn_searchRel_awar_changed_cb(AW_root *awr) { int auto_search = awr->awar(AWAR_NN_SELECTED_AUTO_SEARCH)->read_int(); if (auto_search && nn_of_sel_win && nn_of_sel_win->is_shown()) // do not trigger if window is not shown { nn_trigger_delayed_autosearch_cb(awr); } } static void create_next_neighbours_vars(AW_root *aw_root) { static bool created = false; if (!created) { RootCallback searchRel_awar_changed_cb = makeRootCallback(nn_searchRel_awar_changed_cb); aw_root->awar_int(AWAR_PROBE_ADMIN_PT_SERVER)->add_callback(searchRel_awar_changed_cb); aw_root->awar_int(AWAR_NN_COMPLEMENT, FF_FORWARD)->add_callback(searchRel_awar_changed_cb); aw_root->awar_string(AWAR_NN_RANGE_START, "")->add_callback(searchRel_awar_changed_cb); aw_root->awar_string(AWAR_NN_RANGE_END, "")->add_callback(searchRel_awar_changed_cb); aw_root->awar_int (AWAR_NN_MAX_HITS, 10)->set_minmax(0, 1000)->add_callback(searchRel_awar_changed_cb);; aw_root->awar_float (AWAR_NN_MIN_SCORE, 80)->set_minmax(0, 200)->add_callback(searchRel_awar_changed_cb);; aw_root->awar_int(AWAR_NN_SELECTED_HIT_COUNT, 0); aw_root->awar_int(AWAR_NN_SELECTED_AUTO_SEARCH, 0)->add_callback(nn_auto_search_changed_cb); aw_root->awar_int(AWAR_NN_SELECTED_AUTO_MARK, 0); aw_root->awar_string(AWAR_NN_LISTED_DEST_FIELD, "tmp"); aw_root->awar_int (AWAR_NN_LISTED_SCORED_ENTRIES, 1); AWTC_create_common_next_neighbour_vars(aw_root, searchRel_awar_changed_cb); created = true; } } static AWT_config_mapping_def next_neighbour_config_mapping[] = { // same as ../FAST_ALIGNER/fast_aligner.cxx@RELATIVES_CONFIG { AWAR_NN_OLIGO_LEN, "oligolen" }, { AWAR_NN_MISMATCHES, "mismatches" }, { AWAR_NN_FAST_MODE, "fastmode" }, { AWAR_NN_REL_MATCHES, "relmatches" }, { AWAR_NN_REL_SCALING, "relscaling" }, { AWAR_NN_COMPLEMENT, "complement" }, { AWAR_NN_RANGE_START, "rangestart" }, { AWAR_NN_RANGE_END, "rangeend" }, { AWAR_NN_MAX_HITS, "maxhits" }, { AWAR_NN_MIN_SCORE, "minscore" }, { NULp, NULp } }; static void setup_next_neighbour_config(AWT_config_definition& cdef, bool for_listed) { // fields common for 'listed' and 'selected' cdef.add(next_neighbour_config_mapping); if (for_listed) { cdef.add(AWAR_NN_LISTED_SCORED_ENTRIES, "addscore"); } else { cdef.add(AWAR_NN_SELECTED_AUTO_SEARCH, "autosearch"); cdef.add(AWAR_NN_SELECTED_AUTO_MARK, "automark"); } } static void create_common_next_neighbour_fields(AW_window *aws, bool for_listed) { aws->at("pt_server"); awt_create_PTSERVER_selection_button(aws, AWAR_PROBE_ADMIN_PT_SERVER); const int SCALER_LENGTH = 200; aws->auto_space(5, 5); AWTC_create_common_next_neighbour_fields(aws, SCALER_LENGTH); aws->at("range"); aws->create_input_field(AWAR_NN_RANGE_START, 6); aws->create_input_field(AWAR_NN_RANGE_END, 6); aws->at("compl"); aws->create_option_menu(AWAR_NN_COMPLEMENT); aws->insert_default_option("forward", "", FF_FORWARD); aws->insert_option ("reverse", "", FF_REVERSE); aws->insert_option ("complement", "", FF_COMPLEMENT); aws->insert_option ("reverse-complement", "", FF_REVERSE_COMPLEMENT); aws->insert_option ("fwd + rev-compl", "", FF_FORWARD|FF_REVERSE_COMPLEMENT); aws->insert_option ("rev + compl", "", FF_REVERSE|FF_COMPLEMENT); aws->insert_option ("any", "", FF_FORWARD|FF_REVERSE|FF_COMPLEMENT|FF_REVERSE_COMPLEMENT); aws->update_option_menu(); aws->at("results"); aws->create_input_field_with_scaler(AWAR_NN_MAX_HITS, 5, SCALER_LENGTH, AW_SCALER_EXP_LOWER); aws->at("min_score"); aws->create_input_field_with_scaler(AWAR_NN_MIN_SCORE, 5, SCALER_LENGTH, AW_SCALER_LINEAR); aws->at("config"); AWT_insert_config_manager(aws, AW_ROOT_DEFAULT, "next_neighbours", makeConfigSetupCallback(setup_next_neighbour_config, for_listed)); } static AW_window *create_next_neighbours_listed_window(AW_root *aw_root, DbQuery *query) { static AW_window_simple *aws = NULp; NN_GLOBAL.set_query(query); if (!aws) { create_next_neighbours_vars(aw_root); aws = new AW_window_simple; aws->init(aw_root, "SEARCH_NEXT_NEIGHBOURS_OF_LISTED", "Search Next Neighbours of Listed"); aws->load_xfig("ad_spec_nnm.fig"); aws->at("close"); aws->callback(AW_POPDOWN); aws->create_button("CLOSE", "Close", "C"); aws->at("help"); aws->callback(makeHelpCallback("next_neighbours_listed.hlp")); aws->create_button("HELP", "Help", "H"); create_common_next_neighbour_fields(aws, true); aws->at("add_score"); aws->create_toggle(AWAR_NN_LISTED_SCORED_ENTRIES); aws->at("field"); create_itemfield_selection_button(aws, FieldSelDef(AWAR_NN_LISTED_DEST_FIELD, query_get_gb_main(query), SPECIES_get_selector(), FIELD_FILTER_STRING_WRITEABLE, "target field", SF_ALLOW_NEW), "field"); aws->at("go"); aws->callback(awtc_nn_search_all_listed); aws->button_length(10); aws->create_button("WRITE_FIELDS", "GO"); } return aws; } static AW_window *create_next_neighbours_selected_window(AW_root *aw_root, DbQuery *query) { static AW_window_simple *aws = NULp; NN_GLOBAL.set_query(query); if (!aws) { create_next_neighbours_vars(aw_root); aws = new AW_window_simple; aws->init(aw_root, "SEARCH_NEXT_RELATIVE_OF_SELECTED", "Search Next Neighbours of Selected"); aws->load_xfig("ad_spec_nn.fig"); aws->at("close"); aws->callback(AW_POPDOWN); aws->create_button("CLOSE", "Close", "C"); aws->at("help"); aws->callback(makeHelpCallback("next_neighbours.hlp")); aws->create_button("HELP", "Help", "H"); create_common_next_neighbour_fields(aws, false); aws->button_length(10); aws->at("hit_count"); aws->create_button(NULp, AWAR_NN_SELECTED_HIT_COUNT, NULp, "+"); aws->at("hits"); AW_selection_list *resultList = aws->create_selection_list(AWAR_SPECIES_NAME); NN_GLOBAL.set_result_list(resultList); resultList->insert_default("No hits found", ""); resultList->update(); aws->at("go"); aws->callback(awtc_nn_search); aws->create_button("SEARCH", "Search"); aws->at("auto_go"); aws->label("Auto search on change"); aws->create_toggle(AWAR_NN_SELECTED_AUTO_SEARCH); aws->at("mark"); aws->callback(awtc_mark_hits); aws->create_autosize_button("MARK_HITS", "Mark hits"); aws->at("auto_mark"); aws->label("Auto"); aws->create_toggle(AWAR_NN_SELECTED_AUTO_MARK); aws->at("move"); aws->callback(awtc_move_hits); aws->create_autosize_button("MOVE_TO_HITLIST", "Move to hitlist"); nn_of_sel_win = aws; // store current window (to disable auto search when this window was popped down) } return aws; } // --------------------------------------------- // species/organism specific callbacks static AW_window *popup_new_speciesOrganismWindow(AW_root *aw_root, GBDATA *gb_main, bool organismWindow, int detach_id); static void popup_detached_speciesOrganismWindow(AW_window *aw_parent, const InfoWindow *infoWin) { const InfoWindow *reusable = InfoWindowRegistry::infowin.find_reusable_of_same_type_as(*infoWin); if (reusable) { reusable->reuse(); } else { // create a new window if none is reusable popup_new_speciesOrganismWindow(aw_parent->get_root(), infoWin->get_gbmain(), infoWin->mapsOrganism(), InfoWindowRegistry::infowin.allocate_detach_id(*infoWin)); } } static AW_window *popup_new_speciesOrganismWindow(AW_root *aw_root, GBDATA *gb_main, bool organismWindow, int detach_id) { // INFO_WINDOW_CREATOR // if detach_id is MAIN_WINDOW -> create main window (not detached) AW_window_simple_menu *aws = new AW_window_simple_menu; const ItemSelector& itemType = organismWindow ? ORGANISM_get_selector() : SPECIES_get_selector(); init_info_window(aw_root, aws, itemType, detach_id); aws->load_xfig("ad_spec.fig"); aws->button_length(8); aws->at("close"); aws->callback(AW_POPDOWN); aws->create_button("CLOSE", "Close", "C"); aws->at("search"); aws->callback(makeCreateWindowCallback(DBUI::create_species_query_window, gb_main)); aws->create_autosize_button("SEARCH", "Search...", "S"); aws->at("help"); aws->callback(makeHelpCallback(detach_id ? "sp_info_locked.hlp" : "sp_info.hlp")); // uses_hlp_res("sp_info_locked.hlp", "sp_info.hlp"); see ../../SOURCE_TOOLS/check_resources.pl@uses_hlp_res aws->create_button("HELP", "Help", "H"); DbScanner *scanner = DbScanner::create(gb_main, InfoWindowRegistry::localize_scanner_id(organismWindow ? "organism" : "species", detach_id), aws, "box", "field", "enable", DB_KEYVIEWER, "mark", itemType); const InfoWindow& infoWin = InfoWindowRegistry::infowin.registerInfoWindow(aws, scanner, detach_id); if (infoWin.is_maininfo()) { if (organismWindow) aws->create_menu("ORGANISM", "O", AWM_ALL); else aws->create_menu("SPECIES", "S", AWM_ALL); aws->insert_menu_topic("species_delete", "Delete", "D", "spa_delete.hlp", AWM_ALL, makeWindowCallback(species_delete_cb, gb_main)); aws->insert_menu_topic("species_rename", "Rename", "R", "spa_rename.hlp", AWM_ALL, makeWindowCallback(species_rename_cb, gb_main)); aws->insert_menu_topic("species_copy", "Copy", "y", "spa_copy.hlp", AWM_ALL, makeWindowCallback(species_copy_cb, gb_main)); aws->insert_menu_topic("species_create", "Create", "C", "spa_create.hlp", AWM_ALL, makeWindowCallback(species_create_cb, gb_main)); aws->sep______________(); aws->insert_menu_topic("species_convert_2_sai", "Convert to SAI", "S", "sp_sp_2_ext.hlp", AWM_ALL, makeWindowCallback(move_species_to_extended, gb_main)); } aws->create_menu("FIELDS", "F", AWM_ALL); insert_field_admin_menuitems(aws, gb_main); aws->at("detach"); infoWin.add_detach_area(popup_detached_speciesOrganismWindow); aws->show(); infoWin.attach_selected_item(); return aws; } static void popup_speciesOrganismWindow(AW_root *aw_root, GBDATA *gb_main, bool organismWindow) { int windowIdx = (int)organismWindow; static AW_window *AWS[2] = { NULp, NULp }; if (!AWS[windowIdx]) { AWS[windowIdx] = popup_new_speciesOrganismWindow(aw_root, gb_main, organismWindow, InfoWindow::MAIN_WINDOW); } else { InfoWindowRegistry::reactivate(AWS[windowIdx]); } } void DBUI::popup_species_info_window (AW_root *aw_root, GBDATA *gb_main) { popup_speciesOrganismWindow(aw_root, gb_main, false); } void DBUI::popup_organism_info_window(AW_root *aw_root, GBDATA *gb_main) { popup_speciesOrganismWindow(aw_root, gb_main, true); } static DbQuery *GLOBAL_species_query = NULp; // @@@ fix design void DBUI::unquery_all() { QUERY::unquery_all(NULp, GLOBAL_species_query); } void DBUI::query_update_list() { DbQuery_update_list(GLOBAL_species_query); } AW_window *DBUI::create_species_query_window(AW_root *aw_root, GBDATA *gb_main) { static AW_window_simple_menu *aws = NULp; if (!aws) { aws = new AW_window_simple_menu; aws->init(aw_root, "SPECIES_QUERY", "SEARCH and QUERY"); aws->create_menu("More functions", "f"); aws->load_xfig("ad_query.fig"); query_spec awtqs(SPECIES_get_selector()); awtqs.gb_main = gb_main; awtqs.species_name = AWAR_SPECIES_NAME; awtqs.tree_name = AWAR_TREE; awtqs.select_bit = GB_USERFLAG_QUERY; awtqs.ere_pos_fig = "ere2"; awtqs.by_pos_fig = "by2"; awtqs.qbox_pos_fig = "qbox"; awtqs.key_pos_fig = NULp; awtqs.query_pos_fig = "content"; awtqs.result_pos_fig = "result"; awtqs.count_pos_fig = "count"; awtqs.do_query_pos_fig = "doquery"; awtqs.config_pos_fig = "doconfig"; awtqs.do_mark_pos_fig = "domark"; awtqs.do_unmark_pos_fig = "dounmark"; awtqs.do_mark_nt_pos_fig = "domark_nt"; awtqs.do_unmark_nt_pos_fig = "dounmark_nt"; awtqs.do_delete_pos_fig = "dodelete"; awtqs.do_set_pos_fig = "doset"; awtqs.do_refresh_pos_fig = "dorefresh"; awtqs.popup_info_window = popup_species_info_window; DbQuery *query = create_query_box(aws, &awtqs, "spec"); GLOBAL_species_query = query; aws->create_menu("More search", "s"); aws->insert_menu_topic("spec_search_equal_fields_within_db", "Search For Equal Fields and Mark Duplicates", "E", "search_duplicates.hlp", AWM_ALL, makeWindowCallback (search_duplicated_field_content, query, false)); aws->insert_menu_topic("spec_search_equal_words_within_db", "Search For Equal Words Between Fields and Mark Duplicates", "W", "search_duplicates.hlp", AWM_ALL, makeWindowCallback (search_duplicated_field_content, query, true)); aws->insert_menu_topic("spec_search_next_relativ_of_sel", "Search Next Relatives of SELECTED Species in PT_Server ...", "R", "next_neighbours.hlp", AWM_ALL, makeCreateWindowCallback(create_next_neighbours_selected_window, query)); aws->insert_menu_topic("spec_search_next_relativ_of_listed", "Search Next Relatives of LISTED Species in PT_Server ...", "L", "next_neighbours_listed.hlp", AWM_ALL, makeCreateWindowCallback(create_next_neighbours_listed_window, query)); aws->button_length(7); aws->at("close"); aws->callback(AW_POPDOWN); aws->create_button("CLOSE", "Close", "C"); aws->at("help"); aws->callback(makeHelpCallback("sp_search.hlp")); aws->create_button("HELP", "Help", "H"); } return aws; }