← Back to branch summary

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

« back to all changes in this revision

Viewing changes to MERGE/MG_alignment.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:
MERGE/MG_alignment.cxx
1
 
#include <stdio.h>
2
 
#include <stdlib.h>
 
1
// =============================================================== //
 
2
//                                                                 //
 
3
//   File      : MG_alignment.cxx                                  //
 
4
//   Purpose   :                                                   //
 
5
//                                                                 //
 
6
//   Institute of Microbiology (Technical University Munich)       //
 
7
//   http://www.arb-home.de/                                       //
 
8
//                                                                 //
 
9
// =============================================================== //
 
10
 
 
11
#include "merge.hxx"
 
12
 
 
13
#include <awt_sel_boxes.hxx>
 
14
#include <aw_root.hxx>
 
15
#include <aw_question.hxx>
 
16
#include <aw_awar.hxx>
 
17
#include <aw_msg.hxx>
 
18
#include <arbdbt.h>
 
19
#include <arb_strarray.h>
 
20
 
3
21
#include <unistd.h>
4
 
#include <string.h>
5
 
#include <arbdb.h>
6
 
#include <arbdbt.h>
7
 
#include <aw_root.hxx>
8
 
#include <aw_device.hxx>
9
 
#include <aw_window.hxx>
10
 
#include <awt.hxx>
11
 
#include <awt_sel_boxes.hxx>
12
 
#include "merge.hxx"
13
 
 
14
 
#define AWAR1 "tmp/merge1/"
15
 
#define AWAR2 "tmp/merge2/"
16
 
#define AWAR_ALI1 AWAR1"alignment_name"
17
 
#define AWAR_ALI2 AWAR2"alignment_name"
18
 
 
19
 
void MG_alignment_vars_callback(AW_root *aw_root,GBDATA *gbd, long ali_nr)
20
 
{
21
 
    char buffer[256];
22
 
 
23
 
    GB_push_transaction(gbd);
24
 
    sprintf(buffer,"tmp/merge%li/alignment_name",ali_nr);
25
 
    char    *use = aw_root->awar(buffer)->read_string();
26
 
    GBDATA *ali_cont = GBT_get_alignment(gbd,use);
 
22
 
 
23
#define AWAR_ALI_NAME(db_nr) awar_name_tmp(db_nr, "alignment_name")
 
24
#define AWAR_ALI_DEST(db_nr) awar_name_tmp(db_nr, "alignment_dest")
 
25
#define AWAR_ALI_TYPE(db_nr) awar_name_tmp(db_nr, "alignment_type")
 
26
#define AWAR_ALI_LEN(db_nr)  awar_name_tmp(db_nr, "alignment_len")
 
27
#define AWAR_ALIGNED(db_nr)  awar_name_tmp(db_nr, "aligned")
 
28
#define AWAR_SECURITY(db_nr) awar_name_tmp(db_nr, "security")
 
29
 
 
30
#define AWAR_ALI_SRC AWAR_MERGE_TMP_SRC "alignment_name"
 
31
#define AWAR_ALI_DST AWAR_MERGE_TMP_DST "alignment_name"
 
32
 
 
33
static void MG_alignment_vars_callback(AW_root *aw_root, int db_nr) {
 
34
    GBDATA         *gb_main = get_gb_main(db_nr);
 
35
    GB_transaction  ta(gb_main);
 
36
 
 
37
    char   *use      = aw_root->awar(AWAR_ALI_NAME(db_nr))->read_string();
 
38
    GBDATA *ali_cont = GBT_get_alignment(gb_main, use);
 
39
 
27
40
    if (!ali_cont) {
28
 
        sprintf(buffer,"tmp/merge%li/alignment_type",ali_nr);
29
 
        aw_root->awar(buffer)->unmap();
30
 
 
31
 
        sprintf(buffer,"tmp/merge%li/alignment_len",ali_nr);
32
 
        aw_root->awar(buffer)->unmap();
33
 
 
34
 
        sprintf(buffer,"tmp/merge%li/aligned",ali_nr);
35
 
        aw_root->awar(buffer)->unmap();
36
 
 
37
 
        sprintf(buffer,"tmp/merge%li/security",ali_nr);
38
 
        aw_root->awar(buffer)->unmap();
39
 
    }else{
40
 
 
41
 
        GBDATA *ali_len      = GB_entry(ali_cont,"alignment_len");
42
 
        GBDATA *ali_aligned  = GB_entry(ali_cont,"aligned");
43
 
        GBDATA *ali_type     = GB_entry(ali_cont,"alignment_type");
44
 
        GBDATA *ali_security = GB_entry(ali_cont,"alignment_write_security");
45
 
 
46
 
        sprintf(buffer,"tmp/merge%li/alignment_type",ali_nr);
47
 
        aw_root->awar(buffer)->map(ali_type);
48
 
 
49
 
        sprintf(buffer,"tmp/merge%li/alignment_len",ali_nr);
50
 
        aw_root->awar(buffer)->map(ali_len);
51
 
 
52
 
        sprintf(buffer,"tmp/merge%li/aligned",ali_nr);
53
 
        aw_root->awar(buffer)->map(ali_aligned);
54
 
 
55
 
        sprintf(buffer,"tmp/merge%li/security",ali_nr);
56
 
        aw_root->awar(buffer)->map(ali_security);
57
 
 
58
 
    }
59
 
    GB_pop_transaction(gbd);
 
41
        aw_root->awar(AWAR_ALI_TYPE(db_nr))->unmap();
 
42
        aw_root->awar(AWAR_ALI_LEN (db_nr))->unmap();
 
43
        aw_root->awar(AWAR_ALIGNED (db_nr))->unmap();
 
44
        aw_root->awar(AWAR_SECURITY(db_nr))->unmap();
 
45
    }
 
46
    else {
 
47
        GBDATA *ali_len      = GB_entry(ali_cont, "alignment_len");
 
48
        GBDATA *ali_aligned  = GB_entry(ali_cont, "aligned");
 
49
        GBDATA *ali_type     = GB_entry(ali_cont, "alignment_type");
 
50
        GBDATA *ali_security = GB_entry(ali_cont, "alignment_write_security");
 
51
 
 
52
        aw_root->awar(AWAR_ALI_TYPE(db_nr))->map(ali_type);
 
53
        aw_root->awar(AWAR_ALI_LEN (db_nr))->map(ali_len);
 
54
        aw_root->awar(AWAR_ALIGNED (db_nr))->map(ali_aligned);
 
55
        aw_root->awar(AWAR_SECURITY(db_nr))->map(ali_security);
 
56
 
 
57
    }
60
58
    free(use);
61
59
}
62
60
 
