← Back to branch summary

~ubuntu-branches/debian/jessie/arb/jessie

« back to all changes in this revision

Viewing changes to GENOM/GEN_nds.cxx

  • Committer: Package Import Robot
  • Author(s): Elmar Pruesse, Andreas Tille, Elmar Pruesse
  • Date: 2014-09-02 15:15:06 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20140902151506-jihq58b3iz342wif
Tags: 6.0.2-1
http://bugs.debian.org/741890
http://bugs.debian.org/757497
[ Andreas Tille ]
* New upstream version
  Closes: #741890
* debian/upstream -> debian/upstream/metadata
* debian/control:
   - Build-Depends: added libglib2.0-dev
   - Depends: added mafft, mrbayes
* debian/rules
   - Add explicite --remove-section=.comment option to manual strip call
* cme fix dpkg-control
* arb-common.dirs: Do not create unneeded lintian dir
* Add turkish debconf translation (thanks for the patch to Mert Dirik
  <mertdirik@gmail.com>)
  Closes: #757497

[ Elmar Pruesse ]
* patches removed:
   - 10_config.makefiles.patch,
     80_no_GL.patch
       removed in favor of creating file from config.makefile.template via 
       sed in debian/control
   - 20_Makefile_main.patch
       merged upstream
   - 21_Makefiles.patch
       no longer needed
   - 30_tmpfile_CVE-2008-5378.patch: 
       merged upstream
   - 50_fix_gcc-4.8.patch:
       merged upstream
   - 40_add_libGLU.patch:
       libGLU not needed for arb_ntree)
   - 60_use_debian_packaged_raxml.patch:
       merged upstream
   - 70_hardening.patch
       merged upstream
   - 72_add_math_lib_to_linker.patch
       does not appear to be needed
* patches added:
   - 10_upstream_r12793__show_db_load_progress:
       backported patch showing progress while ARB is loading a database
       (needed as indicator/splash screen while ARB is launching)
   - 20_upstream_r12794__socket_permissions:
       backported security fix
   - 30_upstream_r12814__desktop_keywords:
       backported add keywords to desktop (fixes lintian warning)
   - 40_upstream_r12815__lintian_spelling:
       backported fix for lintian reported spelling errors
   - 50_private_nameservers
       change configuration to put nameservers into users home dirs
       (avoids need for shared writeable directory)
   - 60_use_debian_phyml
       use phyml from debian package for both interfaces in ARB
* debian/rules:
   - create config.makefile from override_dh_configure target
   - use "make tarfile" in override_dh_install
   - remove extra cleaning not needed for ARB 6
   - use "dh_install --list-missing" to avoid missing files
   - added override_dh_fixperms target
* debian/control:
   - added libarb-dev package
   - Depends: added phyml, xdg-utils
   - Suggests: removed phyml
   - fix lintian duplicate-short-description (new descriptions)
* debian/*.install:
   - "unrolled" confusing globbing to select files
   - pick files from debian/tmp
   - moved all config files to /etc/arb
* debian/arb-common.templates: updated
* scripts:
   - removed arb-add-pt-server
   - launch-wrapper: 
     - only add demo.arb to newly created $ARBUSERDATA
     - pass commandline arguments through bin/arb wrapper
   - preinst: removing old PT server index files on upgrade from 5.5*
   - postinst: set setgid on shared PT dir
* rewrote arb.1 manfile
* added file icon for ARB databases
* using upstream arb_tcp.dat

Show diffs side-by-side

added added

removed removed

Lines of Context:
GENOM/GEN_nds.cxx
1
 
/*********************************************************************************
2
 
 *  Coded by Ralf Westram (coder@reallysoft.de) in 2001                          *
3
 
 *  Institute of Microbiology (Technical University Munich)                      *
4
 
 *  http://www.mikro.biologie.tu-muenchen.de/                                    *
5
 
 *********************************************************************************/
6
 
 
7
 
 
8
 
 
9
 
#include <stdio.h>
10
 
#include <stdlib.h>
11
 
#include <string.h>
12
 
 
13
 
#include <arbdb.h>
14
 
