source: branches/species/SL/DB_UI/ui_species.cxx

Last change on this file was 19691, checked in by westram, 2 weeks ago
  • reintegrates 'macros' into 'trunk'
    • fixes macro IDs for mergetool (completing #870).
      • most common problem:
        • several modules were reused (twice) for items of same type, but in different databases.
        • auto-generated IDs were identical.
  • adds: log:branches/macros@19667:19690
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 59.7 KB
Line 
1// =============================================================== //
2//                                                                 //
3//   File      : ui_species.cxx                                    //
4//   Purpose   :                                                   //
5//                                                                 //
6//   Institute of Microbiology (Technical University Munich)       //
7//   http://www.arb-home.de/                                       //
8//                                                                 //
9// =============================================================== //
10
11#include "dbui.h"
12
13#include <awtc_next_neighbours.hxx>
14#include <probe_gui.hxx>
15#include <item_sel_list.h>
16#include <info_window.h>
17#include <db_query.h>
18
19#include <sel_boxes.hxx>
20#include <config_manager.hxx>
21#include <prompt.hxx>
22
23#include <AW_rename.hxx>
24
25#include <aw_awar_defs.hxx>
26#include <aw_root.hxx>
27#include <aw_msg.hxx>
28#include <aw_question.hxx>
29
30#include <arb_defs.h>
31#include <arb_strbuf.h>
32#include <arb_progress.h>
33
34#include <algorithm>
35#include <cmath>
36#include <map>
37
38using namespace DBUI;
39using namespace QUERY;
40
41#define ui_assert(cond) arb_assert(cond)
42
43// awars shared between different itemtypes:
44#define AWAR_FIELD_REORDER_ORDER "tmp/adreorder/order"
45
46// separate awars for different itemtypes:
47#define AWAR_FIELD_REORDER_SOURCE_TMPL "tmp/adreorder/%s/source"
48#define AWAR_FIELD_REORDER_DEST_TMPL   "tmp/adreorder/%s/dest"
49#define AWAR_FIELD_CREATE_NAME_TMPL    "tmp/adfield/%s/name"
50#define AWAR_FIELD_CREATE_TYPE_TMPL    "tmp/adfield/%s/type"
51#define AWAR_FIELD_DELETE_TMPL         "tmp/adfield/%s/source"
52#define AWAR_FIELD_CONVERT_SOURCE_TMPL "tmp/adconvert/%s/source"
53#define AWAR_FIELD_CONVERT_TYPE_TMPL   "tmp/adconvert/%s/type"
54
55// next neighbours of listed and selected:
56// more defined in ../../AWTC/awtc_next_neighbours.hxx@AWAR_NN_BASE
57#define AWAR_NN_COMPLEMENT  AWAR_NN_BASE "complement"
58#define AWAR_NN_RANGE_START AWAR_NN_BASE "range_start"
59#define AWAR_NN_RANGE_END   AWAR_NN_BASE "range_end"
60#define AWAR_NN_MIN_SCORE   AWAR_NN_BASE "min_scored"
61#define AWAR_NN_MAX_HITS    AWAR_NN_BASE "max_hits"
62
63// next neighbours of selected only:
64#define AWAR_NN_BASE_SELECTED        AWAR_NN_BASE "selected/"
65#define AWAR_NN_SELECTED_HIT_COUNT   "tmp/" AWAR_NN_BASE_SELECTED "hit_count"
66#define AWAR_NN_SELECTED_AUTO_SEARCH "tmp/" AWAR_NN_BASE_SELECTED "auto_search"
67#define AWAR_NN_SELECTED_AUTO_MARK   "tmp/" AWAR_NN_BASE_SELECTED "auto_mark"
68
69// next neighbours of listed only:
70#define AWAR_NN_BASE_LISTED           AWAR_NN_BASE "listed/"
71#define AWAR_NN_LISTED_DEST_FIELD     AWAR_NN_BASE_LISTED "dest_field"
72#define AWAR_NN_LISTED_SCORED_ENTRIES AWAR_NN_BASE_LISTED "scored_entries"
73
74enum ReorderMode {
75    // real orders
76    ORDER_ALPHA,
77    ORDER_TYPE,
78    ORDER_FREQ,
79
80    // special modes
81    RIGHT_BEHIND_LEFT,
82    REVERSE_ORDER,
83};
84
85void DBUI::create_dbui_awars(AW_root *aw_root) {
86    aw_root->awar_int(AWAR_FIELD_REORDER_ORDER, ORDER_ALPHA, AW_ROOT_DEFAULT);
87}
88
89inline const char *itemAwar(const char *name_template, ItemSelector& itype) {
90    return GBS_global_string(name_template, itype.item_name);
91}
92static void init_itemtype_specific_DBUI_awars(AW_root *aw_root, ItemSelector& itype) {
93    static bool initialized[QUERY_ITEM_TYPES] = { false };
94
95    if (!initialized[itype.type]) {
96        aw_root->awar_string(itemAwar(AWAR_FIELD_REORDER_SOURCE_TMPL, itype), "",          AW_ROOT_DEFAULT);
97        aw_root->awar_string(itemAwar(AWAR_FIELD_REORDER_DEST_TMPL,   itype), "",          AW_ROOT_DEFAULT);
98        aw_root->awar_string(itemAwar(AWAR_FIELD_CREATE_NAME_TMPL,    itype), "",          AW_ROOT_DEFAULT);
99        aw_root->awar_int   (itemAwar(AWAR_FIELD_CREATE_TYPE_TMPL,    itype), GB_STRING,   AW_ROOT_DEFAULT);
100        aw_root->awar_string(itemAwar(AWAR_FIELD_DELETE_TMPL,         itype), "",          AW_ROOT_DEFAULT);
101        aw_root->awar_string(itemAwar(AWAR_FIELD_CONVERT_SOURCE_TMPL, itype), "",          AW_ROOT_DEFAULT);
102        aw_root->awar_int   (itemAwar(AWAR_FIELD_CONVERT_TYPE_TMPL,   itype), GB_STRING,   AW_ROOT_DEFAULT);
103
104        initialized[itype.type] = true;
105    }
106}
107
108static void move_species_to_extended(AW_window *aww, GBDATA *gb_main) {
109    char     *source = aww->get_root()->awar(AWAR_SPECIES_NAME)->read_string();
110    GB_ERROR  error  = GB_begin_transaction(gb_main);
111
112    if (!error) {
113        GBDATA *gb_sai_data     = GBT_get_SAI_data(gb_main);
114        if (!gb_sai_data) error = GB_await_error();
115        else {
116            GBDATA *gb_species = GBT_find_species(gb_main, source);
117            GBDATA *gb_dest    = GBT_find_SAI_rel_SAI_data(gb_sai_data, source);
118
119            if (gb_dest) error = GBS_global_string("SAI '%s' already exists", source);
120            else if (gb_species) {
121                gb_dest             = GB_create_container(gb_sai_data, "extended");
122                if (!gb_dest) error = GB_await_error();
123                else {
124                    error = GB_copy_dropProtectMarksAndTempstate(gb_dest, gb_species);
125                    if (!error) {
126                        error = GB_delete(gb_species);
127                        if (!error) aww->get_root()->awar(AWAR_SPECIES_NAME)->write_string("");
128                    }
129                }
130            }
131            else error = "Please select a species";
132        }
133    }
134    GB_end_transaction_show_error(gb_main, error, aw_message);
135    free(source);
136}
137
138
139static GB_ERROR species_create_handler(const char *dest, GBDATA *gb_main) {
140    GB_ERROR error = NULp;
141    if (dest[0]) {
142        error = GB_begin_transaction(gb_main);
143        if (!error) {
144            GBDATA *gb_species_data     = GBT_get_species_data(gb_main);
145            if (!gb_species_data) error = GB_await_error();
146            else {
147                GBDATA *gb_dest = GBT_find_species_rel_species_data(gb_species_data, dest);
148
149                if (gb_dest) error = GBS_global_string("Species '%s' already exists", dest);
150                else {
151                    gb_dest             = GBT_find_or_create_species_rel_species_data(gb_species_data, dest, true);
152                    if (!gb_dest) error = GB_await_error();
153                    else AW_root::SINGLETON->awar(AWAR_SPECIES_NAME)->write_string(dest);
154                }
155            }
156        }
157        error = GB_end_transaction(gb_main, error);
158    }
159    else {
160        error = "Please enter a name for the new species";
161    }
162    return error;
163}
164
165static void species_create_cb(AW_window *, GBDATA *gb_main) {
166    AWT_activate_prompt("Create new species", "Enter shortname (ID) of new species:", "", "Create", makeResultHandler(species_create_handler, gb_main), "spa_create.hlp");
167}
168
169static GBDATA *expect_species_selected(AW_root *aw_root, GBDATA *gb_main, char **give_name = NULp) {
170    GB_transaction  ta(gb_main);
171    char           *name       = aw_root->awar(AWAR_SPECIES_NAME)->read_string();
172    GBDATA         *gb_species = GBT_find_species(gb_main, name);
173
174    if (!gb_species) {
175        if (name && name[0]) aw_message(GBS_global_string("Species '%s' does not exist.", name));
176        else aw_message("Please select a species first");
177    }
178
179    if (give_name) *give_name = name;
180    else free(name);
181
182    return gb_species;
183}
184
185static void species_copy_cb(AW_window *aww, GBDATA *gb_main) {
186    AW_root *aw_root    = aww->get_root();
187    char    *name;
188    GBDATA  *gb_species = expect_species_selected(aw_root, gb_main, &name);
189
190    if (gb_species) {
191        GB_transaction      ta(gb_main);
192        GBDATA             *gb_species_data = GB_get_father(gb_species);
193        UniqueNameDetector  und(gb_species_data);
194        GB_ERROR            error           = NULp;
195        char               *copy_name       = AWTC_makeUniqueShortName(GBS_global_string("c%s", name), und);
196
197        if (!copy_name) error = GB_await_error();
198        else {
199            GBDATA *gb_new_species = GB_create_container(gb_species_data, "species");
200
201            if (!gb_new_species) error = GB_await_error();
202            else {
203                error = GB_copy_dropProtectMarksAndTempstate(gb_new_species, gb_species);
204                if (!error) {
205                    error = GBT_write_string(gb_new_species, "name", copy_name);
206                    if (!error) aw_root->awar(AWAR_SPECIES_NAME)->write_string(copy_name); // set focus
207                }
208            }
209
210            free(copy_name);
211        }
212        if (error) {
213            error = ta.close(error);
214            aw_message(error);
215        }
216    }
217}
218
219static GB_ERROR species_rename_handler(const char *new_fullname, GBDATA *gb_species) {
220    GB_transaction  ta(gb_species);
221
222    GBDATA     *gb_full_name = GB_search(gb_species, "full_name", GB_STRING);
223    const char *old_fullname = GB_read_char_pntr(gb_full_name);
224
225    GB_ERROR error = NULp;
226    if (strcmp(old_fullname, new_fullname) == 0) {
227        error = "[nothing changed]";
228    }
229    else {
230        error = GB_write_string(gb_full_name, new_fullname);
231    }
232
233    if (!error) {
234        AW_root *awr    = AW_root::SINGLETON;
235        bool recreateID = ARB_in_expert_mode(awr) && // never re-create ID in novice mode
236            aw_ask_sure("recreate_name_field",
237                        "Regenerate species identifier ('name')?\n"
238                        "(only do this if you know what you're doing)");
239        if (recreateID) {
240            arb_progress progress("Regenerating species ID", 1L);
241            error = AWTC_recreate_name(gb_species);
242            if (!error) awr->awar(AWAR_SPECIES_NAME)->write_string(null2empty(GBT_get_name(gb_species))); // set focus
243        }
244    }
245
246    error = ta.close(error);
247
248    return error;
249}
250static void species_rename_cb(AW_window *aww, GBDATA *gb_main) {
251    AW_root *aw_root    = aww->get_root();
252    GBDATA  *gb_species = expect_species_selected(aw_root, gb_main);
253
254    if (gb_species) {
255        const char *full_name;
256        {
257            GB_transaction  ta(gb_main);
258            GBDATA         *gb_full_name = GB_search(gb_species, "full_name", GB_STRING);
259
260            full_name = gb_full_name ? GB_read_char_pntr(gb_full_name) : "";
261        }
262        AWT_activate_prompt("Rename species", "Modify 'full_name' of species:", full_name, "Rename", makeResultHandler(species_rename_handler, gb_species), "spa_rename.hlp");
263    }
264}
265
266static void species_delete_cb(AW_window *aww, GBDATA *gb_main) {
267    AW_root  *aw_root    = aww->get_root();
268    char     *name;
269    GBDATA   *gb_species = expect_species_selected(aw_root, gb_main, &name);
270    GB_ERROR  error      = NULp;
271
272    if (!gb_species) {
273        error = "Please select a species first";
274    }
275    else if (aw_ask_sure("info_delete_species", GBS_global_string("Are you sure to delete the species '%s'?", name))) {
276        GB_transaction ta(gb_main);
277        error = GB_delete(gb_species);
278        error = ta.close(error);
279        if (!error) aw_root->awar(AWAR_SPECIES_NAME)->write_string("");
280    }
281
282    if (error) aw_message(error);
283    free(name);
284}
285
286static long count_field_occurrence(BoundItemSel *bsel, const char *field_name) {
287    QUERY_RANGE   RANGE = QUERY_ALL_ITEMS;
288    long          count = 0;
289    ItemSelector& sel   = bsel->selector;
290
291    for (GBDATA *gb_container = sel.get_first_item_container(bsel->gb_main, NULp, RANGE);
292         gb_container;
293         gb_container = sel.get_next_item_container(gb_container, RANGE))
294    {
295        for (GBDATA *gb_item = sel.get_first_item(gb_container, RANGE);
296             gb_item;
297             gb_item = sel.get_next_item(gb_item, RANGE))
298        {
299            GBDATA *gb_field = GB_entry(gb_item, field_name);
300            if (gb_field) ++count;
301        }
302    }
303    return count;
304}
305
306class KeySorter : virtual Noncopyable {
307    int      key_count;
308    GBDATA **key;
309
310    int field_count; // = key_count - container_count
311
312    bool order_changed;
313
314    // helper variables for sorting
315    static GB_HASH      *order_hash;
316    static BoundItemSel *bitem_selector;
317    static arb_progress *sort_progress;
318
319    bool legal_pos(int p) { return p >= 0 && p<key_count; }
320    bool legal_field_pos(int p) const { return p >= 0 && p<field_count; }
321    bool legal_field_pos(int p1, int p2) const { return legal_field_pos(p1) && legal_field_pos(p2); }
322
323    void swap(int p1, int p2) {
324        ui_assert(legal_pos(p1));
325        ui_assert(legal_pos(p2));
326
327        GBDATA *k = key[p1];
328        key[p1]   = key[p2];
329        key[p2]   = k;
330
331        order_changed = true;
332    }
333
334    const char *field_name(int p) const {
335        GBDATA *gb_key_name = GB_entry(key[p], "key_name");
336        if (gb_key_name) return GB_read_char_pntr(gb_key_name);
337        return NULp;
338    }
339    GB_TYPES field_type(int p) const {
340        GBDATA *gb_key_type = GB_entry(key[p], "key_type");
341        if (gb_key_type) return GB_TYPES(GB_read_int(gb_key_type));
342        return GB_NONE;
343    }
344    int field_freq(int p) const {
345        const char *name            = field_name(p);
346        if (!order_hash) order_hash = GBS_create_hash(key_count, GB_IGNORE_CASE);
347
348        long freq = GBS_read_hash(order_hash, name);
349        if (!freq) {
350            freq = 1+count_field_occurrence(bitem_selector, name);
351            GBS_write_hash(order_hash, name, freq);
352            if (sort_progress) sort_progress->inc();
353        }
354        return freq;
355    }
356
357    int compare(int p1, int p2, ReorderMode mode) {
358        switch (mode) {
359            case RIGHT_BEHIND_LEFT:
360            case REVERSE_ORDER:
361                ui_assert(0); // illegal ReorderMode
362                break;
363
364            case ORDER_TYPE:  return field_type(p2)-field_type(p1);
365            case ORDER_ALPHA: return strcasecmp(field_name(p1), field_name(p2));
366            case ORDER_FREQ:  return field_freq(p2)-field_freq(p1);
367        }
368        return p2-p1; // keep order
369    }
370
371public:
372    KeySorter(GBDATA *gb_key_data) {
373        key_count   = 0;
374        field_count = 0;
375        key         = NULp;
376
377        for (GBDATA *gb_key = GB_child(gb_key_data); gb_key; gb_key = GB_nextChild(gb_key)) {
378            key_count++;
379        }
380
381        if (key_count) {
382            ARB_alloc(key, key_count);
383
384            int container_count = 0;
385            for (GBDATA *gb_key = GB_child(gb_key_data); gb_key; gb_key = GB_nextChild(gb_key)) {
386                GBDATA   *gb_type = GB_entry(gb_key, CHANGEKEY_TYPE);
387                GB_TYPES  type    = GB_TYPES(GB_read_int(gb_type));
388
389                if (type == GB_DB) { // move containers behind fields
390                    key[key_count-1-container_count++] = gb_key;
391                }
392                else {
393                    key[field_count++] = gb_key;
394                }
395            }
396            ui_assert((container_count+field_count) == key_count);
397            reverse_order(field_count, key_count-1); // of containers
398        }
399        order_changed = false;
400    }
401    ~KeySorter() {
402        ui_assert(!order_changed); // order changed but not written
403        free(key);
404    }
405
406    int get_field_count() const { return field_count; }
407
408    void bubble_sort(int p1, int p2, ReorderMode mode, BoundItemSel *selector) {
409        if (p1>p2) std::swap(p1, p2);
410        if (legal_field_pos(p1, p2)) {
411            if (mode == ORDER_FREQ) {
412                sort_progress = new arb_progress("Calculating field frequencies", long(p2-p1+1));
413            }
414            bitem_selector = selector;
415            while (p1<p2) {
416                bool changed = false;
417
418                int i = p2;
419                while (i>p1) {
420                    if (compare(i-1, i, mode)>0) {
421                        swap(i-1, i);
422                        changed = true;
423                    }
424                    --i;
425                }
426                if (!changed) break;
427                ++p1;
428            }
429            if (order_hash) {
430                GBS_free_hash(order_hash);
431                order_hash = NULp;
432            }
433            if (sort_progress) {
434                delete sort_progress;
435                sort_progress = NULp;
436            }
437        }
438    }
439    void reverse_order(int p1, int p2) {
440        if (p1>p2) std::swap(p1, p2);
441        if (legal_field_pos(p1, p2)) while (p1<p2) swap(p1++, p2--);
442    }
443
444    int index_of(GBDATA *gb_key) {
445        int i;
446        for (i = 0; i<key_count; i++) {
447            if (gb_key == key[i]) break;
448        }
449        if (i == key_count) {
450            ui_assert(0);
451            i = -1;
452        }
453        return i;
454    }
455
456    void move_to(int to_move, int wanted_position) {
457        if (legal_field_pos(to_move, wanted_position)) {
458            while (to_move<wanted_position) {
459                swap(to_move, to_move+1);
460                to_move++;
461            }
462            while (to_move>wanted_position) {
463                swap(to_move, to_move-1);
464                to_move--;
465            }
466        }
467    }
468
469    __ATTR__USERESULT GB_ERROR save_changes() {
470        GB_ERROR warning = NULp;
471        if (order_changed) {
472            if (key_count) {
473                GBDATA *gb_main = GB_get_root(key[0]);
474                warning         = GB_resort_data_base(gb_main, key, key_count);
475            }
476            order_changed = false;
477        }
478        return warning;
479    }
480};
481
482GB_HASH      *KeySorter::order_hash     = NULp;
483BoundItemSel *KeySorter::bitem_selector = NULp;
484arb_progress *KeySorter::sort_progress  = NULp;
485
486static void reorder_keys(AW_window *aws, ReorderMode mode, Itemfield_Selection *sel_left, Itemfield_Selection *sel_right) {
487    ItemSelector& selector = sel_left->get_selector();
488    ui_assert(&selector == &sel_right->get_selector());
489
490    int left_index  = sel_left->get_sellist()->get_index_of_selected();
491    int right_index = sel_right->get_sellist()->get_index_of_selected();
492
493    GB_ERROR warning = NULp;
494
495    GBDATA  *gb_main = sel_left->get_gb_main();
496    AW_root *awr     = aws->get_root();
497
498    init_itemtype_specific_DBUI_awars(awr, selector);
499
500    GB_begin_transaction(gb_main);
501
502    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);
503    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);
504
505    if (!gb_left_field || !gb_right_field || gb_left_field == gb_right_field) {
506        warning = "Please select different fields in both list";
507    }
508    else {
509        GBDATA    *gb_key_data = GB_search(gb_main, selector.change_key_path, GB_CREATE_CONTAINER);
510        KeySorter  sorter(gb_key_data);
511
512        int left_key_idx  = sorter.index_of(gb_left_field);
513        int right_key_idx = sorter.index_of(gb_right_field);
514
515        switch (mode) {
516            case RIGHT_BEHIND_LEFT:
517                sorter.move_to(right_key_idx, left_key_idx+(left_key_idx<right_key_idx));
518                if (right_index>left_index) { left_index++; right_index++; } // make it simple to move several consecutive keys
519                break;
520            case REVERSE_ORDER:
521                sorter.reverse_order(left_key_idx, right_key_idx);
522                std::swap(left_index, right_index);
523                break;
524            default: {
525                BoundItemSel bis(gb_main, selector);
526                sorter.bubble_sort(left_key_idx, right_key_idx, mode, &bis);
527                break;
528            }
529        }
530
531        warning = sorter.save_changes();
532    }
533    GB_commit_transaction(gb_main);
534
535    if (warning) {
536        aw_message(warning);
537    }
538    else {
539        sel_left->get_sellist()->select_element_at(left_index);
540        sel_right->get_sellist()->select_element_at(right_index);
541    }
542}
543
544static void reorder_right_behind_left(AW_window *aws, Itemfield_Selection *selleft, Itemfield_Selection *selright) { reorder_keys(aws, RIGHT_BEHIND_LEFT, selleft, selright); }
545static void reverse_key_order        (AW_window *aws, Itemfield_Selection *selleft, Itemfield_Selection *selright) { reorder_keys(aws, REVERSE_ORDER,     selleft, selright); }
546
547static void sort_keys(AW_window *aws, Itemfield_Selection *selleft, Itemfield_Selection *selright) {
548    ReorderMode mode = ReorderMode(aws->get_root()->awar(AWAR_FIELD_REORDER_ORDER)->read_int());
549    reorder_keys(aws, mode, selleft, selright);
550}
551
552static void reorder_up_down(AW_window *aws, Itemfield_Selection *sel_right, int dir) {
553    GBDATA *gb_main = sel_right->get_gb_main();
554
555    GB_begin_transaction(gb_main);
556    ItemSelector& selector   = sel_right->get_selector();
557    int           list_index = sel_right->get_sellist()->get_index_of_selected();
558
559    const char *field_name = aws->get_root()->awar(itemAwar(AWAR_FIELD_REORDER_DEST_TMPL, selector))->read_char_pntr();
560    GBDATA     *gb_field   = GBT_get_changekey(gb_main, field_name, selector.change_key_path);
561    GB_ERROR    warning    = NULp;
562
563    if (!gb_field) {
564        warning = "Please select the item to move in the right box";
565    }
566    else {
567        GBDATA    *gb_key_data = GB_search(gb_main, selector.change_key_path, GB_CREATE_CONTAINER);
568        KeySorter  sorter(gb_key_data);
569
570        int curr_index = sorter.index_of(gb_field);
571        int dest_index = -1;
572        if (abs(dir) == 1) {
573            dest_index = curr_index+dir;
574            list_index = -1;
575        }
576        else {
577            dest_index = dir<0 ? 0 : sorter.get_field_count()-1;
578        }
579
580        sorter.move_to(curr_index, dest_index);
581        warning = sorter.save_changes();
582
583    }
584
585    GB_commit_transaction(gb_main);
586    if (list_index >= 0) sel_right->get_sellist()->select_element_at(list_index);
587    if (warning) aw_message(warning);
588}
589
590AW_window *DBUI::create_fields_reorder_window(AW_root *root, BoundItemSel *bound_selector) {
591    ItemSelector&     selector = bound_selector->selector;
592    AW_window_simple *aws      = new AW_window_simple;
593
594    init_itemtype_specific_DBUI_awars(root, selector);
595    init_itemType_specific_window(root, aws, selector, "REORDER_FIELDS", "Reorder %s fields", false);
596    aws->load_xfig("ad_kreo.fig");
597
598    aws->at("close");
599    aws->callback(AW_POPDOWN);
600    aws->create_button("CLOSE", "Close", "C");
601
602    aws->at("help");
603    const char *HELPFILE = "spaf_reorder.hlp";
604    aws->callback(makeHelpCallback(HELPFILE));
605    aws->create_button("HELP", "Help", "H");
606
607    Itemfield_Selection *sel1 = create_itemfield_selection_list(aws, FieldSelDef(itemAwar(AWAR_FIELD_REORDER_SOURCE_TMPL, selector), bound_selector->gb_main, selector, FIELD_UNFILTERED), "source");
608    Itemfield_Selection *sel2 = create_itemfield_selection_list(aws, FieldSelDef(itemAwar(AWAR_FIELD_REORDER_DEST_TMPL,   selector), bound_selector->gb_main, selector, FIELD_UNFILTERED), "dest");
609
610    aws->button_length(8);
611
612    aws->at("sort");
613    aws->callback(makeWindowCallback(sort_keys, sel1, sel2));
614    aws->help_text(HELPFILE);
615    aws->create_button("SORT", "Sort by");
616
617    aws->at("sorttype");
618    aws->create_option_menu(AWAR_FIELD_REORDER_ORDER);
619    aws->insert_option("name",      "a", ORDER_ALPHA);
620    aws->insert_option("type",      "t", ORDER_TYPE);
621    aws->insert_option("frequency", "f", ORDER_FREQ);
622    aws->update_option_menu();
623
624    aws->at("leftright");
625    aws->callback(makeWindowCallback(reorder_right_behind_left, sel1, sel2));
626    aws->help_text(HELPFILE);
627    aws->create_autosize_button("MOVE_RIGHT_BEHIND_LEFT", "Move right\nbehind left");
628
629    aws->at("reverse");
630    aws->callback(makeWindowCallback(reverse_key_order, sel1, sel2));
631    aws->help_text(HELPFILE);
632    aws->create_autosize_button("REVERSE", "Reverse");
633
634    aws->button_length(6);
635    struct {
636        const char *tag;
637        const char *macro;
638        int         dir;
639    } reorder[4] = {
640        { "Top",    "MOVE_TOP_RIGHT",  -2 },
641        { "Up",     "MOVE_UP_RIGHT",   -1 },
642        { "Down",   "MOVE_DOWN_RIGHT", +1 },
643        { "Bottom", "MOVE_BOT_RIGHT",  +2 },
644    };
645
646    for (int i = 0; i<4; ++i) {
647        aws->at(reorder[i].tag);
648        aws->callback(makeWindowCallback(reorder_up_down, sel2, reorder[i].dir));
649        aws->help_text(HELPFILE);
650        aws->create_button(reorder[i].macro, reorder[i].tag);
651    }
652
653    return aws;
654}
655
656static void hide_field_cb(AW_window *aws, Itemfield_Selection *item_sel, int hide) {
657    GBDATA   *gb_main = item_sel->get_gb_main();
658    GB_ERROR  error   = GB_begin_transaction(gb_main);
659
660    if (!error) {
661        ItemSelector&  selector  = item_sel->get_selector();
662        char          *source    = aws->get_root()->awar(itemAwar(AWAR_FIELD_DELETE_TMPL, selector))->read_string();
663        GBDATA        *gb_source = GBT_get_changekey(gb_main, source, selector.change_key_path);
664
665        if (!gb_source) error = "Please select the field you want to (un)hide";
666        else error            = GBT_write_int(gb_source, CHANGEKEY_HIDDEN, hide);
667
668        free(source);
669    }
670    GB_end_transaction_show_error(gb_main, error, aw_message);
671    if (!error) item_sel->get_sellist()->move_selection(1);
672}
673
674static void field_delete_cb(AW_window *aws, Itemfield_Selection *item_sel) {
675    GBDATA   *gb_main = item_sel->get_gb_main();
676    GB_ERROR  error   = GB_begin_transaction(gb_main);
677
678    if (!error) {
679        ItemSelector&      selector   = item_sel->get_selector();
680        char              *source     = aws->get_root()->awar(itemAwar(AWAR_FIELD_DELETE_TMPL, selector))->read_string();
681        AW_selection_list *sellist    = item_sel->get_sellist();
682        int                curr_index = sellist->get_index_of_selected();
683        GBDATA            *gb_source  = GBT_get_changekey(gb_main, source, selector.change_key_path);
684
685        if (!gb_source) error = "Please select the field you want to delete";
686        else error            = GB_delete(gb_source);
687
688        for (GBDATA *gb_item_container = selector.get_first_item_container(gb_main, aws->get_root(), QUERY_ALL_ITEMS);
689             !error && gb_item_container;
690             gb_item_container = selector.get_next_item_container(gb_item_container, QUERY_ALL_ITEMS))
691        {
692            for (GBDATA * gb_item = selector.get_first_item(gb_item_container, QUERY_ALL_ITEMS);
693                 !error && gb_item;
694                 gb_item = selector.get_next_item(gb_item, QUERY_ALL_ITEMS))
695            {
696                GBDATA *gbd = GB_search(gb_item, source, GB_FIND);
697
698                if (gbd) {
699                    error = GB_delete(gbd);
700                    if (!error) {
701                        // item has disappeared, this selects the next one:
702                        sellist->select_element_at(curr_index);
703                    }
704                }
705            }
706        }
707
708        free(source);
709    }
710
711    GB_end_transaction_show_error(gb_main, error, aw_message);
712}
713
714
715AW_window *DBUI::create_field_delete_window(AW_root *root, BoundItemSel *bound_selector) {
716    ItemSelector&     selector = bound_selector->selector;
717    AW_window_simple *aws      = new AW_window_simple;
718
719    init_itemtype_specific_DBUI_awars(root, selector);
720    init_itemType_specific_window(root, aws, selector, "DELETE_FIELD", "Delete %s field", false);
721    aws->load_xfig("ad_delof.fig");
722    aws->button_length(6);
723
724    aws->at("close"); aws->callback(AW_POPDOWN);
725    aws->create_button("CLOSE", "Close", "C");
726
727    aws->at("help"); aws->callback(makeHelpCallback("spaf_delete.hlp"));
728    aws->create_button("HELP", "Help", "H");
729
730    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");
731
732    aws->button_length(13);
733    aws->at("hide");
734    aws->callback(makeWindowCallback(hide_field_cb, item_sel, 1));
735    aws->create_button("HIDE_FIELD", "Hide field", "H");
736
737    aws->at("unhide");
738    aws->callback(makeWindowCallback(hide_field_cb, item_sel, 0));
739    aws->create_button("UNHIDE_FIELD", "Unhide field", "U");
740
741    aws->at("delf");
742    aws->callback(makeWindowCallback(field_delete_cb, item_sel));
743    aws->create_button("DELETE_FIELD", "Delete field\n(data deleted)", "C");
744
745    return aws;
746}
747
748static void field_create_cb(AW_window *aws, BoundItemSel *bound_selector) {
749    ItemSelector& selector = bound_selector->selector;
750
751    GB_push_transaction(bound_selector->gb_main);
752    char     *name   = aws->get_root()->awar(itemAwar(AWAR_FIELD_CREATE_NAME_TMPL, selector))->read_string();
753    GB_ERROR  error  = GB_check_key(name);
754    GB_ERROR  error2 = GB_check_hkey(name);
755    if (error && !error2) {
756        aw_message("Warning: Your key contain a '/' character,\n"
757                   "    that means it is a hierarchical key");
758        error = NULp;
759    }
760
761    GB_TYPES type = GB_TYPES(aws->get_root()->awar(itemAwar(AWAR_FIELD_CREATE_TYPE_TMPL, selector))->read_int());
762
763    if (!error) error = GBT_add_new_changekey_to_keypath(bound_selector->gb_main, name, type, selector.change_key_path);
764    aws->hide_or_notify(error);
765    free(name);
766    GB_pop_transaction(bound_selector->gb_main);
767}
768
769inline void insert_fieldtype_toggles(AW_window *aws) {
770    aws->insert_toggle("Ascii text",        "s", (int)GB_STRING);
771    aws->insert_toggle("Rounded numerical", "i", (int)GB_INT);
772    aws->insert_toggle("Floating-point n.", "F", (int)GB_FLOAT);
773    aws->insert_toggle("Bitmask (0/1)",     "B", (int)GB_BITS);
774    // keep in sync with ../ITEMS/item_sel_list.cxx@FIELD_TYPE_DESCRIPTIONS
775}
776
777AW_window *DBUI::create_field_create_window(AW_root *root, BoundItemSel *bound_selector) {
778    ItemSelector&     selector = bound_selector->selector;
779    AW_window_simple *aws      = new AW_window_simple;
780
781    init_itemtype_specific_DBUI_awars(root, selector);
782    init_itemType_specific_window(root, aws, selector, "CREATE_FIELD", "Create new %s field", false);
783    aws->load_xfig("ad_fcrea.fig");
784
785    aws->at("close");
786    aws->callback(AW_POPDOWN);
787    aws->create_button("CLOSE", "Close", "C");
788
789    aws->at("input");
790    aws->label("FIELD NAME");
791    aws->create_input_field(itemAwar(AWAR_FIELD_CREATE_NAME_TMPL, selector), 15);
792
793    aws->at("type");
794    aws->create_toggle_field(itemAwar(AWAR_FIELD_CREATE_TYPE_TMPL, selector), "FIELD TYPE");
795    insert_fieldtype_toggles(aws);
796    aws->update_toggle_field();
797
798    aws->at("ok");
799    aws->callback(makeWindowCallback(field_create_cb, bound_selector));
800    aws->create_button("CREATE", "Create", "C");
801
802    return aws;
803}
804
805
806static void field_convert_commit_cb(AW_window *aws, BoundItemSel *bound_selector) {
807    AW_root *root    = aws->get_root();
808    GBDATA  *gb_main = bound_selector->gb_main;
809
810    GB_push_transaction(gb_main);
811    ItemSelector& selector = bound_selector->selector;
812
813    // @@@ GBT_convert_changekey currently only works for species fields, make it work with genes/exp/... as well => pass selector into GBT_convert_changekey
814    GB_ERROR error = GBT_convert_changekey(gb_main,
815                                           root->awar(itemAwar(AWAR_FIELD_CONVERT_SOURCE_TMPL, selector))->read_char_pntr(),
816                                           (GB_TYPES)root->awar(itemAwar(AWAR_FIELD_CONVERT_TYPE_TMPL, selector))->read_int());
817
818    GB_end_transaction_show_error(gb_main, error, aw_message);
819}
820
821static void field_convert_update_typesel_cb(AW_root *root, BoundItemSel *bound_selector) {
822    ItemSelector& selector = bound_selector->selector;
823    int type;
824    {
825        GBDATA         *gb_main = bound_selector->gb_main;
826        GB_transaction  ta(gb_main);
827
828        type = GBT_get_type_of_changekey(gb_main,
829                                         root->awar(itemAwar(AWAR_FIELD_CONVERT_SOURCE_TMPL, selector))->read_char_pntr(),
830                                         selector.change_key_path);
831    }
832
833    root->awar(itemAwar(AWAR_FIELD_CONVERT_TYPE_TMPL, selector))->write_int(type);
834}
835
836static AW_window *create_field_convert_window(AW_root *root, BoundItemSel *bound_selector) {
837    ItemSelector&     selector = bound_selector->selector;
838    AW_window_simple *aws      = new AW_window_simple;
839
840    init_itemtype_specific_DBUI_awars(root, selector);
841    init_itemType_specific_window(root, aws, selector, "CONVERT_FIELD", "Convert %s field", false);
842    aws->load_xfig("ad_conv.fig");
843
844    aws->at("close");
845    aws->callback(AW_POPDOWN);
846    aws->create_button("CLOSE", "Close", "C");
847
848    aws->at("help");
849    aws->callback(makeHelpCallback("spaf_convert.hlp"));
850    aws->create_button("HELP", "Help", "H");
851
852    const char *awarname_field = itemAwar(AWAR_FIELD_CONVERT_SOURCE_TMPL, selector);
853    root->awar(awarname_field)->add_callback(makeRootCallback(field_convert_update_typesel_cb, bound_selector));
854    create_itemfield_selection_list(aws, FieldSelDef(awarname_field, bound_selector->gb_main, selector, FIELD_FILTER_STRING_READABLE, "field", SF_SHOW_TYPE), "source");
855
856    aws->at("typesel");
857    aws->create_toggle_field(itemAwar(AWAR_FIELD_CONVERT_TYPE_TMPL, selector));
858    insert_fieldtype_toggles(aws);
859    aws->update_toggle_field();
860
861    aws->at("convert");
862    aws->callback(makeWindowCallback(field_convert_commit_cb, bound_selector));
863    aws->create_button("CONVERT", "Convert", "T");
864
865    return aws;
866}
867
868void DBUI::insert_field_admin_menuitems(AW_window *aws, GBDATA *gb_main) {
869    static BoundItemSel *bis = new BoundItemSel(gb_main, SPECIES_get_selector());
870    ui_assert(bis->gb_main == gb_main);
871
872    aws->insert_menu_topic(aws->local_id("spec_reorder_fields"), "Reorder fields ...",     "R", "spaf_reorder.hlp", AWM_ALL, makeCreateWindowCallback(create_fields_reorder_window, bis));
873    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));
874    aws->insert_menu_topic(aws->local_id("spec_create_field"),   "Create fields ...",      "C", "spaf_create.hlp",  AWM_ALL, makeCreateWindowCallback(create_field_create_window,   bis));
875    aws->insert_menu_topic(aws->local_id("spec_convert_field"),  "Convert fields ...",     "t", "spaf_convert.hlp", AWM_EXP, makeCreateWindowCallback(create_field_convert_window,  bis));
876    aws->sep______________();
877    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));
878    aws->insert_menu_topic("spec_refresh_fields", "Refresh fields",         "f", "scandb.hlp", AWM_ALL, makeWindowCallback(species_field_selection_list_update_cb,     gb_main));
879}
880
881inline int get_and_fix_range_from_awar(AW_awar *awar) {
882    const char *input = awar->read_char_pntr();
883    int         bpos = atoi(input);
884    int         ipos;
885
886    if (bpos>0) {
887        awar->write_string(GBS_global_string("%i", bpos));
888        ipos = bio2info(bpos);
889    }
890    else {
891        ipos = -1;
892        awar->write_string("");
893    }
894    return ipos;
895}
896
897class NN_GlobalData {
898    DbQuery           *query;
899    AW_selection_list *resultList;     // result list from create_next_neighbours_selected_window()
900
901public:
902    NN_GlobalData() :
903        query(NULp),
904        resultList(NULp)
905    {}
906
907    void set_query(DbQuery *new_query) {
908        if (new_query != query) {
909            ui_assert(!query); // need redesign b4 changing query works
910            query = new_query;
911        }
912    }
913    void set_result_list(AW_selection_list *new_resultList) {
914        if (new_resultList != resultList) {
915            ui_assert(!resultList); // need redesign b4 changing query works
916            resultList = new_resultList;
917        }
918    }
919
920    DbQuery *get_query() const { ui_assert(query); return query; }
921
922    AW_selection_list *get_result_list() const { ui_assert(resultList); return resultList; }
923    GBDATA *get_gb_main() const { return query_get_gb_main(get_query()); }
924};
925static NN_GlobalData NN_GLOBAL;
926
927static PosRange get_nn_range_from_awars(AW_root *aw_root) {
928    int start = get_and_fix_range_from_awar(aw_root->awar(AWAR_NN_RANGE_START));
929    int end   = get_and_fix_range_from_awar(aw_root->awar(AWAR_NN_RANGE_END));
930
931    return PosRange(start, end);
932}
933
934inline char *read_sequence_region(GBDATA *gb_data, const PosRange& range) {
935    return range.dup_corresponding_part(GB_read_char_pntr(gb_data), GB_read_count(gb_data));
936}
937
938static void awtc_nn_search_all_listed(AW_window *aww) {
939    DbQuery *query   = NN_GLOBAL.get_query();
940    GBDATA  *gb_main = query_get_gb_main(query);
941
942    ui_assert(speciesOrOrganism(get_queried_itemtype(query).type));
943
944    GB_begin_transaction(gb_main);
945
946    long        queriedCount = count_queried_items(query, QUERY_ALL_ITEMS);
947    GB_ERROR    error        = queriedCount ? NULp : "No species listed in query";
948    const char *dest_field   = NULp;
949    AW_root    *aw_root      = aww->get_root();
950
951    if (!error) {
952        dest_field = prepare_and_get_selected_itemfield(aw_root, AWAR_NN_LISTED_DEST_FIELD, gb_main, get_queried_itemtype(query));
953        error = dest_field ? NULp : GB_await_error();
954    }
955
956    if (!error) {
957        arb_progress progress("Searching next neighbours", queriedCount);
958        progress.auto_subtitles("Species");
959
960        int    pts            = aw_root->awar(AWAR_PROBE_ADMIN_PT_SERVER)->read_int();
961        char  *ali_name       = aw_root->awar(AWAR_DEFAULT_ALIGNMENT)->read_string();
962        int    oligo_len      = aw_root->awar(AWAR_NN_OLIGO_LEN)->read_int();
963        int    mismatches     = aw_root->awar(AWAR_NN_MISMATCHES)->read_int();
964        bool   fast_mode      = aw_root->awar(AWAR_NN_FAST_MODE)->read_int();
965        bool   rel_matches    = aw_root->awar(AWAR_NN_REL_MATCHES)->read_int();
966        int    wanted_entries = aw_root->awar(AWAR_NN_MAX_HITS)->read_int();
967        bool   scored_entries = aw_root->awar(AWAR_NN_LISTED_SCORED_ENTRIES)->read_int();
968        float  min_score      = aw_root->awar(AWAR_NN_MIN_SCORE)->read_float();
969
970        FF_complement        compl_mode  = static_cast<FF_complement>(aw_root->awar(AWAR_NN_COMPLEMENT)->read_int());
971        RelativeScoreScaling rel_scaling = static_cast<RelativeScoreScaling>(aw_root->awar(AWAR_NN_REL_SCALING)->read_int());
972
973        PosRange org_range = get_nn_range_from_awars(aw_root);
974
975        for (GBDATA *gb_species = GBT_first_species(gb_main);
976             !error && gb_species;
977             gb_species = GBT_next_species(gb_species))
978        {
979            if (!IS_QUERIED(gb_species, query)) continue;
980            GBDATA *gb_data = GBT_find_sequence(gb_species, ali_name);
981            if (gb_data) {
982                PosRange         range    = org_range; // modified by read_sequence_region
983                char            *sequence = read_sequence_region(gb_data, range);
984                PT_FamilyFinder  ff(gb_main, pts, oligo_len, mismatches, fast_mode, rel_matches, rel_scaling);
985
986                ff.restrict_2_region(range);
987
988                error = ff.searchFamily(sequence, compl_mode, wanted_entries, min_score);
989                if (!error) {
990                    const FamilyList *fm = ff.getFamilyList();
991
992                    GBS_strstruct *value = NULp;
993                    while (fm) {
994                        const char *thisValue = NULp;
995                        if (rel_matches) {
996                            ui_assert((fm->rel_matches*100) >= min_score); // filtered by ptserver
997                            thisValue = scored_entries
998                                ? GBS_global_string("%.1f%%:%s", fm->rel_matches*100, fm->name)
999                                : fm->name;
1000                        }
1001                        else {
1002                            ui_assert(fm->matches >= min_score); // filtered by ptserver
1003                            thisValue = scored_entries
1004                                ? GBS_global_string("%li:%s", fm->matches, fm->name)
1005                                : fm->name;
1006                        }
1007
1008                        if (thisValue) {
1009                            if (!value) { // first entry
1010                                value = new GBS_strstruct(1000);
1011                            }
1012                            else {
1013                                value->put(';');
1014                            }
1015                            value->cat(thisValue);
1016                        }
1017
1018                        fm = fm->next;
1019                    }
1020
1021                    if (value) {
1022                        ui_assert(GBT_get_type_of_changekey(gb_main, dest_field, CHANGE_KEY_PATH) == GB_STRING);
1023
1024                        GBDATA *gb_dest = GB_search(gb_species, dest_field, GB_STRING);
1025                        error           = GB_write_string(gb_dest, value->get_data());
1026
1027                        delete value;
1028                    }
1029                    else {
1030                        GBDATA *gb_dest = GB_search(gb_species, dest_field, GB_FIND);
1031                        if (gb_dest) error = GB_delete(gb_dest);
1032                    }
1033                }
1034                free(sequence);
1035            }
1036            progress.inc_and_check_user_abort(error);
1037        }
1038        free(ali_name);
1039    }
1040    GB_end_transaction_show_error(gb_main, error, aw_message);
1041}
1042
1043static void awtc_mark_hits(AW_window *) {
1044    AW_selection_list *resultList = NN_GLOBAL.get_result_list();
1045    GB_HASH           *list_hash  = resultList->to_hash(false);
1046    GBDATA            *gb_main    = NN_GLOBAL.get_gb_main();
1047
1048    GB_transaction ta(gb_main);
1049    for (GBDATA *gb_species = GBT_first_species(gb_main);
1050         gb_species;
1051         gb_species = GBT_next_species(gb_species))
1052    {
1053        int hit = GBS_read_hash(list_hash, GBT_get_name_or_description(gb_species));
1054        GB_write_flag(gb_species, hit);
1055    }
1056}
1057
1058static void awtc_nn_search(AW_window *) {
1059    AW_root  *aw_root  = AW_root::SINGLETON;
1060    GBDATA   *gb_main  = NN_GLOBAL.get_gb_main();
1061    GB_ERROR  error    = NULp;
1062    PosRange  range    = get_nn_range_from_awars(aw_root);
1063    char     *sequence = NULp;
1064    {
1065        GB_transaction  ta(gb_main);
1066
1067        char   *sel_species = aw_root->awar(AWAR_SPECIES_NAME)->read_string();
1068        GBDATA *gb_species  = GBT_find_species(gb_main, sel_species);
1069
1070        if (!gb_species) {
1071            error = "Select a species first";
1072        }
1073        else {
1074            char   *ali_name = aw_root->awar(AWAR_DEFAULT_ALIGNMENT)->read_string();
1075            GBDATA *gb_data  = GBT_find_sequence(gb_species, ali_name);
1076
1077            if (gb_data) {
1078                sequence = read_sequence_region(gb_data, range);
1079            }
1080            else {
1081                error = GBS_global_string("Species '%s' has no sequence '%s'", sel_species, ali_name);
1082            }
1083            free(ali_name);
1084        }
1085        free(sel_species);
1086    }
1087
1088    int   pts         = aw_root->awar(AWAR_PROBE_ADMIN_PT_SERVER)->read_int();
1089    int   oligo_len   = aw_root->awar(AWAR_NN_OLIGO_LEN)->read_int();
1090    int   mismatches  = aw_root->awar(AWAR_NN_MISMATCHES)->read_int();
1091    bool  fast_mode   = aw_root->awar(AWAR_NN_FAST_MODE)->read_int();
1092    bool  rel_matches = aw_root->awar(AWAR_NN_REL_MATCHES)->read_int();
1093    float min_score   = aw_root->awar(AWAR_NN_MIN_SCORE)->read_float();
1094
1095    RelativeScoreScaling rel_scaling = static_cast<RelativeScoreScaling>(aw_root->awar(AWAR_NN_REL_SCALING)->read_int());
1096
1097    PT_FamilyFinder ff(gb_main, pts, oligo_len, mismatches, fast_mode, rel_matches, rel_scaling);
1098
1099    ff.restrict_2_region(range);
1100
1101    int max_hits = 0; // max wanted hits
1102
1103    if (!error) {
1104        FF_complement compl_mode = static_cast<FF_complement>(aw_root->awar(AWAR_NN_COMPLEMENT)->read_int());
1105        max_hits                 = aw_root->awar(AWAR_NN_MAX_HITS)->read_int();
1106
1107        error = ff.searchFamily(sequence, compl_mode, max_hits, min_score);
1108    }
1109
1110    // update result list
1111    {
1112        AW_selection_list* sel = NN_GLOBAL.get_result_list();
1113        sel->clear();
1114
1115        int hits = 0;
1116        if (error) {
1117            aw_message(error);
1118            sel->insert_default("<Error>", "");
1119        }
1120        else {
1121            int count     = 1;
1122            int shownHits = max_hits>0 ? max_hits : ff.getRealHits();
1123            int numWidth  = log(shownHits)/log(10)+1;
1124
1125            for (const FamilyList *fm = ff.getFamilyList(); fm; fm = fm->next) {
1126                const char *dis;
1127                if (rel_matches) {
1128                    dis = GBS_global_string("#%0*i %-12s Rel.hits: %5.1f%%", numWidth, count, fm->name, fm->rel_matches*100);
1129                }
1130                else {
1131                    dis = GBS_global_string("#%0*i %-12s Hits: %4li", numWidth, count, fm->name, fm->matches);
1132                }
1133
1134                sel->insert(dis, fm->name);
1135                count++;
1136            }
1137
1138            sel->insert_default(ff.hits_were_truncated() ? "<List truncated>" : "<No more hits>", "");
1139            hits = ff.getRealHits();
1140        }
1141        aw_root->awar(AWAR_NN_SELECTED_HIT_COUNT)->write_int(hits);
1142        if (aw_root->awar(AWAR_NN_SELECTED_AUTO_MARK)->read_int()) {
1143            awtc_mark_hits(NULp);
1144            aw_root->awar(AWAR_TREE_REFRESH)->touch();
1145        }
1146        sel->update();
1147    }
1148
1149    free(sequence);
1150}
1151
1152static void awtc_move_hits(AW_window *aww) {
1153    AW_root *aw_root         = aww->get_root();
1154    char    *current_species = aw_root->awar(AWAR_SPECIES_NAME)->read_string();
1155
1156    if (!current_species) current_species = strdup("<unknown>");
1157
1158    char *hit_description = GBS_global_string_copy("<neighbour of %s: %%s>", current_species);
1159
1160    copy_selection_list_2_query_box(NN_GLOBAL.get_query(), NN_GLOBAL.get_result_list(), hit_description);
1161
1162    free(hit_description);
1163    free(current_species);
1164}
1165
1166static bool autosearch_triggered = false;
1167static unsigned nn_perform_delayed_autosearch_cb(AW_root*) {
1168    awtc_nn_search(NULp);
1169    autosearch_triggered = false;
1170    return 0;
1171}
1172static void nn_trigger_delayed_autosearch_cb(AW_root *awr) {
1173    // automatic search is triggered delayed to make sure
1174    // dependencies between involved awars have propagated.
1175    if (!autosearch_triggered) { // ignore multiple triggers (happens when multiple awars change, e.g. when loading config)
1176        autosearch_triggered = true;
1177        awr->add_timed_callback(200, makeTimedCallback(nn_perform_delayed_autosearch_cb));
1178    }
1179}
1180
1181static void nn_auto_search_changed_cb(AW_root *awr) {
1182    int auto_search = awr->awar(AWAR_NN_SELECTED_AUTO_SEARCH)->read_int();
1183
1184    AW_awar *awar_sel_species = awr->awar(AWAR_SPECIES_NAME);
1185    if (auto_search) {
1186        awar_sel_species->add_callback(nn_trigger_delayed_autosearch_cb);
1187        nn_trigger_delayed_autosearch_cb(awr);
1188    }
1189    else {
1190        awar_sel_species->remove_callback(nn_trigger_delayed_autosearch_cb);
1191    }
1192}
1193
1194static AW_window *nn_of_sel_win = NULp;
1195static void nn_searchRel_awar_changed_cb(AW_root *awr) {
1196    int auto_search = awr->awar(AWAR_NN_SELECTED_AUTO_SEARCH)->read_int();
1197    if (auto_search &&
1198        nn_of_sel_win && nn_of_sel_win->is_shown()) // do not trigger if window is not shown
1199    {
1200        nn_trigger_delayed_autosearch_cb(awr);
1201    }
1202}
1203
1204static void create_next_neighbours_vars(AW_root *aw_root) {
1205    static bool created = false;
1206
1207    if (!created) {
1208        RootCallback searchRel_awar_changed_cb = makeRootCallback(nn_searchRel_awar_changed_cb);
1209
1210        aw_root->awar_int(AWAR_PROBE_ADMIN_PT_SERVER)->add_callback(searchRel_awar_changed_cb);
1211        aw_root->awar_int(AWAR_NN_COMPLEMENT,  FF_FORWARD)->add_callback(searchRel_awar_changed_cb);
1212
1213        aw_root->awar_string(AWAR_NN_RANGE_START, "")->add_callback(searchRel_awar_changed_cb);
1214        aw_root->awar_string(AWAR_NN_RANGE_END,   "")->add_callback(searchRel_awar_changed_cb);
1215        aw_root->awar_int   (AWAR_NN_MAX_HITS,    10)->set_minmax(0, 1000)->add_callback(searchRel_awar_changed_cb);;
1216        aw_root->awar_float (AWAR_NN_MIN_SCORE,   80)->set_minmax(0, 200)->add_callback(searchRel_awar_changed_cb);;
1217
1218        aw_root->awar_int(AWAR_NN_SELECTED_HIT_COUNT,   0);
1219        aw_root->awar_int(AWAR_NN_SELECTED_AUTO_SEARCH, 0)->add_callback(nn_auto_search_changed_cb);
1220        aw_root->awar_int(AWAR_NN_SELECTED_AUTO_MARK,   0);
1221
1222        aw_root->awar_string(AWAR_NN_LISTED_DEST_FIELD,     "tmp");
1223        aw_root->awar_int   (AWAR_NN_LISTED_SCORED_ENTRIES, 1);
1224
1225        AWTC_create_common_next_neighbour_vars(aw_root, searchRel_awar_changed_cb);
1226
1227        created = true;
1228    }
1229}
1230
1231static AWT_config_mapping_def next_neighbour_config_mapping[] = {
1232    // same as ../FAST_ALIGNER/fast_aligner.cxx@RELATIVES_CONFIG
1233    { AWAR_NN_OLIGO_LEN,   "oligolen" },
1234    { AWAR_NN_MISMATCHES,  "mismatches" },
1235    { AWAR_NN_FAST_MODE,   "fastmode" },
1236    { AWAR_NN_REL_MATCHES, "relmatches" },
1237    { AWAR_NN_REL_SCALING, "relscaling" },
1238
1239    { AWAR_NN_COMPLEMENT,  "complement" },
1240    { AWAR_NN_RANGE_START, "rangestart" },
1241    { AWAR_NN_RANGE_END,   "rangeend" },
1242    { AWAR_NN_MAX_HITS,    "maxhits" },
1243    { AWAR_NN_MIN_SCORE,   "minscore" },
1244
1245    { NULp, NULp }
1246};
1247
1248static void setup_next_neighbour_config(AWT_config_definition& cdef, bool for_listed) {
1249    // fields common for 'listed' and 'selected'
1250    cdef.add(next_neighbour_config_mapping);
1251
1252    if (for_listed) {
1253        cdef.add(AWAR_NN_LISTED_SCORED_ENTRIES, "addscore");
1254    }
1255    else {
1256        cdef.add(AWAR_NN_SELECTED_AUTO_SEARCH, "autosearch");
1257        cdef.add(AWAR_NN_SELECTED_AUTO_MARK,   "automark");
1258    }
1259}
1260
1261static void create_common_next_neighbour_fields(AW_window *aws, bool for_listed) {
1262    aws->at("pt_server");
1263    awt_create_PTSERVER_selection_button(aws, AWAR_PROBE_ADMIN_PT_SERVER);
1264
1265    const int SCALER_LENGTH = 200;
1266
1267    aws->auto_space(5, 5);
1268    AWTC_create_common_next_neighbour_fields(aws, SCALER_LENGTH);
1269
1270
1271    aws->at("range");
1272    aws->create_input_field(AWAR_NN_RANGE_START, 6);
1273    aws->create_input_field(AWAR_NN_RANGE_END,   6);
1274
1275    aws->at("compl");
1276    aws->create_option_menu(AWAR_NN_COMPLEMENT);
1277    aws->insert_default_option("forward",            "", FF_FORWARD);
1278    aws->insert_option        ("reverse",            "", FF_REVERSE);
1279    aws->insert_option        ("complement",         "", FF_COMPLEMENT);
1280    aws->insert_option        ("reverse-complement", "", FF_REVERSE_COMPLEMENT);
1281    aws->insert_option        ("fwd + rev-compl",    "", FF_FORWARD|FF_REVERSE_COMPLEMENT);
1282    aws->insert_option        ("rev + compl",        "", FF_REVERSE|FF_COMPLEMENT);
1283    aws->insert_option        ("any",                "", FF_FORWARD|FF_REVERSE|FF_COMPLEMENT|FF_REVERSE_COMPLEMENT);
1284    aws->update_option_menu();
1285
1286    aws->at("results");
1287    aws->create_input_field_with_scaler(AWAR_NN_MAX_HITS, 5, SCALER_LENGTH, AW_SCALER_EXP_LOWER);
1288
1289    aws->at("min_score");
1290    aws->create_input_field_with_scaler(AWAR_NN_MIN_SCORE, 5, SCALER_LENGTH, AW_SCALER_LINEAR);
1291
1292    aws->at("config");
1293    AWT_insert_config_manager(aws, AW_ROOT_DEFAULT, "next_neighbours", makeConfigSetupCallback(setup_next_neighbour_config, for_listed));
1294}
1295
1296static AW_window *create_next_neighbours_listed_window(AW_root *aw_root, DbQuery *query) {
1297    static AW_window_simple *aws = NULp;
1298    NN_GLOBAL.set_query(query);
1299    if (!aws) {
1300        create_next_neighbours_vars(aw_root);
1301
1302        aws = new AW_window_simple;
1303        aws->init(aw_root, "SEARCH_NEXT_NEIGHBOURS_OF_LISTED", "Search Next Neighbours of Listed");
1304        aws->load_xfig("ad_spec_nnm.fig");
1305
1306        aws->at("close");
1307        aws->callback(AW_POPDOWN);
1308        aws->create_button("CLOSE", "Close", "C");
1309
1310        aws->at("help");
1311        aws->callback(makeHelpCallback("next_neighbours_listed.hlp"));
1312        aws->create_button("HELP", "Help", "H");
1313
1314        create_common_next_neighbour_fields(aws, true);
1315
1316        aws->at("add_score");
1317        aws->create_toggle(AWAR_NN_LISTED_SCORED_ENTRIES);
1318
1319        aws->at("field");
1320        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");
1321
1322        aws->at("go");
1323        aws->callback(awtc_nn_search_all_listed);
1324        aws->button_length(10);
1325        aws->create_button("WRITE_FIELDS", "GO");
1326    }
1327    return aws;
1328}
1329
1330static AW_window *create_next_neighbours_selected_window(AW_root *aw_root, DbQuery *query) {
1331    static AW_window_simple *aws = NULp;
1332    NN_GLOBAL.set_query(query);
1333    if (!aws) {
1334        create_next_neighbours_vars(aw_root);
1335
1336        aws = new AW_window_simple;
1337        aws->init(aw_root, "SEARCH_NEXT_RELATIVE_OF_SELECTED", "Search Next Neighbours of Selected");
1338        aws->load_xfig("ad_spec_nn.fig");
1339
1340        aws->at("close");
1341        aws->callback(AW_POPDOWN);
1342        aws->create_button("CLOSE", "Close", "C");
1343
1344        aws->at("help");
1345        aws->callback(makeHelpCallback("next_neighbours.hlp"));
1346        aws->create_button("HELP", "Help", "H");
1347
1348        create_common_next_neighbour_fields(aws, false);
1349
1350        aws->button_length(10);
1351        aws->at("hit_count");
1352        aws->create_button(NULp, AWAR_NN_SELECTED_HIT_COUNT, NULp, "+");
1353
1354        aws->at("hits");
1355        AW_selection_list *resultList = aws->create_selection_list(AWAR_SPECIES_NAME);
1356        NN_GLOBAL.set_result_list(resultList);
1357        resultList->insert_default("No hits found", "");
1358        resultList->update();
1359
1360        aws->at("go");
1361        aws->callback(awtc_nn_search);
1362        aws->create_button("SEARCH", "Search");
1363
1364        aws->at("auto_go");
1365        aws->label("Auto search on change");
1366        aws->create_toggle(AWAR_NN_SELECTED_AUTO_SEARCH);
1367
1368        aws->at("mark");
1369        aws->callback(awtc_mark_hits);
1370        aws->create_autosize_button("MARK_HITS", "Mark hits");
1371
1372        aws->at("auto_mark");
1373        aws->label("Auto");
1374        aws->create_toggle(AWAR_NN_SELECTED_AUTO_MARK);
1375
1376        aws->at("move");
1377        aws->callback(awtc_move_hits);
1378        aws->create_autosize_button("MOVE_TO_HITLIST", "Move to hitlist");
1379
1380        nn_of_sel_win = aws; // store current window (to disable auto search when this window was popped down)
1381    }
1382    return aws;
1383}
1384
1385// ---------------------------------------------
1386//      species/organism specific callbacks
1387
1388static AW_window *popup_new_speciesOrganismWindow(AW_root *aw_root, GBDATA *gb_main, bool organismWindow, int detach_id);
1389
1390static void popup_detached_speciesOrganismWindow(AW_window *aw_parent, const InfoWindow *infoWin) {
1391    const InfoWindow *reusable = InfoWindowRegistry::infowin.find_reusable_of_same_type_as(*infoWin);
1392    if (reusable) {
1393        reusable->reuse();
1394    }
1395    else { // create a new window if none is reusable
1396        popup_new_speciesOrganismWindow(aw_parent->get_root(),
1397                                        infoWin->get_gbmain(),
1398                                        infoWin->mapsOrganism(),
1399                                        InfoWindowRegistry::infowin.allocate_detach_id(*infoWin));
1400    }
1401}
1402
1403static AW_window *popup_new_speciesOrganismWindow(AW_root *aw_root, GBDATA *gb_main, bool organismWindow, int detach_id) { // INFO_WINDOW_CREATOR
1404    // if detach_id is MAIN_WINDOW -> create main window (not detached)
1405
1406    AW_window_simple_menu *aws      = new AW_window_simple_menu;
1407    const ItemSelector&    itemType = organismWindow ? ORGANISM_get_selector() : SPECIES_get_selector();
1408
1409    init_info_window(aw_root, aws, itemType, detach_id);
1410
1411    aws->load_xfig("ad_spec.fig");
1412
1413    aws->button_length(8);
1414
1415    aws->at("close");
1416    aws->callback(AW_POPDOWN);
1417    aws->create_button("CLOSE", "Close", "C");
1418
1419    aws->at("search");
1420    aws->callback(makeCreateWindowCallback(DBUI::create_species_query_window, gb_main));
1421    aws->create_autosize_button("SEARCH", "Search...", "S");
1422
1423    aws->at("help");
1424    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
1425    aws->create_button("HELP", "Help", "H");
1426
1427    DbScanner *scanner = DbScanner::create(gb_main,
1428                                           InfoWindowRegistry::localize_scanner_id(organismWindow ? "organism" : "species", detach_id),
1429                                           aws, "box", "field", "enable", DB_KEYVIEWER, "mark", itemType);
1430
1431    const InfoWindow& infoWin = InfoWindowRegistry::infowin.registerInfoWindow(aws, scanner, detach_id);
1432
1433    if (infoWin.is_maininfo()) {
1434        if (organismWindow) aws->create_menu("ORGANISM",    "O", AWM_ALL);
1435        else                aws->create_menu("SPECIES",     "S", AWM_ALL);
1436
1437        aws->insert_menu_topic("species_delete",        "Delete",         "D", "spa_delete.hlp",  AWM_ALL, makeWindowCallback(species_delete_cb,        gb_main));
1438        aws->insert_menu_topic("species_rename",        "Rename",         "R", "spa_rename.hlp",  AWM_ALL, makeWindowCallback(species_rename_cb,        gb_main));
1439        aws->insert_menu_topic("species_copy",          "Copy",           "y", "spa_copy.hlp",    AWM_ALL, makeWindowCallback(species_copy_cb,          gb_main));
1440        aws->insert_menu_topic("species_create",        "Create",         "C", "spa_create.hlp",  AWM_ALL, makeWindowCallback(species_create_cb,        gb_main));
1441        aws->sep______________();
1442        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));
1443    }
1444
1445    aws->create_menu("FIELDS", "F", AWM_ALL);
1446    insert_field_admin_menuitems(aws, gb_main);
1447
1448    aws->at("detach");
1449    infoWin.add_detach_area(popup_detached_speciesOrganismWindow);
1450
1451    aws->show();
1452    infoWin.attach_selected_item();
1453    return aws;
1454}
1455
1456static void popup_speciesOrganismWindow(AW_root *aw_root, GBDATA *gb_main, bool organismWindow) {
1457    int windowIdx = (int)organismWindow;
1458
1459    static AW_window *AWS[2] = { NULp, NULp };
1460    if (!AWS[windowIdx]) {
1461        AWS[windowIdx] = popup_new_speciesOrganismWindow(aw_root, gb_main, organismWindow, InfoWindow::MAIN_WINDOW);
1462    }
1463    else {
1464        InfoWindowRegistry::reactivate(AWS[windowIdx]);
1465    }
1466}
1467
1468void DBUI::popup_species_info_window (AW_root *aw_root, GBDATA *gb_main) { popup_speciesOrganismWindow(aw_root, gb_main, false); }
1469void DBUI::popup_organism_info_window(AW_root *aw_root, GBDATA *gb_main) { popup_speciesOrganismWindow(aw_root, gb_main, true);  }
1470
1471static DbQuery *GLOBAL_species_query = NULp; // @@@ fix design
1472
1473void DBUI::unquery_all() {
1474    QUERY::unquery_all(NULp, GLOBAL_species_query);
1475}
1476
1477void DBUI::query_update_list() {
1478    DbQuery_update_list(GLOBAL_species_query);
1479}
1480
1481AW_window *DBUI::create_species_query_window(AW_root *aw_root, GBDATA *gb_main) {
1482    static AW_window_simple_menu *aws = NULp;
1483    if (!aws) {
1484        aws = new AW_window_simple_menu;
1485        aws->init(aw_root, "SPECIES_QUERY", "SEARCH and QUERY");
1486        aws->create_menu("More functions", "f");
1487        aws->load_xfig("ad_query.fig");
1488
1489
1490        query_spec awtqs(SPECIES_get_selector());
1491
1492        awtqs.gb_main              = gb_main;
1493        awtqs.species_name         = AWAR_SPECIES_NAME;
1494        awtqs.tree_name            = AWAR_TREE;
1495        awtqs.select_bit           = GB_USERFLAG_QUERY;
1496        awtqs.use_menu             = 1;
1497        awtqs.ere_pos_fig          = "ere2";
1498        awtqs.by_pos_fig           = "by2";
1499        awtqs.qbox_pos_fig         = "qbox";
1500        awtqs.key_pos_fig          = NULp;
1501        awtqs.query_pos_fig        = "content";
1502        awtqs.result_pos_fig       = "result";
1503        awtqs.count_pos_fig        = "count";
1504        awtqs.do_query_pos_fig     = "doquery";
1505        awtqs.config_pos_fig       = "doconfig";
1506        awtqs.do_mark_pos_fig      = "domark";
1507        awtqs.do_unmark_pos_fig    = "dounmark";
1508        awtqs.do_mark_nt_pos_fig   = "domark_nt";
1509        awtqs.do_unmark_nt_pos_fig = "dounmark_nt";
1510        awtqs.do_delete_pos_fig    = "dodelete";
1511        awtqs.do_set_pos_fig       = "doset";
1512        awtqs.do_refresh_pos_fig   = "dorefresh";
1513        awtqs.open_parser_pos_fig  = "openparser";
1514        awtqs.popup_info_window    = popup_species_info_window;
1515
1516        DbQuery *query           = create_query_box(aws, &awtqs, "spec");
1517        GLOBAL_species_query = query;
1518
1519        aws->create_menu("More search",     "s");
1520        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));
1521        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));
1522        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));
1523        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));
1524
1525        aws->button_length(7);
1526
1527        aws->at("close");
1528        aws->callback(AW_POPDOWN);
1529        aws->create_button("CLOSE", "Close", "C");
1530
1531        aws->at("help");
1532        aws->callback(makeHelpCallback("sp_search.hlp"));
1533        aws->create_button("HELP", "Help", "H");
1534    }
1535    return aws;
1536}
1537
Note: See TracBrowser for help on using the repository browser.