source: trunk/GENOM/GEN_nds.cxx

Last change on this file was 18704, checked in by westram, 3 years ago
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 11.6 KB
Line 
1// =============================================================== //
2//                                                                 //
3//   File      : GEN_nds.cxx                                       //
4//   Purpose   :                                                   //
5//                                                                 //
6//   Coded by Ralf Westram (coder@reallysoft.de) in 2001           //
7//   Institute of Microbiology (Technical University Munich)       //
8//   http://www.arb-home.de/                                       //
9//                                                                 //
10// =============================================================== //
11
12#include "GEN.hxx"
13
14#include <nds.h>
15#include <item_sel_list.h>
16#include <awt_sel_boxes.hxx>
17
18#include <aw_msg.hxx>
19#include <aw_root.hxx>
20#include <aw_awar.hxx>
21
22#include <ad_cb.h>
23#include <gb_aci.h>
24
25#define gen_assert(bed) arb_assert(bed)
26
27using namespace std;
28
29// Note: this file is based on ../AWT/AWT_nds.cxx
30
31#define GEN_NDS_COUNT       10
32#define GEN_NDS_STRING_SIZE 4000
33
34struct GEN_NodeTextBuilder {
35    char  buf[GEN_NDS_STRING_SIZE];
36    char  zbuf[GEN_NDS_COUNT];
37    long  lengths[GEN_NDS_COUNT];
38    long  rek[GEN_NDS_COUNT];
39    char *dkeys[GEN_NDS_COUNT];
40    char *parsing[GEN_NDS_COUNT];
41    long  count;
42    int   errorclip;
43};
44
45static GEN_NodeTextBuilder *gen_nds_ms = NULp;
46
47void GEN_make_node_text_init(GBDATA *gb_main) {
48    const char *sf = "flag1";
49    const char *sl = "len1";
50
51    if (!gen_nds_ms) ARB_calloc(gen_nds_ms, 1);
52
53    GBDATA *gb_arb_presets = GB_search(gb_main, "arb_presets", GB_CREATE_CONTAINER);
54    int     count          = 0;
55
56    for (GBDATA *gbz = GB_entry(gb_arb_presets, "gene_viewkey"); gbz; gbz  = GB_nextEntry(gbz)) {
57        // toggle set ?
58        if (GB_read_int(GB_entry(gbz, sf))) {
59            freeset(gen_nds_ms->dkeys[count], GB_read_string(GB_entry(gbz, "key_text")));
60            if (GB_first_non_key_char(gen_nds_ms->dkeys[count])) {
61                gen_nds_ms->rek[count] = 1;
62            }
63            else {
64                gen_nds_ms->rek[count] = 0;
65            }
66            gen_nds_ms->lengths[count] = GB_read_int(GB_entry(gbz, sl));
67            GBDATA *gbe = GB_entry(gbz, "pars");
68            freenull(gen_nds_ms->parsing[count]);
69            if (gbe && GB_read_string_count(gbe)>1) gen_nds_ms->parsing[count] = GB_read_string(gbe);
70            count++;
71        }
72    }
73
74    gen_nds_ms->errorclip = 0;
75    gen_nds_ms->count     = count;
76}
77
78char *GEN_make_node_text_nds(GBDATA *gbd, int mode) {
79    // if mode == 0 compress info else format info
80
81    char *bp = gen_nds_ms->buf;
82    gen_assert(gbd);
83
84    long first = 0;
85    for (long i = 0; i < gen_nds_ms->count; i++) {
86        GBDATA *gbe;
87        if (gen_nds_ms->rek[i]) { // hierarchical key
88            gbe = GB_search(gbd, gen_nds_ms->dkeys[i], GB_FIND);
89        }
90        else { // flat entry
91            gbe = GB_entry(gbd, gen_nds_ms->dkeys[i]);
92        }
93
94        if (!mode && !gbe) continue;
95        if (!mode && first) {
96            (*bp++) = ',';
97        }
98        (*bp++) = ' ';
99        first++;
100        if (gbe) {
101            switch (GB_read_type(gbe)) {
102                case GB_INT:
103                    if (mode) {
104                        char buf[20];
105                        sprintf(buf, "%%%lii", gen_nds_ms->lengths[i]);
106                        sprintf(bp, buf, GB_read_int(gbe));
107                    }
108                    else {
109                        sprintf(bp, "%li", GB_read_int(gbe));
110                    }
111                    bp += strlen(bp);
112                    break;
113                case GB_BYTE:
114                    if (mode) {
115                        char buf[20];
116                        sprintf(buf, "%%%lii", gen_nds_ms->lengths[i]);
117                        sprintf(bp, buf, GB_read_byte(gbe));
118                    }
119                    else {
120                        sprintf(bp, "%i", GB_read_byte(gbe));
121                    }
122                    bp += strlen(bp);
123                    break;
124                case GB_STRING: {
125                    char       *pars = NULp;
126                    const char *p    = NULp;
127
128                    if (gen_nds_ms->parsing[i]) {
129                        char *p2 = GB_read_string(gbe);
130                        pars     = GB_command_interpreter_in_env(p2, gen_nds_ms->parsing[i], GBL_simple_call_env(gbd));
131                        free(p2);
132
133                        if (!pars) {
134                            pars = ARB_strdup("<error>");
135                            if (!gen_nds_ms->errorclip++) {
136                                aw_message(GB_await_error());
137                            }
138                        }
139                        p = pars;
140                    }
141                    else {
142                        p = GB_read_char_pntr(gbe);
143                    }
144
145                    long dlen = gen_nds_ms->lengths[i];
146                    if (dlen + (bp - gen_nds_ms->buf) + 256 > GEN_NDS_STRING_SIZE) {
147                        dlen = GEN_NDS_STRING_SIZE - 256 - (bp - gen_nds_ms->buf);
148                    }
149
150                    if (dlen> 0) {
151                        int len = strlen(p);
152                        long j = len;
153                        if (j > dlen)   j = dlen;
154                        for (; j; j--) *bp++ = *p++; // LOOP_VECTORIZED // tested down to gcc 5.5.0 (may fail on older gcc versions)
155                        if (mode) {
156                            long post = dlen - len;
157                            while (post-- > 0) *(bp++) = ' ';
158                        }
159                    }
160                    free(pars);
161                    break;
162                }
163                case GB_FLOAT:
164                    sprintf(bp, "%4.4f", GB_read_float(gbe));
165                    bp += strlen(bp);
166                    break;
167                default:
168                    break;
169            }
170        }
171        else if (mode) {
172            long j = gen_nds_ms->lengths[i];
173            if (j + (bp - gen_nds_ms->buf) + 256 > GEN_NDS_STRING_SIZE) {
174                j = GEN_NDS_STRING_SIZE - 256 - (bp - gen_nds_ms->buf);
175            }
176            for (; j > 0; j--)  *(bp++) = ' ';
177        }
178    }
179    *bp = 0;
180
181    return NDS_mask_nonprintable_chars(gen_nds_ms->buf);
182}
183
184void GEN_create_nds_vars(AW_root *aw_root, AW_default awdef, GBDATA *gb_main, const DatabaseCallback& NDS_changed_callback) {
185    GB_ERROR  error          = GB_push_transaction(gb_main);
186    GBDATA   *gb_arb_presets = GB_search(gb_main, "arb_presets", GB_CREATE_CONTAINER);
187    GBDATA   *gb_viewkey     = NULp;
188
189    for (int i=0; i<GEN_NDS_COUNT && !error; i++) {
190        char  buf[256];
191        char *keystart = buf+sprintf(buf, "tmp/gene_viewkey_%i/", i);
192
193        if (gb_viewkey) {
194            gen_assert(GB_has_key(gb_viewkey, "gene_viewkey"));
195            gb_viewkey = GB_nextEntry(gb_viewkey);
196        }
197        else {
198            gb_viewkey = GB_entry(gb_arb_presets, "gene_viewkey");
199        }
200        if (!gb_viewkey) {
201            gb_viewkey = GB_create_container(gb_arb_presets, "gene_viewkey");
202        }
203
204        if (!gb_viewkey) {
205            error = GB_await_error();
206        }
207        else {
208            GB_add_callback(gb_viewkey, GB_CB_CHANGED, NDS_changed_callback);
209
210            const char *default_key = NULp;
211            switch (i) {
212                case 1:  default_key = "pos_start"; break;
213                case 2:  default_key = "pos_stop"; break;
214                case 3:  default_key = "product"; break;
215                default: default_key = "name"; break;
216            }
217            GBDATA *gb_key_text     = GB_searchOrCreate_string(gb_viewkey, "key_text", default_key);
218            if (!gb_key_text) error = GB_await_error();
219            else {
220                strcpy(keystart, "key_text");
221                aw_root->awar_string(buf, "", awdef);
222                aw_root->awar(buf)->map(gb_key_text);
223            }
224        }
225
226        if (!error) {
227            GBDATA *gb_pars     = GB_searchOrCreate_string(gb_viewkey, "pars", "");
228            if (!gb_pars) error = GB_await_error();
229            else {
230                strcpy(keystart, "pars");
231                aw_root->awar_string(buf, "", awdef);
232                aw_root->awar(buf)->map(gb_pars);
233            }
234        }
235
236        if (!error) {
237            GBDATA *gb_flag1     = GB_searchOrCreate_int(gb_viewkey, "flag1", i <= 2 ? 1 : 0);
238            if (!gb_flag1) error = GB_await_error();
239            else {
240                strcpy(keystart, "flag1");
241                aw_root->awar_int(buf, 0, awdef);
242                aw_root->awar(buf)->map(gb_flag1);
243            }
244        }
245
246        if (!error) {
247            GBDATA *gb_len1     = GB_searchOrCreate_int(gb_viewkey, "len1", 30);
248            if (!gb_len1) error = GB_await_error();
249            else {
250                strcpy(keystart, "len1");
251                aw_root->awar_int(buf, 0, awdef);
252                aw_root->awar(buf)->set_minmax(0, GEN_NDS_STRING_SIZE);
253                aw_root->awar(buf)->map(gb_len1);
254            }
255        }
256    }
257
258    if (!error) {
259        GBDATA *gb_next;
260        gen_assert(GB_has_key(gb_viewkey, "gene_viewkey"));
261        while (!error && (gb_next = GB_nextEntry(gb_viewkey))) {
262            error = GB_delete(gb_next);
263        }
264    }
265
266    aw_root->awar_string("tmp/gene_viewkey/key_text", "", awdef);
267
268    error = GB_end_transaction(gb_main, error);
269    if (error) aw_message(error);
270}
271
272AW_window *GEN_open_nds_window(AW_root *aw_root, GBDATA *gb_main) {
273    static AW_window_simple *aws = NULp;
274    if (!aws) {
275        aws = new AW_window_simple;
276
277        aws->init(aw_root, "GENE_NDS_PROPS", "Gene NDS");
278        aws->load_xfig("awt/nds.fig");
279        aws->auto_space(10, 5);
280
281        aws->callback(AW_POPDOWN);
282        aws->at("close");
283        aws->create_button("CLOSE", "CLOSE", "C");
284
285        aws->at("help");
286        aws->callback(makeHelpCallback("props_nds.hlp"));
287        aws->create_button("HELP", "HELP", "H");
288
289        aws->button_length(13);
290        int dummy, closey;
291        aws->at_newline();
292        aws->get_at_position(&dummy, &closey);
293
294        aws->create_button(NULp, "K");
295
296        aws->at_newline();
297
298        int showx, fieldx, columnx, srtx, srtux;
299
300        aws->auto_space(10, 0);
301
302        for (int i=0; i<GEN_NDS_COUNT; i++) {
303            char buf[256];
304
305            sprintf(buf, "tmp/gene_viewkey_%i/flag1", i);
306            aws->get_at_position(&showx, &dummy);
307            aws->create_toggle(buf);
308
309            sprintf(buf, "tmp/gene_viewkey_%i/key_text", i);
310            aws->get_at_position(&fieldx, &dummy);
311            create_itemfield_selection_button(aws, FieldSelDef(buf, gb_main, GEN_get_selector(), FIELD_FILTER_NDS, "display-field"), NULp);
312
313            sprintf(buf, "tmp/gene_viewkey_%i/len1", i);
314            aws->get_at_position(&columnx, &dummy);
315            aws->create_input_field(buf, 4);
316
317            sprintf(buf, "tmp/gene_viewkey_%i/pars", i);
318            const char *inputFieldAwarName = ARB_strdup(buf);
319
320            aws->get_at_position(&srtx, &dummy);
321
322            aws->button_length(0);
323
324            aws->callback(makeWindowCallback(NDS_popup_select_srtaci_window, inputFieldAwarName));
325            sprintf(buf, "SELECT_SRTACI_%i", i);
326            aws->create_button(buf, "S", "S");
327
328            aws->get_at_position(&srtux, &dummy);
329            aws->create_input_field(inputFieldAwarName, 50);
330            aws->at_newline();
331        }
332        aws->at(showx, closey);
333
334        aws->at_x(showx);
335        aws->create_button(NULp, "SHOW");
336
337        aws->at_x(fieldx);
338        aws->create_button(NULp, "FIELD");
339
340        aws->at_x(columnx);
341        aws->create_button(NULp, "WIDTH");
342
343        aws->at_x(srtx);
344        aws->create_button(NULp, "SRT");
345
346        aws->at_x(srtux);
347        aws->create_button(NULp, "ACI/SRT PROGRAM");
348    }
349    return aws;
350}
351
Note: See TracBrowser for help on using the repository browser.