← Back to branch summary

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

« back to all changes in this revision

Viewing changes to EDIT4/ED4_visualizeSAI.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:
EDIT4/ED4_visualizeSAI.cxx
1
 
/*=======================================================================================*/
2
 
/*                                                                                       */
3
 
/*    File       : ED4_visualizeSAI.cxx                                                  */
4
 
/*    Purpose    : To Visualise the Sequence Associated Information (SAI) in the Editor  */
5
 
/*    Author     : Yadhu Kumar (yadhu@mikro.biologie.tu-muenchen.de)                     */
6
 
/*    web site   : http://www.arb-home.de/                                               */
7
 
/*                                                                                       */
8
 
/*        Copyright Department of Microbiology (Technical University Munich)             */
9
 
/*                                                                                       */
10
 
/*=======================================================================================*/
11
 
 
12
 
#include <stdio.h>
13
 
#include <stdlib.h>
14
 
#include <iostream>
15
 
 
16
 
#include <arbdb.h>
17
 
#include <arbdbt.h>
18
 
#include <aw_root.hxx>
19
 
#include <aw_window.hxx>
 
1
// =============================================================== //
 
2
//                                                                 //
 
3
//   File      : ED4_visualizeSAI.cxx                              //
 
4
//   Purpose   : Visualize sequence associated information (SAI)   //
 
5
//               in the Editor                                     //
 
6
//                                                                 //
 
7
//   Coded by Yadhu Kumar (yadhu@mikro.biologie.tu-muenchen.de)    //
 
8
//   Institute of Microbiology (Technical University Munich)       //
 
9
//   http://www.arb-home.de/                                       //
 
10
//                                                                 //
 
11
// =============================================================== //
 
12
 
 
13
#include <ed4_extern.hxx>
 
14
#include "ed4_class.hxx"
 
15
 
20
16
#include <aw_awars.hxx>
21
 
#include <awt.hxx>
22
17
#include <awt_canvas.hxx>
23
18
#include <awt_sel_boxes.hxx>
24
19
#include <aw_preset.hxx>
25
 
 
26
 
#include <ed4_extern.hxx>
27
 
 
28
 
#include "ed4_class.hxx"
29
 
#include "ed4_visualizeSAI.hxx"
30
 
 
31
 
                   // --------------------------------------------------------------------------------
 
20
#include <aw_msg.hxx>
 
21
#include <aw_root.hxx>
 
22
#include <aw_question.hxx>
 
23
#include <aw_select.hxx>
 
24
 
 
25
#include <arbdbt.h>
 
26
#include <ad_cb.h>
 
27
#include <arb_strbuf.h>
 
28
 
 
29
#include <iostream>
 
30
 
 
31
// --------------------------------------------------------------------------------
32
32
 
33
33
#define AWAR_SAI_CLR_TAB              "saicolors/"
34
 
#define AWAR_SAI_SELECT               AWAR_SAI_CLR_TAB "select" // current visualized SAI
35
 
#define AWAR_SAI_CLR_DEF              AWAR_SAI_CLR_TAB "clr_trans_tab/" // container for definitions
36
 
#define AWAR_SAI_ENABLE               AWAR_SAI_CLR_TAB "enable" // global enable of visualization
37
 
#define AWAR_SAI_ALL_SPECIES          AWAR_SAI_CLR_TAB "all_species" // 1 = all / 0 = marked
38
 
#define AWAR_SAI_AUTO_SELECT          AWAR_SAI_CLR_TAB "auto_select" // 1 = auto select / 0 = manual select
39
 
#define AWAR_SAI_CLR_TRANS_TABLE      AWAR_SAI_CLR_TAB "clr_trans_table" // current translation table
40
 
#define AWAR_SAI_CLR_TRANS_TAB_NAMES  AWAR_SAI_CLR_TAB "clr_trans_tab_names" // ;-seperated list of existing translation tables
41
 
#define AWAR_SAI_CLR_TRANS_TAB_REL    AWAR_SAI_CLR_TAB "sai_relation/" // container to store trans tables for each SAI
42
 
#define AWAR_SAI_CLR_DEFAULTS_CREATED AWAR_SAI_CLR_TAB "defaults_created" // whether defaults have been created (create only once)
 
34
#define AWAR_SAI_VISUALIZED           AWAR_SAI_CLR_TAB "current"             // current visualized SAI
 
35
#define AWAR_SAI_CLR_DEF              AWAR_SAI_CLR_TAB "clr_trans_tab/"      // container for definitions
 
36
#define AWAR_SAI_ENABLE               AWAR_SAI_CLR_TAB "enable"              // global enable of visualization
 
37
#define AWAR_SAI_ALL_SPECIES          AWAR_SAI_CLR_TAB "all_species"         // 1 = all / 0 = marked
 
38
#define AWAR_SAI_AUTO_SELECT          AWAR_SAI_CLR_TAB "auto_select"         // 1 = auto select / 0 = manual select
 
39
#define AWAR_SAI_CLR_TRANS_TABLE      AWAR_SAI_CLR_TAB "clr_trans_table"     // current translation table
 
40
#define AWAR_SAI_CLR_TRANS_TAB_NAMES  AWAR_SAI_CLR_TAB "clr_trans_tab_names" // ;-separated list of existing translation tables
 
41
#define AWAR_SAI_CLR_TRANS_TAB_REL    AWAR_SAI_CLR_TAB "sai_relation/"       // container to store trans tables for each SAI
 
42
#define AWAR_SAI_CLR_DEFAULTS_CREATED AWAR_SAI_CLR_TAB "defaults_created"    // whether defaults have been created (create only once)
43
43
 
44
44
#define AWAR_SAI_CLR_TRANS_TAB_NEW_NAME "tmp/sai/clr_trans_tab_new_name" // textfield to enter translation table name
45
45
#define AWAR_SAI_CLR                    "tmp/sai/color_0" // the definition of the current translation table (number runs from 0 to 9)
53
53
extern GBDATA *GLOBAL_gb_main;
54
54
 
55
55
static bool clrDefinitionsChanged       = false;
56
 
static bool inCallback                  = false; // used to avoid multiple refreshs
 
56
static bool inCallback                  = false; // used to avoid multiple refreshes
57
57
static bool in_colorDefChanged_callback = false; // used to avoid colorDef correction
58
58
 
59
59
// --------------------------------------------------------------------------------
74
74
    e4_assert(awarName);
75
75
    e4_assert(awarName[0]); // empty awar is bad
76
76
 
77
 
#ifdef DEBUG
78
 
    int size =
79
 
#endif
80
 
    sprintf(buf,AWAR_SAI_CLR_DEF "%s", awarName);
 
77
    IF_ASSERTION_USED(int size =) sprintf(buf, AWAR_SAI_CLR_DEF "%s", awarName);
81
78
    e4_assert(size<BUFSIZE);
82
79
    return buf;
83
80
}
84
81
#undef BUFSIZE
85
82
 
86
 
/* --------------------------------------------------------- */
 
83
// ---------------------------------------------------------
87
84
 
