source: branches/alilink/EDIT4/ED4_seq_colors.cxx

Last change on this file was 18126, checked in by westram, 5 years ago
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 20.0 KB
Line 
1// ================================================================ //
2//                                                                  //
3//   File      : ED4_seq_colors.cxx                                 //
4//   Purpose   : Sequence foreground coloring.                      //
5//               Viewing differences only.                          //
6//                                                                  //
7//   Institute of Microbiology (Technical University Munich)        //
8//   http://www.arb-home.de/                                        //
9//                                                                  //
10// ================================================================ //
11
12#include "ed4_seq_colors.hxx"
13#include "ed4_class.hxx"
14#include "ed4_extern.hxx"
15
16#include <aw_root.hxx>
17#include <aw_awar.hxx>
18#include <aw_awar_defs.hxx>
19#include <aw_msg.hxx>
20#include <arbdbt.h>
21#include <arb_global_defs.h>
22
23#include <cctype>
24
25static int default_NUC_set = 0;     // number of default nucleotide set
26static int default_AMI_set = 3;     // number of default amino acid set
27
28#define SEQ_COLOR_SETS      8
29#define SEQ_COLOR_SET_ELEMS 28 // has to be a even number!
30
31#define AWAR_SEQ_PATH                  "awt/seq_colors/"
32#define AWAR_SEQ_NAME_STRINGS_TEMPLATE AWAR_SEQ_PATH  "strings/elem_%i"
33#define AWAR_SEQ_NAME_TEMPLATE         AWAR_SEQ_PATH  "set_%i/elem_%i"
34#define AWAR_SEQ_NAME_SELECTOR_NA      AWAR_SEQ_PATH   "na/select"
35#define AWAR_SEQ_NAME_SELECTOR_AA      AWAR_SEQ_PATH   "aa/select"
36
37static const char *default_sets[SEQ_COLOR_SETS] = {
38    //A B C D E F G H I J K L M N O P Q R S T U V W X Y Z * -
39    "=2=0=3=0=0=0=4=0=0=0=0=0=0=6=0=0=0=0=0=5=5=0=0=0=0=0=0=6", // A, C, G, TU and N in 5 colors
40    "R2=0Y3=0=0=0R2=0=0=0=0=0=0=0=0=0=0=2=0Y3Y3=0=0=0=3=0=0=6", // AG and CTU in 2 colors
41    "=6=5=6=5=7=7=6=5=7=7=3=7=3=9=7=7=7=3=3=6=6=5=3=7=3=7=7=6", // ambiguity
42    "=7=0=7=8=2=9=8=9=3=0=2=3=7=8=0=8=2=2=2=2=0=3=9=6=9=0=0=6", // Protein colors
43
44    "=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=6",
45    "o9=0|2=0=0=0o5=0=0=0=0=0=0=0=0=0=0=0=0|8|8=0=0=0=0=0=0=6", // ambiguity (symbols)
46    "=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=6",
47    "=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=0=6",
48};
49
50static bool seq_color_awars_created = false;
51
52// --------------------------------------------------------------------------------
53
54static const char *default_characters(int elem) {
55    static char result[3] = "xX";
56
57    if (elem<26) { //  first 26 elements (0-25) are characters
58        result[0] = 'a'+elem;
59        result[1] = 'A'+elem;
60    }
61    else if (elem == 26) { // stop codon
62        result[0] = '*';
63        result[1] = 0;
64    }
65    else if (elem == 27) { // gaps
66        result[0] = '-';
67        result[1] = '.';
68    }
69
70    return result;
71}
72static const char *default_color(int cset, int elem) {
73    // returns default color numbers for seq-color-set
74    static char result[3] = "=0";
75    const char *pos       = default_sets[cset]+2*elem;
76
77    result[0] = pos[0];
78    result[1] = pos[1];
79
80    if (result[0] == '=' && result[1] == '0') result[0] = 0;
81
82    return result;
83}
84
85static void color_awar_changed_cb(AW_root *, ED4_seq_colors *sc) {
86    sc->reload();
87}
88
89static void create_seq_color_awars(AW_root *awr, ED4_seq_colors *sc) {
90    e4_assert(!seq_color_awars_created);
91
92    RootCallback update_cb = makeRootCallback(color_awar_changed_cb, sc);
93    awr->awar_int(AWAR_SEQ_NAME_SELECTOR_NA, default_NUC_set, AW_ROOT_DEFAULT)->add_callback(update_cb);
94    awr->awar_int(AWAR_SEQ_NAME_SELECTOR_AA, default_AMI_set, AW_ROOT_DEFAULT)->add_callback(update_cb);
95
96    for (int elem = 0; elem<SEQ_COLOR_SET_ELEMS; ++elem) {
97        const char *awar_name = GBS_global_string(AWAR_SEQ_NAME_STRINGS_TEMPLATE, elem);
98        awr->awar_string(awar_name, default_characters(elem))->add_callback(update_cb);
99
100        for (int cset = 0; cset<SEQ_COLOR_SETS; ++cset) {
101            awar_name         = GBS_global_string(AWAR_SEQ_NAME_TEMPLATE, cset, elem);
102            AW_awar *awar_col = awr->awar_string(awar_name, default_color(cset, elem));
103
104            if (strcmp(awar_col->read_char_pntr(), "=0") == 0) { // translate old->new default
105                awar_col->write_string("");
106            }
107
108            // add callback AFTER writing to awar above to avoid recursion
109            // (the CB calls this function again, and seq_color_awars_created is set
110            // to true at the very end...
111            awar_col->add_callback(update_cb);
112        }
113    }
114
115    seq_color_awars_created = true;
116}
117
118AW_window *ED4_create_seq_colors_window(AW_root *awr, ED4_seq_colors *sc) {
119    char                     buf[256];
120    static AW_window_simple *aws = NULp;
121    if (aws) return aws;
122
123    if (!seq_color_awars_created) create_seq_color_awars(awr, sc);
124
125    aws = new AW_window_simple;
126    aws->init(awr, "SEQUENCE_MAPPING", "Sequence color mapping");
127
128    aws->at(10, 10);
129    aws->auto_space(0, 3);
130
131    aws->callback(AW_POPDOWN);
132    aws->create_button("CLOSE", "CLOSE", "C");
133
134    aws->callback(makeHelpCallback("sequence_colors.hlp"));
135    aws->create_button("HELP", "HELP");
136   
137    aws->at_newline();
138
139    for (int seqType=0; seqType<2; seqType++) {
140        if (seqType==0) {
141            aws->label("Select color-set for Nucleotides (NA):");
142            aws->create_toggle_field(AWAR_SEQ_NAME_SELECTOR_NA, 1);
143        }
144        else {
145            aws->label("Select color-set for Amino Acids (AA):");
146            aws->create_toggle_field(AWAR_SEQ_NAME_SELECTOR_AA, 1);
147        }
148
149        for (int cset = 0; cset < SEQ_COLOR_SETS; cset++) {
150            sprintf(buf, "%i", cset+1);
151            aws->insert_toggle(buf, " ", cset);
152        }
153        aws->update_toggle_field();
154        aws->at_newline();
155    }
156
157    const int BIG_COLUMNS    = 2;
158    const int CHAR_COL_WIDTH = 4;
159    const int SET_COL_WIDTH  = 2;
160
161    int col_x_off[BIG_COLUMNS][SEQ_COLOR_SETS+1];
162
163    aws->auto_space(3, 2);
164
165    for (int bcol = 0; bcol<BIG_COLUMNS; ++bcol) {
166        col_x_off[bcol][0] = aws->get_at_xposition();
167        aws->button_length(CHAR_COL_WIDTH);
168        aws->create_button(NULp, "Chars");
169       
170        aws->button_length(SET_COL_WIDTH);
171        for (int cset = 0; cset < SEQ_COLOR_SETS; cset++) {
172            sprintf(buf, "  %i", cset+1);
173            col_x_off[bcol][cset+1] = aws->get_at_xposition();
174            aws->create_button(NULp, buf);
175        }
176
177        if (!bcol) {
178            int set_col_pixel_width = col_x_off[0][1]-col_x_off[0][0];
179            aws->at_x(aws->get_at_xposition()+set_col_pixel_width);
180        }
181    }
182
183    aws->at_newline();
184
185    const int ROWS = SEQ_COLOR_SET_ELEMS/2;
186    for (int r = 0; r<ROWS; r++) {
187        for (int bcol = 0; bcol<BIG_COLUMNS; ++bcol) {
188            int elem = bcol*ROWS+r;
189
190            sprintf(buf, AWAR_SEQ_NAME_STRINGS_TEMPLATE, elem);
191            aws->at_x(col_x_off[bcol][0]);
192            aws->create_input_field(buf, CHAR_COL_WIDTH);
193
194            for (int cset = 0; cset < SEQ_COLOR_SETS; cset++) {
195                sprintf(buf, AWAR_SEQ_NAME_TEMPLATE, cset, elem);
196                aws->at_x(col_x_off[bcol][cset+1]);
197                aws->create_input_field(buf, SET_COL_WIDTH);
198            }
199        }
200        aws->at_newline();
201    }
202
203    aws->window_fit();
204
205    return aws;
206}
207
208// GC order needed for sequence coloring
209STATIC_ASSERT((ED4_G_SEQUENCES+1) == ED4_G_HELIX);
210STATIC_ASSERT((ED4_G_HELIX+1)     == ED4_G_COLOR_2);
211
212void ED4_seq_colors::reload() {
213    for (int i=0; i<256; i++) { // LOOP_VECTORIZED=* // >=8.1: 2x; 7.4: 1x // tested down to gcc 5.5.0 (may fail on older gcc versions)
214        char_2_gc[i]   = char_2_gc_aa[i]   = base_gc;
215        char_2_char[i] = char_2_char_aa[i] = i;
216    }
217
218    AW_root *aw_root = AW_root::SINGLETON;
219
220    if (!seq_color_awars_created) create_seq_color_awars(aw_root, this);
221
222    const char *selector_awar[2] = { AWAR_SEQ_NAME_SELECTOR_NA, AWAR_SEQ_NAME_SELECTOR_AA };
223
224    for (int selector = 0; selector<2; selector++) {
225        long def_set = selector == 0 ? default_NUC_set : default_AMI_set;
226        long cset    = aw_root->awar(selector_awar[selector])->read_int();
227
228        if (cset < 0 || cset >= SEQ_COLOR_SETS) {
229            cset = def_set;
230        }
231
232        for (int elem = 0; elem < SEQ_COLOR_SET_ELEMS; elem++) {
233            char awar_name[256];
234
235            sprintf(awar_name, AWAR_SEQ_NAME_STRINGS_TEMPLATE, elem);
236            unsigned char *sc = (unsigned char *)aw_root->awar(awar_name)->read_string();
237
238            sprintf(awar_name, AWAR_SEQ_NAME_TEMPLATE, (int)cset, elem);
239            char *val = aw_root->awar(awar_name)->read_string();
240            if (!val[0]) freedup(val, "=0"); // interpret '' as '  = 0'
241
242            if (strlen(val) != 2 || val[1] >'9' || val[1] < '0') {
243                aw_message(GB_export_errorf("Error in Color Lookup Table: '%s' is not of type X#", val));
244            }
245            else {
246                if (selector == 0) { // Nucleotide colors
247                    for (int i=0; sc[i]; i++) {
248                        char_2_gc[sc[i]] = val[1]-'0' + base_gc;
249                        if (val[0] != '=') char_2_char[sc[i]] = val[0];
250                    }
251                }
252                else {
253                    for (int i=0; sc[i]; i++) {
254                        char_2_gc_aa[sc[i]] = val[1]-'0' + base_gc;
255                        if (val[0] != '=') char_2_char_aa[sc[i]] = val[0];
256                    }
257                }
258            }
259            free(val);
260            free(sc);
261        }
262    }
263
264    run_cb();
265}
266
267ED4_seq_colors::ED4_seq_colors(int baseGC, void (*changed_cb)()) {
268    cb      = changed_cb;
269    base_gc = baseGC;
270
271    this->reload();
272}
273
274// -----------------------
275//      ED4_reference
276
277ED4_reference::ED4_reference(GBDATA *_gb_main)
278    : gb_main(_gb_main),
279      nodiff('#'), // notused; overwritten by user default later
280      mindcase(true),
281      ref_len(0),
282      reference(NULp),
283      ref_term(NULp)
284{
285    reset_gap_table();
286}
287
288ED4_reference::~ED4_reference() {
289    clear();
290}
291
292void ED4_reference::reset_gap_table() {
293    for (int i = 0; i<256; ++i) is_gap[i] = false;
294}
295
296void ED4_reference::set_gap_handling(bool mindgaptype, const char *gaptypes) {
297    reset_gap_table();
298    if (!mindgaptype) { // treat all gaps as "equal"
299        for (int i = 0; gaptypes[i]; ++i) {
300            is_gap[safeCharIndex(gaptypes[i])] = true;
301        }
302    }
303}
304
305void ED4_reference::expand_to_length(int len) {
306    if (len>ref_len && is_set()) {
307        char *ref2 = ARB_calloc<char>(len+1);
308
309        if (reference) {
310            strcpy(ref2, reference);
311            free(reference);
312        }
313        reference = ref2;
314        ref_len   = len;
315    }
316}
317
318void ED4_reference::update_data() {
319    freeset(reference, ref_term->get_sequence_copy(&ref_len));
320}
321
322void ED4_reference::data_changed_cb(ED4_species_manager *IF_ASSERTION_USED(calledFrom)) {
323    e4_assert(ref_term);
324    if (ref_term) {
325#if defined(ASSERTION_USED)
326        if (calledFrom) e4_assert(ref_term->get_parent(LEV_SPECIES)->to_species_manager() == calledFrom);
327#endif
328        update_data();
329    }
330}
331static void refdata_changed_cb(ED4_species_manager *sman, ED4_reference *ref) {
332    ref->data_changed_cb(sman);
333    ED4_ROOT->request_refresh_for_specific_terminals(LEV_SEQUENCE_STRING); // refresh all sequences
334}
335static void refdata_deleted_cb() {
336    ED4_viewDifferences_disable();
337}
338
339void ED4_reference::clear() {
340    // remove change cb
341    if (ref_term) {
342        ED4_species_manager *sman = ref_term->get_parent(LEV_SPECIES)->to_species_manager();
343        sman->remove_sequence_changed_cb(makeED4_species_managerCallback(refdata_changed_cb, this));
344        sman->remove_delete_callback(makeED4_managerCallback(refdata_deleted_cb));
345    }
346
347    freenull(reference);
348    ref_len  = 0;
349    ref_term = NULp;
350}
351
352void ED4_reference::define(const ED4_sequence_terminal *rterm) {
353    clear();
354    ref_term = rterm;
355    update_data();
356
357    // add change cb
358    ED4_species_manager *sman = ref_term->get_parent(LEV_SPECIES)->to_species_manager();
359    sman->add_sequence_changed_cb(makeED4_species_managerCallback(refdata_changed_cb, this));
360    sman->add_delete_callback(makeED4_managerCallback(refdata_deleted_cb));
361}
362
363bool ED4_reference::reference_is_a_consensus() const {
364    return is_set() && ref_term->is_consensus_sequence_terminal();
365}
366
367// --------------------------------------------------------------------------------
368
369#define APREFIX_DIFF_SAVE "edit4/diff/"
370#define APREFIX_DIFF_TEMP "tmp/" APREFIX_DIFF_SAVE
371
372#define AWAR_DIFF_TYPE        APREFIX_DIFF_TEMP "type"
373#define AWAR_DIFF_NAME        APREFIX_DIFF_TEMP "name"
374#define AWAR_NODIFF_INDICATOR APREFIX_DIFF_SAVE "indicator"
375#define AWAR_DIFF_MINDCASE    APREFIX_DIFF_SAVE "mindcase"
376#define AWAR_DIFF_MINDGAPTYPE APREFIX_DIFF_SAVE "mindgaptype"
377#define AWAR_DIFF_GAPTYPES    APREFIX_DIFF_SAVE "gaptypes"
378
379enum ViewDiffType {
380    VD_DISABLED,
381    VD_SELECTED,
382    VD_FOLLOW,
383};
384
385static ED4_terminal *detect_current_ref_terminal()  {
386    ED4_cursor   *cursor  = &current_cursor();
387    ED4_terminal *refTerm = cursor->owner_of_cursor;
388
389    if (refTerm) {
390        if (!(refTerm->is_consensus_terminal() ||
391              refTerm->is_SAI_terminal() ||
392              refTerm->is_species_seq_terminal()))
393        {
394            refTerm = NULp;
395        }
396    }
397
398    if (!refTerm) {
399        aw_message("Please set the cursor to a species, SAI or group consensus.");
400    }
401
402    return refTerm;
403}
404
405static void set_diff_reference(ED4_terminal *refTerm) {
406    ED4_reference *ref = ED4_ROOT->reference;
407    if (!refTerm) {
408        ref->clear();
409    }
410    else {
411        ED4_sequence_terminal *refSeqTerm = dynamic_cast<ED4_sequence_terminal*>(refTerm);
412        if (refSeqTerm) {
413            AW_awar                   *awar_refName = AW_root::SINGLETON->awar(AWAR_DIFF_NAME);
414            ED4_species_name_terminal *nameTerm     = refSeqTerm->corresponding_species_name_terminal();
415
416            ref->define(refSeqTerm);
417            if (refTerm->is_consensus_terminal()) {
418                awar_refName->write_string(GBS_global_string("consensus %s", nameTerm->get_displayed_text()));
419            }
420            else {
421                e4_assert(refTerm->is_species_seq_terminal() || refTerm->is_SAI_terminal());
422                awar_refName->write_string(nameTerm->get_displayed_text());
423            }
424        }
425        else {
426            aw_message("Not supported for this terminal type");
427        }
428    }
429
430    ED4_ROOT->request_refresh_for_specific_terminals(LEV_SEQUENCE_STRING);
431}
432
433static SmartCharPtr last_used_ref_term_name;
434
435static void set_current_as_diffRef(bool enable) {
436    ED4_MostRecentWinContext context;
437
438    ED4_terminal *refTerm = enable ? detect_current_ref_terminal() : NULp;
439    if (!enable || refTerm) { // do not disable, if current terminal has wrong type
440        set_diff_reference(refTerm);
441        if (refTerm) last_used_ref_term_name = ARB_strdup(refTerm->id);
442    }
443}
444
445static void change_reference_cb(AW_window *aww) {
446    set_current_as_diffRef(true);
447
448    AW_awar *awar_refType = aww->get_root()->awar(AWAR_DIFF_TYPE);
449    if (awar_refType->read_int() == VD_DISABLED) {
450        awar_refType->write_int(VD_SELECTED);
451    }
452}
453
454static void diff_type_changed_cb(AW_root *awr) {
455    AW_awar      *awar_refType = awr->awar(AWAR_DIFF_TYPE);
456    ViewDiffType  type         = ViewDiffType(awar_refType->read_int());
457
458    switch (type) {
459        case VD_DISABLED:
460            set_current_as_diffRef(false);
461            break;
462
463        case VD_FOLLOW:
464        case VD_SELECTED: {
465            ED4_terminal *last_used_ref_term = NULp;
466            if (last_used_ref_term_name.isSet()) {
467                ED4_base *found = ED4_ROOT->main_manager->search_ID(&*last_used_ref_term_name);
468                if (found && found->is_terminal()) {
469                    last_used_ref_term = found->to_terminal();
470                }
471            }
472            if (last_used_ref_term) {
473                set_diff_reference(last_used_ref_term);
474                if (type == VD_FOLLOW) set_current_as_diffRef(true);
475            }
476            else {
477                set_current_as_diffRef(true);
478            }
479            if (!ED4_ROOT->reference->is_set()) {
480                awar_refType->write_int(VD_DISABLED);
481            }
482            break;
483        }
484    }
485}
486
487static void update_reference_settings(AW_root *awr) {
488    ED4_reference *ref = ED4_ROOT->reference;
489    ref->set_nodiff_indicator(awr->awar(AWAR_NODIFF_INDICATOR)->read_char_pntr()[0]);
490    ref->set_case_sensitive(awr->awar(AWAR_DIFF_MINDCASE)->read_int());
491    ref->set_gap_handling(awr->awar(AWAR_DIFF_MINDGAPTYPE)->read_int(), awr->awar(AWAR_DIFF_GAPTYPES)->read_char_pntr());
492}
493static void diff_setting_changed_cb(AW_root *awr) {
494    update_reference_settings(awr);
495    ED4_ROOT->request_refresh_for_specific_terminals(LEV_SEQUENCE_STRING);
496}
497
498static void nodiff_indicator_changed_cb(AW_root *awr) {
499    AW_awar    *awar_indicator = awr->awar(AWAR_NODIFF_INDICATOR);
500    const char *indicator      = awar_indicator->read_char_pntr();
501
502    if (!indicator[0]) {
503        awar_indicator->write_string(" ");
504    }
505    else {
506        diff_setting_changed_cb(awr);
507    }
508}
509
510static bool viewDifferences_awars_initialized = false;
511
512static void create_viewDifferences_awars(AW_root *awr) {
513    if (!viewDifferences_awars_initialized) {
514        awr->awar_int(AWAR_DIFF_TYPE, VD_DISABLED)->add_callback(diff_type_changed_cb);
515        awr->awar_string(AWAR_DIFF_NAME, "<none selected>");
516        awr->awar_string(AWAR_NODIFF_INDICATOR, " ")->add_callback(nodiff_indicator_changed_cb)->set_srt(" ?=?:? =?:?*=?");
517        awr->awar_int(AWAR_DIFF_MINDCASE, 1)->add_callback(diff_setting_changed_cb);
518        awr->awar_int(AWAR_DIFF_MINDGAPTYPE, 1)->add_callback(diff_setting_changed_cb);
519        awr->awar_string(AWAR_DIFF_GAPTYPES, GAP::anyGapChars())->add_callback(diff_setting_changed_cb);
520
521        viewDifferences_awars_initialized = true;
522    }
523}
524
525void ED4_toggle_viewDifferences(AW_root *awr) {
526    static ViewDiffType lastActiveType = VD_SELECTED;
527
528    create_viewDifferences_awars(awr);
529    update_reference_settings(awr);
530
531    AW_awar      *awar_difftype = awr->awar(AWAR_DIFF_TYPE);
532    ViewDiffType  currType      = ViewDiffType(awar_difftype->read_int());
533
534    if (currType == VD_DISABLED || !ED4_ROOT->reference->is_set()) {
535        currType = lastActiveType;
536    }
537    else {
538        lastActiveType = currType;
539        currType       = VD_DISABLED;
540    }
541
542    awar_difftype->rewrite_int(currType); // rewrite to allow activation after automatic deactivation in ED4_reference (e.g. by killing ref-term)
543}
544void ED4_viewDifferences_setNewReference() {
545    set_current_as_diffRef(true);
546}
547void ED4_viewDifferences_announceTerminalChange() {
548    if (ED4_ROOT->reference->is_set() &&
549        ED4_ROOT->aw_root->awar(AWAR_DIFF_TYPE)->read_int() == VD_FOLLOW)
550    {
551        ED4_viewDifferences_setNewReference();
552    }
553}
554void ED4_viewDifferences_disable() {
555    set_current_as_diffRef(false);
556}
557
558AW_window *ED4_create_viewDifferences_window(AW_root *awr) {
559    static AW_window_simple *aws = NULp;
560    if (!aws) {
561        if (!ED4_ROOT->reference->is_set()) ED4_toggle_viewDifferences(awr); // automatically activate if off
562
563        aws = new AW_window_simple;
564        aws->init(awr, "VIEW_DIFF", "View sequence differences");
565        aws->load_xfig("edit4/viewdiff.fig");
566
567        aws->at("close");
568        aws->callback(AW_POPDOWN);
569        aws->create_button("CLOSE", "CLOSE", "C");
570
571        aws->at("help");
572        aws->callback(makeHelpCallback("viewdiff.hlp"));
573        aws->create_button("HELP", "HELP");
574
575        aws->at("show");
576        aws->create_toggle_field(AWAR_DIFF_TYPE);
577        aws->insert_toggle("None (=disable)", "N", VD_DISABLED);
578        aws->insert_toggle("Selected:",       "S", VD_SELECTED);
579        aws->insert_toggle("Follow cursor",   "F", VD_FOLLOW);
580        aws->update_toggle_field();
581
582        aws->at("ref");
583        aws->button_length(20);
584        aws->create_button(NULp, AWAR_DIFF_NAME, NULp, "+");
585
586        aws->at("set");
587        aws->button_length(4);
588        aws->callback(change_reference_cb);
589        aws->create_button("SET", "SET");
590
591        aws->at("nodiff");
592        aws->create_input_field(AWAR_NODIFF_INDICATOR);
593
594        aws->at("case");
595        aws->create_toggle(AWAR_DIFF_MINDCASE);
596
597        aws->at("gap");
598        aws->create_toggle(AWAR_DIFF_MINDGAPTYPE);
599        aws->at("gapchars");
600        aws->create_input_field(AWAR_DIFF_GAPTYPES, 8);
601    }
602    return aws;
603}
Note: See TracBrowser for help on using the repository browser.