← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ARB_GDE/GDE.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:
ARB_GDE/GDE.cxx
1
 
#include <cstdio>
2
 
#include <cstdlib>
3
 
#include <cstring>
4
 
#include <cmath>
 
1
#include "GDE_extglob.h"
 
2
#include "GDE_awars.h"
5
3
 
6
 
#include <arbdb.h>
7
 
#include <arbdbt.h>
8
 
// #include <malloc.h>
 
4
#include <aw_window.hxx>
 
5
#include <aw_msg.hxx>
 
6
#include <aw_awar.hxx>
 
7
#include <aw_file.hxx>
9
8
#include <aw_root.hxx>
10
 
#include <aw_device.hxx>
11
 
#include <aw_window.hxx>
12
 
#include <awt.hxx>
 
9
#include <aw_awar_defs.hxx>
13
10
#include <awt_sel_boxes.hxx>
14
 
 
15
 
#include "gde.hxx"
16
 
#include "GDE_menu.h"
17
 
#include "GDE_def.h"
18
 
#include "GDE_extglob.h"
19
 
#include "GDE_awars.h"
20
 
 
21
 
adfiltercbstruct *agde_filtercd = 0;
22
 
 
23
 
Gmenu menu[GDEMAXMENU];
24
 
int num_menus = 0,repeat_cnt = 0;
25
 
//Frame frame,pframe,infoframe;
26
 
//Panel popup,infopanel;
27
 
//Panel_item left_foot,right_foot;
28
 
//Canvas EditCan,EditNameCan;
29
 
int DisplayType;
30
 
GmenuItem *current_item;
31
 
NA_Alignment *DataSet = NULL;
32
 
 
33
 
char GDEBLANK[] = "\0";
 
11
#include <awt_filter.hxx>
 
12
 
 
13
#include <cmath>
 
14
#include <arb_str.h>
 
15
 
 
16
// AISC_MKPT_PROMOTE:#ifndef GDE_MENU_H
 
17
// AISC_MKPT_PROMOTE:#include "GDE_menu.h"
 
18
// AISC_MKPT_PROMOTE:#endif
 
19
 
 
20
adfiltercbstruct *agde_filter = 0;
 
21
 
 
22
Gmenu         menu[GDEMAXMENU];
 
23
int           num_menus = 0;
 
24
NA_Alignment *DataSet   = NULL;
 
25
 
 
26
static char GDEBLANK[] = "\0";
34
27
 
35
28
#define SLIDERWIDTH 5           // input field width for numbers
36
29
 
37
 
