source: branches/profile/EDIT4/graph_aligner_gui.cxx

Last change on this file was 12757, checked in by westram, 5 years ago
  • unify selectionlist creator names
  • awt_create_selection_list_on_pt_servers
    • remove param 'popup', instead split into two function (button and list) as done for SAIs
File size: 22.3 KB
Line 
1// =============================================================== //
2//                                                                 //
3//   File      : graph_aligner_gui.cxx                             //
4//   Purpose   :                                                   //
5//                                                                 //
6//   Coded by Elmar Pruesse in October 2008                        //
7//   Institute of Microbiology (Technical University Munich)       //
8//   http://www.arb-home.de/                                       //
9//                                                                 //
10// =============================================================== //
11
12#include "graph_aligner_gui.hxx"
13
14#include "ed4_defs.hxx"
15
16// need to use AlignDataAccess defined here to get selected species
17#include <fast_aligner.hxx>
18
19#include <aw_awars.hxx>
20#include <aw_msg.hxx>
21#include <aw_root.hxx>
22#include <awt_sel_boxes.hxx>
23#include <servercntrl.h>
24#include <PT_com.h>
25#include <client.h>
26#include <arbdbt.h>
27#include <arb_strbuf.h>
28
29#include <sys/types.h>
30#include <sys/wait.h>
31
32#include <unistd.h>
33
34#include <string>
35#include <sstream>
36#include <iostream>
37#include <vector>
38
39
40using std::cerr;
41using std::cout;
42using std::endl;
43
44#define GA_AWAR_ROOT "sina/"
45#define GA_AWAR_CMD GA_AWAR_ROOT "command"
46#define GA_AWAR_TGT GA_AWAR_ROOT "target"
47#define GA_AWAR_SAI GA_AWAR_ROOT "sai"
48#define GA_AWAR_ALIGNMENT GA_AWAR_ROOT "alignment"
49#define GA_AWAR_PROTECTION GA_AWAR_ROOT "protection"
50#define GA_AWAR_TURN_CHECK GA_AWAR_ROOT "turncheck"
51#define GA_AWAR_LOGLEVEL GA_AWAR_ROOT "loglevel"
52#define GA_AWAR_REALIGN GA_AWAR_ROOT "realign"
53#define GA_AWAR_COPYMARKREF GA_AWAR_ROOT "copymarkref"
54#define GA_AWAR_MATCH_SCORE GA_AWAR_ROOT "match_score"
55#define GA_AWAR_MISMATCH_SCORE GA_AWAR_ROOT "mismatch_score"
56#define GA_AWAR_GAP_PEN GA_AWAR_ROOT "gap_pen"
57#define GA_AWAR_GAP_EXT GA_AWAR_ROOT "gap_ext"
58#define GA_AWAR_ADVANCED GA_AWAR_ROOT "advanced"
59#define GA_AWAR_FS_MIN GA_AWAR_ROOT "fs_min"
60#define GA_AWAR_FS_MAX GA_AWAR_ROOT "fs_max"
61#define GA_AWAR_FS_MSC GA_AWAR_ROOT "fs_msc"
62#define GA_AWAR_MIN_FULL GA_AWAR_ROOT "min_full"
63#define GA_AWAR_FULL_MINLEN GA_AWAR_ROOT "full_minlen"
64#define GA_AWAR_OVERHANG GA_AWAR_ROOT "overhang"
65#define GA_AWAR_THREADS GA_AWAR_ROOT "threads"
66#define GA_AWAR_QSIZE GA_AWAR_ROOT "qsize"
67#define GA_AWAR_KMER_LEN GA_AWAR_ROOT "kmer_len"
68#define GA_AWAR_KMER_MM GA_AWAR_ROOT "kmer_mm"
69#define GA_AWAR_MIN_LEN GA_AWAR_ROOT "min_len"
70#define GA_AWAR_WEIGHT GA_AWAR_ROOT "weight"
71#define GA_AWAR_INSERT GA_AWAR_ROOT "insert"
72#define GA_AWAR_LOWERCASE GA_AWAR_ROOT "lowercase"
73#define GA_AWAR_AUTOFILTER GA_AWAR_ROOT "autofilter"
74#define GA_AWAR_KMER_NOREL GA_AWAR_ROOT "kmer_norel"
75#define GA_AWAR_KMER_NOFAST GA_AWAR_ROOT "kmer_nofast"
76#define GA_AWAR_SHOW_DIST GA_AWAR_ROOT "show_dist"
77#define GA_AWAR_SHOW_DIFF GA_AWAR_ROOT "show_diff"
78#define GA_AWAR_COLOR GA_AWAR_ROOT "color"
79#define GA_AWAR_GENE_START GA_AWAR_ROOT "gene_start"
80#define GA_AWAR_GENE_END GA_AWAR_ROOT "gene_end"
81#define GA_AWAR_FS_COVER_GENE GA_AWAR_ROOT "fs_cover_gene"
82
83void create_sina_variables(AW_root *root, AW_default db1) {
84    root->awar_string(GA_AWAR_CMD, "sina", db1);
85    root->awar_int(GA_AWAR_TGT, 2, db1);
86    root->awar_int(AWAR_PT_SERVER, 0, db1);
87    root->awar_string(GA_AWAR_SAI, "", db1);
88    root->awar_int(GA_AWAR_PROTECTION, 0, db1);
89    root->awar_string(GA_AWAR_LOGLEVEL, "3", db1); // @@@ change to int?
90    root->awar_int(GA_AWAR_TURN_CHECK, 1, db1);
91    root->awar_int(GA_AWAR_REALIGN, 1, db1);
92    root->awar_int(GA_AWAR_COPYMARKREF, 0, db1);
93    root->awar_float(GA_AWAR_GAP_PEN, 5.0, db1);
94    root->awar_float(GA_AWAR_GAP_EXT, 2.0, db1);
95    root->awar_float(GA_AWAR_MATCH_SCORE, 2.0, db1);
96    root->awar_float(GA_AWAR_MISMATCH_SCORE, -1.0, db1);
97    root->awar_int(GA_AWAR_ADVANCED, 0, db1);
98    root->awar_int(GA_AWAR_FS_MIN, 40, db1);
99    root->awar_int(GA_AWAR_FS_MAX, 40, db1);
100    root->awar_float(GA_AWAR_FS_MSC, .7, db1);
101    root->awar_int(GA_AWAR_MIN_FULL, 1, db1);
102    root->awar_int(GA_AWAR_FULL_MINLEN, 1400, db1);
103    root->awar_string(GA_AWAR_OVERHANG, "attach", db1);
104    root->awar_int(GA_AWAR_THREADS, 1, db1);
105    root->awar_int(GA_AWAR_QSIZE, 1, db1);
106    root->awar_int(GA_AWAR_KMER_LEN, 10, db1);
107    root->awar_int(GA_AWAR_KMER_MM, 0, db1);
108    root->awar_int(GA_AWAR_MIN_LEN, 150, db1);
109    root->awar_float(GA_AWAR_WEIGHT, 1, db1);
110    root->awar_string(GA_AWAR_INSERT, "shift", db1);
111    root->awar_string(GA_AWAR_LOWERCASE, "none", db1);
112    root->awar_string(GA_AWAR_AUTOFILTER, "none", db1);
113    root->awar_int(GA_AWAR_KMER_NOREL, 0, db1);
114    root->awar_int(GA_AWAR_KMER_NOFAST, 0, db1);
115    root->awar_int(GA_AWAR_SHOW_DIST, 0, db1);
116    root->awar_int(GA_AWAR_SHOW_DIFF, 0, db1);
117    root->awar_int(GA_AWAR_COLOR, 1, db1);
118    root->awar_int(GA_AWAR_GENE_START, 0, db1);
119    root->awar_int(GA_AWAR_GENE_END, 0, db1);
120    root->awar_int(GA_AWAR_FS_COVER_GENE, 1, db1);
121}
122
123AW_active sina_mask(AW_root *root) {
124    const char *sinaName    = root->awar(GA_AWAR_CMD)->read_char_pntr();
125    char       *sina        = GB_executable(sinaName);
126    const char *fail_reason = 0;
127
128    if (sina) {
129        int exitstatus = system(GBS_global_string("%s --has-cli-vers ARB5.99", sina));
130        exitstatus     = WEXITSTATUS(exitstatus);
131
132        switch (exitstatus) {
133        case EXIT_SUCCESS:
134            break;
135
136        case EXIT_FAILURE:
137            fail_reason = "Incompatible SINA and ARB versions";
138            break;
139
140        case 127:                                   // libs missing
141        default:                                    // unexpected
142            fail_reason = GBS_global_string("Could execute SINA binary '%s' (exitstatus was %i)",
143                                            sinaName, exitstatus);
144            break;
145        }
146        free(sina);
147    }
148    else {
149        fail_reason = GBS_global_string("%s not found", sinaName);
150    }
151
152    if (fail_reason) {
153        fprintf(stderr,
154                "Note: SINA (SILVA Aligner) disabled (Reason: %s)\n"
155                "      Visit http://www.ribocon.com/sina/ for more information.\n",
156                fail_reason);
157    }
158
159    return fail_reason ? AWM_DISABLED : AWM_ALL;
160}
161
162inline const char *stream2static(const std::stringstream& str) {
163    return GBS_static_string(str.str().c_str());
164}
165
166inline const char *empty_as_none(const char *sainame) {
167    // see http://bugs.arb-home.de/ticket/519
168    if (sainame && !sainame[0]) sainame = "none";
169    return sainame;
170}
171
172static void sina_start(AW_window *window, AW_CL cl_AlignDataAccess) {
173    cerr << "Starting SINA..." << endl;
174
175    // make string from pt server selection
176    AW_root *root = window->get_root();
177    int      pt   = root->awar(AWAR_PT_SERVER)->read_int();
178
179    std::stringstream ptnam;
180    ptnam << "ARB_PT_SERVER" << pt;
181
182    const char *pt_server = GBS_read_arb_tcp(ptnam.str().c_str());
183    GB_ERROR    gb_error  = NULL;
184
185    if (!pt_server) {
186        gb_error = GBS_global_string("Unable to find definition for chosen PT-server\n(Reason: %s)", GB_await_error());
187    }
188    else {
189        const char *pt_db = pt_server + strlen(pt_server) + 1;
190        pt_db += strlen(pt_db)+3;
191
192        // start pt server if necessary
193        gb_error = arb_look_and_start_server(AISC_MAGIC_NUMBER, ptnam.str().c_str());
194        if (gb_error) {
195            std::stringstream tmp;
196            tmp << "Cannot contact PT server. Aborting" << endl
197                << " ID: \"" << tmp.str().c_str()
198                << "\" PORT: \"" << pt_server
199                << "\" DB: \"" << pt_db  << endl
200                << "\" GBERROR: \"" << gb_error << "\"" << endl;
201            gb_error = stream2static(tmp);
202        }
203        else {
204            // create temporary file
205            char* tmpfile;
206            FILE* tmpfile_F;
207            {
208                char* tmpfile_tpl = GB_unique_filename("sina_select", "tmp");
209                tmpfile_F         = GB_fopen_tempfile(tmpfile_tpl, "w", &tmpfile);
210                free(tmpfile_tpl);
211            }
212
213            if (!tmpfile_F) {
214                std::stringstream tmp;
215                tmp << "Error: Unable to create temporary file \"" << tmpfile << "\"!";
216                gb_error = stream2static(tmp);
217            }
218            else {
219                GB_remove_on_exit(tmpfile);
220
221                std::vector<std::string> spec_names;
222                switch (root->awar(GA_AWAR_TGT)->read_int()) {
223                    case 0: { // current
224                        char *spec_name = root->awar(AWAR_SPECIES_NAME)->read_string();
225                        if (spec_name) {
226                            fwrite(spec_name, strlen(spec_name), 1, tmpfile_F);
227                            fwrite("\n", 1, 1, tmpfile_F);
228                        }
229                        else {
230                            gb_error = "Unable to get name of currently active species";
231                        }
232                        free(spec_name);
233                        break;
234                    }
235                    case 1: { // selected
236                        const AlignDataAccess *data_access = (const AlignDataAccess *)cl_AlignDataAccess;
237                        GB_begin_transaction(GLOBAL_gb_main);
238                        int num_selected = 0;
239                        for (GBDATA *gb_spec = data_access->get_first_selected_species(&num_selected);
240                             gb_spec;
241                             gb_spec = data_access->get_next_selected_species())
242                        {
243                            GBDATA *gbd_name = GB_find(gb_spec, "name", SEARCH_CHILD);
244                            if (gbd_name) {
245                                const char *str = GB_read_char_pntr(gbd_name);
246                                fwrite(str, strlen(str), 1, tmpfile_F);
247                                fwrite("\n", 1, 1, tmpfile_F);
248                            }
249                        }
250                        GB_commit_transaction(GLOBAL_gb_main);
251                        break;
252                    }
253                    case 2: { // marked
254                        GB_begin_transaction(GLOBAL_gb_main);
255                        for (GBDATA *gb_spec = GBT_first_marked_species(GLOBAL_gb_main);
256                             gb_spec; gb_spec = GBT_next_marked_species(gb_spec)) {
257                            GBDATA *gbd_name = GB_find(gb_spec, "name", SEARCH_CHILD);
258                            if (gbd_name) {
259                                const char *str = GB_read_char_pntr(gbd_name);
260                                fwrite(str, strlen(str), 1, tmpfile_F);
261                                fwrite("\n", 1, 1, tmpfile_F);
262                            }
263                        }
264                        GB_commit_transaction(GLOBAL_gb_main);
265                        break;
266                    }
267                }
268                fclose(tmpfile_F);
269
270                if (!gb_error) {
271                    // build command line
272                    GBS_strstruct *cl = GBS_stropen(2000);
273
274                    GBS_strcat(cl, root->awar(GA_AWAR_CMD)->read_char_pntr());
275                    GBS_strcat(cl, " -i :");
276                    GBS_strcat(cl, " --ptdb :");
277                    GBS_strcat(cl, " --ptport ");      GBS_strcat(cl,   pt_server);
278                    GBS_strcat(cl, " --turn ");        GBS_strcat(cl,   root->awar(GA_AWAR_TURN_CHECK)->read_int() ? "all" : "none");
279                    GBS_strcat(cl, " --overhang ");    GBS_strcat(cl,   root->awar(GA_AWAR_OVERHANG)->read_char_pntr());
280                    GBS_strcat(cl, " --filter ");      GBS_strcat(cl,   empty_as_none(root->awar(GA_AWAR_SAI)->read_char_pntr()));
281                    GBS_strcat(cl, " --fs-min ");      GBS_intcat(cl,   root->awar(GA_AWAR_FS_MIN)->read_int());
282                    GBS_strcat(cl, " --fs-msc ");      GBS_floatcat(cl, root->awar(GA_AWAR_FS_MSC)->read_float());
283                    GBS_strcat(cl, " --fs-max ");      GBS_intcat(cl,   root->awar(GA_AWAR_FS_MAX)->read_int());
284                    GBS_strcat(cl, " --fs-req 1");
285                    GBS_strcat(cl, " --fs-req-full "); GBS_intcat(cl,   root->awar(GA_AWAR_MIN_FULL)->read_int());
286                    GBS_strcat(cl, " --fs-full-len "); GBS_intcat(cl,   root->awar(GA_AWAR_FULL_MINLEN)->read_int());
287                    GBS_strcat(cl, " --fs-kmer-len "); GBS_intcat(cl,   root->awar(GA_AWAR_KMER_LEN)->read_int());
288                    GBS_strcat(cl, " --fs-kmer-mm ");  GBS_intcat(cl,   root->awar(GA_AWAR_KMER_MM)->read_int());
289                    GBS_strcat(cl, " --fs-min-len ");  GBS_intcat(cl,   root->awar(GA_AWAR_MIN_LEN)->read_int());
290                    GBS_strcat(cl, " --fs-weight ");   GBS_intcat(cl,   root->awar(GA_AWAR_WEIGHT)->read_float());
291                    GBS_strcat(cl, " --pen-gap ");     GBS_floatcat(cl, root->awar(GA_AWAR_GAP_PEN)->read_float());
292                    GBS_strcat(cl, " --pen-gapext ");  GBS_floatcat(cl, root->awar(GA_AWAR_GAP_EXT)->read_float());
293                    GBS_strcat(cl, " --match-score "); GBS_floatcat(cl, root->awar(GA_AWAR_MATCH_SCORE)->read_float());
294                    GBS_strcat(cl, " --mismatch-score "); GBS_floatcat(cl, root->awar(GA_AWAR_MISMATCH_SCORE)->read_float());
295                    GBS_strcat(cl, " --prot-level ");  GBS_intcat(cl,   root->awar(GA_AWAR_PROTECTION)->read_int());
296                    GBS_strcat(cl, " --select-file "); GBS_strcat(cl,   tmpfile);
297                    GBS_strcat(cl, " --insertion ");   GBS_strcat(cl,   root->awar(GA_AWAR_INSERT)->read_char_pntr());
298                    GBS_strcat(cl, " --lowercase ");   GBS_strcat(cl,   root->awar(GA_AWAR_LOWERCASE)->read_char_pntr());
299                    GBS_strcat(cl, " --auto-filter-field "); GBS_strcat(cl, root->awar(GA_AWAR_AUTOFILTER)->read_char_pntr());
300                    GBS_strcat(cl, " --gene-start ");  GBS_intcat(cl,   root->awar(GA_AWAR_GENE_START)->read_int());
301                    GBS_strcat(cl, " --gene-end ");    GBS_intcat(cl,   root->awar(GA_AWAR_GENE_END)->read_int());
302                    GBS_strcat(cl, " --fs-cover-gene ");GBS_intcat(cl,   root->awar(GA_AWAR_FS_COVER_GENE)->read_int());
303
304
305                    if (root->awar(GA_AWAR_KMER_NOREL)->read_int()) GBS_strcat(cl, " --fs-kmer-norel ");
306                    if (root->awar(GA_AWAR_KMER_NOFAST)->read_int()) GBS_strcat(cl, " --fs-kmer-no-fast ");
307                    if (root->awar(GA_AWAR_SHOW_DIST)->read_int()) GBS_strcat(cl, " --show-dist ");
308                    if (root->awar(GA_AWAR_SHOW_DIFF)->read_int()) GBS_strcat(cl, " --show-diff ");
309                    if (root->awar(GA_AWAR_COLOR)->read_int())     GBS_strcat(cl, " --color");
310                    if (root->awar(GA_AWAR_REALIGN)->read_int())     GBS_strcat(cl, " --realign");
311
312                    gb_error = GB_xcmd(GBS_mempntr(cl), true, false);
313                    GBS_strforget(cl);
314                }
315
316                if (!gb_error) aw_message("SINA finished aligning.");
317            }
318            free(tmpfile);
319        }
320    }
321   
322    aw_message_if(gb_error);
323}
324
325
326
327static char* filter_sai(GBDATA *gb_extended, AW_CL) {
328    char   *result = 0;
329    GBDATA *gbd    = GB_search(gb_extended, "ali_16s/_TYPE", GB_FIND);
330    if (gbd) {
331        const char* type = GB_read_char_pntr(gbd);
332        if (type && strncmp("PV", type, 2) == 0) {
333            gbd    = GB_find(gb_extended, "name", SEARCH_CHILD);
334            result = GB_read_string(gbd);
335        }
336    }
337    return result;
338}
339
340static AW_window_simple* new_sina_simple(AW_root *root, AW_CL cl_AlignDataAccess, bool adv) {
341    int closex, closey, startx, starty, winx, winy;
342    const int hgap = 10;
343    AW_window_simple *aws = new AW_window_simple;
344
345    aws->init(root, "SINA", "SINA (SILVA Incremental Aligner)");
346
347    aws->button_length(12);
348    aws->at(10, 10);
349    aws->auto_space(5, 5);
350
351    aws->callback(AW_POPDOWN);
352    aws->create_button("CLOSE", "CLOSE", "O");
353    aws->get_at_position(&closex, &closey);
354
355    aws->at_shift(10, 0);
356    aws->callback(show_sina_window, cl_AlignDataAccess, 0);
357    aws->label_length(0);
358    aws->label("Show advanced options");
359    aws->create_toggle(GA_AWAR_ADVANCED);
360
361    aws->at_newline();
362    aws->at_shift(0, hgap);
363    aws->label_length(15);
364    aws->create_toggle_field(GA_AWAR_TGT, "Align what?", "A");
365    aws->insert_toggle("Current Species:", "C", 0);
366    aws->insert_toggle("Selected Species", "S", 1);
367    aws->insert_default_toggle("Marked Species", "M", 2);
368    aws->update_toggle_field();
369
370    aws->at_shift(0, 3);
371    aws->create_input_field(AWAR_SPECIES_NAME, 20);
372
373    aws->at_newline();
374    aws->at_shift(0, hgap);
375    aws->button_length(24);
376    aws->label("PT Server:");
377    awt_create_PTSERVER_selection_button(aws, AWAR_PT_SERVER);
378
379    aws->at_newline();
380    aws->label_length(0);
381    aws->label("Overhang placement");
382    aws->create_option_menu(GA_AWAR_OVERHANG, true);
383    aws->insert_option("keep attached", 0, "attach");
384    aws->insert_option("move to edge", 0, "edge");
385    aws->insert_option("remove", 0, "remove");
386    aws->update_option_menu();
387
388    aws->at_newline();
389    aws->label("Handling of unmappable insertions");
390    aws->create_option_menu(GA_AWAR_INSERT, true);
391    aws->insert_option("Shift surrounding bases", 0, "shift");
392    aws->insert_option("Forbid during DP alignment", 0, "forbid");
393    aws->insert_option("Delete bases", 0, "remove");
394    aws->update_option_menu();
395
396    aws->at_newline();
397    aws->label("Character Case");
398    aws->create_option_menu(GA_AWAR_LOWERCASE, true);
399    aws->insert_option("Do not modify", 0, "original");
400    aws->insert_option("Show unaligned bases as lower case", 0, "unaligned");
401    aws->insert_option("Uppercase all", 0, "none");
402    aws->update_option_menu();
403
404    aws->at_newline();
405    aws->label("Family conservation weight (0-1)");
406    aws->create_input_field(GA_AWAR_WEIGHT, 3);
407
408    aws->at_newline();
409    aws->label("Size of full-length sequences");
410    aws->create_input_field(GA_AWAR_FULL_MINLEN, 5);
411
412    if (adv) {
413        aws->at_newline();
414        aws->at_shift(0, hgap);
415
416        aws->at_newline();
417
418        aws->label("Pos. Var.:");
419        awt_create_SAI_selection_button(GLOBAL_gb_main, aws, GA_AWAR_SAI, filter_sai, 0);
420
421        aws->at_newline();
422        aws->label("Field used for automatic filter selection");
423        aws->create_input_field(GA_AWAR_AUTOFILTER, 20);
424
425        aws->label("Turn check");
426        aws->create_toggle(GA_AWAR_TURN_CHECK);
427
428        aws->at_newline();
429        aws->label("Realign");
430        aws->create_toggle(GA_AWAR_REALIGN);
431
432       /*
433        aws->at_newline();
434        aws->label("(Copy and) mark sequences used as reference");
435        aws->create_toggle(GA_AWAR_COPYMARKREF);
436        */
437
438        aws->at_newline();
439        aws->at_shift(0, hgap);
440        aws->label_length(0);
441
442        aws->label("Gap insertion/extension penalties");
443        aws->create_input_field(GA_AWAR_GAP_PEN, 5);
444        aws->create_input_field(GA_AWAR_GAP_EXT, 5);
445
446        aws->at_newline();
447        aws->label("Match score");
448        aws->create_input_field(GA_AWAR_MATCH_SCORE, 3);
449        aws->label("Mismatch score");
450        aws->create_input_field(GA_AWAR_MISMATCH_SCORE, 3);
451
452        aws->at_newline();
453        aws->label("Family search min/min_score/max");
454        aws->create_input_field(GA_AWAR_FS_MIN, 3);
455        aws->create_input_field(GA_AWAR_FS_MSC, 3);
456        aws->create_input_field(GA_AWAR_FS_MAX, 3);
457
458        aws->at_newline();
459        aws->label("Minimal number of full length sequences");
460        aws->create_input_field(GA_AWAR_MIN_FULL, 3);
461
462        aws->at_newline();
463        aws->label("Family search oligo length / mismatches");
464        aws->create_input_field(GA_AWAR_KMER_LEN, 3);
465        aws->create_input_field(GA_AWAR_KMER_MM, 3);
466
467        aws->at_newline();
468        aws->label("Minimal reference sequence length");
469        aws->create_input_field(GA_AWAR_MIN_LEN, 5);
470
471        aws->at_newline();
472        aws->label("Alignment bounds: start");
473        aws->create_input_field(GA_AWAR_GENE_START, 6);
474        aws->label("end");
475        aws->create_input_field(GA_AWAR_GENE_END, 6);
476
477        aws->at_newline();
478        aws->label("Number of references required to touch bounds");
479        aws->create_input_field(GA_AWAR_FS_COVER_GENE, 3);
480
481        aws->at_newline();
482        aws->label("Disable fast search");
483        aws->create_toggle(GA_AWAR_KMER_NOFAST);
484
485        aws->at_newline();
486        aws->label("Score search results by absolute oligo match count");
487        aws->create_toggle(GA_AWAR_KMER_NOREL);
488
489        aws->at_newline();
490        aws->label("SINA command");
491        aws->create_input_field(GA_AWAR_CMD, 20);
492
493        aws->at_shift(0, hgap);
494    }
495
496    aws->at_newline();
497    aws->at_shift(0, hgap);
498
499    aws->label_length(17);
500    aws->label("Protection Level");
501    aws->create_option_menu(GA_AWAR_PROTECTION, true);
502    aws->insert_option("0", 0, 0);
503    aws->insert_option("1", 0, 1);
504    aws->insert_option("2", 0, 2);
505    aws->insert_option("3", 0, 3);
506    aws->insert_option("4", 0, 4);
507    aws->insert_option("5", 0, 5);
508    aws->insert_option("6", 0, 6);
509    aws->update_option_menu();
510
511    /*
512      aws->at_newline();
513    aws->create_option_menu(GA_AWAR_LOGLEVEL, "Logging level", "L");
514    aws->insert_option("silent", 0, "1");
515    aws->insert_option("quiet", 0, "2");
516    aws->insert_default_option("normal", 0, "3");
517    aws->insert_option("verbose", 0, "4");
518    aws->insert_option("debug", 0, "5");
519    aws->insert_option("debug more", 0, "6");
520    aws->update_option_menu();
521    */
522
523    aws->at_newline();
524    aws->label("Show changed sections of alignment");
525    aws->create_toggle(GA_AWAR_SHOW_DIFF);
526    aws->label("color bases");
527    aws->create_toggle(GA_AWAR_COLOR);
528
529    aws->at_newline();
530    aws->label("Show statistics");
531    aws->create_toggle(GA_AWAR_SHOW_DIST);
532
533    aws->get_window_size(winx, winy);
534    aws->get_at_position(&startx, &starty);
535
536    aws->button_length(12);
537
538    aws->at(winx-closex+5, closey);
539    aws->callback(makeHelpCallback("sina_main.hlp"));
540    aws->create_button("HELP", "HELP");
541
542    aws->at(winx-closex+5, starty);
543    aws->callback(sina_start, cl_AlignDataAccess);
544    aws->highlight();
545    aws->create_button("Start", "Start", "S");
546
547    return aws;
548}
549
550void show_sina_window(AW_window *aw, AW_CL cl_AlignDataAccess, AW_CL) {
551    static AW_window_simple *ga_aws = 0;
552    static AW_window_simple *ga_aws_adv = 0;
553
554    AW_root *root = aw->get_root();
555    if (root->awar(GA_AWAR_ADVANCED)->read_int()) {
556        if (!ga_aws_adv) ga_aws_adv = new_sina_simple(root, cl_AlignDataAccess, true);
557        ga_aws_adv->show();
558        if (ga_aws) ga_aws->hide();
559    }
560    else {
561        if (!ga_aws) ga_aws = new_sina_simple(root, cl_AlignDataAccess, false);
562        ga_aws->show();
563        if (ga_aws_adv) ga_aws_adv->hide();
564    }
565}
566
Note: See TracBrowser for help on using the repository browser.