88
85
static void setVisualizeSAI_cb(AW_root *awr) {
89
86
    ED4_ROOT->visualizeSAI = awr->awar(AWAR_SAI_ENABLE)->read_int();
90
 
    ED4_ROOT->refresh_all_windows(1); //refresh editor
 
87
    ED4_ROOT->request_refresh_for_sequence_terminals();
91
88
}
92
89
 
93
90
static void setVisualizeSAI_options_cb(AW_root *awr) {
94
91
    ED4_ROOT->visualizeSAI_allSpecies = awr->awar(AWAR_SAI_ALL_SPECIES)->read_int();
95
 
    ED4_ROOT->refresh_all_windows(1); //refresh editor
 
92
    ED4_ROOT->request_refresh_for_sequence_terminals();
96
93
}
97
94
 
98
95
static bool colorTransTable_exists(AW_root *awr, const char *name) {
126
123
    clrDefinitionsChanged = true;
127
124
 
128
125
    if (!in_colorDefChanged_callback) { // this callback is special, because it may change all other color defs
129
 
        in_colorDefChanged_callback = true;
130
 
 
131
 
        bool old_inCallback = inCallback;
132
 
        inCallback          = true;
133
 
 
134
 
        char *clrTabName = awr->awar(AWAR_SAI_CLR_TRANS_TABLE)->read_string();
135
 
        if (clrTabName[0]) {
136
 
            unsigned char charUsed[256]; memset(charUsed,255,256);
137
 
 
138
 
            {
139
 
                for (int i=0; i<10 ; i++){
140
 
                    char *awarString_next = awr->awar_string(getAwarName(i))->read_string();
141
 
                    for(int c=0; awarString_next[c]; ++c){
142
 
                        charUsed[(unsigned char)awarString_next[c]] = i;
143
 
                    }
144
 
                    free(awarString_next);
145
 
                }
146
 
 
147
 
                int   awarNo     = (int)cl_awarNo;
148
 
                char *awarString = awr->awar_string(getAwarName(awarNo))->read_string();
149
 
                for(int c=0; awarString[c]; ++c){
150
 
                    charUsed[(unsigned char)awarString[c]] = awarNo;
151
 
                }
152
 
                free(awarString);
153
 
            }
154
 
 
155
 
            typedef unsigned char mystr[256];
156
 
            mystr s[10];
157
 
            for (int i=0; i<10; i++)  s[i][0]=0; //initializing the strings
158
 
 
159
 
            for (int i=0; i<256; i++) {
160
 
                int table = charUsed[i];
161
 
                if (table != 255) {
162
 
                    char *eos = strchr((char *)s[table],0); // get pointer to end of string
163
 
                    eos[0] = char(i);
164
 
                    eos[1] = 0;
165
 
                }
166
 
            }
167
 
 
168
 
            {
169
 
                GBS_strstruct *clrDefStr = GBS_stropen(500);            /* create output stream */
170
 
                for(int i=0; i<10; i++){
171
 
                    awr->awar_string(getAwarName(i))->write_string((char *)s[i]);
172
 
 
173
 
                    char *escaped = GBS_escape_string((char*)s[i], ";", '&');
174
 
                    GBS_strcat(clrDefStr, escaped);
175
 
                    free(escaped);
176
 
                    GBS_chrcat(clrDefStr, ';');
177
 
                }
178
 
 
179
 
                char    *colorDef = GBS_strclose(clrDefStr);
180
 
                AW_awar *awar_def = awr->awar_string(getClrDefAwar(clrTabName), "", AW_ROOT_DEFAULT);
181
 
                awar_def->write_string(colorDef); // writing clr defnition to clr trans table awar
182
 
                free(colorDef);
183
 
            }
184
 
        }
185
 
        else {
186
 
            if (!old_inCallback) { // only warn when user really changed the setting
187
 
                aw_message("Please select a VALID Color Translation Table to EDIT.");
188
 
            }
189
 
        }
190
 
        free(clrTabName);
191
 
        inCallback = old_inCallback;
192
 
 
193
 
        if (!inCallback) {
194
 
            ED4_ROOT->refresh_all_windows(1); //refresh editor
195
 
        }
196
 
 
197
 
        in_colorDefChanged_callback = false;
 
126
        LocallyModify<bool> flag(in_colorDefChanged_callback, true);
 
127
 
 
128
        {
 
129
            LocallyModify<bool> in_cb(inCallback, true);
 
130
 
 
131
            char *clrTabName = awr->awar(AWAR_SAI_CLR_TRANS_TABLE)->read_string();
 
132
            if (clrTabName[0]) {
 
133
                unsigned char charUsed[256]; memset(charUsed, 255, 256);
 
134
 
 
135
                {
 
136
                    for (int i=0; i<10;  i++) {
 
137
                        char *awarString_next = awr->awar_string(getAwarName(i))->read_string();
 
138
                        for (int c=0; awarString_next[c]; ++c) {
 
139
                            charUsed[(unsigned char)awarString_next[c]] = i;
 
140
                        }
 
141
                        free(awarString_next);
 
142
                    }
 
143
 
 
144
                    int   awarNo     = (int)cl_awarNo;
 
145
                    char *awarString = awr->awar_string(getAwarName(awarNo))->read_string();
 
146
                    for (int c=0; awarString[c]; ++c) {
 
147
                        charUsed[(unsigned char)awarString[c]] = awarNo;
 
148
                    }
 
149
                    free(awarString);
 
150
                }
 
151
 
 
152
                typedef unsigned char mystr[256];
 
153
                mystr s[10];
 
154
                for (int i=0; i<10; i++)  s[i][0]=0; // initializing the strings
 
155
 
 
156
                for (int i=0; i<256; i++) {
 
157
                    int table = charUsed[i];
 
158
                    if (table != 255) {
 
159
                        char *eos = strchr((char *)s[table], 0); // get pointer to end of string
 
160
                        eos[0] = char(i);
 
161
                        eos[1] = 0;
 
162
                    }
 
163
                }
 
164
 
 
165
                {
 
166
                    GBS_strstruct *clrDefStr = GBS_stropen(500);            // create output stream
 
167
                    for (int i=0; i<10; i++) {
 
168
                        awr->awar_string(getAwarName(i))->write_string((char *)s[i]);
 
169
 
 
170
                        char *escaped = GBS_escape_string((char*)s[i], ";", '&');
 
171
                        GBS_strcat(clrDefStr, escaped);
 
172
                        free(escaped);
 
173
                        GBS_chrcat(clrDefStr, ';');
 
174
                    }
 
175
 
 
176
                    char    *colorDef = GBS_strclose(clrDefStr);
 
177
                    AW_awar *awar_def = awr->awar_string(getClrDefAwar(clrTabName), "", AW_ROOT_DEFAULT);
 
178
                    awar_def->write_string(colorDef); // writing clr definition to clr trans table awar
 
179
                    free(colorDef);
 
180
                }
 
181
            }
 
182
            else {
 
183
                if (!in_cb.old_value()) { // only warn when user really changed the setting
 
184
                    aw_message("Please select a VALID Color Translation Table to EDIT.");
 
185
                }
 
186
            }
 
187
            free(clrTabName);
 
188
        }
 
189
 
 
190
        if (!inCallback) ED4_ROOT->request_refresh_for_sequence_terminals();
198
191
    }
199
192
}
200
193
 