63
61
 
64
 
void MG_create_alignment_awars(AW_root *aw_root,AW_default aw_def)
65
 
{
66
 
    aw_root->awar_string( AWAR_ALI1, "" ,   aw_def);
67
 
    aw_root->awar_string( AWAR_ALI2, "" ,   aw_def);
68
 
 
69
 
    aw_root->awar_string( AWAR1"alignment_dest", "" ,   aw_def);
70
 
    aw_root->awar_string( AWAR2"alignment_dest", "" ,   aw_def);
71
 
    aw_root->awar_string( AWAR1"alignment_type", "" ,   aw_def);
72
 
    aw_root->awar_string( AWAR2"alignment_type", "" ,   aw_def);
73
 
    aw_root->awar_int( AWAR1"alignment_len", 0 ,    aw_def);
74
 
    aw_root->awar_int( AWAR2"alignment_len", 0 ,    aw_def);
75
 
    aw_root->awar_int( AWAR1"aligned", 0 ,  aw_def);
76
 
    aw_root->awar_int( AWAR2"aligned", 0 ,  aw_def);
77
 
    aw_root->awar_int( AWAR1"security", 0 , aw_def);
78
 
    aw_root->awar_int( AWAR2"security", 0 , aw_def);
79
 
 
80
 
}
81
 
 
82
 
int MG_check_alignment(AW_window *aww,int fast)
83
 
{
84
 
    AWUSE(aww);
85
 
    // check type and names !!!!
86
 
    char result[1024];
87
 
    result[0] = 0;
88
 
    if (!fast){
89
 
        aw_openstatus("Checking alignments");
90
 
        sleep(1);
91
 
    }
92
 
    GB_begin_transaction(GLOBAL_gb_dest);
93
 
    GB_begin_transaction(GLOBAL_gb_merge);
94
 
    char **names = GBT_get_alignment_names(GLOBAL_gb_merge);
95
 
    char **name;
96
 
    GBDATA *gb_ali1;
97
 
    GBDATA *gb_ali2;
98
 
    GBDATA *gb_presets2;
99
 
 
100
 
    for (name = names; *name; name++) {
101
 
        if (! (gb_ali2 = GBT_get_alignment(GLOBAL_gb_dest,*name)) ) {
102
 
            gb_ali1 = GBT_get_alignment(GLOBAL_gb_merge,*name);
103
 
            gb_presets2 = GB_search(GLOBAL_gb_dest,"presets",GB_CREATE_CONTAINER);
104
 
            gb_ali2 = GB_create_container(gb_presets2,"alignment");
105
 
            GB_copy(gb_ali2,gb_ali1);
106
 
            GBT_add_new_changekey( GLOBAL_gb_dest, (char *)GBS_global_string("%s/data",*name),GB_STRING);
107
 
        }
108
 
        char *type1 = GBT_get_alignment_type_string(GLOBAL_gb_merge,*name);
109
 
        char *type2 = GBT_get_alignment_type_string(GLOBAL_gb_dest,*name);
110
 
        if (strcmp(type1,type2)) {
111
 
            sprintf(result,"The alignments '%s' have different types (%s != %s)", *name,type1,type2);
112
 
            break;
113
 
        }
114
 
        delete(type1);
115
 
        delete(type2);
116
 
    }
117
 
    GBT_free_names(names);
118
 
    GB_commit_transaction(GLOBAL_gb_dest);
119
 
    GB_commit_transaction(GLOBAL_gb_merge);
120
 
    if (strlen(result)) aw_message(result);
121
 
    if (!fast){
122
 
        aw_closestatus();
123
 
    }
124
 
    return strlen(result);
125
 
}
126
 
 
127
 