#include <arbdbt.h>
15
 
 
 
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
#include <aw_msg.hxx>
16
18
#include <aw_root.hxx>
17
 
#include <aw_device.hxx>
18
 
#include <aw_window.hxx>
19
 
#include <awt.hxx>
20
 
#include <awt_nds.hxx>
21
 
#include <awt_item_sel_list.hxx>
22
 
#include <awt_sel_boxes.hxx>
23
 
 
24
 
#include "GEN_interface.hxx"
 
19
#include <aw_awar.hxx>
 
20
#include <ad_cb.h>
25
21
 
26
22
#define gen_assert(bed) arb_assert(bed)
27
23
 
32
28
#define GEN_NDS_COUNT       10
33
29
#define GEN_NDS_STRING_SIZE 4000
34
30
 
35
 
struct make_node_text_struct {
 
31
struct GEN_NodeTextBuilder {
36
32
    char  buf[GEN_NDS_STRING_SIZE];
37
33
    char  zbuf[GEN_NDS_COUNT];
38
34
    long  lengths[GEN_NDS_COUNT];
39
35
    long  rek[GEN_NDS_COUNT];
40
36
    char *dkeys[GEN_NDS_COUNT];
41
37
    char *parsing[GEN_NDS_COUNT];
42
 
    //  long  inherit[GEN_NDS_COUNT];
43
38
    long  count;
44
39
    int   errorclip;
45
 
 
46
 
} *gen_nds_ms = 0;
47
 
 
48
 
//  -----------------------------------------------------
49
 
//      void GEN_make_node_text_init(GBDATA *gb_main)
50
 
//  -----------------------------------------------------
 
40
};
 
41
 
 
42
static GEN_NodeTextBuilder *gen_nds_ms = 0;
 
43
 
51
44
void GEN_make_node_text_init(GBDATA *gb_main) {
52
 
    GBDATA     *gbz,*gbe;
 
45
    GBDATA     *gbz, *gbe;
53
46
    const char *sf, *sl;
54
47
    int         count;
55
48
 
56
49
    sf = "flag1";
57
50
    sl = "len1";
58
51
 
59
 
    if (!gen_nds_ms) gen_nds_ms = (struct make_node_text_struct *) GB_calloc(sizeof(struct make_node_text_struct),1);
 
52
    if (!gen_nds_ms) gen_nds_ms = (GEN_NodeTextBuilder *) GB_calloc(sizeof(GEN_NodeTextBuilder), 1);
60
53
 
61
 
    GBDATA *gb_arb_presets = GB_search(gb_main,"arb_presets",GB_CREATE_CONTAINER);
 
54
    GBDATA *gb_arb_presets = GB_search(gb_main, "arb_presets", GB_CREATE_CONTAINER);
62
55
    count                  = 0;
63
56
 
64
57
    for (gbz = GB_entry(gb_arb_presets, "gene_viewkey"); gbz; gbz  = GB_nextEntry(gbz)) {
65
 
        /* toggle set ? */
 
58
        // toggle set ?
66
59
        if (GB_read_int(GB_entry(gbz, sf))) {
67
60
            freeset(gen_nds_ms->dkeys[count], GB_read_string(GB_entry(gbz, "key_text")));
68
61
            if (GB_first_non_key_char(gen_nds_ms->dkeys[count])) {
72
65
                gen_nds_ms->rek[count] = 0;
73
66
            }
74
67
            gen_nds_ms->lengths[count] = GB_read_int(GB_entry(gbz, sl));
75
 
            //          gen_nds_ms->inherit[count] = GB_read_int(GB_entry(gbz, "inherit"));
76
68
            gbe = GB_entry(gbz, "pars");
77
 
            freeset(gen_nds_ms->parsing[count], 0);
78
 
            if (gbe && GB_read_string_count(gbe)>1 ) gen_nds_ms->parsing[count] = GB_read_string(gbe);
 
69
            freenull(gen_nds_ms->parsing[count]);
 
70
            if (gbe && GB_read_string_count(gbe)>1) gen_nds_ms->parsing[count] = GB_read_string(gbe);
79
71
            count++;
80
72
        }
81
73
    }
83
75
    gen_nds_ms->count = count;
84
76
}
85
77
 