201
194
static void colorDefTabNameChanged_callback(AW_root *awr) {
202
195
    char *clrTabName     = awr->awar(AWAR_SAI_CLR_TRANS_TABLE)->read_string();
203
 
    bool  old_inCallback = inCallback;
204
 
    inCallback           = true;
205
196
    {
206
 
        bool old_in_colorDefChanged_callback = in_colorDefChanged_callback;
207
 
        in_colorDefChanged_callback          = true; // avoid correction
208
 
 
209
 
        // clear current translation table definition
210
 
        for(int i=0; i<10 ; i++) {
211
 
            AW_awar *transDef_awar = awr->awar_string(getAwarName(i), "", AW_ROOT_DEFAULT);
212
 
            transDef_awar->write_string("");
213
 
        }
214
 
 
215
 
        if (clrTabName[0]) {
216
 
            AW_awar *clrTabDef_awar = awr->awar_string(getClrDefAwar(clrTabName), "", AW_ROOT_DEFAULT);
217
 
            char    *clrTabDef      = clrTabDef_awar->read_string();
218
 
 
219
 
            if (clrTabDef[0]) {
220
 
                int i        = 0;
221
 
                int tokStart = 0;
222
 
 
223
 
                for (int si = 0; clrTabDef[si]; ++si) {
224
 
                    if (clrTabDef[si] == ';') {
225
 
                        e4_assert(i >= 0 && i<10);
226
 
                        AW_awar *awar = awr->awar(getAwarName(i));
227
 
 
228
 
                        if (tokStart == si) { // empty definition
229
 
                            awar->write_string("");
230
 
                        }
231
 
                        else {
232
 
                            int toklen = si-tokStart;
233
 
 
234
 
                            e4_assert(toklen > 0);
235
 
                            e4_assert(clrTabDef[tokStart+toklen] == ';');
236
 
                            clrTabDef[tokStart+toklen] = 0;
237
 
 
238
 
                            char *unescaped = GBS_unescape_string(clrTabDef+tokStart, ";", '&');
239
 
                            awar->write_string(unescaped);
240
 
                            free(unescaped);
241
 
 
242
 
                            clrTabDef[tokStart+toklen] = ';';
243
 
                        }
244
 
                        ++i;
245
 
                        tokStart = si+1;
 
197
        LocallyModify<bool> flag(inCallback, true);
 
198
        {
 
199
            LocallyModify<bool> flag2(in_colorDefChanged_callback, true); // avoid correction
 
200
 
 
201
            // clear current translation table definition
 
202
            for (int i=0; i<10; i++) {
 
203
                AW_awar *transDef_awar = awr->awar_string(getAwarName(i), "", AW_ROOT_DEFAULT);
 
204
                transDef_awar->write_string("");
 
205
            }
 
206
 
 
207
            if (clrTabName[0]) {
 
208
                AW_awar *clrTabDef_awar = awr->awar_string(getClrDefAwar(clrTabName), "", AW_ROOT_DEFAULT);
 
209
                char    *clrTabDef      = clrTabDef_awar->read_string();
 
210
 
 
211
                if (clrTabDef[0]) {
 
212
                    int i        = 0;
 
213
                    int tokStart = 0;
 
214
 
 
215
                    for (int si = 0; clrTabDef[si]; ++si) {
 
216
                        if (clrTabDef[si] == ';') {
 
217
                            e4_assert(i >= 0 && i<10);
 
218
                            AW_awar *awar = awr->awar(getAwarName(i));
 
219
 
 
220
                            if (tokStart == si) { // empty definition
 
221
                                awar->write_string("");
 
222
                            }
 
223
                            else {
 
224
                                int toklen = si-tokStart;
 
225
 
 
226
                                e4_assert(toklen > 0);
 
227
                                e4_assert(clrTabDef[tokStart+toklen] == ';');
 
228
                                clrTabDef[tokStart+toklen] = 0;
 
229
 
 
230
                                char *unescaped = GBS_unescape_string(clrTabDef+tokStart, ";", '&');
 
231
                                awar->write_string(unescaped);
 
232
                                free(unescaped);
 
233
 
 
234
                                clrTabDef[tokStart+toklen] = ';';
 
235
                            }
 
236
                            ++i;
 
237
                            tokStart = si+1;
 
238
                        }
246
239
                    }
 
240
                    e4_assert(i == 10);
247
241
                }
248
 
                e4_assert(i == 10);
 
242
                free(clrTabDef);
249
243
            }
250
 
            free(clrTabDef);
251
244
        }
252
 
        in_colorDefChanged_callback = old_in_colorDefChanged_callback;
253
245
        colorDefChanged_callback(awr, 0); // correct first def manually
254
 
    }
255
 
    {
256
 
        // store the selected tabel as default for this SAI:
257
 
        char *saiName = awr->awar(AWAR_SAI_SELECT)->read_string();
258
 
        if (saiName[0]) {
259
 
            char buf[100];
260
 
            sprintf(buf, AWAR_SAI_CLR_TRANS_TAB_REL "%s", saiName);
261
 
            awr->awar_string(buf, "", AW_ROOT_DEFAULT); // create an AWAR for the selected SAI and
262
 
            awr->awar(buf)->write_string(clrTabName); // write the existing clr trans table names to the same
 
246
        {
 
247
            // store the selected table as default for this SAI:
 
248
            char *saiName = awr->awar(AWAR_SAI_VISUALIZED)->read_string();
 
249
            if (saiName[0]) {
 
250
                char buf[100];
 
251
                sprintf(buf, AWAR_SAI_CLR_TRANS_TAB_REL "%s", saiName);
 
252
                awr->awar_string(buf, "", AW_ROOT_DEFAULT); // create an AWAR for the selected SAI and
 
253
                awr->awar(buf)->write_string(clrTabName); // write the existing clr trans table names to the same
 
254
            }
 
255
            free(saiName);
263
256
        }
264
 
        free(saiName);
265
257
    }
266
 
    inCallback = old_inCallback;
267
258
    free(clrTabName);
268
259
 
269
 
    if (!inCallback && clrDefinitionsChanged) {
270
 
        ED4_ROOT->refresh_all_windows(1); //refresh editor
271
 
    }
 
260
    if (!inCallback && clrDefinitionsChanged) ED4_ROOT->request_refresh_for_sequence_terminals();
272
261
}
273
262
 
274
 
static void refresh_display_cb(GBDATA *, int *, GB_CB_TYPE cb_type) {
 
263
static void refresh_display_cb(GB_CB_TYPE cb_type) {
275
264
    if ((cb_type & GB_CB_CHANGED) &&
276
265
        ED4_ROOT->aw_root->awar(AWAR_SAI_ENABLE)->read_int())
277
266
    {
278
267
        clrDefinitionsChanged = 1;
279
 
        ED4_ROOT->refresh_all_windows(1); //refresh editor when current SAI is changed
 
268
        ED4_ROOT->request_refresh_for_sequence_terminals();
280
269
    }
281
270
}
282
271
 
283
272
static void saiChanged_callback(AW_root *awr) {
284
 
    bool old_inCallback = inCallback;
285
 
    inCallback          = true;
286
 
    char *saiName       = 0;
 
273
    char *saiName = 0;
287
274
    {
288
 
        static GBDATA *gb_last_SAI = 0;
289
 
 
290
 
        if (gb_last_SAI) {
291
 
            GB_transaction dummy(GLOBAL_gb_main);
292
 
            GB_remove_callback(gb_last_SAI, GB_CB_CHANGED, refresh_display_cb, 0);
293
 
            gb_last_SAI = 0;
294
 
        }
295
 
 
296
 
        saiName = awr->awar(AWAR_SAI_SELECT)->read_string();
297
 
        char *transTabName = 0;
298
 
 
299
 
        if (saiName[0]) {
300
 
            char  buf[100];
301
 
            sprintf(buf, AWAR_SAI_CLR_TRANS_TAB_REL "%s", saiName);
302
 
            awr->awar_string(buf, "", AW_ROOT_DEFAULT);
303
 
            transTabName = awr->awar(buf)->read_string();
304
 
        }
305
 
 
 
275
        LocallyModify<bool> flag(inCallback, true);
306
276
        {
307
 
            GB_transaction dummy(GLOBAL_gb_main);
308
 
            gb_last_SAI = GBT_find_SAI(GLOBAL_gb_main, saiName);
 
277
            static GBDATA *gb_last_SAI = 0;
 
278
 
309
279
            if (gb_last_SAI) {
310
 
                GB_add_callback(gb_last_SAI, GB_CB_CHANGED, refresh_display_cb, 0);
311
 
            }
 
280
                GB_transaction ta(GLOBAL_gb_main);
 
281
                GB_remove_callback(gb_last_SAI, GB_CB_CHANGED, makeDatabaseCallback(refresh_display_cb));
 
282
                gb_last_SAI = 0;
 
283
            }
 
284
 
 
285
            saiName = awr->awar(AWAR_SAI_VISUALIZED)->read_string();
 
286
            char *transTabName = 0;
 
287
 
 
288
            if (saiName[0]) {
 
289
                char  buf[100];
 
290
                sprintf(buf, AWAR_SAI_CLR_TRANS_TAB_REL "%s", saiName);
 
291
                awr->awar_string(buf, "", AW_ROOT_DEFAULT);
 
292
                transTabName = awr->awar(buf)->read_string();
 
293
            }
 
294
 
 
295
            {
 
296
                GB_transaction ta(GLOBAL_gb_main);
 
297
                gb_last_SAI = GBT_find_SAI(GLOBAL_gb_main, saiName);
 
298
                if (gb_last_SAI) {
 
299
                    GB_add_callback(gb_last_SAI, GB_CB_CHANGED, makeDatabaseCallback(refresh_display_cb));
 
300
                }
 
301
            }
 
302
            awr->awar(AWAR_SAI_CLR_TRANS_TABLE)->write_string(transTabName ? transTabName : "");
 
303
            free(transTabName);
 
304
 
 
305
            clrDefinitionsChanged = true; // SAI changed -> update needed
312
306
        }
313
 
        awr->awar(AWAR_SAI_CLR_TRANS_TABLE)->write_string(transTabName ? transTabName : "");
314
 
        free(transTabName);
315
 
 
316
 
        clrDefinitionsChanged = true; // SAI changed -> update needed
317
307
    }
318
 
    inCallback = old_inCallback;
319
 
 
 
308
    
320
309
    if (!inCallback && clrDefinitionsChanged) {
321
 
        ED4_ROOT->refresh_all_windows(1); //refresh editor
322
310
        // SAI changed notify Global SAI Awar AWAR_SAI_GLOBAL
323
 
        awr->awar(AWAR_SAI_GLOBAL)->write_string(saiName); 
 
311
        awr->awar(AWAR_SAI_GLOBAL)->write_string(saiName);
 
312
        ED4_ROOT->request_refresh_for_sequence_terminals();
324
313
    }
325
314
    free(saiName);
326
315
}
327
316
 
328
 
static void update_ClrTransTabNamesList_cb(AW_root *awr, AW_CL cl_aws, AW_CL cl_id) {
329
 
    AW_window         *aws              = (AW_window*)cl_aws;
330
 
    AW_selection_list *id               = (AW_selection_list*)cl_id;
 
317
static void update_ClrTransTabNamesList_cb(AW_root *awr, AW_CL cl_colorTransList) {
 
318
    AW_selection_list *colorTransList   = (AW_selection_list*)cl_colorTransList;
331
319
    char              *clrTransTabNames = awr->awar(AWAR_SAI_CLR_TRANS_TAB_NAMES)->read_string();
332
320
 
333
 
    aws->clear_selection_list(id);
 
321
    colorTransList->clear();
334
322
 
335
 
    for (char *tok = strtok(clrTransTabNames,"\n"); tok; tok = strtok(0,"\n")) {
336
 
        aws->insert_selection(id,tok,tok);
 
323
    for (char *tok = strtok(clrTransTabNames, "\n"); tok; tok = strtok(0, "\n")) {
 
324
        colorTransList->insert(tok, tok);
337
325
    }
338
 
    aws->insert_default_selection(id, "????", "");
339
 
    aws->update_selection_list(id);
 
326
    colorTransList->insert_default("????", "");
 
327
    colorTransList->update();
340
328
 
341
329
    free(clrTransTabNames);
342
330
}
346
334
#if defined(DEBUG)
347
335
    printf("curr_sai='%s'\n", curr_sai);
348
336
#endif // DEBUG
349
 
    aw_root->awar(AWAR_SAI_SELECT)->write_string(curr_sai);
 
337
    aw_root->awar(AWAR_SAI_VISUALIZED)->write_string(curr_sai);
350
338
    free(curr_sai);
351
339
}
352
340
 
353
341
static void set_autoselect_cb(AW_root *aw_root) {
354
342
    static bool callback_active = false;
355
343
 
356
 
    if (aw_root->awar(AWAR_SAI_AUTO_SELECT)->read_int()) { // auto select is avtivated
 
344
    if (aw_root->awar(AWAR_SAI_AUTO_SELECT)->read_int()) { // auto select is activated
357
345
        aw_root->awar(AWAR_SAI_NAME)->add_callback(autoselect_cb);
358
346
        callback_active = true;
359
347
    }
365
353
    }
366
354
}
367
355
 
368
 
static void addNewTransTable(AW_root *aw_root, const char *newClrTransTabName, const char *defaultDefinition, bool autoselect) {
369
 
    AW_awar *table_def_awar = aw_root->awar_string(getClrDefAwar(newClrTransTabName), defaultDefinition , AW_ROOT_DEFAULT);
 
356
static void addOrUpdateTransTable(AW_root *aw_root, const char *newClrTransTabName, const char *defaultDefinition, bool autoselect) {
 
357
    AW_awar *table_def_awar = aw_root->awar_string(getClrDefAwar(newClrTransTabName), defaultDefinition,  AW_ROOT_DEFAULT);
370
358
    table_def_awar->write_string(defaultDefinition);
371
359
 
372
 
    e4_assert(!colorTransTable_exists(aw_root, newClrTransTabName));
373
 
 
374
 
    AW_awar *names_awar = aw_root->awar(AWAR_SAI_CLR_TRANS_TAB_NAMES);
375
 
    char    *old_names  = names_awar->read_string();
376
 
    names_awar->write_string(old_names[0]
377
 
                             ? GBS_global_string("%s\n%s", old_names, newClrTransTabName)
378
 
                             : newClrTransTabName); // add new name
379
 
    free(old_names);
 
360
    if (!colorTransTable_exists(aw_root, newClrTransTabName)) {
 
361
        AW_awar    *names_awar = aw_root->awar(AWAR_SAI_CLR_TRANS_TAB_NAMES);
 
362
        const char *old_names  = names_awar->read_char_pntr();
 
363
        names_awar->write_string(old_names[0]
 
364
                                 ? GBS_global_string("%s\n%s", old_names, newClrTransTabName)
 
365
                                 : newClrTransTabName); // add new name
 
366
    }
380
367
 
381
368
    if (autoselect) {
382
369
        aw_root->awar(AWAR_SAI_CLR_TRANS_TABLE)->write_string(newClrTransTabName); // select new
384
371
}
385
372
 
386
373
static void addDefaultTransTable(AW_root *aw_root, const char *newClrTransTabName, const char *defaultDefinition) {
387
 
    if (!colorTransTable_exists(aw_root, newClrTransTabName)) {
388
 
        addNewTransTable(aw_root, newClrTransTabName, defaultDefinition, false);
389
 
    }
 
374
    addOrUpdateTransTable(aw_root, newClrTransTabName, defaultDefinition, false);
390
375
}
391
376
 
392
377
void ED4_createVisualizeSAI_Awars(AW_root *aw_root, AW_default aw_def) {  // --- Creating and initializing AWARS -----
393
 
    aw_root->awar_int   (AWAR_SAI_ENABLE,                 0,  aw_def);
394
 
    aw_root->awar_int   (AWAR_SAI_ALL_SPECIES,            0,  aw_def);
395
 
    aw_root->awar_int   (AWAR_SAI_AUTO_SELECT,            0,  aw_def);
396
 
    aw_root->awar_string(AWAR_SAI_SELECT,                 "", aw_def);
 
378
    aw_root->awar_int(AWAR_SAI_ENABLE,      0, aw_def);
 
379
    aw_root->awar_int(AWAR_SAI_ALL_SPECIES, 0, aw_def);
 
380
    aw_root->awar_int(AWAR_SAI_AUTO_SELECT, 0, aw_def);
 
381
 
 
382
    aw_root->awar_string(AWAR_SAI_VISUALIZED,             "", aw_def);
397
383
    aw_root->awar_string(AWAR_SAI_CLR_TRANS_TABLE,        "", aw_def);
398
384
    aw_root->awar_string(AWAR_SAI_CLR_TRANS_TAB_NEW_NAME, "", aw_def);
399
385
    aw_root->awar_string(AWAR_SAI_CLR_TRANS_TAB_NAMES,    "", aw_def);
400
386
 
401
 
    for (int i=0;i<10;i++){   // initialising 10 color definition string AWARS
402
 
       AW_awar *def_awar = aw_root->awar_string(getAwarName(i),"",aw_def);
 
387
    for (int i=0; i<10; i++) { // initializing 10 color definition string AWARS
 
388
       AW_awar *def_awar = aw_root->awar_string(getAwarName(i), "", aw_def);
403
389
       def_awar->add_callback(colorDefChanged_callback, (AW_CL)i);
404
390
    }
405
 
    aw_root->awar(AWAR_SAI_ENABLE)->add_callback(setVisualizeSAI_cb);
406
 
    aw_root->awar(AWAR_SAI_ALL_SPECIES)->add_callback(setVisualizeSAI_options_cb);
407
 
    aw_root->awar(AWAR_SAI_AUTO_SELECT)->add_callback(set_autoselect_cb);
408
 
    aw_root->awar(AWAR_SAI_SELECT)->add_callback(saiChanged_callback);
 
391
    aw_root->awar(AWAR_SAI_ENABLE)         ->add_callback(setVisualizeSAI_cb);
 
392
    aw_root->awar(AWAR_SAI_ALL_SPECIES)    ->add_callback(setVisualizeSAI_options_cb);
 
393
    aw_root->awar(AWAR_SAI_AUTO_SELECT)    ->add_callback(set_autoselect_cb);
 
394
    aw_root->awar(AWAR_SAI_VISUALIZED)     ->add_callback(saiChanged_callback);
409
395
    aw_root->awar(AWAR_SAI_CLR_TRANS_TABLE)->add_callback(colorDefTabNameChanged_callback);
410
396
 
411
397
    ED4_ROOT->visualizeSAI            = aw_root->awar(AWAR_SAI_ENABLE)->read_int();
412
398
    ED4_ROOT->visualizeSAI_allSpecies = aw_root->awar(AWAR_SAI_ALL_SPECIES)->read_int();
413
399
 
414
400
    // create some defaults:
415
 
    AW_awar *awar_defaults_created = aw_root->awar_int(AWAR_SAI_CLR_DEFAULTS_CREATED, 0,  aw_def);
416
 
 
417
 
    if (awar_defaults_created->read_int() == 0) {
418
 
        addDefaultTransTable(aw_root, "numeric",   "0;1;2;3;4;5;6;7;8;9;");
419
 
        addDefaultTransTable(aw_root, "binary",    ".;+;;;;;;;;;");
420
 
        addDefaultTransTable(aw_root, "consensus", "=ACGTU;;acgtu;.;;;;;;;");
421
 
        addDefaultTransTable(aw_root, "helix",     ";;<>;;;;;[];;;");
422
 
        addDefaultTransTable(aw_root, "xstring",   ";x;;;;;;;;;");
423
 
        addDefaultTransTable(aw_root, "gaps",      ";-.;;;;;;;;;");
424
 
 
425
 
        awar_defaults_created->write_int(1);
426
 
    }
427
 
 
428
 
    inCallback = true;          // avoid refresh
 
401
    aw_root->awar_int(AWAR_SAI_CLR_DEFAULTS_CREATED, 1,  aw_def); // @@@ Feb 2012 - remove me in some years
 
402
 
 
403
    addDefaultTransTable(aw_root, "numeric",   "0;1;2;3;4;5;6;7;8;9;");
 
404
    addDefaultTransTable(aw_root, "binary",    ".0;;+1;;;;;;;;");
 
405
    addDefaultTransTable(aw_root, "consensus", "=ACGTU;;acgtu;.;;;;;;;");
 
406
    addDefaultTransTable(aw_root, "helix",     ";;<>;;;;;[];;;");
 
407
    addDefaultTransTable(aw_root, "xstring",   ";x;;;;;;;;;");
 
408
    addDefaultTransTable(aw_root, "gaps",      ";-.;;;;;;;;;");
 
409
 
 
410
    LocallyModify<bool> flag(inCallback, true); // avoid refresh
429
411
    saiChanged_callback(aw_root);
430
412
    colorDefTabNameChanged_callback(aw_root); // init awars for selected table
431
413
    set_autoselect_cb(aw_root);
432
 
    inCallback = false;
433
414
}
434
415
 
435
416
static void createCopyClrTransTable(AW_window *aws, AW_CL cl_mode) {
441
422
    char    *newClrTransTabName = 0;
442
423
    char    *clrTabSourceName   = 0;
443
424
 
444
 
    switch(mode){
 
425
    switch (mode) {
445
426
    case ED4_VIS_CREATE:
446
 
        newClrTransTabName = GBS_string_2_key(aw_root->awar(AWAR_SAI_CLR_TRANS_TAB_NEW_NAME)->read_string());
 
427
        newClrTransTabName = GBS_string_2_key(aw_root->awar(AWAR_SAI_CLR_TRANS_TAB_NEW_NAME)->read_char_pntr());
447
428
 
448
429
        if (strcmp(newClrTransTabName, "__") == 0) { // user entered nothing
449
430
            aw_message("Please enter a translation table name");
452
433
            aw_message(GBS_global_string("Color translation table '%s' already exists.", newClrTransTabName));
453
434
        }
454
435
        else {
455
 
            addNewTransTable(aw_root, newClrTransTabName, "", true);
 
436
            addOrUpdateTransTable(aw_root, newClrTransTabName, "", true);
456
437
        }
457
438
        break;
458
439
 
459
440
    case ED4_VIS_COPY:
460
 
        newClrTransTabName = GBS_string_2_key(aw_root->awar(AWAR_SAI_CLR_TRANS_TAB_NEW_NAME)->read_string());
 
441
        newClrTransTabName = GBS_string_2_key(aw_root->awar(AWAR_SAI_CLR_TRANS_TAB_NEW_NAME)->read_char_pntr());
461
442
        clrTabSourceName   = aw_root->awar(AWAR_SAI_CLR_TRANS_TABLE)->read_string();
462
443
 
463
444
        if (!clrTabSourceName[0]) {
468
449
        }
469
450
        else {
470
451
            char *old_def = aw_root->awar(getClrDefAwar(clrTabSourceName))->read_string();
471
 
            addNewTransTable(aw_root, newClrTransTabName, old_def, true);
 
452
            addOrUpdateTransTable(aw_root, newClrTransTabName, old_def, true);
472
453
            free(old_def);
473
454
        }
474
455
        break;
481
462
}
482
463
 
483
464
static void deleteColorTranslationTable(AW_window *aws) {
484
 
    bool delete_table = aw_ask_sure("Are you sure you want to delete the selected COLOR TRANSLATION TABLE?");
485
 
    if (delete_table) {
486
 
        AW_root *aw_root = aws->get_root();
487
 
        char *clrTabName = aw_root->awar_string(AWAR_SAI_CLR_TRANS_TABLE)->read_string();
488
 
 
489
 
        if (clrTabName[0]) {
490
 
            AW_awar       *awar_tabNames    = aw_root->awar(AWAR_SAI_CLR_TRANS_TAB_NAMES);
491
 
            char          *clrTransTabNames = awar_tabNames->read_string();
492
 
            GBS_strstruct *newTransTabName  = GBS_stropen(strlen(clrTransTabNames));
493
 
 
494
 
            for (const char *tok = strtok(clrTransTabNames,"\n"); tok; tok = strtok(0,"\n")) {
495
 
                if (strcmp(clrTabName, tok) != 0) { // merge all not to delete
496
 
                    GBS_strcat(newTransTabName, tok);
497
 
                    GBS_strcat(newTransTabName, "\n");
498
 
                }
 
465
    AW_root *aw_root = aws->get_root();
 
466
    char *clrTabName = aw_root->awar_string(AWAR_SAI_CLR_TRANS_TABLE)->read_string();
 
467
 
 
468
    if (clrTabName[0]) {
 
469
        AW_awar       *awar_tabNames    = aw_root->awar(AWAR_SAI_CLR_TRANS_TAB_NAMES);
 
470
        char          *clrTransTabNames = awar_tabNames->read_string();
 
471
        GBS_strstruct *newTransTabName  = GBS_stropen(strlen(clrTransTabNames));
 
472
 
 
473
        for (const char *tok = strtok(clrTransTabNames, "\n"); tok; tok = strtok(0, "\n")) {
 
474
            if (strcmp(clrTabName, tok) != 0) { // merge all not to delete
 
475
                GBS_strcat(newTransTabName, tok);
 
476
                GBS_strcat(newTransTabName, "\n");
499
477
            }
500
 
 
501
 
            aw_root->awar_string(getClrDefAwar(clrTabName))->write_string("");
502
 
            char *new_name = GBS_strclose(newTransTabName);
503
 
            awar_tabNames->write_string(new_name); // updates selection list
504
 
            free(new_name);
505
 
 
506
 
            free(clrTransTabNames);
507
 
        }
508
 
        else {
509
 
            aw_message("Selected Color Translation Table is not VALID and cannot be DELETED!");
510
 
        }
511
 
        free(clrTabName);
512
 
    }
 
478
        }
 
479
 
 
480
        aw_root->awar_string(getClrDefAwar(clrTabName))->write_string("");
 
481
        char *new_name = GBS_strclose(newTransTabName);
 
482
        awar_tabNames->write_string(new_name); // updates selection list
 
483
        free(new_name);
 
484
 
 
485
        free(clrTransTabNames);
 
486
    }
 
487
    else {
 
488
        aw_message("Selected Color Translation Table is not VALID and cannot be DELETED!");
 
489
    }
 
490
    free(clrTabName);
513
491
}
514
492
 
515
493
static AW_selection_list *buildClrTransTabNamesList(AW_window *aws) {
516
 
    AW_root           *awr = aws->get_root();
517
 
    AW_selection_list *id  = aws->create_selection_list(AWAR_SAI_CLR_TRANS_TABLE);
518
 
 
519
 
    update_ClrTransTabNamesList_cb(awr, (AW_CL)aws, (AW_CL)id);
520
 
 
521
 
    return id;
 
494
    AW_root           *awr            = aws->get_root();
 
495
    AW_selection_list *colorTransList = aws->create_selection_list(AWAR_SAI_CLR_TRANS_TABLE, true);
 
496
 
 
497
    update_ClrTransTabNamesList_cb(awr, (AW_CL)colorTransList);
 
498
 
 
499
    return colorTransList;
522
500
}
523
501
 
524
502
const char *ED4_getSaiColorString(AW_root *awr, int start, int end) {
530
508
 
531
509
    e4_assert(start<=end);
532
510
 
533
 
    if(lastStart==start && lastEnd==end  && !clrDefinitionsChanged && lastVisualize) {
534
 
        return saiColors-start;    //if start and end positions are same as the previous positions and no settings
535
 
    }                              //were changed return the last calculated saiColors string
 
511
    if (lastStart==start && lastEnd==end  && !clrDefinitionsChanged && lastVisualize) {
 
512
        return saiColors-start;    // if start and end positions are same as the previous positions and no settings
 
513
    }                              // were changed return the last calculated saiColors string
536
514
 
537
515
    lastStart = start; lastEnd = end; clrDefinitionsChanged = false; // storing start and end positions
538
516
 
539
517
    int seqSize = end-start+1;
540
518
 
541
 
    if(seqSize>seqBufferSize){
 
519
    if (seqSize>seqBufferSize) {
542
520
        free(saiColors);
543
521
        seqBufferSize = seqSize;
544
522
        saiColors =  (char*)GB_calloc(seqBufferSize, sizeof(char));
545
523
    }
546
 
    else memset(saiColors,0,sizeof(char)*seqSize);
 
524
    else memset(saiColors, 0, sizeof(char)*seqSize);
547
525
 
548
 
    char *saiSelected = awr->awar(AWAR_SAI_SELECT)->read_string();
 
526
    char *saiSelected = awr->awar(AWAR_SAI_VISUALIZED)->read_string();
549
527
 
550
528
    GB_push_transaction(GLOBAL_gb_main);
551
529
    char   *alignment_name = GBT_get_default_alignment(GLOBAL_gb_main);
615
593
}
616
594
 
617
595
 
618
 
/* -------------------- Creating Windows and Display dialogs -------------------- */
 
596
// -------------------- Creating Windows and Display dialogs --------------------
619
597
 
620
 
static AW_window *create_copyColorTranslationTable_window(AW_root *aw_root){  // creates copy color tranlation table window
 
598
static AW_window *create_copyColorTranslationTable_window(AW_root *aw_root) { // creates copy color translation table window
621
599
    AW_window_simple *aws = new AW_window_simple;
622
 
    aws->init( aw_root, "COPY_CLR_TR_TABLE", "Copy Color Translation Table");
 
600
    aws->init(aw_root, "COPY_CLR_TR_TABLE", "Copy Color Translation Table");
623
601
    aws->load_xfig("ad_al_si.fig");
624
602
 
625
603
    aws->at("close");
626
 
    aws->callback( (AW_CB0)AW_POPDOWN);
627
 
    aws->create_button("CLOSE","CLOSE","C");
 
604
    aws->callback((AW_CB0)AW_POPDOWN);
 
605
    aws->create_button("CLOSE", "CLOSE", "C");
628
606
 
629
607
    aws->at("label");
630
 
    aws->create_autosize_button(0,"Please enter the new name\nfor the Color Translation Table");
 
608
    aws->create_autosize_button(0, "Please enter the new name\nfor the Color Translation Table");
631
609
 
632
610
    aws->at("input");
633
 
    aws->create_input_field(AWAR_SAI_CLR_TRANS_TAB_NEW_NAME,15);
 
611
    aws->create_input_field(AWAR_SAI_CLR_TRANS_TAB_NEW_NAME, 15);
634
612
 
635
613
    aws->at("ok");
636
614
    aws->callback(createCopyClrTransTable, (AW_CL)ED4_VIS_COPY);
637
 
    aws->create_button("GO","GO","G");
 
615
    aws->create_button("GO", "GO", "G");
638
616
 
639
617
    return (AW_window *)aws;
640
618
}
641
619
 
642
 
static AW_window *create_createColorTranslationTable_window(AW_root *aw_root){ // creates create color tranlation table window
 
620
static AW_window *create_createColorTranslationTable_window(AW_root *aw_root) { // creates create color translation table window
643
621
    AW_window_simple *aws = new AW_window_simple;
644
 
    aws->init( aw_root, "CREATE_CLR_TR_TABLE", "Create Color Translation Table");
 
622
    aws->init(aw_root, "CREATE_CLR_TR_TABLE", "Create Color Translation Table");
645
623
    aws->load_xfig("ad_al_si.fig");
646
624
 
647
625
    aws->at("close");
648
 
    aws->callback( (AW_CB0)AW_POPDOWN);
649
 
    aws->create_button("CLOSE","CLOSE","C");
 
626
    aws->callback((AW_CB0)AW_POPDOWN);
 
627
    aws->create_button("CLOSE", "CLOSE", "C");
650
628
 
651
629
    aws->at("label");
652
 
    aws->create_autosize_button(0,"Please enter the name\nfor the Color Translation Table");
 
630
    aws->create_autosize_button(0, "Please enter the name\nfor the Color Translation Table");
653
631
 
654
632
    aws->at("input");
655
 
    aws->create_input_field(AWAR_SAI_CLR_TRANS_TAB_NEW_NAME,15);
 
633
    aws->create_input_field(AWAR_SAI_CLR_TRANS_TAB_NEW_NAME, 15);
656
634
 
657
635
    aws->at("ok");
658
636
    aws->callback(createCopyClrTransTable, (AW_CL)ED4_VIS_CREATE);
659
 
    aws->create_button("GO","GO","G");
 
637
    aws->create_button("GO", "GO", "G");
660
638
 
661
639
    return (AW_window *)aws;
662
640
}
682
660
    }
683
661
}
684
662
 
685
 
static AW_window *create_editColorTranslationTable_window(AW_root *aw_root){  // creates edit color tranlation table window
 
663
static AW_window *create_editColorTranslationTable_window(AW_root *aw_root) { // creates edit color translation table window
686
664
    static AW_window_simple *aws = 0;
687
 
    if(aws) return (AW_window *)aws;
688
 
 
689
 
    aws = new AW_window_simple;
690
 
    aws->init( aw_root, "EDIT_CTT", "Color Translation Table");
691
 
    aws->load_xfig("saiColorRange.fig");
692
 
 
693
 
    char at_name[] = "rangex";
694
 
    char *dig      = strchr(at_name, 0)-1;
695
 
 
696
 
    for (int i = 0; i<AWAR_SAI_CLR_COUNT; ++i) {
697
 
        dig[0] = '0'+i;
698
 
        aws->at(at_name);
699
 
        aws->create_input_field(getAwarName(i), 20);
700
 
    }
701
 
 
702
 
    aws->at("close");
703
 
    aws->callback(AW_POPDOWN);
704
 
    aws->create_button("CLOSE","CLOSE","C");
705
 
 
706
 
    aws->at("reverse");
707
 
    aws->callback(reverseColorTranslationTable);
708
 
    aws->create_button("REVERSE", "Reverse", "R");
709
 
 
710
 
    aws->at("colors");
711
 
    aws->callback(AW_POPUP,(AW_CL)AW_create_gc_window, (AW_CL)ED4_ROOT->aw_gc_manager);
712
 
    aws->button_length(0);
713
 
    aws->create_button("COLORS","#colors.xpm");
714
 
 
715
 
    return (AW_window *)aws;
716
 
}
717
 
 
718
 
static AW_window *openSelectSAI_window(AW_root *aw_root, AW_CL cl_awar_name){
719
 
    const char *awar_name = reinterpret_cast<const char *>(cl_awar_name);
720
 
 
721
 
    static GB_HASH *SAI_window_hash = 0;
722
 
    if (!SAI_window_hash) SAI_window_hash = GBS_create_hash(10, GB_MIND_CASE);
723
 
 
724
 
    AW_window_simple *aws = reinterpret_cast<AW_window_simple *>(GBS_read_hash(SAI_window_hash, awar_name));
725
 
 
726
665
    if (!aws) {
727
666
        aws = new AW_window_simple;
728
 
        aws->init( aw_root, "SELECT_SAI", "SELECT SAI");
729
 
        aws->load_xfig("selectSAI.fig");
730
 
 
731
 
        aws->at("selection");
732
 
        aws->callback((AW_CB0)AW_POPDOWN);
733
 
        awt_create_selection_list_on_extendeds(GLOBAL_gb_main, (AW_window *)aws, awar_name);
 
667
        aws->init(aw_root, "EDIT_CTT", "Color Translation Table");
 
668
        aws->load_xfig("saiColorRange.fig");
 
669
 
 
670
        char at_name[] = "rangex";
 
671
        char *dig      = strchr(at_name, 0)-1;
 
672
 
 
673
        for (int i = 0; i<AWAR_SAI_CLR_COUNT; ++i) {
 
674
            dig[0] = '0'+i;
 
675
            aws->at(at_name);
 
676
            aws->create_input_field(getAwarName(i), 20);
 
677
        }
734
678
 
735
679
        aws->at("close");
736
680
        aws->callback(AW_POPDOWN);
737
 
        aws->create_button("CLOSE","CLOSE","C");
738
 
 
739
 
        aws->window_fit();
740
 
 
741
 
        GBS_write_hash(SAI_window_hash, awar_name, reinterpret_cast<long>(aws));
 
681
        aws->create_button("CLOSE", "CLOSE", "C");
 
682
 
 
683
        aws->at("reverse");
 
684
        aws->callback(reverseColorTranslationTable);
 
685
        aws->create_button("REVERSE", "Reverse", "R");
 
686
 
 
687
        aws->at("colors");
 
688
        aws->callback(makeWindowCallback(ED4_popup_gc_window, ED4_ROOT->gc_manager));
 
689
        aws->button_length(0);
 
690
        aws->create_button("COLORS", "#colors.xpm");
742
691
    }
743
 
    
744
692
    return aws;
745
693
}
746
694
 
747
 
void ED4_create_SAI_selection_button(AW_window *aws, const char *cawar_name) {
748
 
    char *awar_name         = strdup(cawar_name);
749
 
    int   old_button_length = aws->get_button_length();
750
 
 
751
 
    aws->button_length(30);
752
 
 
753
 
    aws->callback(AW_POPUP, (AW_CL)openSelectSAI_window, (AW_CL)awar_name);
754
 
    aws->create_button("SELECT_SAI", awar_name);
755
 
    
756
 
    aws->button_length(old_button_length);
757
 
}
758
 
 
759
695
AW_window *ED4_createVisualizeSAI_window(AW_root *aw_root) {
760
696
    static AW_window_simple *aws = 0;
761
697
    if (!aws) {
762
698
 
763
699
        aws = new AW_window_simple;
764
700
 
765
 
        aws->init( aw_root, "VISUALIZE_SAI", "Visualize SAIs");
 
701
        aws->init(aw_root, "VISUALIZE_SAI", "Visualize SAIs");
766
702
        aws->load_xfig("visualizeSAI.fig");
767
703
 
768
 
        aws->callback( AW_POPUP_HELP,(AW_CL)"visualizeSAI.hlp");
 
704
        aws->callback(makeHelpCallback("visualizeSAI.hlp"));
769
705
        aws->at("help");
770
 
        aws->create_button("HELP","HELP","H");
 
706
        aws->create_button("HELP", "HELP", "H");
771
707
 
772
708
        aws->at("close");
773
709
        aws->callback((AW_CB0)AW_POPDOWN);
774
 
        aws->create_button("CLOSE","CLOSE","C");
 
710
        aws->create_button("CLOSE", "CLOSE", "C");
775
711
 
776
712
        aws->at("enable");
777
713
        aws->create_toggle(AWAR_SAI_ENABLE);
778
714
 
779
715
        aws->at("sai");
780
 
        ED4_create_SAI_selection_button(aws, AWAR_SAI_SELECT);
 
716
        aws->button_length(30);
 
717
        awt_create_SAI_selection_button(GLOBAL_gb_main, aws, AWAR_SAI_VISUALIZED);
781
718
 
782
719
        aws->at("auto_select");
783
720
        aws->create_toggle(AWAR_SAI_AUTO_SELECT);
787
724
 
788
725
        aws->at("edit");
789
726
        aws->button_length(10);
790
 
        aws->callback(AW_POPUP,(AW_CL)create_editColorTranslationTable_window,0);
791
 
        aws->create_button("EDIT","EDIT");
 
727
        aws->callback(AW_POPUP, (AW_CL)create_editColorTranslationTable_window, 0);
 
728
        aws->create_button("EDIT", "EDIT");
792
729
 
793
730
        aws->at("create");
794
 
        aws->callback(AW_POPUP,(AW_CL)create_createColorTranslationTable_window,0);
795
 
        aws->create_button("CREATE","CREATE");
 
731
        aws->callback(AW_POPUP, (AW_CL)create_createColorTranslationTable_window, 0);
 
732
        aws->create_button("CREATE", "CREATE");
796
733
 
797
734
        aws->at("copy");
798
 
        aws->callback(AW_POPUP,(AW_CL)create_copyColorTranslationTable_window,0);
799
 
        aws->create_button("COPY","COPY");
 
735
        aws->callback(AW_POPUP, (AW_CL)create_copyColorTranslationTable_window, 0);
 
736
        aws->create_button("COPY", "COPY");
800
737
 
801
738
        aws->at("delete");
802
 
        aws->callback((AW_CB1)deleteColorTranslationTable,0);
803
 
        aws->create_button("DELETE","DELETE");
 
739
        aws->callback((AW_CB1)deleteColorTranslationTable, 0);
 
740
        aws->create_button("DELETE", "DELETE");
804
741
 
805
742
        aws->at("marked");
806
 
        aws->create_toggle_field(AWAR_SAI_ALL_SPECIES,1);
 
743
        aws->create_toggle_field(AWAR_SAI_ALL_SPECIES, 1);
807
744
        aws->insert_toggle("MARKED SPECIES", "M", 0);
808
745
        aws->insert_toggle("ALL SPECIES", "A", 1);
809
746
        aws->update_toggle_field();
810
747
 
811
748
        AW_awar *trans_tabs = aw_root->awar(AWAR_SAI_CLR_TRANS_TAB_NAMES);
812
 
        trans_tabs->add_callback(update_ClrTransTabNamesList_cb, (AW_CL)aws, (AW_CL)clrTransTableLst);
 
749
        trans_tabs->add_callback(update_ClrTransTabNamesList_cb, (AW_CL)clrTransTableLst);
813
750
        trans_tabs->touch();        // force update
814
751
    }
815
752
    aws->show();
817
754
    return aws;
818
755
}
819
756
 
820
 
bool ED4_SAIs_visualized() {
821
 
    return ED4_ROOT->visualizeSAI;
822
 
}