static void GDE_showhelp_cb(AW_window *aw, GmenuItem *gmenuitem, AW_CL /*cd*/) {
38
 
    const char *help_file = gmenuitem->help;
39
 
    if (help_file) {
40
 
        char *agde_help_file = GBS_string_eval(help_file, "*.help=agde_*1.hlp", 0);
41
 
        AW_POPUP_HELP(aw, (AW_CL)agde_help_file);
42
 
        free(agde_help_file);
 
30
struct gde_iteminfo {
 
31
    GmenuItem *item;
 
32
    int        idx;
 
33
    gde_iteminfo(GmenuItem *item_, int idx_) : item(item_), idx(idx_) {}
 
34
};
 
35
 
 
36
static void GDE_showhelp_cb(AW_window *aw, GmenuItem *gmenuitem, AW_CL /* cd */) {
 
37
    if (gmenuitem->help) {
 
38
        AW_help_popup(aw, gmenuitem->help);
43
39
    }
44
40
    else {
45
41
        aw_message("Sorry - no help available (please report to devel@arb-home.de)");
46
42
    }
47
43
}
48
44
 
49
 
char *GDE_makeawarname(GmenuItem *gmenuitem,long i)
50
 
{
51
 
    char  name[GB_KEY_LEN_MAX*4+5];
 
45
static char *GDE_makeawarname_in(GmenuItem *gmenuitem, long i, const char *awar_root) {
52
46
    char *gmenu_label     = GBS_string_2_key(gmenuitem->parent_menu->label);
53
47
    char *gmenuitem_label = GBS_string_2_key(gmenuitem->label);
54
48
    char *arg             = GBS_string_2_key(gmenuitem->arg[i].symbol);
55
49
 
56
 
    sprintf(name,"gde/%s/%s/%s", gmenu_label, gmenuitem_label, arg);
57
 
    
 
50
    char *name = GBS_global_string_copy("%s/%s/%s/%s", awar_root, gmenu_label, gmenuitem_label, arg);
 
51
 
58
52
    free(gmenu_label);
59
53
    free(gmenuitem_label);
60
54
    free(arg);
61
55
 
62
 
    return(strdup(name));
 
56
    return name;
63
57
}
64
58
 
 
59
char *GDE_makeawarname(GmenuItem *gmenuitem, long i) { return GDE_makeawarname_in(gmenuitem, i, "gde"); }
 
60
char *GDE_maketmpawarname(GmenuItem *gmenuitem, long i) { return GDE_makeawarname_in(gmenuitem, i, "tmp/gde"); }
 
61
 
65
62
static void GDE_slide_awar_int_cb(AW_window *aws, AW_CL cl_awar_name, AW_CL cd_diff)
66
63
{
67
64
    int      diff = (int)cd_diff;
71
68
}
72
69
static void GDE_slide_awar_float_cb(AW_window *aws, AW_CL cl_awar_name, AW_CL cd_diff)
73
70
{
74
 
    double   diff    = *(double*)cd_diff;
 
71
    double   diff    = *(double*)(char*)/*avoid aliasing problems*/cd_diff; 
75
72
    AW_awar *awar    = aws->get_root()->awar((const char *)cl_awar_name);
76
73
    double   new_val = awar->read_float()+diff;
77
74
 
84
81
    awar->write_float(new_val);
85
82
}
86
83
 
87
 
static void GDE_create_infieldwithpm(AW_window *aws,char *newawar,long width)
88
 
{
89
 
    char *awar=strdup(newawar);
90
 
    aws->create_input_field(newawar,(int)width);
 
84
static void GDE_create_infieldwithpm(AW_window *aws, char *newawar, long width) {
 
85
    aws->create_input_field(newawar, (int)width);
91
86
    if (aws->get_root()->awar(newawar)->get_type() == AW_INT) {
92
87
        aws->button_length(3);
93
 
        aws->callback(GDE_slide_awar_int_cb,(AW_CL)awar,-1);
94
 
        aws->create_button(0,"-","-");
95
 
        aws->callback(GDE_slide_awar_int_cb,(AW_CL)awar,+1);
96
 
        aws->create_button(0,"+","+");
 
88
        char *awar = strdup(newawar);
 
89
        aws->callback(GDE_slide_awar_int_cb, (AW_CL)awar, -1); aws->create_button(0, "-", "-");
 
90
        aws->callback(GDE_slide_awar_int_cb, (AW_CL)awar, + 1); aws->create_button(0, "+", "+");
97
91
    }
98
92
    else if (aws->get_root()->awar(newawar)->get_type() == AW_FLOAT) {
99
93
        aws->button_length(3);
100
 
        aws->callback(GDE_slide_awar_float_cb,(AW_CL)awar,(AW_CL)new double(-0.1));
101
 
        aws->create_button(0,"-","-");
102
 
        aws->callback(GDE_slide_awar_float_cb,(AW_CL)awar,(AW_CL)new double(+0.1));
103
 
        aws->create_button(0,"+","+");
 
94
        char *awar = strdup(newawar);
 
95
        aws->callback(GDE_slide_awar_float_cb, (AW_CL)awar, (AW_CL)new double(-0.1)); aws->create_button(0, "-", "-");
 
96
        aws->callback(GDE_slide_awar_float_cb, (AW_CL)awar, (AW_CL)new double(+0.1)); aws->create_button(0, "+", "+");
104
97
    }
105
98
}
106
99
 
107
 
static char *gde_filter_weights(GBDATA *gb_sai,AW_CL ){
 
100
static char *gde_filter_weights(GBDATA *gb_sai, AW_CL) {
108
101
    char   *ali_name = GBT_get_default_alignment(GB_get_root(gb_sai));
109
 
    GBDATA *gb_ali   = GB_entry(gb_sai,ali_name);
 
102
    GBDATA *gb_ali   = GB_entry(gb_sai, ali_name);
110
103
    char   *result   = 0;
111
104
 
112
105
    if (gb_ali) {
114
107
        if (gb_type) {
115
108
            const char *type = GB_read_char_pntr(gb_type);
116
109
 
117
 
            if (GBS_string_matches( type,"PV?:*",GB_MIND_CASE)) {
 
110
            if (GBS_string_matches(type, "PV?:*", GB_MIND_CASE)) {
118
111
                result = GBS_global_string_copy("%s: %s", GBT_read_name(gb_sai), type);
119
112
            }
120
113
 
126
119
 
127
120
}
128
121
 
129
 
 
130
 
 
131
 
static AW_window *GDE_menuitem_cb(AW_root *aw_root,GmenuItem *gmenuitem) {
 
122
static AW_window *GDE_create_filename_browser_window(AW_root *aw_root, const char *awar_prefix, const char *title) {
 
123
    AW_window_simple *aws = new AW_window_simple;
 
124
 
 
125
    {
 
126
        char *wid = GBS_string_2_key(awar_prefix);
 
127
        aws->init(aw_root, wid, title);
 
128
        free(wid);
 
129
    }
 
130
    aws->load_xfig("sel_box.fig");
 
131
 
 
132
    aws->at("close");
 
133
    aws->callback((AW_CB0) AW_POPDOWN);
 
134
    aws->create_button("CLOSE", "CLOSE", "C");
 
135
 
 
136
    AW_create_standard_fileselection(aws, awar_prefix);
 
137
 
 
138
    return aws;
 
139
}
 
140
 
 
141
static void GDE_popup_filename_browser(AW_window *aw, AW_CL cl_iteminfo, AW_CL cl_title) {
 
142
    gde_iteminfo *info         = (gde_iteminfo*)cl_iteminfo;
 
143
    GmenuItem    *gmenuitem    = info->item;
 
144
    int           idx          = info->idx;
 
145
    char         *base_awar    = GDE_maketmpawarname(gmenuitem, idx);
 
146
 
 
147
    static GB_HASH *popup_hash  = NULL;
 
148
    if (!popup_hash) popup_hash = GBS_create_hash(20, GB_MIND_CASE);
 
149
 
 
150
    AW_window *aw_browser = (AW_window*)GBS_read_hash(popup_hash, base_awar);
 
151
    if (!aw_browser) {
 
152
        const char *title = (const char *)cl_title;
 
153
        aw_browser        = GDE_create_filename_browser_window(aw->get_root(), base_awar, title);
 
154
        GBS_write_hash(popup_hash, base_awar, (long)aw_browser);
 
155
    }
 
156
    aw_browser->activate();
 
157
    free(base_awar);
 
158
}
 
159
 
 
160
static AW_window *GDE_menuitem_cb(AW_root *aw_root, GmenuItem *gmenuitem) {
132
161
#define BUFSIZE 200
133
162
    char bf[BUFSIZE+1];
134
 
#if defined(ASSERTION_USED)
135
 
    int printed = 
136
 
#endif // ASSERTION_USED
137
 
        sprintf(bf,"GDE / %s / %s",gmenuitem->parent_menu->label,gmenuitem->label);
138
 
    
139
 
    gb_assert(printed<=BUFSIZE);
 
163
    IF_ASSERTION_USED(int printed =)
 
164
        sprintf(bf, "GDE / %s / %s", gmenuitem->parent_menu->label, gmenuitem->label);
 
165
 
 
166
    gde_assert(printed<=BUFSIZE);
140
167
    char seqtype = gmenuitem->seqtype;
141
168
 
142
169
    if (gmenuitem->aws == NULL) {
143
170
        AW_window_simple *aws = new AW_window_simple;
144
 
        aws->init(aw_root,bf,bf);
 
171
        aws->init(aw_root, bf, bf);
145
172
 
146
 
        switch (gde_cgss.wt) {
147
 
            case CGSS_WT_DEFAULT: {
 
173
        switch (db_access.window_type) {
 
174
            case GDE_WINDOWTYPE_DEFAULT: {
148
175
                if (seqtype == '-') aws->load_xfig("gdeitem_simple.fig");
149
176
                else                aws->load_xfig("gdeitem.fig");
150
177
                break;
151
178
            }
152
 
            case CGSS_WT_EDIT:
153
 
                gde_assert(seqtype != '-');
154
 
                aws->load_xfig("gde2item.fig");
155
 
                break;
156
 
            case CGSS_WT_EDIT4:
 
179
            case GDE_WINDOWTYPE_EDIT4:
157
180
                gde_assert(seqtype != '-');
158
181
                aws->load_xfig("gde3item.fig");
159
182
                break;
160
 
            default:
161
 
                gde_assert(0);
162
183
        }
163
184
 
164
 
        aws->set_window_size(1000,2000);
 
185
        aws->set_window_size(1000, 2000);
165
186
        aws->button_length(10);
166
 
        aws->at(10,10);
167
 
        aws->auto_space(0,10);
 
187
        aws->at(10, 10);
 
188
        aws->auto_space(0, 10);
168
189
 
169
190
        aws->at("help");
170
 
        aws->callback((AW_CB2)GDE_showhelp_cb,(AW_CL)gmenuitem,0);
171
 
        aws->create_button("GDE_HELP","HELP...","H");
 
191
        aws->callback((AW_CB2)GDE_showhelp_cb, (AW_CL)gmenuitem, 0);
 
192
        aws->create_button("GDE_HELP", "HELP", "H");
172
193
 
173
194
        aws->at("start");
174
 
        aws->callback((AW_CB2)GDE_startaction_cb,(AW_CL)gmenuitem,0);
175
 
        aws->create_button("GO", "GO","O");
 
195
        aws->callback((AW_CB2)GDE_startaction_cb, (AW_CL)gmenuitem, 0);
 
196
        aws->create_button("GO", "GO", "O");
176
197
 
177
198
        aws->at("cancel");
178
199
        aws->callback((AW_CB0)AW_POPDOWN);
179
 
        aws->create_button("CLOSE", "CLOSE","C");
 
200
        aws->create_button("CLOSE", "CLOSE", "C");
180
201
 
181
202
 
182
203
        if (gmenuitem->numinputs>0) {
183
 
            switch (gde_cgss.wt) {
184
 
                case CGSS_WT_DEFAULT: {
 
204
            switch (db_access.window_type) {
 
205
                case GDE_WINDOWTYPE_DEFAULT: {
185
206
                    if (seqtype != '-') { // '-' means "skip sequence export"
186
207
                        aws->at("which_alignment");
187
208
                        const char *ali_filter = seqtype == 'A' ? "pro=:ami=" : (seqtype == 'N' ? "dna=:rna=" : "*=");
188
 
                        awt_create_selection_list_on_ad(GLOBAL_gb_main, (AW_window *)aws, AWAR_GDE_ALIGNMENT, ali_filter);
 
209
                        awt_create_selection_list_on_alignments(db_access.gb_main, (AW_window *)aws, AWAR_GDE_ALIGNMENT, ali_filter);
189
210
 
190
 
                        aws->at( "which_species" );
 
211
                        aws->at("which_species");
191
212
                        aws->create_toggle_field(AWAR_GDE_SPECIES);
192
 
                        aws->insert_toggle( "all", "a", 0 );
193
 
                        aws->insert_default_toggle( "marked",  "m", 1 );
 
213
                        aws->insert_toggle("all", "a", 0);
 
214
                        aws->insert_default_toggle("marked",   "m", 1);
194
215
                        aws->update_toggle_field();
195
216
 
196
217
                        if (seqtype != 'N') {
201
222
                    }
202
223
                    break;
203
224
                }
204
 
                case CGSS_WT_EDIT:
205
 
                    aws->at("bottom"); aws->create_toggle("gde/bottom_area");
206
 
                    aws->at("bottomsai"); aws->create_toggle("gde/bottom_area_sai");
207
 
                    aws->at("bottomh"); aws->create_toggle("gde/bottom_area_helix");
208
 
                    goto both_edits;
209
 
                case CGSS_WT_EDIT4:
 
225
                case GDE_WINDOWTYPE_EDIT4:
210
226
                    aws->at("topk"); aws->create_toggle("gde/top_area_kons");
211
227
                    aws->at("middlek"); aws->create_toggle("gde/middle_area_kons");
212
228
                    aws->at("topr"); aws->create_toggle("gde/top_area_remark");
213
229
                    aws->at("middler"); aws->create_toggle("gde/middle_area_remark");
214
 
                    goto both_edits;
215
 
                both_edits:
216
230
                    aws->at("top"); aws->create_toggle("gde/top_area");
217
231
                    aws->at("topsai"); aws->create_toggle("gde/top_area_sai");
218
232
                    aws->at("toph"); aws->create_toggle("gde/top_area_helix");
224
238
 
225
239
            if (seqtype != '-') {
226
240
                aws->at("compression");
227
 
                aws->create_option_menu(AWAR_GDE_COMPRESSION, "", "");
 
241
                aws->create_option_menu(AWAR_GDE_COMPRESSION, true);
228
242
                aws->insert_option("none", "n", COMPRESS_NONE);
229
243
                aws->insert_option("vertical gaps", "v", COMPRESS_VERTICAL_GAPS);
230
244
                aws->insert_default_option("columns w/o info", "i", COMPRESS_NONINFO_COLUMNS);
233
247
 
234
248
                aws->button_length(12);
235
249
                aws->at("filtername");
236
 
                if (!agde_filtercd) { // create only one filter - used for all GDE calls 
237
 
                    agde_filtercd = awt_create_select_filter(aws->get_root(),GLOBAL_gb_main, AWAR_GDE_FILTER_NAME);
 
250
                if (!agde_filter) { // create only one filter - used for all GDE calls
 
251
                    agde_filter = awt_create_select_filter(aws->get_root(), db_access.gb_main, AWAR_GDE_FILTER_NAME);
238
252
                }
239
 
                aws->callback((AW_CB2)AW_POPUP, (AW_CL)awt_create_select_filter_win, (AW_CL)agde_filtercd);
 
253
                aws->callback(makeCreateWindowCallback(awt_create_select_filter_win, agde_filter));
240
254
                aws->create_button("SELECT_FILTER", AWAR_GDE_FILTER_NAME);
241
255
            }
242
256
 
249
263
 
250
264
        int labellength = 1;
251
265
        long i;
252
 
        for (i=0;i<gmenuitem->numargs;i++) {
253
 
            if(!(gmenuitem->arg[i].label)) gmenuitem->arg[i].label = GDEBLANK;
 
266
        for (i=0; i<gmenuitem->numargs; i++) {
 
267
            if (!(gmenuitem->arg[i].label)) gmenuitem->arg[i].label = GDEBLANK;
254
268
 
255
269
            const char *label    = gmenuitem->arg[i].label;
256
270
            const char *linefeed = strchr(label, '\n');
271
285
            }
272
286
        }
273
287
        aws->label_length(labellength);
274
 
        aws->auto_space(0,0);
275
 
 
276
 
        for (i=0;i<gmenuitem->numargs;i++) {
277
 
            GmenuItemArg itemarg=gmenuitem->arg[i];
278
 
 
279
 
            if(itemarg.type==SLIDER) {
280
 
                char *newawar=GDE_makeawarname(gmenuitem,i);
281
 
                if ( int(gmenuitem->arg[i].fvalue) == gmenuitem->arg[i].fvalue &&
282
 
                     int(gmenuitem->arg[i].min) == gmenuitem->arg[i].min &&
283
 
                     int(gmenuitem->arg[i].max) == gmenuitem->arg[i].max){
284
 
                    aw_root->awar_int(newawar,(long)gmenuitem->arg[i].fvalue,AW_ROOT_DEFAULT);
285
 
                }else{
286
 
                    aw_root->awar_float(newawar,gmenuitem->arg[i].fvalue,AW_ROOT_DEFAULT);
287
 
                }
288
 
                aw_root->awar(newawar)->set_minmax(gmenuitem->arg[i].min,gmenuitem->arg[i].max);
289
 
                aws->label(gmenuitem->arg[i].label);
290
 
                GDE_create_infieldwithpm(aws,newawar,SLIDERWIDTH);
 
288
        aws->auto_space(0, 0);
 
289
 
 
290
        for (i=0; i<gmenuitem->numargs; i++) {
 
291
            GmenuItemArg itemarg = gmenuitem->arg[i];
 
292
 
 
293
            if (itemarg.type==SLIDER) {
 
294
                char *newawar=GDE_makeawarname(gmenuitem, i);
 
295
                if (int(itemarg.fvalue) == itemarg.fvalue &&
 
296
                     int(itemarg.min) == itemarg.min &&
 
297
                     int(itemarg.max) == itemarg.max) {
 
298
                    aw_root->awar_int(newawar, (long)itemarg.fvalue, AW_ROOT_DEFAULT);
 
299
                }
 
300
                else {
 
301
                    aw_root->awar_float(newawar, itemarg.fvalue, AW_ROOT_DEFAULT);
 
302
                }
 
303
                aw_root->awar(newawar)->set_minmax(itemarg.min, itemarg.max);
 
304
                aws->label(itemarg.label);
 
305
                aws->sens_mask(itemarg.active_mask);
 
306
                GDE_create_infieldwithpm(aws, newawar, SLIDERWIDTH);
291
307
                // maybe bound checking //
292
308
                free(newawar);
293
309
            }
294
 
            else if(itemarg.type==CHOOSER) {
 
310
            else if (itemarg.type==CHOOSER) {
295
311
                char    *defopt           = itemarg.choice[0].method;
296
 
                char    *newawar          = GDE_makeawarname(gmenuitem,i);
297
 
                AW_awar *curr_awar        = aw_root->awar_string(newawar,defopt,AW_ROOT_DEFAULT);
 
312
                char    *newawar          = GDE_makeawarname(gmenuitem, i);
 
313
                AW_awar *curr_awar        = aw_root->awar_string(newawar, defopt, AW_ROOT_DEFAULT);
298
314
                char    *curr_value       = curr_awar->read_string();
299
315
                bool     curr_value_legal = false;
300
316
 
301
 
                aws->label(gmenuitem->arg[i].label);
302
 
                if ((strcasecmp(itemarg.choice[0].label,"no") == 0) ||
303
 
                    (strcasecmp(itemarg.choice[0].label,"yes") == 0))
 
317
                aws->label(itemarg.label);
 
318
                aws->sens_mask(itemarg.active_mask);
 
319
                if ((strcasecmp(itemarg.choice[0].label, "no") == 0) ||
 
320
                    (strcasecmp(itemarg.choice[0].label, "yes") == 0))
304
321
                {
305
 
                    aws->create_toggle_field(newawar,1);
 
322
                    aws->create_toggle_field(newawar, 1);
306
323
                }
307
324
                else {
308
325
                    aws->create_toggle_field(newawar);
309
326
                }
310
327
 
311
 
                for(long j=0;j<itemarg.numchoices;j++) {
 
328
                for (long j=0; j<itemarg.numchoices; j++) {
312
329
                    if (strcmp(itemarg.choice[j].method, curr_value) == 0) curr_value_legal = true;
313
330
 
314
331
                    if (!j) {
315
 
                        aws->insert_default_toggle(itemarg.choice[j].label,"1", itemarg.choice[j].method);
 
332
                        aws->insert_default_toggle(itemarg.choice[j].label, "1", itemarg.choice[j].method);
316
333
                    }
317
334
                    else {
318
 
                        aws->insert_toggle(itemarg.choice[j].label,"1", itemarg.choice[j].method);
 
335
                        aws->insert_toggle(itemarg.choice[j].label, "1", itemarg.choice[j].method);
319
336
                    }
320
337
                }
321
338
                if (!curr_value_legal) curr_awar->write_string(defopt); // if saved value no longer occurs in choice -> overwrite with default
323
340
                aws->update_toggle_field();
324
341
                free(newawar);
325
342
            }
326
 
            else if(itemarg.type==CHOICE_MENU) {
 
343
            else if (itemarg.type==CHOICE_MENU) {
327
344
                char    *defopt           = itemarg.choice[itemarg.ivalue].method;
328
 
                char    *newawar          = GDE_makeawarname(gmenuitem,i);
329
 
                AW_awar *curr_awar        = aw_root->awar_string(newawar,defopt,AW_ROOT_DEFAULT);
 
345
                char    *newawar          = GDE_makeawarname(gmenuitem, i);
 
346
                AW_awar *curr_awar        = aw_root->awar_string(newawar, defopt, AW_ROOT_DEFAULT);
330
347
                char    *curr_value       = curr_awar->read_string();
331
348
                bool     curr_value_legal = false;
332
349
 
333
 
                aws->label(gmenuitem->arg[i].label);
334
 
                aws->create_option_menu(newawar,NULL,"");
 
350
                if (itemarg.label[0]) aws->label(itemarg.label);
 
351
                aws->sens_mask(itemarg.active_mask);
 
352
                aws->create_option_menu(newawar, true);
335
353
 
336
 
                for(long j=0;j<itemarg.numchoices;j++) {
 
354
                for (long j=0; j<itemarg.numchoices; j++) {
337
355
                    if (strcmp(itemarg.choice[j].method, curr_value) == 0) curr_value_legal = true;
338
 
                    aws->insert_option(itemarg.choice[j].label,"1", itemarg.choice[j].method);
 
356
                    aws->insert_option(itemarg.choice[j].label, "1", itemarg.choice[j].method);
339
357
                }
340
358
                if (!curr_value_legal) curr_awar->write_string(defopt); // if saved value no longer occurs in choice -> overwrite with default
341
359
                free(curr_value);
342
360
                aws->update_option_menu();
343
361
                free(newawar);
344
362
            }
345
 
            else if(itemarg.type==TEXTFIELD) {
 
363
            else if (itemarg.type==TEXTFIELD) {
346
364
                char *defopt  = itemarg.textvalue;
347
 
                char *newawar = GDE_makeawarname(gmenuitem,i);
348
 
                aw_root->awar_string(newawar,defopt,AW_ROOT_DEFAULT);
349
 
                aws->label(gmenuitem->arg[i].label);
350
 
                aws->create_input_field(newawar,itemarg.textwidth/*TEXTFIELDWIDTH*/);
351
 
                free(newawar);
352
 
            }
353
 
            else if(itemarg.type==CHOICE_TREE) {
354
 
                char *defopt=itemarg.textvalue;
355
 
                char *newawar=GDE_makeawarname(gmenuitem,i);
356
 
                aw_root->awar_string(newawar,defopt,AW_ROOT_DEFAULT);
357
 
                aws->label(gmenuitem->arg[i].label);
358
 
                awt_create_selection_list_on_trees(GLOBAL_gb_main,aws,newawar);
359
 
                free(newawar);
360
 
            }
361
 
            else if(itemarg.type==CHOICE_SAI) {
362
 
                char *defopt=itemarg.textvalue;
363
 
                char *newawar=GDE_makeawarname(gmenuitem,i);
364
 
                aw_root->awar_string(newawar,defopt,AW_ROOT_DEFAULT);
365
 
                aws->label(gmenuitem->arg[i].label);
366
 
                awt_create_selection_list_on_extendeds(GLOBAL_gb_main,aws,newawar);
367
 
                free(newawar);
368
 
            }
369
 
            else if(itemarg.type==CHOICE_WEIGHTS) {
370
 
                char *defopt=itemarg.textvalue;
371
 
                char *newawar=GDE_makeawarname(gmenuitem,i);
372
 
                aw_root->awar_string(newawar,defopt,AW_ROOT_DEFAULT);
373
 
                aws->label(gmenuitem->arg[i].label);
374
 
                void *id = awt_create_selection_list_on_extendeds(GLOBAL_gb_main,aws,newawar,gde_filter_weights);
375
 
                free(newawar);
376
 
                aw_root->awar(AWAR_GDE_ALIGNMENT)->add_callback((AW_RCB1)awt_create_selection_list_on_extendeds_update,(AW_CL)id);
 
365
                char *newawar = GDE_makeawarname(gmenuitem, i);
 
366
                aw_root->awar_string(newawar, defopt, AW_ROOT_DEFAULT);
 
367
                aws->label(itemarg.label);
 
368
                aws->sens_mask(itemarg.active_mask);
 
369
                aws->create_input_field(newawar, itemarg.textwidth);  // TEXTFIELDWIDTH
 
370
                free(newawar);
 
371
            }
 
372
            else if (itemarg.type==FILE_SELECTOR) {
 
373
                char *base_awar = GDE_maketmpawarname(gmenuitem, i);
 
374
                char *name_awar = GBS_global_string_copy("%s/file_name", base_awar);
 
375
 
 
376
                AW_create_fileselection_awars(aw_root, base_awar, "", itemarg.textvalue, "");
 
377
 
 
378
                aws->label(itemarg.label);
 
379
                aws->sens_mask(itemarg.active_mask);
 
380
                aws->create_input_field(name_awar, 40);
 
381
                aws->callback(GDE_popup_filename_browser, (AW_CL)new gde_iteminfo(gmenuitem, i), (AW_CL)strdup(itemarg.label));
 
382
                aws->create_button("", "Browse");
 
383
 
 
384
                free(name_awar);
 
385
                free(base_awar);
 
386
            }
 
387
            else if (itemarg.type==CHOICE_TREE) {
 
388
                char *defopt=itemarg.textvalue;
 
389
                char *newawar=GDE_makeawarname(gmenuitem, i);
 
390
                aw_root->awar_string(newawar, defopt, AW_ROOT_DEFAULT);
 
391
                aws->sens_mask(itemarg.active_mask);
 
392
                if (itemarg.label[0]) aws->create_button(NULL, itemarg.label);
 
393
                awt_create_selection_list_on_trees(db_access.gb_main, aws, newawar, true);
 
394
                free(newawar);
 
395
            }
 
396
            else if (itemarg.type==CHOICE_SAI) {
 
397
                char *defopt=itemarg.textvalue;
 
398
                char *newawar=GDE_makeawarname(gmenuitem, i);
 
399
                aw_root->awar_string(newawar, defopt, AW_ROOT_DEFAULT);
 
400
                aws->sens_mask(itemarg.active_mask);
 
401
                if (itemarg.label[0]) aws->create_button(NULL, itemarg.label);
 
402
                awt_create_selection_list_on_sai(db_access.gb_main, aws, newawar, true);
 
403
                free(newawar);
 
404
            }
 
405
            else if (itemarg.type==CHOICE_WEIGHTS) {
 
406
                char *defopt=itemarg.textvalue;
 
407
                char *newawar=GDE_makeawarname(gmenuitem, i);
 
408
                aw_root->awar_string(newawar, defopt, AW_ROOT_DEFAULT);
 
409
                aws->sens_mask(itemarg.active_mask);
 
410
                if (itemarg.label[0]) aws->create_button(NULL, itemarg.label);
 
411
                AWT_sai_selection *id = awt_create_selection_list_on_sai(db_access.gb_main, aws, newawar, true, gde_filter_weights);
 
412
                free(newawar);
 
413
                aw_root->awar(AWAR_GDE_ALIGNMENT)->add_callback(makeRootCallback(awt_selection_list_on_sai_update_cb, id));
377
414
            }
378
415
 
379
416
            aws->at_newline();
380
 
            // if((gmenuitem->numargs<8) || GDE_odd(i)) aws->at_newline();
381
 
            // else aws->at_shift( 50,0 );
382
417
        }
383
418
        aws->at_newline();
384
419
        aws->window_fit();
392
427
 
393
428
 
394
429
 
395
 
void GDE_load_menu(AW_window *awm, AW_active mask, const char *menulabel, const char *menuitemlabel) {
 
430
void GDE_load_menu(AW_window *awm, AW_active /*mask*/, const char *menulabel) {
396
431
    // Load GDE menu items.
397
432
    //
398
433
    // If 'menulabel' == NULL -> load all menus
399
434
    // Else                   -> load specified menu
400
 
    // 
401
 
    // If 'menuitemlabel' == NULL -> load complete menu(s)
402
 
    // Else                       -> load only specific menu topic
403
 
 
404
 
    char       buffer[1024];
405
 
    char      *help;
406
 
    long       nitem,num_items;
407
 
    GmenuItem *menuitem;
408
 
    char       hotkey[]   = "x";
409
 
    bool       menuloaded = false;
410
 
    bool       itemloaded = false;
 
435
    //
 
436
    // Always loads complete menu(s).
 
437
 
 
438
    gde_assert(db_access.gb_main); // forgot to call GDE_create_var() ?
 
439
 
 
440
    char hotkey[]   = "x";
 
441
    bool menuloaded = false;
 
442
    bool itemloaded = false;
411
443
 
412
444
    for (long nmenu = 0; nmenu<num_menus; nmenu++) {
413
445
        {
414
446
            const char *menuname = menu[nmenu].label;
415
 
            if (menulabel){
416
 
                if (strcmp(menulabel,menuname)) {
 
447
            if (menulabel) {
 
448
                if (strcmp(menulabel, menuname)) {
417
449
                    continue;
418
450
                }
419
451
            }
420
452
            else {
421
 
                hotkey[0]     = menu[nmenu].meta;
422
 
                awm->insert_sub_menu(menuname, hotkey);
 
453
                hotkey[0] = menu[nmenu].meta;
 
454
                awm->insert_sub_menu(menuname, hotkey, menu[nmenu].active_mask);
423
455
            }
424
456
        }
425
457
 
426
458
        menuloaded = true;
427
459
 
428
 
        num_items = menu[nmenu].numitems;
429
 
        for (nitem=0; nitem<num_items;nitem++) {
430
 
            menuitem=&menu[nmenu].item[nitem];
431
 
            if (!menuitemlabel || strcmp(menuitem->label,menuitemlabel) == 0) {
432
 
                itemloaded = true;
433
 
                if (menuitem->help) {
434
 
                    sprintf(buffer,"GDEHELP/%s",menuitem->help);
435
 
                    help = strdup(buffer);
436
 
                }
437
 
                else {
438
 
                    help = 0;
439
 
                }
440
 
                hotkey[0]     = menuitem->meta;
441
 
                awm->insert_menu_topic(0,menuitem->label,hotkey,
442
 
                                       help, mask,
443
 
                                       AW_POPUP, (AW_CL)GDE_menuitem_cb, (AW_CL)menuitem);
444
 
            }
 
460
        long num_items = menu[nmenu].numitems;
 
461
        for (long nitem=0; nitem<num_items; nitem++) {
 
462
            GmenuItem *menuitem=&menu[nmenu].item[nitem];
 
463
            itemloaded = true;
 
464
            gde_assert(!menuitem->help || ARB_strBeginsWith(menuitem->help, "agde_"));
 
465
            hotkey[0] = menuitem->meta;
 
466
            awm->insert_menu_topic(menuitem->label, menuitem->label, hotkey,
 
467
                                   menuitem->help, menuitem->active_mask,
 
468
                                   AW_POPUP, (AW_CL)GDE_menuitem_cb, (AW_CL)menuitem);
445
469
        }
446
 
        if (!menulabel){
 
470
 
 
471
        if (!menulabel) {
447
472
            awm->close_sub_menu();
448
473
        }
449
474
    }
451
476
    if (!menuloaded && menulabel) {
452
477
        fprintf(stderr, "GDE-Warning: Could not find requested menu '%s'\n", menulabel);
453
478
    }
454
 
    if (!itemloaded && menuitemlabel) {
455
 
        if (menulabel) {
456
 
            fprintf(stderr, "GDE-Warning: Could not find requested topic '%s' in menu '%s'\n", menuitemlabel, menulabel);
457
 
        }
458
 
        else {
459
 
            fprintf(stderr, "GDE-Warning: Could not find requested topic '%s'\n", menuitemlabel);
460
 
        }
461
 
    }
462
479
}
463
480
 
464
 
struct choose_get_sequence_struct gde_cgss = { 0, CGSS_WT_DEFAULT, 0 };
465
 
 
466
 
void create_gde_var(AW_root  *aw_root, AW_default aw_def,
467
 
                    char *(*get_sequences)(void *THIS, GBDATA **&the_species,
468
 
                                           uchar **&the_names,
469
 
                                           uchar **&the_sequences,
470
 
                                           long &numberspecies,long &maxalignlen),
471
 
                    gde_cgss_window_type wt,
472
 
                    void *THIS)
473
 
{
474
 
    gde_cgss.get_sequences= get_sequences;
475
 
    gde_cgss.wt = wt;
476
 
    gde_cgss.THIS= THIS;
477
 
 
478
 
    // aw_root->awar_string("tmp/gde/helptext", "help", aw_def); // only occurrence
 
481
struct gde_database_access db_access = { NULL, GDE_WINDOWTYPE_DEFAULT, 0, NULL};
 
482
 
 
483
GB_ERROR GDE_create_var(AW_root *aw_root, AW_default aw_def, GBDATA *gb_main, GDE_get_sequences_cb get_sequences, gde_window_type window_type, AW_CL client_data) {
 
484
    db_access.get_sequences = get_sequences;
 
485
    db_access.window_type   = window_type;
 
486
    db_access.client_data   = client_data;
 
487
    db_access.gb_main       = gb_main;
 
488
 
479
489
    aw_root->awar_string(AWAR_GDE_ALIGNMENT, "", aw_def);
480
490
 
481
 
    switch (gde_cgss.wt)
482
 
    {
483
 
        case CGSS_WT_EDIT4:
484
 
            aw_root->awar_int("gde/top_area_kons",1,aw_def);
485
 
            aw_root->awar_int("gde/top_area_remark",1,aw_def);
486
 
            aw_root->awar_int("gde/middle_area_kons",1,aw_def);
487
 
            aw_root->awar_int("gde/middle_area_remark",1,aw_def);
488
 
        case CGSS_WT_EDIT:
489
 
            aw_root->awar_int("gde/top_area",1,aw_def);
490
 
            aw_root->awar_int("gde/top_area_sai",1,aw_def);
491
 
            aw_root->awar_int("gde/top_area_helix",1,aw_def);
492
 
            aw_root->awar_int("gde/middle_area",1,aw_def);
493
 
            aw_root->awar_int("gde/middle_area_sai",1,aw_def);
494
 
            aw_root->awar_int("gde/middle_area_helix",1,aw_def);
495
 
            aw_root->awar_int("gde/bottom_area",1,aw_def);
496
 
            aw_root->awar_int("gde/bottom_area_sai",1,aw_def);
497
 
            aw_root->awar_int("gde/bottom_area_helix",1,aw_def);
498
 
        default:
 
491
    switch (db_access.window_type) {
 
492
        case GDE_WINDOWTYPE_EDIT4:
 
493
            aw_root->awar_int("gde/top_area_kons",      1, aw_def);
 
494
            aw_root->awar_int("gde/top_area_remark",    1, aw_def);
 
495
            aw_root->awar_int("gde/middle_area_kons",   1, aw_def);
 
496
            aw_root->awar_int("gde/middle_area_remark", 1, aw_def);
 
497
            aw_root->awar_int("gde/top_area",           1, aw_def);
 
498
            aw_root->awar_int("gde/top_area_sai",       1, aw_def);
 
499
            aw_root->awar_int("gde/top_area_helix",     1, aw_def);
 
500
            aw_root->awar_int("gde/middle_area",        1, aw_def);
 
501
            aw_root->awar_int("gde/middle_area_sai",    1, aw_def);
 
502
            aw_root->awar_int("gde/middle_area_helix",  1, aw_def);
 
503
            aw_root->awar_int("gde/bottom_area",        1, aw_def);
 
504
            aw_root->awar_int("gde/bottom_area_sai",    1, aw_def);
 
505
            aw_root->awar_int("gde/bottom_area_helix",  1, aw_def);
 
506
            break;
 
507
        case GDE_WINDOWTYPE_DEFAULT:
499
508
            break;
500
509
    }
501
510
 
502
 
    aw_root->awar_string("presets/use",             "", GLOBAL_gb_main);
 
511
    aw_root->awar_string(AWAR_DEFAULT_ALIGNMENT, "", db_access.gb_main);
503
512
    
504
513
    aw_root->awar_string(AWAR_GDE_FILTER_NAME,      "", aw_def);
505
514
    aw_root->awar_string(AWAR_GDE_FILTER_FILTER,    "", aw_def);
507
516
 
508
517
    aw_root->awar_int(AWAR_GDE_CUTOFF_STOPCODON, 0, aw_def);
509
518
    aw_root->awar_int(AWAR_GDE_SPECIES,          1, aw_def);
510
 
    
 
519
 
511
520
    aw_root->awar_int(AWAR_GDE_COMPRESSION, COMPRESS_NONINFO_COLUMNS, aw_def);
512
521
 
513
 
    aw_root->awar(AWAR_GDE_ALIGNMENT)->map("presets/use");
514
 
    aw_root->awar(AWAR_GDE_FILTER_ALIGNMENT)->map("presets/use");
 
522
    aw_root->awar(AWAR_GDE_ALIGNMENT)->map(AWAR_DEFAULT_ALIGNMENT);
 
523
    aw_root->awar(AWAR_GDE_FILTER_ALIGNMENT)->map(AWAR_DEFAULT_ALIGNMENT);
515
524
 
516
 
    DataSet = (NA_Alignment *) Calloc(1,sizeof(NA_Alignment));
 
525
    DataSet = (NA_Alignment *) Calloc(1, sizeof(NA_Alignment));
517
526
    DataSet->rel_offset = 0;
518
 
    ParseMenu();
 
527
    return LoadMenus();
519
528
}
520
529