86
 
//  -----------------------------------------------------------------------------
87
 
//      char *GEN_make_node_text_nds(GBDATA *gb_main, GBDATA * gbd, int mode)
88
 
//  -----------------------------------------------------------------------------
89
 
char *GEN_make_node_text_nds(GBDATA *gb_main, GBDATA * gbd, int mode)
90
 
{
91
 
    /* if mode ==0 compress info else format info */
92
 
    char     *bp;
93
 
    GBDATA   *gbe;
94
 
    long      i, j;
95
 
    long      first;
96
 
    //     GBT_TREE *father;
97
 
 
98
 
    bp = gen_nds_ms->buf;
99
 
    gb_assert(gbd);
100
 
    //     if (!gbd) {
101
 
    //         static char hae[] = "??????";
102
 
    //         if (!species) return hae;
103
 
    //         sprintf(gen_nds_ms->buf,"<%s>",species->name);
104
 
    //         return gen_nds_ms->buf;
105
 
    //     }
106
 
 
107
 
    first = 0;
108
 
    for (i = 0; i < gen_nds_ms->count; i++) {
109
 
        if (gen_nds_ms->rek[i]) {       /* hierarchical key */
110
 
            gbe = GB_search(gbd,gen_nds_ms->dkeys[i],0);
111
 
        }else{              /* flat entry */
 
78
char *GEN_make_node_text_nds(GBDATA *gb_main, 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
112
91
            gbe = GB_entry(gbd, gen_nds_ms->dkeys[i]);
113
92
        }
114
93
 
115
 
        //         if (!gbe && gen_nds_ms->inherit[i] && species ) {
116
 
        //             for (    father = species->father;
117
 
        //                     father && !gbe;
118
 
        //                     father = father->father){
119
 
        //                 if (father->gb_node){
120
 
        //                     gbe = GB_entry(father->gb_node, gen_nds_ms->dkeys[i]);
121
 
        //                 }
122
 
        //             }
123
 
        //         }
124
 
 
125
94
        if (!mode && !gbe) continue;
126
95
        if (!mode && first) {
127
96
            (*bp++) = ',';
133
102
                case GB_INT:
134
103
                    if (mode) {
135
104
                        char buf[20];
136
 
                        sprintf(buf,"%%%lii", gen_nds_ms->lengths[i]);
 
105
                        sprintf(buf, "%%%lii", gen_nds_ms->lengths[i]);
137
106
                        sprintf(bp, buf, GB_read_int(gbe));
138
 
                    } else {
 
107
                    }
 
108
                    else {
139
109
                        sprintf(bp, "%li", GB_read_int(gbe));
140
110
                    }
141
111
                    bp += strlen(bp);
143
113
                case GB_BYTE:
144
114
                    if (mode) {
145
115
                        char buf[20];
146
 
                        sprintf(buf,"%%%lii", gen_nds_ms->lengths[i]);
 
116
                        sprintf(buf, "%%%lii", gen_nds_ms->lengths[i]);
147
117
                        sprintf(bp, buf, GB_read_byte(gbe));
148
 
                    } else {
 
118
                    }
 
119
                    else {
149
120
                        sprintf(bp, "%i", GB_read_byte(gbe));
150
121
                    }
151
122
                    bp += strlen(bp);
152
123
                    break;
153
124
                case GB_STRING: {
154
 
                    long        post;
155
 
                    long        dlen;
156
125
                    char       *pars = 0;
157
126
                    const char *p    = 0;
158
127
 
159
128
                    if (gen_nds_ms->parsing[i]) {
160
129
                        char *p2 = GB_read_string(gbe);
161
 
                        pars     = GB_command_interpreter(gb_main, p2, gen_nds_ms->parsing[i],gbd, 0);
 
130
                        pars     = GB_command_interpreter(gb_main, p2, gen_nds_ms->parsing[i], gbd, 0);
162
131
                        free(p2);
163
 
                        
164
 
                        if (!pars){
 
132
 
 
133
                        if (!pars) {
165
134
                            pars = strdup("<error>");
166
135
                            if (!gen_nds_ms->errorclip++) {
167
136
                                aw_message(GB_await_error());
173
142
                        p = GB_read_char_pntr(gbe);
174
143
                    }
175
144
 
176
 
                    dlen = gen_nds_ms->lengths[i];
177
 
                    if (dlen + (bp - gen_nds_ms->buf) +256 > GEN_NDS_STRING_SIZE) {
 
145
                    long dlen = gen_nds_ms->lengths[i];
 
146
                    if (dlen + (bp - gen_nds_ms->buf) + 256 > GEN_NDS_STRING_SIZE) {
178
147
                        dlen = GEN_NDS_STRING_SIZE - 256 - (bp - gen_nds_ms->buf);
179
148
                    }
180
149
 
181
 
                    if (dlen> 0){
 
150
                    if (dlen> 0) {
182
151
                        int len = strlen(p);
183
 
                        j = len;
 
152
                        long j = len;
184
153
                        if (j > dlen)   j = dlen;
185
154
                        for (; j; j--) *bp++ = *p++;
186
 
                        if (mode){
187
 
                            post = dlen - len;
 
155
                        if (mode) {
 
156
                            long post = dlen - len;
188
157
                            while (post-- > 0) *(bp++) = ' ';
189
158
                        }
190
159
                    }
191
 
                    if (pars) free(pars);
 
160
                    free(pars);
192
161
                    break;
193
162
                }
194
163
                case GB_FLOAT:
198
167
                default:
199
168
                    break;
200
169
            }
201
 
        } else if (mode) {
202
 
            j = gen_nds_ms->lengths[i];
 
170
        }
 
171
        else if (mode) {
 
172
            long j = gen_nds_ms->lengths[i];
203
173
            if (j + (bp - gen_nds_ms->buf) + 256 > GEN_NDS_STRING_SIZE) {
204
174
                j = GEN_NDS_STRING_SIZE - 256 - (bp - gen_nds_ms->buf);
205
175
            }
206
176
            for (; j > 0; j--)  *(bp++) = ' ';
207
177
        }
208
 
    }           /* for */
 
178
    }
209
179
    *bp = 0;
210
 
    return gen_nds_ms->buf;
 
180
 
 
181
    return NDS_mask_nonprintable_chars(gen_nds_ms->buf);
211
182
}
212
183
 
213
 
 
214
 
 
215
 
void GEN_create_nds_vars(AW_root *aw_root,AW_default awdef,GBDATA *gb_main, GB_CB NDS_changed_callback) {
 
184
void GEN_create_nds_vars(AW_root *aw_root, AW_default awdef, GBDATA *gb_main, const DatabaseCallback& NDS_changed_callback) {
216
185
    GB_ERROR  error          = GB_push_transaction(gb_main);
217
 
    GBDATA   *gb_arb_presets = GB_search(gb_main,"arb_presets",GB_CREATE_CONTAINER);
 
186
    GBDATA   *gb_arb_presets = GB_search(gb_main, "arb_presets", GB_CREATE_CONTAINER);
218
187
    GBDATA   *gb_viewkey     = 0;
219
188
 
220
189
    for (int i=0; i<GEN_NDS_COUNT && !error; i++) {
221
190
        char  buf[256];
222
 
        char *keystart = buf+sprintf(buf,"tmp/gene_viewkey_%i/",i);
 
191
        char *keystart = buf+sprintf(buf, "tmp/gene_viewkey_%i/", i);
223
192
 
224
193
        if (gb_viewkey) {
225
194
            gen_assert(GB_has_key(gb_viewkey, "gene_viewkey"));
226
195
            gb_viewkey = GB_nextEntry(gb_viewkey);
227
196
        }
228
197
        else {
229
 
            gb_viewkey = GB_entry(gb_arb_presets,"gene_viewkey");
 
198
            gb_viewkey = GB_entry(gb_arb_presets, "gene_viewkey");
230
199
        }
231
 
        if (!gb_viewkey){
232
 
            gb_viewkey = GB_create_container(gb_arb_presets,"gene_viewkey");
 
200
        if (!gb_viewkey) {
 
201
            gb_viewkey = GB_create_container(gb_arb_presets, "gene_viewkey");
233
202
        }
234
203
 
235
204
        if (!gb_viewkey) {
236
205
            error = GB_await_error();
237
206
        }
238
207
        else {
239
 
            GB_add_callback(gb_viewkey, GB_CB_CHANGED, NDS_changed_callback, 0);
 
208
            GB_add_callback(gb_viewkey, GB_CB_CHANGED, NDS_changed_callback);
240
209
 
241
210
            const char *default_key = 0;
242
211
            switch (i) {
249
218
            if (!gb_key_text) error = GB_await_error();
250
219
            else {
251
220
                strcpy(keystart, "key_text");
252
 
                aw_root->awar_string(buf,"",awdef);
 
221
                aw_root->awar_string(buf, "", awdef);
253
222
                aw_root->awar(buf)->map(gb_key_text);
254
223
            }
255
224
        }
259
228
            if (!gb_pars) error = GB_await_error();
260
229
            else {
261
230
                strcpy(keystart, "pars");
262
 
                aw_root->awar_string(buf,"",awdef);
 
231
                aw_root->awar_string(buf, "", awdef);
263
232
                aw_root->awar(buf)->map(gb_pars);
264
233
            }
265
234
        }
269
238
            if (!gb_flag1) error = GB_await_error();
270
239
            else {
271
240
                strcpy(keystart, "flag1");
272
 
                aw_root->awar_int(buf,0,awdef);
 
241
                aw_root->awar_int(buf, 0, awdef);
273
242
                aw_root->awar(buf)->map(gb_flag1);
274
243
            }
275
244
        }
279
248
            if (!gb_len1) error = GB_await_error();
280
249
            else {
281
250
                strcpy(keystart, "len1");
282
 
                aw_root->awar_int(buf,0,awdef);
 
251
                aw_root->awar_int(buf, 0, awdef);
283
252
                aw_root->awar(buf)->set_minmax(0, GEN_NDS_STRING_SIZE);
284
253
                aw_root->awar(buf)->map(gb_len1);
285
254
            }
294
263
        }
295
264
    }
296
265
 
297
 
    aw_root->awar_string("tmp/gene_viewkey/key_text","",awdef);
 
266
    aw_root->awar_string("tmp/gene_viewkey/key_text", "", awdef);
298
267
 
299
268
    error = GB_end_transaction(gb_main, error);
300
269
    if (error) aw_message(error);
301
270
}
302
 
//  ---------------------------------------------------------------------------------------
303
 
//      void GEN_create_select_nds_window(AW_window *aww,char *key_text,AW_CL cgb_main)
304
 
//  ---------------------------------------------------------------------------------------
305
 
void GEN_create_select_nds_window(AW_window *aww,char *key_text,AW_CL cgb_main)
 
271
 
 
272
static void GEN_create_select_nds_window(AW_window *aww, char *key_text, AW_CL cgb_main)
306
273
{
307
 
#warning make this function more general like AWT_popup_select_species_field_window
308
 
    
 
274
#if defined(WARN_TODO)
 
275
#warning make this function more general like popup_select_species_field_window
 
276
#endif
 
277
 
309
278
    static AW_window *win = 0;
310
279
    AW_root *aw_root = aww->get_root();
311
280
    aw_root->awar("tmp/gene_viewkey/key_text")->map(key_text);
312
281
    if (!win) {
313
282
        AW_window_simple *aws = new AW_window_simple;
314
 
        aws->init( aw_root, "NDS", "NDS_SELECT");
 
283
        aws->init(aw_root, "NDS", "NDS_SELECT");
315
284
        aws->load_xfig("awt/nds_sel.fig");
316
285
        aws->button_length(13);
317
286
 
318
 
        aws->callback( AW_POPDOWN);
 
287
        aws->callback(AW_POPDOWN);
319
288
        aws->at("close");
320
 
        aws->create_button("CLOSE", "CLOSE","C");
 
289
        aws->create_button("CLOSE", "CLOSE", "C");
321
290
 
322
 
        awt_create_selection_list_on_scandb((GBDATA *)cgb_main,
323
 
                                            (AW_window*)aws,"tmp/gene_viewkey/key_text",
324
 
                                            AWT_NDS_FILTER,
325
 
                                            "scandb","rescandb", &GEN_item_selector, 20, 10);
326
 
        //aw_root->awar(key_text)->add_callback((AW_RCB1)awt_pop_down_select_nds,(AW_CL)aws);
 
291
        create_selection_list_on_itemfields((GBDATA*)cgb_main, aws, "tmp/gene_viewkey/key_text", true, FIELD_FILTER_NDS, "scandb", "rescandb", GEN_get_selector(), 20, 10, SF_STANDARD, NULL);
327
292
 
328
293
        win =  (AW_window*)aws;
329
294
    }
330
295
    win->activate();
331
296
}
332
 
//  -----------------------------------------------------------------------
333
 
//      AW_window *GEN_open_nds_window(AW_root *aw_root,AW_CL cgb_main)
334
 
//  -----------------------------------------------------------------------
335
 
AW_window *GEN_open_nds_window(AW_root *aw_root,AW_CL cgb_main)
 
297
 
 
298
AW_window *GEN_open_nds_window(AW_root *aw_root, AW_CL cgb_main)
336
299
{
337
300
    static AW_window_simple *aws = 0;
338
301
    if (!aws) {
339
302
        aws = new AW_window_simple;
340
 
    
341
 
        aws->init( aw_root, "GENE_NDS_PROPS", "Gene NDS");
 
303
 
 
304
        aws->init(aw_root, "GENE_NDS_PROPS", "Gene NDS");
342
305
        aws->load_xfig("awt/nds.fig");
343
 
        aws->auto_space(10,5);
 
306
        aws->auto_space(10, 5);
344
307
 
345
 
        aws->callback( AW_POPDOWN);
 
308
        aws->callback(AW_POPDOWN);
346
309
        aws->at("close");
347
 
        aws->create_button("CLOSE", "CLOSE","C");
 
310
        aws->create_button("CLOSE", "CLOSE", "C");
348
311
 
349
312
        aws->at("help");
350
 
        aws->callback(AW_POPUP_HELP,(AW_CL)"props_nds.hlp");
351
 
        aws->create_button("HELP", "HELP","H");
 
313
        aws->callback(makeHelpCallback("props_nds.hlp"));
 
314
        aws->create_button("HELP", "HELP", "H");
352
315
 
353
316
        aws->button_length(13);
354
 
        int dummy,closey;
355
 
        aws->at_newline();
356
 
        aws->get_at_position( &dummy,&closey );
357
 
 
358
 
        aws->create_button(0,"K");
359
 
 
360
 
        aws->at_newline();
361
 
 
362
 
 
363
 
        int showx,fieldselectx,fieldx, /*inheritx,*/ columnx,srtx,srtux;
364
 
 
365
 
        aws->auto_space(10,0);
 
317
        int dummy, closey;
 
318
        aws->at_newline();
 
319
        aws->get_at_position(&dummy, &closey);
 
320
 
 
321
        aws->create_button(0, "K");
 
322
 
 
323
        aws->at_newline();
 
324
 
 
325
 
 
326
        int showx, fieldselectx, fieldx, columnx, srtx, srtux;
 
327
 
 
328
        aws->auto_space(10, 0);
366
329
 
367
330
        int i;
368
 
        for (   i=0;i<GEN_NDS_COUNT; i++) {
 
331
        for (i=0; i<GEN_NDS_COUNT; i++) {
369
332
            char buf[256];
370
333
 
371
 
            sprintf(buf,"tmp/gene_viewkey_%i/flag1",i);
372
 
            aws->get_at_position( &showx,&dummy );
 
334
            sprintf(buf, "tmp/gene_viewkey_%i/flag1", i);
 
335
            aws->get_at_position(&showx, &dummy);
373
336
            aws->create_toggle(buf);
374
337
 
375
338
            aws->button_length(20);
376
 
            sprintf(buf,"tmp/gene_viewkey_%i/key_text",i);
377
 
            aws->get_at_position( &fieldx,&dummy );
378
 
            aws->create_input_field(buf,15);
379
 
 
380
 
            aws->button_length(0);
381
 
            aws->callback((AW_CB)GEN_create_select_nds_window, (AW_CL)strdup(buf),cgb_main);
382
 
            aws->get_at_position( &fieldselectx,&dummy );
383
 
            aws->create_button("SELECT_NDS","S");
384
 
 
385
 
            //      sprintf(buf,"tmp/gene_viewkey_%i/inherit",i);
386
 
            //      aws->get_at_position( &inheritx,&dummy );
387
 
            //      aws->create_toggle(buf);
388
 
 
389
 
            sprintf(buf,"tmp/gene_viewkey_%i/len1",i);
390
 
            aws->get_at_position( &columnx,&dummy );
391
 
            aws->create_input_field(buf,4);
392
 
 
393
 
            sprintf(buf,"tmp/gene_viewkey_%i/pars",i);
394
 
            aws->get_at_position( &srtx,&dummy );
395
 
 
396
 
            aws->button_length(0);
397
 
 
398
 
            aws->callback(AWT_create_select_srtaci_window,(AW_CL)strdup(buf),0);
399
 
            aws->create_button("SELECT_SRTACI", "S","S");
400
 
 
401
 
            aws->get_at_position( &srtux,&dummy );
402
 
            aws->create_input_field(buf,40);
 
339
            sprintf(buf, "tmp/gene_viewkey_%i/key_text", i);
 
340
            aws->get_at_position(&fieldx, &dummy);
 
341
            aws->create_input_field(buf, 15);
 
342
 
 
343
            aws->button_length(0);
 
344
            aws->callback((AW_CB)GEN_create_select_nds_window, (AW_CL)strdup(buf), cgb_main);
 
345
            aws->get_at_position(&fieldselectx, &dummy);
 
346
            sprintf(buf, "SELECT_NDS_%i", i);
 
347
            aws->create_button(buf, "S");
 
348
 
 
349
            sprintf(buf, "tmp/gene_viewkey_%i/len1", i);
 
350
            aws->get_at_position(&columnx, &dummy);
 
351
            aws->create_input_field(buf, 4);
 
352
 
 
353
            sprintf(buf, "tmp/gene_viewkey_%i/pars", i);
 
354
            const char *inputFieldAwarName = strdup(buf);
 
355
 
 
356
            aws->get_at_position(&srtx, &dummy);
 
357
 
 
358
            aws->button_length(0);
 
359
 
 
360
            aws->callback(makeWindowCallback(AWT_popup_select_srtaci_window, inputFieldAwarName));
 
361
            sprintf(buf, "SELECT_SRTACI_%i", i);
 
362
            aws->create_button(buf, "S", "S");
 
363
 
 
364
            aws->get_at_position(&srtux, &dummy);
 
365
            aws->create_input_field(inputFieldAwarName, 40);
403
366
            aws->at_newline();
404
367
        }
405
 
        aws->at(showx,closey);
 
368
        aws->at(showx, closey);
406
369
 
407
370
        aws->at_x(fieldselectx);
408
 
        aws->create_button(0,"SEL");
 
371
        aws->create_button(0, "SEL");
409
372
 
410
373
        aws->at_x(showx);
411
 
        aws->create_button(0,"SHOW");
 
374
        aws->create_button(0, "SHOW");
412
375
 
413
376
        aws->at_x(fieldx);
414
 
        aws->create_button(0,"FIELD");
415
 
 
416
 
        //  aws->at_x(inheritx);
417
 
        //  aws->create_button(0,"INH.");
 
377
        aws->create_button(0, "FIELD");
418
378
 
419
379
        aws->at_x(columnx);
420
 
        aws->create_button(0,"WIDTH");
 
380
        aws->create_button(0, "WIDTH");
421
381
 
422
382
        aws->at_x(srtx);
423
 
        aws->create_button(0,"SRT");
 
383
        aws->create_button(0, "SRT");
424
384
 
425
385
        aws->at_x(srtux);
426
 
        aws->create_button(0,"ACI/SRT PROGRAM");
 
386
        aws->create_button(0, "ACI/SRT PROGRAM");
427
387
    }
428
388
    return aws;
429
389
}
430
390
 
431
 
 
432