void MG_ad_al_delete_cb(AW_window *aww,AW_CL db_nr)
128
 
{
129
 
    if (aw_ask_sure("Are you sure to delete all data belonging to this alignment?")) {
130
 
        char     buffer[256];
131
 
        sprintf(buffer,"tmp/merge%li/alignment_name",db_nr);
132
 
 
133
 
        GBDATA *gbd    = (db_nr == 1) ? GLOBAL_gb_merge : GLOBAL_gb_dest;
134
 
        char   *source = aww->get_root()->awar(buffer)->read_string();
 
62
void MG_create_alignment_awars(AW_root *aw_root, AW_default aw_def) {
 
63
    for (int db_nr = 1; db_nr <= 2; ++db_nr) {
 
64
        aw_root->awar_string(AWAR_ALI_NAME(db_nr), "", aw_def);
 
65
        aw_root->awar_string(AWAR_ALI_DEST(db_nr), "", aw_def);
 
66
        aw_root->awar_string(AWAR_ALI_TYPE(db_nr), "", aw_def);
 
67
        aw_root->awar_int   (AWAR_ALI_LEN (db_nr), 0,  aw_def);
 
68
        aw_root->awar_int   (AWAR_ALIGNED (db_nr), 0,  aw_def);
 
69
        aw_root->awar_int   (AWAR_SECURITY(db_nr), 0,  aw_def);
 
70
    }
 
71
}
 
72
 
 
73
static void copy_and_check_alignments_ignoreResult() { MG_copy_and_check_alignments(); }
 
74
int MG_copy_and_check_alignments() {
 
75
    // returns 0 if alignments are ok for merging.
 
76
    // otherwise an error message is shown in message box.
 
77
    // checks types and names.
 
78
 
 
79
    GB_ERROR error = NULL;
 
80
 
 
81
    GB_begin_transaction(GLOBAL_gb_dst);
 
82
    GB_begin_transaction(GLOBAL_gb_src);
 
83
 
 
84
    ConstStrArray names;
 
85
    GBT_get_alignment_names(names, GLOBAL_gb_src);
 
86
 
 
87
    GBDATA *gb_dst_presets = NULL;
 
88
 
 
89
    for (int i = 0; names[i] && !error; ++i) {
 
90
        const char *name       = names[i];
 
91
        GBDATA     *gb_dst_ali = GBT_get_alignment(GLOBAL_gb_dst, name);
 
92
 
 
93
        if (!gb_dst_ali) {
 
94
            GB_clear_error(); // ignore "alignment not found"
 
95
 
 
96
            GBDATA *gb_src_ali = GBT_get_alignment(GLOBAL_gb_src, name);
 
97
            mg_assert(gb_src_ali);
 
98
 
 
99
            if (!gb_dst_presets) gb_dst_presets = GBT_get_presets(GLOBAL_gb_dst);
 
100
 
 
101
            gb_dst_ali = GB_create_container(gb_dst_presets, "alignment");
 
102
            GB_copy(gb_dst_ali, gb_src_ali);
 
103
            GBT_add_new_changekey(GLOBAL_gb_dst, (char *)GBS_global_string("%s/data", name), GB_STRING);
 
104
        }
 
105
 
 
106
        char *src_type = GBT_get_alignment_type_string(GLOBAL_gb_src, name);
 
107
        char *dst_type = GBT_get_alignment_type_string(GLOBAL_gb_dst, name);
 
108
 
 
109
        if (strcmp(src_type, dst_type) != 0) {
 
110
            error = GBS_global_string("The alignments '%s' have different types (%s != %s)", name, src_type, dst_type);
 
111
        }
 
112
        free(dst_type);
 
113
        free(src_type);
 
114
    }
 
115
 
 
116
    GB_commit_transaction(GLOBAL_gb_dst);
 
117
    GB_commit_transaction(GLOBAL_gb_src);
 
118
 
 
119
    if (error) aw_message(error);
 
120
 
 
121
    return !!error;
 
122
}
 
123
 
 
124
static void MG_ad_al_delete_cb(AW_window *aww, int db_nr) {
 
125
    if (aw_ask_sure("merge_delete_ali", "Are you sure to delete all data belonging to this alignment?")) {
 
126
        GBDATA *gb_main = get_gb_main(db_nr);
 
127
        char   *source  = aww->get_root()->awar(AWAR_ALI_NAME(db_nr))->read_string();
135
128
        {
136
 
            GB_transaction ta(gbd);
137
 
            GB_ERROR       error = GBT_rename_alignment(gbd,source,0,0,1);
 
129
            GB_transaction ta(gb_main);
 
130
            GB_ERROR       error = GBT_rename_alignment(gb_main, source, 0, 0, 1);
138
131
 
139
 
            if (error) {
140
 
                error = ta.close(error);
141
 
                aw_message(error);
142
 
            }
 
132
            error = ta.close(error);
 
133
            if (error) aw_message(error);
143
134
        }
144
135
        free(source);
145
136
    }
146
137
}
147
138
 
148
139
 
149
 
void MG_ed_al_check_len_cb(AW_window *aww,AW_CL db_nr)
150
 
{
151
 
    char *error = 0;
152
 
    char  buffer[256];
153
 
    sprintf(buffer,"tmp/merge%li/alignment_name",db_nr);
154
 
 
155
 
    GBDATA *gbd = (db_nr == 1) ? GLOBAL_gb_merge : GLOBAL_gb_dest;
156
 
    char   *use = aww->get_root()->awar(buffer)->read_string();
157
 
 
158
 
    GB_begin_transaction(gbd);
159
 
    if (!error) error = (char *)GBT_check_data(gbd,use);
160
 
    GB_commit_transaction(gbd);
161
 
    if (error) aw_message(error);
162
 
    delete use;
 
140
static void MG_ed_al_check_len_cb(AW_window *aww, int db_nr) {
 
141
    GBDATA *gb_main = get_gb_main(db_nr);
 
142
    char   *use     = aww->get_root()->awar(AWAR_ALI_NAME(db_nr))->read_string();
 
143
 
 
144
    GB_transaction ta(gb_main);
 
145
 
 
146
    GB_ERROR error = GBT_check_data(gb_main, use);
 
147
    error          = ta.close(error);
 
148
 
 
149
    aw_message_if(error);
 
150
    free(use);
163
151
}
164
152
 
165
 
void MG_copy_delete_rename(AW_window * aww, AW_CL db_nr, AW_CL dele)
166
 
{
167
 
    GBDATA   *gbd    = (db_nr == 1) ? GLOBAL_gb_merge : GLOBAL_gb_dest;
168
 
    char     *source = aww->get_root()->awar(GBS_global_string("tmp/merge%li/alignment_name", db_nr))->read_string();
169
 
    char     *dest   = aww->get_root()->awar(GBS_global_string("tmp/merge%li/alignment_dest", db_nr))->read_string();
170
 
    GB_ERROR  error  = GB_begin_transaction(gbd);
171
 
 
172
 
    if (!error) error = GBT_rename_alignment(gbd, source, dest, (int)1, (int)dele);
173
 
    if (!error) error = GBT_add_new_changekey(gbd, GBS_global_string("%s/data", dest), GB_STRING);
174
 
    
175
 
    error = GB_end_transaction(gbd, error);
 
153
static void MG_copy_delete_rename(AW_window * aww, int db_nr, int dele) {
 
154
    GBDATA *gb_main = get_gb_main(db_nr);
 
155
 
 
156
    AW_root *awr    = aww->get_root();
 
157
    char    *source = awr->awar(AWAR_ALI_NAME(db_nr))->read_string();
 
158
    char    *dest   = awr->awar(AWAR_ALI_DEST(db_nr))->read_string();
 
159
 
 
160
    GB_ERROR error = GB_begin_transaction(gb_main);
 
161
 
 
162
    if (!error) error = GBT_rename_alignment(gb_main, source, dest, (int)1, (int)dele);
 
163
    if (!error) error = GBT_add_new_changekey(gb_main, GBS_global_string("%s/data", dest), GB_STRING);
 
164
 
 
165
    error = GB_end_transaction(gb_main, error);
176
166
    aww->hide_or_notify(error);
177
167
 
178
168
    free(source);
180
170
}
181
171
 
182
172
 
183
 
AW_window *create_alignment_copy_window(AW_root *root,AW_CL db_nr)
184
 
{
185
 
    AW_window_simple *aws = new AW_window_simple;
186
 
    char header[80];
187
 
    sprintf(header,"ALIGNMENT COPY %li",db_nr);
188
 
    aws->init( root, header, header);
189
 
    aws->load_xfig("ad_al_si.fig");
190
 
 
191
 
    aws->callback( (AW_CB0)AW_POPDOWN);
192
 
    aws->at("close");
193
 
    aws->create_button("CLOSE","CLOSE","C");
194
 
 
195
 
    aws->at("label");
196
 
    aws->create_autosize_button(0,"Please enter the new name\nof the alignment");
197
 
 
198
 
    aws->at("input");
199
 
    char buffer[256];
200
 
    sprintf(buffer,"tmp/merge%li/alignment_dest",db_nr);
201
 
    aws->create_input_field(buffer,15);
202
 
 
203
 
    aws->at("ok");
204
 
    aws->callback(MG_copy_delete_rename,db_nr,0);
205
 
    aws->create_button("GO","GO","G");
206
 
 
207
 
    return (AW_window *)aws;
208
 
}
209
 
AW_window *MG_create_alignment_rename_window(AW_root *root,AW_CL db_nr)
210
 
{
211
 
    AW_window_simple *aws = new AW_window_simple;
212
 
    char header[80];
213
 
    sprintf(header,"ALIGNMENT RENAME %li",db_nr);
214
 
    aws->init( root, header,header);
215
 
    aws->load_xfig("ad_al_si.fig");
216
 
 
217
 
    aws->callback( (AW_CB0)AW_POPDOWN);
218
 
    aws->at("close");
219
 
    aws->create_button("CLOSE","CLOSE","C");
220
 
 
221
 
    aws->at("label");
222
 
    aws->create_autosize_button(0,"Please enter the name\nof the new alignment");
223
 
 
224
 
    aws->at("input");
225
 
    char buffer[256];
226
 
    sprintf(buffer,"tmp/merge%li/alignment_dest",db_nr);
227
 
    aws->create_input_field(buffer,15);
228
 
 
229
 
    aws->at("ok");
230
 
    aws->callback(MG_copy_delete_rename,db_nr,1);
231
 
    aws->create_button("GO","GO","G");
232
 
 
233
 
    return (AW_window *)aws;
234
 
}
235
 
 
236
 
void MG_aa_create_alignment(AW_window *aww,AW_CL db_nr)
237
 
{
238
 
    GBDATA     *gbd          = (db_nr == 1) ? GLOBAL_gb_merge : GLOBAL_gb_dest;
239
 
    const char *name_field   = GBS_global_string("tmp/merge%li/alignment_dest", db_nr);
240
 
    char       *name         = aww->get_root()->awar(name_field)->read_string();
241
 
    GB_ERROR    error        = GB_begin_transaction(gbd);
242
 
    GBDATA     *gb_alignment = GBT_create_alignment(gbd,name,0,0,0,"dna");
243
 
    
 
173
static AW_window *create_alignment_copy_window(AW_root *root, int db_nr)
 
174
{
 
175
    AW_window_simple *aws = new AW_window_simple;
 
176
    char header[80];
 
177
    sprintf(header, "ALIGNMENT COPY %i", db_nr);
 
178
    aws->init(root, header, header);
 
179
    aws->load_xfig("ad_al_si.fig");
 
180
 
 
181
    aws->callback((AW_CB0)AW_POPDOWN);
 
182
    aws->at("close");
 
183
    aws->create_button("CLOSE", "CLOSE", "C");
 
184
 
 
185
    aws->at("label");
 
186
    aws->create_autosize_button(0, "Please enter the new name\nof the alignment");
 
187
 
 
188
    aws->at("input");
 
189
    aws->create_input_field(AWAR_ALI_DEST(db_nr), 15);
 
190
 
 
191
    aws->at("ok");
 
192
    aws->callback(makeWindowCallback(MG_copy_delete_rename, db_nr, 0));
 
193
    aws->create_button("GO", "GO", "G");
 
194
 
 
195
    return (AW_window *)aws;
 
196
}
 
197
static AW_window *MG_create_alignment_rename_window(AW_root *root, int db_nr)
 
198
{
 
199
    AW_window_simple *aws = new AW_window_simple;
 
200
    char header[80];
 
201
    sprintf(header, "ALIGNMENT RENAME %i", db_nr);
 
202
    aws->init(root, header, header);
 
203
    aws->load_xfig("ad_al_si.fig");
 
204
 
 
205
    aws->callback((AW_CB0)AW_POPDOWN);
 
206
    aws->at("close");
 
207
    aws->create_button("CLOSE", "CLOSE", "C");
 
208
 
 
209
    aws->at("label");
 
210
    aws->create_autosize_button(0, "Please enter the name\nof the new alignment");
 
211
 
 
212
    aws->at("input");
 
213
    aws->create_input_field(AWAR_ALI_DEST(db_nr), 15);
 
214
 
 
215
    aws->at("ok");
 
216
    aws->callback(makeWindowCallback(MG_copy_delete_rename, db_nr, 1));
 
217
    aws->create_button("GO", "GO", "G");
 
218
 
 
219
    return (AW_window *)aws;
 
220
}
 
221
 
 
222
static void MG_aa_create_alignment(AW_window *aww, int db_nr) {
 
223
    GBDATA   *gb_main      = get_gb_main(db_nr);
 
224
    char     *name         = aww->get_root()->awar(AWAR_ALI_DEST(db_nr))->read_string();
 
225
    GB_ERROR  error        = GB_begin_transaction(gb_main);
 
226
    GBDATA   *gb_alignment = GBT_create_alignment(gb_main, name, 0, 0, 0, "dna");
 
227
 
244
228
    if (!gb_alignment) error = GB_await_error();
245
 
    GB_end_transaction_show_error(gbd, error, aw_message);
 
229
    GB_end_transaction_show_error(gb_main, error, aw_message);
246
230
    free(name);
247
231
}
248
232
 
249
 
AW_window *MG_create_alignment_create_window(AW_root *root,AW_CL db_nr)
250
 
{
 
233
static AW_window *MG_create_alignment_create_window(AW_root *root, int db_nr) {
251
234
    AW_window_simple *aws = new AW_window_simple;
252
235
    char header[80];
253
 
    sprintf(header,"ALIGNMENT CREATE %li",db_nr);
254
 
    aws->init( root, header,header);
 
236
    sprintf(header, "ALIGNMENT CREATE %i", db_nr);
 
237
    aws->init(root, header, header);
255
238
    aws->load_xfig("ad_al_si.fig");
256
239
 
257
 
    aws->callback( (AW_CB0)AW_POPDOWN);
 
240
    aws->callback((AW_CB0)AW_POPDOWN);
258
241
    aws->at("close");
259
 
    aws->create_button("CLOSE","CLOSE","C");
 
242
    aws->create_button("CLOSE", "CLOSE", "C");
260
243
 
261
244
    aws->at("label");
262
 
    aws->create_autosize_button(0,"Please enter the new name\nof the alignment");
 
245
    aws->create_autosize_button(0, "Please enter the new name\nof the alignment");
263
246
 
264
247
    aws->at("input");
265
 
    char buffer[256];
266
 
    sprintf(buffer,"tmp/merge%li/alignment_dest",db_nr);
267
 
    aws->create_input_field(buffer,15);
 
248
    aws->create_input_field(AWAR_ALI_DEST(db_nr), 15);
268
249
 
269
250
    aws->at("ok");
270
 
    aws->callback(MG_aa_create_alignment,db_nr);
271
 
    aws->create_button("GO","GO","G");
 
251
    aws->callback(makeWindowCallback(MG_aa_create_alignment, db_nr));
 
252
    aws->create_button("GO", "GO", "G");
272
253
 
273
254
    return (AW_window *)aws;
274
255
}
275
256
 
276
257
 
277
258
 
278
 
AW_window *MG_create_alignment_window(AW_root *root,AW_CL db_nr)
279
 
{
280
 
    char              buffer[256];
281
 
    GBDATA           *gbd = (db_nr == 1) ? GLOBAL_gb_merge : GLOBAL_gb_dest;
 
259
static AW_window *MG_create_alignment_window(AW_root *root, int db_nr) {
 
260
    GBDATA           *gb_main = get_gb_main(db_nr);
282
261
    AW_window_simple *aws = new AW_window_simple;
283
262
    char              header[80];
284
 
    
285
 
    sprintf(header,"ALIGNMENT CONTROL %li",db_nr);
286
 
    aws->init( root, header, header);
 
263
 
 
264
    sprintf(header, "ALIGNMENT CONTROL %i", db_nr);
 
265
    aws->init(root, header, header);
287
266
    aws->load_xfig("merge/ad_align.fig");
288
267
 
289
 
    aws->callback( (AW_CB0)AW_POPDOWN);
 
268
    aws->callback((AW_CB0)AW_POPDOWN);
290
269
    aws->at("close");
291
 
    aws->create_button("CLOSE","CLOSE","C");
 
270
    aws->create_button("CLOSE", "CLOSE", "C");
292
271
 
293
 
    aws->callback( AW_POPUP_HELP,(AW_CL)"ad_align.hlp");
 
272
    aws->callback(makeHelpCallback("ad_align.hlp"));
294
273
    aws->at("help");
295
 
    aws->create_button("HELP","HELP","H");
 
274
    aws->create_button("HELP", "HELP", "H");
296
275
 
297
276
    aws->button_length(13);
298
277
 
299
278
    aws->at("list");
300
 
    sprintf(buffer,"tmp/merge%li/alignment_name",db_nr);
301
 
    awt_create_selection_list_on_ad(gbd,(AW_window *)aws,buffer,"*=");
 
279
    awt_create_selection_list_on_alignments(gb_main, aws, AWAR_ALI_NAME(db_nr), "*=");
302
280
 
303
281
    aws->at("delete");
304
 
    aws->callback(MG_ad_al_delete_cb,db_nr);
305
 
    aws->create_button("DELETE","DELETE","D");
 
282
    aws->callback(makeWindowCallback(MG_ad_al_delete_cb, db_nr));
 
283
    aws->create_button("DELETE", "DELETE", "D");
306
284
 
307
285
    aws->at("rename");
308
 
    aws->callback(AW_POPUP,(AW_CL)MG_create_alignment_rename_window,db_nr);
309
 
    aws->create_button("RENAME","RENAME","R");
 
286
    aws->callback(makeCreateWindowCallback(MG_create_alignment_rename_window, db_nr));
 
287
    aws->create_button("RENAME", "RENAME", "R");
310
288
 
311
289
    aws->at("create");
312
 
    aws->callback(AW_POPUP,(AW_CL)MG_create_alignment_create_window,db_nr);
313
 
    aws->create_button("CREATE","CREATE","N");
 
290
    aws->callback(makeCreateWindowCallback(MG_create_alignment_create_window, db_nr));
 
291
    aws->create_button("CREATE", "CREATE", "N");
314
292
 
315
293
    aws->at("copy");
316
 
    aws->callback(AW_POPUP,(AW_CL)create_alignment_copy_window,db_nr);
317
 
    aws->create_button("COPY","COPY","C");
 
294
    aws->callback(makeCreateWindowCallback(create_alignment_copy_window, db_nr));
 
295
    aws->create_button("COPY", "COPY", "C");
318
296
 
319
297
    aws->at("aligned");
320
 
    sprintf(buffer,"tmp/merge%li/aligned",db_nr);
321
 
    aws->create_option_menu(buffer);
322
 
    aws->insert_option("justified","j",1);
323
 
    aws->insert_default_option("not justified","n",0);
 
298
    aws->create_option_menu(AWAR_ALIGNED(db_nr), true);
 
299
    aws->insert_option("justified", "j", 1);
 
300
    aws->insert_default_option("not justified", "n", 0);
324
301
    aws->update_option_menu();
325
302
 
326
 
 
327
 
 
328
303
    aws->at("len");
329
 
    sprintf(buffer,"tmp/merge%li/alignment_len",db_nr);
330
 
    aws->create_input_field(buffer,8);
 
304
    aws->create_input_field(AWAR_ALI_LEN(db_nr), 8);
331
305
 
332
306
    aws->at("type");
333
 
    sprintf(buffer,"tmp/merge%li/alignment_type",db_nr);
334
 
    aws->create_option_menu(buffer);
335
 
    aws->insert_option("dna","d","dna");
336
 
    aws->insert_option("rna","r","rna");
337
 
    aws->insert_option("pro","p","ami");
338
 
    aws->insert_default_option("???","?","usr");
 
307
    aws->create_option_menu(AWAR_ALI_TYPE(db_nr), true);
 
308
    aws->insert_option("dna", "d", "dna");
 
309
    aws->insert_option("rna", "r", "rna");
 
310
    aws->insert_option("pro", "p", "ami");
 
311
    aws->insert_default_option("???", "?", "usr");
339
312
    aws->update_option_menu();
340
313
 
341
314
    aws->at("security");
342
 
    sprintf(buffer,"tmp/merge%li/security",db_nr);
343
 
    //  aws->get_root()->awar(buffer)->add_callback(MG_ed_al_check_len_cb,db_nr);
344
 
    aws->callback(MG_ed_al_check_len_cb,db_nr);
345
 
    aws->create_option_menu(buffer);
346
 
    aws->insert_option("0","0",0);
347
 
    aws->insert_option("1","1",1);
348
 
    aws->insert_option("2","2",2);
349
 
    aws->insert_option("3","3",3);
350
 
    aws->insert_option("4","4",4);
351
 
    aws->insert_option("5","5",5);
352
 
    aws->insert_default_option("6","6",6);
 
315
    aws->callback(makeWindowCallback(MG_ed_al_check_len_cb, db_nr));
 
316
    aws->create_option_menu(AWAR_SECURITY(db_nr), true);
 
317
    aws->insert_option("0", "0", 0);
 
318
    aws->insert_option("1", "1", 1);
 
319
    aws->insert_option("2", "2", 2);
 
320
    aws->insert_option("3", "3", 3);
 
321
    aws->insert_option("4", "4", 4);
 
322
    aws->insert_option("5", "5", 5);
 
323
    aws->insert_default_option("6", "6", 6);
353
324
    aws->update_option_menu();
354
325
 
355
 
    return (AW_window *)aws;
356
 
 
 
326
    return aws;
357
327
}
358
328
 
359
 
AW_window *MG_merge_alignment_cb(AW_root *awr){
360
 
    static AW_window_simple *aws = 0;
361
 
    if (aws) return (AW_window *)aws;
362
 
 
363
 
    awr->awar(AWAR_ALI1)->add_callback( (AW_RCB)MG_alignment_vars_callback,(AW_CL)GLOBAL_gb_merge,1);
364
 
    awr->awar(AWAR_ALI2)->add_callback( (AW_RCB)MG_alignment_vars_callback,(AW_CL)GLOBAL_gb_dest,2);
365
 
 
366
 
    aws = new AW_window_simple;
367
 
    aws->init( awr, "MERGE_ALIGNMENTS", "MERGE ALIGNMENTS");
 
329
AW_window *MG_create_merge_alignment_window(AW_root *awr) {
 
330
    AW_window_simple *aws = new AW_window_simple;
 
331
 
 
332
    awr->awar(AWAR_ALI_SRC)->add_callback(makeRootCallback(MG_alignment_vars_callback, 1));
 
333
    awr->awar(AWAR_ALI_DST)->add_callback(makeRootCallback(MG_alignment_vars_callback, 2));
 
334
 
 
335
    aws->init(awr, "MERGE_ALIGNMENTS", "MERGE ALIGNMENTS");
368
336
    aws->load_xfig("merge/alignment.fig");
369
337
 
370
 
    aws->at("close");aws->callback((AW_CB0)AW_POPDOWN);
371
 
    aws->create_button("CLOSE","CLOSE","C");
 
338
    aws->at("close"); aws->callback((AW_CB0)AW_POPDOWN);
 
339
    aws->create_button("CLOSE", "CLOSE", "C");
372
340
 
373
341
    aws->at("help");
374
 
    aws->callback(AW_POPUP_HELP,(AW_CL)"mg_alignment.hlp");
375
 
    aws->create_button("HELP","HELP","H");
 
342
    aws->callback(makeHelpCallback("mg_alignment.hlp"));
 
343
    aws->create_button("HELP", "HELP", "H");
376
344
 
377
345
    aws->at("check");
378
 
    aws->callback((AW_CB1)MG_check_alignment,0);
379
 
    aws->create_button("CHECK","Check");
 
346
    aws->callback(makeWindowCallback(copy_and_check_alignments_ignoreResult));
 
347
    aws->create_button("CHECK", "Check");
380
348
 
381
349
    aws->at("ali1");
382
 
    awt_create_selection_list_on_ad(GLOBAL_gb_merge,(AW_window *)aws,AWAR_ALI1,"*=");
 
350
    awt_create_selection_list_on_alignments(GLOBAL_gb_src, aws, AWAR_ALI_SRC, "*=");
383
351
 
384
352
    aws->at("ali2");
385
 
    awt_create_selection_list_on_ad(GLOBAL_gb_dest,(AW_window *)aws,AWAR_ALI2,"*=");
 
353
    awt_create_selection_list_on_alignments(GLOBAL_gb_dst, aws, AWAR_ALI_DST, "*=");
386
354
 
387
355
    aws->at("modify1");
388
 
    aws->callback(AW_POPUP,(AW_CL)MG_create_alignment_window,1);
389
 
    aws->create_button("MODIFY_DB1","MODIFY");
 
356
    aws->callback(makeCreateWindowCallback(MG_create_alignment_window, 1));
 
357
    aws->create_button("MODIFY_DB1", "MODIFY");
390
358
 
391
359
    aws->at("modify2");
392
 
    aws->callback(AW_POPUP,(AW_CL)MG_create_alignment_window,2);
393
 
    aws->create_button("MODIFY_DB2","MODIFY");
 
360
    aws->callback(makeCreateWindowCallback(MG_create_alignment_window, 2));
 
361
    aws->create_button("MODIFY_DB2", "MODIFY");
394
362
 
395
363
 
396
364
    aws->button_length(0);
397
365
    aws->shadow_width(1);
398
366
    aws->at("icon");
399
 
    aws->callback(AW_POPUP_HELP,(AW_CL)"mg_alignment.hlp");
400
 
    aws->create_button("HELP_MERGE", "#merge/icon.bitmap");
 
367
    aws->callback(makeHelpCallback("mg_alignment.hlp"));
 
368
    aws->create_button("HELP_MERGE", "#merge/icon.xpm");
401
369
 
402
 
    return (AW_window *)aws;
 
370
    return aws;
403
371
}