source: branches/stable/SL/REFENTRIES/refentries.cxx

Last change on this file was 12267, checked in by westram, 5 years ago
File size: 11.8 KB
Line 
1// ============================================================ //
2//                                                              //
3//   File      : refentries.cxx                                 //
4//   Purpose   :                                                //
5//                                                              //
6//   Coded by Ralf Westram (coder@reallysoft.de) in June 2011   //
7//   Institute of Microbiology (Technical University Munich)    //
8//   http://www.arb-home.de/                                    //
9//                                                              //
10// ============================================================ //
11
12#include "refentries.h"
13
14#include <arb_msg.h>
15#include <aw_window.hxx>
16#include <aw_root.hxx>
17#include <aw_awars.hxx>
18#include <aw_msg.hxx>
19#include <arbdbt.h>
20#include <arb_strarray.h>
21
22#include <cctype>
23
24namespace RefEntries {
25
26    static ARB_ERROR generate_item_error(const char *format, ItemSelector& itemtype, GBDATA *gb_item) {
27        GBDATA *gb_main          = GB_get_root(gb_item);
28        char   *item_id          = itemtype.generate_item_id(gb_main, gb_item);
29        char   *item_description = GBS_global_string_copy("%s '%s'", itemtype.item_name, item_id);
30
31        re_assert(strstr(format, "%s"));
32        ARB_ERROR error = GBS_global_string(format, item_description);
33
34        free(item_description);
35        free(item_id);
36
37        return error;
38    }
39
40    const char *RefSelector::get_refs(ItemSelector& itemtype, GBDATA *gb_item) const {
41        const char *refs    = NULL;
42        GBDATA     *gb_refs = GB_entry(gb_item, field);
43        if (gb_refs) {
44            refs = GB_read_char_pntr(gb_refs);
45        }
46        else if (error_if_field_missing) {
47            GB_export_error(generate_item_error(GBS_global_string("%%s has no field '%s'", field), itemtype, gb_item).deliver());
48        }
49        return refs;
50    }
51
52    char *RefSelector::filter_refs(const char *refs, GBDATA *gb_item) const {
53        return refs ? GB_command_interpreter(GB_get_root(gb_item), refs, aci, gb_item, NULL) : NULL;
54    }
55
56    static ARB_ERROR addRefsTo(DBItemSet& referred, ItemSelector& itemtype, GBDATA *gb_item, const RefSelector& ref) {
57        ARB_ERROR   error;
58        const char *refs     = ref.get_refs(itemtype, gb_item);
59        char       *filtered = ref.filter_refs(refs, gb_item);
60
61        if (!filtered) {
62            if (GB_have_error()) error = GB_await_error();
63        }
64        else {
65            ConstStrArray refNames;
66            GBT_split_string(refNames, filtered, ";, ", true);
67            size_t   refCount = refNames.size();
68
69            for (size_t r = 0; r<refCount && !error; ++r) {
70                GBDATA *gb_main     = GB_get_root(gb_item);
71                GBDATA *gb_referred = itemtype.find_item_by_id(gb_main, refNames[r]);
72                if (gb_referred) {
73                    referred.insert(gb_referred);
74                }
75                else if (!ref.ignore_unknown_refs()) {
76                    error = generate_item_error(GBS_global_string("%%s refers to unknown %s '%s'\n"
77                                                                  "in content of field '%s'\n"
78                                                                  "(content ='%s',\n"
79                                                                  " filtered='%s')\n",
80                                                                  itemtype.item_name, refNames[r],
81                                                                  ref.get_field(),
82                                                                  refs,
83                                                                  filtered),
84                                                itemtype, gb_item);
85                }
86            }
87
88            free(filtered);
89        }
90
91        return error;
92    }
93
94    ARB_ERROR ReferringEntriesHandler::with_all_referred_items(QUERY_RANGE range, const RefSelector& refsel, referred_item_handler callback) {
95        re_assert(range != QUERY_CURRENT_ITEM); // would need AW_root
96
97        ARB_ERROR  error;
98        DBItemSet referred;
99
100        {
101            GB_transaction ta(gb_main);
102
103            for (GBDATA *gb_container = itemtype.get_first_item_container(gb_main, NULL, QUERY_ALL_ITEMS);
104                 gb_container && !error;
105                 gb_container = itemtype.get_next_item_container(gb_container, QUERY_ALL_ITEMS))
106            {
107                for (GBDATA *gb_item = itemtype.get_first_item(gb_container, range);
108                     gb_item && !error;
109                     gb_item = itemtype.get_next_item(gb_item, range))
110                {
111                    error = addRefsTo(referred, itemtype, gb_item, refsel);
112                }
113            }
114        }
115
116        if (!error) error = callback(gb_main, referred);
117        return error;
118    }
119
120    ARB_ERROR ReferringEntriesHandler::with_all_referred_items(GBDATA *gb_item, const RefSelector& refsel, referred_item_handler callback) {
121        DBItemSet referred;
122        ARB_ERROR  error  = addRefsTo(referred, itemtype, gb_item, refsel);
123        if (!error) error = callback(gb_main, referred);
124        return error;
125    }
126
127
128
129    // ------------------------
130    //      GUI related below
131
132
133#define AWAR_MARKBYREF                "awt/refs/"
134#define AWAR_MARKBYREF_ALL            AWAR_MARKBYREF "which"
135#define AWAR_MARKBYREF_FIELD          AWAR_MARKBYREF "field"
136#define AWAR_MARKBYREF_IGNORE_MISSING AWAR_MARKBYREF "ignore_missing"
137#define AWAR_MARKBYREF_IGNORE_UNKNOWN AWAR_MARKBYREF "ignore_unknown"
138#define AWAR_MARKBYREF_FILTER         AWAR_MARKBYREF "filter"
139
140#define AWAR_MARKBYREF_TEMP "tmp/awt/refs/"
141#define AWAR_MARKBYREF_SELECTED AWAR_MARKBYREF_TEMP "selected"
142#define AWAR_MARKBYREF_CONTENT  AWAR_MARKBYREF_TEMP "content"
143#define AWAR_MARKBYREF_RESULT   AWAR_MARKBYREF_TEMP "result"
144
145    static void perform_refentries(AW_window *aww, AW_CL cl_reh, AW_CL cl_ricb) {
146        ReferringEntriesHandler *reh  = (ReferringEntriesHandler*)cl_reh;
147        referred_item_handler    ricb = (referred_item_handler)cl_ricb;
148
149        AW_root         *aw_root   = aww->get_root();
150        QUERY_RANGE  range = aw_root->awar(AWAR_MARKBYREF_ALL)->read_int() ? QUERY_ALL_ITEMS : QUERY_MARKED_ITEMS;
151
152        RefSelector refsel(aw_root->awar(AWAR_MARKBYREF_FIELD)->read_char_pntr(),
153                           aw_root->awar(AWAR_MARKBYREF_FILTER)->read_char_pntr(),
154                           !aw_root->awar(AWAR_MARKBYREF_IGNORE_MISSING)->read_int(),
155                           !aw_root->awar(AWAR_MARKBYREF_IGNORE_UNKNOWN)->read_int());
156
157        ARB_ERROR error = reh->with_all_referred_items(range, refsel, ricb);
158        aw_message_if(error);
159    }
160
161    static void refresh_result_cb(AW_root *aw_root, AW_CL cl_reh) {
162        ReferringEntriesHandler *reh      = (ReferringEntriesHandler*)cl_reh;
163        ItemSelector&            itemtype = reh->get_referring_item();
164        GBDATA                  *gb_main  = reh->get_gbmain();
165        GB_transaction           ta(gb_main);
166
167        GBDATA  *gb_item       = itemtype.get_selected_item(gb_main, aw_root);
168        AW_awar *awar_selected = aw_root->awar(AWAR_MARKBYREF_SELECTED);
169
170        if (!gb_item) {
171            awar_selected->write_string(GBS_global_string("<no %s selected>", itemtype.item_name));
172        }
173        else {
174            char *id = itemtype.generate_item_id(gb_main, gb_item);
175            if (!id) {
176                awar_selected->write_string(GB_await_error());
177            }
178            else {
179                awar_selected->write_string(id);
180
181                AW_awar *awar_content = aw_root->awar(AWAR_MARKBYREF_CONTENT);
182
183                RefSelector refsel(aw_root->awar(AWAR_MARKBYREF_FIELD)->read_char_pntr(),
184                                   aw_root->awar(AWAR_MARKBYREF_FILTER)->read_char_pntr(),
185                                   true, true);
186
187                const char *refs = refsel.get_refs(itemtype, gb_item);
188
189                if (!refs) awar_content->write_string(GB_await_error());
190                else {
191                    awar_content->write_string(refs);
192
193                    AW_awar *awar_result = aw_root->awar(AWAR_MARKBYREF_RESULT);
194                    char    *result      = refsel.filter_refs(refs, gb_item);
195
196                    if (result) {
197                        awar_result->write_string(result);
198                        free(result);
199                    }
200                    else {
201                        awar_result->write_string(GB_await_error());
202                    }
203                }
204
205                free(id);
206            }
207        }
208    }
209
210    static void bind_result_refresh_cbs(AW_root *aw_root, ReferringEntriesHandler *reh) {
211        aw_root->awar(AWAR_MARKBYREF_FIELD)->add_callback(refresh_result_cb, (AW_CL)reh);
212        aw_root->awar(AWAR_MARKBYREF_FILTER)->add_callback(refresh_result_cb, (AW_CL)reh);
213        aw_root->awar(AWAR_SPECIES_NAME)->add_callback(refresh_result_cb, (AW_CL)reh); // @@@ hack
214    }
215
216    void create_refentries_awars(AW_root *aw_root, AW_default aw_def) {
217        aw_root->awar_string(AWAR_MARKBYREF_FIELD, "used_rels",       aw_def);
218        aw_root->awar_string(AWAR_MARKBYREF_FILTER,   "/[0-9.]+[%]*://", aw_def);
219       
220        aw_root->awar_string(AWAR_MARKBYREF_SELECTED, "a", aw_def);
221        aw_root->awar_string(AWAR_MARKBYREF_CONTENT,  "b", aw_def);
222        aw_root->awar_string(AWAR_MARKBYREF_RESULT,   "c", aw_def);
223
224        aw_root->awar_int(AWAR_MARKBYREF_ALL,            0, aw_def);
225        aw_root->awar_int(AWAR_MARKBYREF_IGNORE_MISSING, 0, aw_def);
226        aw_root->awar_int(AWAR_MARKBYREF_IGNORE_UNKNOWN, 0, aw_def);
227    }
228
229    AW_window *create_refentries_window(AW_root *aw_root, ReferringEntriesHandler *reh, const char *window_id, const char *title, const char *help, client_area_builder build_client_area, const char *action, referred_item_handler action_cb) {
230        AW_window_simple *aws = new AW_window_simple;
231
232        aws->init(aw_root, window_id, title);
233        aws->at(10, 10);
234        aws->auto_space(10, 10);
235
236        bind_result_refresh_cbs(aw_root, reh);
237
238        aws->callback((AW_CB0) AW_POPDOWN);
239        aws->create_button("CLOSE", "CLOSE", "C");
240
241        aws->callback(makeHelpCallback(help));
242        aws->create_button("HELP", "HELP", "H");
243
244        const int LABEL_LENGTH = 27;
245        aws->label_length(LABEL_LENGTH);
246
247        ItemSelector& itemtype = reh->get_referring_item();
248
249        char *items_name = strdup(itemtype.items_name);
250        items_name[0]    = toupper(items_name[0]);
251
252        aws->at_newline();
253        aws->label(GBS_global_string("%s to examine", items_name));
254        aws->create_option_menu(AWAR_MARKBYREF_ALL, true);
255        aws->insert_option("Marked", "M", 0);
256        aws->insert_option("All",    "A", 1);
257        aws->update_option_menu();
258
259        aws->at_newline();
260        aws->label("Field containing references");
261        aws->create_input_field(AWAR_MARKBYREF_FIELD, 10);
262
263        aws->at_newline();
264        aws->label("Ignore if field missing?");
265        aws->create_toggle(AWAR_MARKBYREF_IGNORE_MISSING);
266
267        aws->at_newline();
268        aws->label("Filter content by ACI");
269        aws->create_input_field(AWAR_MARKBYREF_FILTER, 30);
270
271        aws->label_length(10);
272        aws->button_length(40);
273        aws->at_newline(); aws->label("Selected"); aws->create_button(NULL, AWAR_MARKBYREF_SELECTED);
274        aws->at_newline(); aws->label("Content");  aws->create_button(NULL, AWAR_MARKBYREF_CONTENT);
275        aws->at_newline(); aws->label("Result");   aws->create_button(NULL, AWAR_MARKBYREF_RESULT);
276        aws->label_length(LABEL_LENGTH);
277
278        aws->at_newline();
279        aws->label("Ignore unknown references?");
280        aws->create_toggle(AWAR_MARKBYREF_IGNORE_UNKNOWN);
281
282        if (build_client_area) build_client_area(aws);
283
284        aws->at_newline();
285        aws->callback(perform_refentries, (AW_CL)reh, (AW_CL)action_cb);
286        aws->create_autosize_button("ACTION", action, "");
287
288        aws->window_fit();
289
290        free(items_name);
291
292        refresh_result_cb(aw_root, (AW_CL)reh);
293
294        return aws;
295    }
296
297};
298
Note: See TracBrowser for help on using the repository browser.