// ========================================================= //
//                                                           //
//   File      : saicalc.cxx                                 //
//   Purpose   : SAI calculator (gui)                        //
//                                                           //
//   Coded by Ralf Westram (coder@reallysoft.de) in Oct 19   //
//   http://www.arb-home.de/                                 //
//                                                           //
// ========================================================= //

#include "saicalc.h"
#include "saiop.h"

#include <sel_boxes.hxx>
#include <config_manager.hxx>

#include <aw_select.hxx>
#include <aw_awar_defs.hxx>
#include <aw_awar.hxx>
#include <aw_root.hxx>
#include <aw_msg.hxx>
#include <rootAsWin.h>
#include <downcast.h>
#include "calculator.h"

using namespace std;

#define AWAR_SC_BASE           "sai/calc/"
#define AWAR_SC_TEMP           "tmp/" AWAR_SC_BASE
#define AWAR_SC_TRANSLATE_BASE AWAR_SC_BASE "translate/"
#define AWAR_SC_TRANSLATE_TEMP AWAR_SC_TEMP "translate/"
#define AWAR_SC_MATRIX_BASE    AWAR_SC_BASE "matrix/"
#define AWAR_SC_MATRIX_TEMP    AWAR_SC_TEMP "matrix/"
#define AWAR_SC_BOOL_BASE      AWAR_SC_BASE "bool/"
#define AWAR_SC_BOOL_TEMP      AWAR_SC_TEMP "bool/"
#define AWAR_SC_ACI_BASE       AWAR_SC_BASE "aci/"
#define AWAR_SC_ACI_TEMP       AWAR_SC_TEMP "aci/"

#define AWAR_SC_TARGET_SAI      AWAR_SC_BASE "target"
#define AWAR_SC_SOURCE_SAI_LIST AWAR_SC_BASE "sources" // format = "name1;name2;..."
#define AWAR_SC_METHOD          AWAR_SC_BASE "method"  // = SaiOperatorType
#define AWAR_SC_SCOPE           AWAR_SC_BASE "scope"   // = SaiAliScope
#define AWAR_SC_METHOD_CONFIG   AWAR_SC_TEMP "config"  // mapped to config of currently selected SaiOperatorType

#define AWAR_SC_TRANSLATE_CONFIG   AWAR_SC_TRANSLATE_BASE "config"
#define AWAR_SC_TRANSLATE_DEFAULT  AWAR_SC_TRANSLATE_TEMP "default"
#define AWAR_SC_TRANSLATE_IO_TEMPL AWAR_SC_TRANSLATE_TEMP "%c%i"

#define AWAR_SC_MATRIX_CONFIG     AWAR_SC_MATRIX_BASE "config"
#define AWAR_SC_MATRIX_CELL_TEMPL AWAR_SC_MATRIX_TEMP "m%i_%i"

#define AWAR_SC_BOOL_CONFIG   AWAR_SC_BOOL_BASE "config"
#define AWAR_SC_BOOL_IN1      AWAR_SC_BOOL_TEMP "in1"
#define AWAR_SC_BOOL_IN0      AWAR_SC_BOOL_TEMP "in0"
#define AWAR_SC_BOOL_OP       AWAR_SC_BOOL_TEMP "op"
#define AWAR_SC_BOOL_OUT1     AWAR_SC_BOOL_TEMP "out1"
#define AWAR_SC_BOOL_OUT0     AWAR_SC_BOOL_TEMP "out0"
#define AWAR_SC_BOOL_SEL_RULE AWAR_SC_BOOL_TEMP "selrule"
#define AWAR_SC_BOOL_RULES    AWAR_SC_BOOL_TEMP "rules"

#define AWAR_SC_ACI_CONFIG AWAR_SC_ACI_BASE "config"
#define AWAR_SC_ACI        AWAR_SC_ACI_TEMP "aci"

#define TRANSLATION_RULES 10

#define MATRIX_RULES (7+1)      // includes default translation rule
#define MATRIX_AWARS (MATRIX_RULES+1)

static AWT_config_mapping_def saicalc_config_mapping[] = {
    { AWAR_SC_TARGET_SAI,      "target" },
    { AWAR_SC_SOURCE_SAI_LIST, "sources" },
    { AWAR_SC_METHOD,          "method" },
    { AWAR_SC_SCOPE,           "scope" },
    { AWAR_SC_METHOD_CONFIG,   "~config" }, // during restore this has to change after AWAR_SC_METHOD (otherwise we run into spurious errors). Ensured here by alphabetical order!

    { NULp, NULp }
};

static AWT_predefined_config saicalc_predefined_configs[] = {
    { "*diff2",         "Compares 2 SAI.\nResult: '-' where equal\n        'x' where different",                                                         "method='0';target='diff';~config='aci=\\'colsplit|compare|plus(1)|translate(\"012\",\"x-x\")\\''" },
    { "*diff2_ignCase", "Compares 2 SAI (ignoring case).\nResult: '-' where equal \n        'x' where different",                                        "method='0';target='idiff';~config='aci=\\'upper|colsplit|compare|plus(1)|translate(\"012\",\"x-x\")\\''" },
    { "*count_x",       "Count 'x' in multiple SAI (up to 9).",                                                                                          "method='0';target='x-count';~config='aci=\\'keep(\"x\")|len|translate(\"0\",\"-\")\\''" },
    { "*sum_up_2",      "Sum up 2 SAI containing digits and gaps\n(raises error if result overflows 9).",                                                "method='0';target='sum';~config='aci=\\'translate(\"-=\",\"00\")|colsplit|plus\\''" },
    { "*cutByTermini",  "Sai1: termini (containing 'x' in region)\nSai2: any\n=> same as Sai2 at all 'x' in Sai1\n   else same as Sai1 (normally gap).", "method='0';sources='termini';~config='aci=\\'command(\"/^x//\")|head(1)\\''" },
    { "*invert_binary", "inverts binary SAI\n(works with binary source and/or target)",                                                                  "method='0';~config='aci=\\'translate(\"01\",\"10\")\\''" },

    { NULp, NULp, NULp }
};

static void sai_seletion_changed_cb(AW_selection *sel_sai, bool /*interactive*/, AW_CL) { // @@@ impl 'interactive'
    StrArray sainame;
    sel_sai->get_values(sainame);

    char *sainameList = GBT_join_strings(sainame, ';');
    AW_root::SINGLETON->awar(AWAR_SC_SOURCE_SAI_LIST)->write_string(sainameList);
    free(sainameList);
}
static void fill_with_source_sais(ConstStrArray& sainame, AW_root *awr) {
    char *sainameList = awr->awar(AWAR_SC_SOURCE_SAI_LIST)->read_string();
    GBT_splitNdestroy_string(sainame, sainameList, ";", SPLIT_DROPEMPTY);
}
static void source_sai_list_changed_cb(AW_root *awr, AW_selection *sel_sai) {
    ConstStrArray sainame;
    fill_with_source_sais(sainame, awr);
    awt_set_subset_selection_content(sel_sai, sainame);
}

static const char *awar_translate(bool in, int num) {
    static SmartCharPtr result; // result is kept until next call of awar_translate()
    result = GBS_global_string_copy(AWAR_SC_TRANSLATE_IO_TEMPL, in ? 'i' : 'o', num);
    return &*result;
}

static AW_window *create_translator_config_window(AW_root *awr) {
    AW_window_simple *aws = new AW_window_simple;

    aws->init(awr, "SAI_TRANSLATOR", "SAI translator configuration");
    aws->load_xfig("saitrans.fig");

    aws->auto_space(5, 5);
    aws->button_length(8);

    aws->at("close");
    aws->callback(AW_POPDOWN);
    aws->create_button("CLOSE", "CLOSE", "O");

    aws->callback(makeHelpCallback("saicalc.hlp"));
    aws->create_button("HELP", "HELP");

    aws->at("target"); int x2 = aws->get_at_xposition();
    aws->at("source"); int x1 = aws->get_at_xposition();

    for (int i = 0; i<TRANSLATION_RULES; ++i) {
        aws->at_x(x1);
        aws->create_input_field(awar_translate(true, i), 15);

        aws->at_x(x2);
        aws->create_input_field(awar_translate(false, i), 3);

        aws->at_newline();
    }

    aws->at_x(x1);
    aws->label("Default:");
    aws->create_input_field(AWAR_SC_TRANSLATE_DEFAULT, 3);

    aws->window_fit();

    return aws;
}



static const char *awar_matrix_cell(int x, int y) {
    sai_assert(x>=0 && x<MATRIX_AWARS);
    sai_assert(y>=0 && y<MATRIX_AWARS);

    // meaning of indices:
    // 0                     = heading
    // 1                     = default translation
    // 2 .. (MATRIX_AWARS-1) = translations

    // for unused combinations, this function returns NULp:
    if ((x == 0 && (y == 0 || y == 1))
        ||
        (x == 1 && y == 0))
    {
        return NULp;
    }

    static SmartCharPtr awarName;
    awarName = GBS_global_string_copy(AWAR_SC_MATRIX_CELL_TEMPL, x, y);
    return &*awarName;
}

static void normalize_matrix_cb(AW_window *aww) {
    // reloading awar from config does always normalize
    aww->get_root()->awar(AWAR_SC_MATRIX_CONFIG)->touch();
}

static AW_window *create_matrix_config_window(AW_root *awr) {
    AW_window_simple *aws = new AW_window_simple;

    aws->init(awr, "SAI_MATRIX_TRANSLATOR", "SAI matrix translator configuration");
    aws->load_xfig("saimatrix.fig");

    aws->auto_space(5, 5);
    aws->button_length(8);

    aws->at("close");
    aws->callback(AW_POPDOWN);
    aws->create_button("CLOSE", "CLOSE", "O");

    aws->callback(makeHelpCallback("saicalc.hlp"));
    aws->create_button("HELP", "HELP");

    int xpos[MATRIX_AWARS];
    int ypos[MATRIX_AWARS];
    int xcheck, ycheck;

    aws->at("col1"); aws->get_at_position(&xpos[1], &ypos[0]);
    aws->at("col2"); aws->get_at_position(&xpos[2], &ycheck);

    aws->at("row1"); aws->get_at_position(&xpos[0], &ypos[1]);
    aws->at("row2"); aws->get_at_position(&xcheck, &ypos[2]);

    // distribute coordinates:
    {
        int xdiff = xpos[2]-xpos[1];
        int ydiff = ypos[2]-ypos[1];

        bool figConsistent = (xpos[0] == xcheck) && (ypos[0] == ycheck) && xdiff>0 && ydiff>0;
        if (figConsistent) {
            for (int p = 3; p<MATRIX_AWARS; ++p) {
                xpos[p] = xpos[p-1] + xdiff;
                ypos[p] = ypos[p-1] + ydiff;
            }
        }
        else {
            sai_assert(figConsistent);
            aw_message("internal error: invalid position values");
        }
    }

    // create fields upon awars:
    for (int x = 0; x<MATRIX_AWARS; ++x) {
        for (int y = 0; y<MATRIX_AWARS; ++y) {
            const char *awar_name = awar_matrix_cell(x, y);
            aws->at(xpos[x], ypos[y]);
            if (awar_name) {
                aws->create_input_field(awar_name, 5);
            }
        }
    }

    aws->at_newline();
    aws->at_x(xpos[0]);
    aws->callback(normalize_matrix_cb);
    aws->create_autosize_button("NORMALIZE", "Normalize");

    return aws;
}

static AW_window *create_aciapp_config_window(AW_root *awr) {
    AW_window_simple *aws = new AW_window_simple;

    aws->init(awr, "SAI_ACI_CONFIG", "SAI ACI configuration");
    aws->load_xfig("saiaci.fig");

    aws->auto_space(5, 5);
    aws->button_length(8);

    aws->at("close");
    aws->callback(AW_POPDOWN);
    aws->create_button("CLOSE", "CLOSE", "O");

    aws->callback(makeHelpCallback("saicalc.hlp"));
    aws->create_button("HELP", "HELP");

    aws->at("aci");
    aws->create_input_field(AWAR_SC_ACI);

    return aws;
}

// --------------------------
//      boolchain config

static const char* const  RULELIST_DELIMITER = "\1";
static AW_selection_list *boolrule_sellst    = NULp;

static void refill_boolrules_sellist(const ConstStrArray& ruleArray) {
    // fill selection list from array content:
    if (boolrule_sellst) {
        boolrule_sellst->clear();
        for (int r = 0; ruleArray[r]; ++r) {
            boolrule_sellst->insert(ruleArray[r], ruleArray[r]);
        }
        if (ruleArray.empty()) {
            boolrule_sellst->insert_default("<no rules defined>", "");
        }
        else {
            boolrule_sellst->insert_default("", "");
        }
        boolrule_sellst->update();
    }
}

static void update_rulesAwar(AW_root *awr, const CharPtrArray& ruleArray) {
    // Updates AWAR_SC_BOOL_RULES from rules stored in ruleArray.
    //
    // Note: if any of the rules in 'ruleArray' does contain RULELIST_DELIMITER,
    // the whole update mechanism would not work.
    // -> workaround: test for and remove delimiter char. warn user.

    bool seenDelimiter = false;
    for (int i = 0; ruleArray[i] && !seenDelimiter; ++i) {
        seenDelimiter = strchr(ruleArray[i], RULELIST_DELIMITER[0]);
    }

    if (seenDelimiter) {
        // replace all delimiters (into copy of array):
        StrArray copy;
        char srt[] = ":?=";
        srt[1]     = RULELIST_DELIMITER[0];

        for (int i = 0; ruleArray[i]; ++i) {
            copy.put(GBS_string_eval(ruleArray[i], srt));
            if (strlen(copy[i]) != strlen(ruleArray[i])) {
                aw_message(GBS_global_string("Warning: detected delimiter (ASCII %i) in '%s' and removed it.",
                                             int(RULELIST_DELIMITER[0]), ruleArray[i]));
            }
        }

        update_rulesAwar(awr, copy);
    }
    else {
        char *rulelist = GBT_join_strings(ruleArray, RULELIST_DELIMITER[0]);
        awr->awar(AWAR_SC_BOOL_RULES)->write_string(rulelist);
        free(rulelist);
    }
}

static void fill_boolrules_array_from_AWAR(AW_root *awr, ConstStrArray& ruleArray) {
    char *rulelist = awr->awar(AWAR_SC_BOOL_RULES)->read_string();
    GBT_splitNdestroy_string(ruleArray, rulelist, RULELIST_DELIMITER, SPLIT_DROPEMPTY);
}
static void refill_boolrules_sellist_from_AWAR(AW_root *awr) {
    if (boolrule_sellst) {
        ConstStrArray ruleArray;
        fill_boolrules_array_from_AWAR(awr, ruleArray);
        refill_boolrules_sellist(ruleArray);
    }
}

static SaiBoolRulePtr build_rule_from_AWARs(AW_root *awr, bool createFirstRule) {
    // build SaiBoolRule from rule defining awars:

    SaiBoolOp op;
    if (createFirstRule) {
        op = SBO_FIRST;
    }
    else {
        op = SaiBoolOp(awr->awar(AWAR_SC_BOOL_OP)->read_int());
        sai_assert(op != SBO_FIRST);
    }

    const char *trueChars  = awr->awar(AWAR_SC_BOOL_IN1)->read_char_pntr();
    const char *falseChars = awr->awar(AWAR_SC_BOOL_IN0)->read_char_pntr();

    bool specifiedChars = trueChars[0]; // if trueChars specified -> define via trueChars
    // otherwise: define via no chars (or accept all chars as true = empty no chars)

    return new SaiBoolRule(op, specifiedChars, specifiedChars ? trueChars : falseChars);
}

static void add_boolrule_cb(AW_window *aww) {
    AW_root *awr = aww->get_root();

    ConstStrArray ruleArray; // split existing rules into array
    fill_boolrules_array_from_AWAR(awr, ruleArray);

    const bool     first = ruleArray.empty();
    SaiBoolRulePtr rule  = build_rule_from_AWARs(awr, first);

    ruleArray.put(rule->to_string().c_str()); // insert new rule into array
    update_rulesAwar(awr, ruleArray);         // write back array to awar (will refresh selection list via callback)
}
static void mod_boolrule_cb(AW_window *aww) {
    int selIdx = boolrule_sellst->get_index_of_selected();
    if (selIdx>=0) {
        ConstStrArray  ruleArray; // split existing rules into array
        AW_root       *awr = aww->get_root();

        fill_boolrules_array_from_AWAR(awr, ruleArray);

        const bool     first = selIdx == 0;
        SaiBoolRulePtr rule  = build_rule_from_AWARs(awr, first);

        ruleArray.replace(selIdx, rule->to_string().c_str()); // update rule in array
        update_rulesAwar(awr, ruleArray);                     // write back array to awar (will refresh selection list via callback)
        boolrule_sellst->select_element_at(selIdx);
    }
    else {
        aw_message("No operation selected to modify.");
    }
}
static void del_boolrule_cb(AW_window *aww) {
    int selIdx = boolrule_sellst->get_index_of_selected();
    if (selIdx>=0) {
        string         replaced;
        ConstStrArray  ruleArray;
        AW_root       *awr = aww->get_root();

        fill_boolrules_array_from_AWAR(awr, ruleArray);
        ruleArray.safe_remove(selIdx);
        if (selIdx == 0 && !ruleArray.empty()) {
            // correct 1st rule (has to be SBO_FIRST)
            ErrorOrSaiBoolRulePtr product = SaiBoolRule::make(ruleArray[0]);
            if (product.hasError()) { // should be impossible .. just in case.
                aw_message(product.getError().deliver());
                return;
            }

            const SaiBoolRule& rule = *product.getValue();
            SaiBoolRule        new1st(SBO_FIRST, rule.specifiesTrueChars(), rule.get_chars());

            replaced = new1st.to_string();
            ruleArray.replace(0, replaced.c_str());
        }
        update_rulesAwar(awr, ruleArray);

        boolrule_sellst->select_element_at(selIdx);
    }
    else {
        aw_message("No operation selected to delete.");
    }
}

static AW_window *create_boolchain_config_window(AW_root *awr) {
    AW_window_simple *aws = new AW_window_simple;

    aws->init(awr, "SAI_BOOLCHAIN_CONFIG", "SAI boolchain configuration");
    aws->load_xfig("saichain.fig");

    aws->auto_space(5, 5);
    aws->button_length(8);

    aws->at("close");
    aws->callback(AW_POPDOWN);
    aws->create_button("CLOSE", "CLOSE", "O");

    aws->callback(makeHelpCallback("saicalc.hlp"));
    aws->create_button("HELP", "HELP");

    aws->at("trueIn");  aws->create_input_field(AWAR_SC_BOOL_IN1, 5);
    aws->at("falseIn"); aws->create_input_field(AWAR_SC_BOOL_IN0, 5);

    aws->at("op");
    aws->create_option_menu(AWAR_SC_BOOL_OP);
    aws->insert_default_option("AND",  "A", SBO_AND);
    aws->insert_option        ("OR",   "O", SBO_OR);
    aws->insert_option        ("XOR",  "X", SBO_XOR);
    aws->insert_option        ("NAND", "D", SBO_NAND);
    aws->insert_option        ("NOR",  "N", SBO_NOR);
    aws->insert_option        ("XNOR", "R", SBO_XNOR);
    aws->update_option_menu();

    aws->at("trueOut");  aws->create_input_field(AWAR_SC_BOOL_OUT1, 1);
    aws->at("falseOut"); aws->create_input_field(AWAR_SC_BOOL_OUT0, 1);

    aws->at("rules");
    boolrule_sellst = aws->create_selection_list(AWAR_SC_BOOL_SEL_RULE);
    refill_boolrules_sellist_from_AWAR(awr);

    aws->at("add");
    aws->callback(add_boolrule_cb); aws->create_button("ADD",    "ADD");
    aws->callback(mod_boolrule_cb); aws->create_button("UPDATE", "UPDATE");
    aws->callback(del_boolrule_cb); aws->create_button("DELETE", "DELETE");

    return aws;
}

static void saicalc_edit_method_cb(AW_root *awr, bool forcePopup) {
    // forcePopup==false -> only popup if another config window was visible

    static AW_window *aww[SAI_OPERATOR_TYPES] = { NULp, NULp, NULp, NULp };
    static AW_window *aw_visible = NULp;

    SaiOperatorType type = SaiOperatorType(awr->awar(AWAR_SC_METHOD)->read_int());

    sai_assert(int(type) >= 0 && int(type)<SAI_OPERATOR_TYPES);

    // always show one window only (popdown previous before popping up a new one):
    if (aw_visible && aw_visible != aww[type]) {
        if (aw_visible->is_shown()) forcePopup = true;
        aw_visible->hide();
        aw_visible = NULp;
    }

    if (!forcePopup) return;

    if (!aww[type]) {
        AW_window *awe = NULp;

        switch (type) {
            case SOP_TRANSLATE:
                awe = create_translator_config_window(awr);
                break;
            case SOP_ACI:
                awe = create_aciapp_config_window(awr);
                break;
            case SOP_MATRIX:
                awe = create_matrix_config_window(awr);
                break;
            case SOP_BOOLCHAIN:
                awe = create_boolchain_config_window(awr);
                break;
        }

        if (awe) {
            aww[type] = awe;
        }
        else {
            aw_message("cannot edit this type of calculation method (yet)");
        }
    }

    aw_visible = aww[type];
    if (aw_visible) {
        aw_visible->activate();
    }
}

static SaiOperatorPtr createOpFromConfigAwar(SaiOperatorType type, AW_awar *awar_config) {
    // creates an SaiOperator from the config awar

    SaiOperatorPtr         saiOp;
    const char            *config  = awar_config->read_char_pntr();
    ErrorOrSaiOperatorPtr  product = SaiOperator::make(type, config);

    if (product.hasError()) {
        aw_message(GBS_global_string("Failed to load config: %s", product.getError().deliver()));
    }
    else {
        saiOp = product.getValue();
    }
    return saiOp;
}

// --------------------------------------------------------------------------------

static bool in_translate_awar_callback = false;

static void translate_config_changed_cb(AW_root *awr) { // [CFG->AWARS]
    if (!in_translate_awar_callback) {
        LocallyModify<bool> avoid_recursion(in_translate_awar_callback, true);

        // parse config
        SaiOperatorPtr saiOp = createOpFromConfigAwar(SOP_TRANSLATE, awr->awar(AWAR_SC_TRANSLATE_CONFIG));
        if (saiOp.isSet()) {
            // reverse generate rules and default char:
            const SaiTranslator *translator = DOWNCAST(SaiTranslator*, &*saiOp);
            ConfigMapping        cmap;
            translator->deduceTranslations(cmap);

            // 1st clear all awars:
            for (int i = 0; i<TRANSLATION_RULES; ++i) {
                awr->awar(awar_translate(true, i))->write_string("");
                awr->awar(awar_translate(false, i))->write_string("");
            }

            // set specific awars:
            ConstStrArray keys;
            cmap.get_entries(keys);

            for (int k = 0; keys[k]; ++k) {
                const char *value    = cmap.get_entry(keys[k]);
                bool        accepted = false;
                if (strncmp(keys[k], "trans", 5) == 0) {
                    const int num = atoi(keys[k]+5);
                    if (num>0) {
                        char firstChar[2] = "x";
                        firstChar[0]      = value[0];

                        awr->awar(awar_translate(false, num-1))->write_string(firstChar);
                        awr->awar(awar_translate(true, num-1))->write_string(value+1);
                        accepted = true;
                    }
                }
                else if (strcmp(keys[k], "default") == 0) {
                    awr->awar(AWAR_SC_TRANSLATE_DEFAULT)->write_string(value);
                    accepted = true;
                }
                if (!accepted) {
                    aw_message(GBS_global_string("Failed to deduce translations (invalid key '%s')", keys[k]));
                }
            }
        }
    }
}

static void translate_gui_changed_cb(AW_root *awr, bool /*insetChanged*/, int /*num*/) { // [AWARS->OP->CFG]
    // @@@ implement parameters: use to decide how to resolve conflicts,
    // @@@ e.g. when a CHAR is added to 'from'-set => CHAR has to be removed from all other 'from'-sets

    if (!in_translate_awar_callback) {
        LocallyModify<bool> avoid_recursion(in_translate_awar_callback, true);

        // create SaiTranslator from awars:
        const char    *translate_default = awr->awar(AWAR_SC_TRANSLATE_DEFAULT)->read_char_pntr();
        SaiTranslator  translator(translate_default[0] ? translate_default[0] : '-');
        for (int i = 0; i<TRANSLATION_RULES; ++i) {
            const char *translate_from = awr->awar(awar_translate(true, i))->read_char_pntr();
            const char *translate_to   = awr->awar(awar_translate(false, i))->read_char_pntr();

            if (translate_from[0] && translate_to[0]) {
                translator.addTranslation(translate_from, translate_to[0]);
            }
        }

        // ask SaiOperator to create config and store in config awar:
        string cfg = translator.get_config();
        awr->awar(AWAR_SC_TRANSLATE_CONFIG)->write_string(cfg.c_str());
    }
}

// --------------------------------------------------------------------------------

static bool in_matrix_awar_callback = false;

static const char *content_matrix_cell(int x, int y) {
    const char *awarname = awar_matrix_cell(x, y);
    if (awarname) return AW_root::SINGLETON->awar(awarname)->read_char_pntr();
    return NULp;
}

static SaiOperatorPtr buildColumnTranslatorFromAwars(int x, bool returnDefault) {
    sai_assert(x>0);

    const char *globalDefTrans  = content_matrix_cell(1, 1);
    const bool  globalIsDefined = globalDefTrans && globalDefTrans[0];

    const char *defTrans  = content_matrix_cell(x, 1);
    bool        isDefined = defTrans && defTrans[0];

    char           defResChar = isDefined ? defTrans[0] : (globalIsDefined ? globalDefTrans[0] : '-');
    SaiTranslator *colTrans   = new SaiTranslator(defResChar);

    for (int y = 2; y<MATRIX_AWARS; ++y) {
        const char *from      = content_matrix_cell(0, y);
        const char *cellTrans = content_matrix_cell(x, y);

        if (cellTrans && cellTrans[0]) {
            if (from && from[0]) {
                colTrans->addTranslation(from, cellTrans[0]);
                isDefined = true;
            }
        }
    }

    SaiOperatorPtr colTransPtr(colTrans);
    if (!isDefined && !returnDefault) { // undefined empty column
        colTransPtr.setNull(); // return NULp instead
    }

    sai_assert(implicated(returnDefault, colTransPtr.isSet()));
    return colTransPtr;
}

typedef vector<string> StringVector;

struct CompareByLength { bool operator()(const string& s1, const string& s2) const { return s1.length()>s2.length(); } };
struct CompareAlpha    { bool operator()(const string& s1, const string& s2) const { return s1<s2; } };

static void detectEqualRowsAndColumns(const string& out, StringVector& row, StringVector& col) {
    bool check_row[255], check_col[255];
    for (int i = 0; i<255; ++i) {
        check_row[i] = check_col[i] = true;
    }

    // search equal columns:
    for (int x1 = 0; x1<255; ++x1) {
        if (check_col[x1]) {
            string c(1, char(x1+1));
            for (int x2 = x1+1; x2<255; ++x2) {
                if (check_col[x2]) {
                    bool equal = true;
                    for (int y = 0; y<255 && equal; ++y) {
                        equal = out[y*255+x1] == out[y*255+x2];
                    }
                    if (equal) {
                        c             += char(x2+1);
                        check_col[x2]  = false;
                    }
                }
            }
            check_col[x1] = false;
            col.push_back(c);
        }
    }

    // search equal rows:
    for (int y1 = 0; y1<255; ++y1) {
        if (check_row[y1]) {
            string r(1, char(y1+1));
            for (int y2 = y1+1; y2<255; ++y2) {
                if (check_row[y2]) {
                    bool equal = true;
                    for (int x = 0; x<255 && equal; ++x) {
                        equal = out[y1*255+x] == out[y2*255+x];
                    }
                    if (equal) {
                        r             += char(y2+1);
                        check_row[y2]  = false;
                    }
                }
            }
            check_row[y1] = false;
            row.push_back(r);
        }
    }

    // sort vectors (longest on 1st position, rest alphabetically):
    sort(row.begin(), row.end(), CompareByLength());
    sort(col.begin(), col.end(), CompareByLength());

    StringVector::iterator r2nd = row.begin(); ++r2nd;
    StringVector::iterator c2nd = col.begin(); ++c2nd;

    sort(r2nd, row.end(), CompareAlpha());
    sort(c2nd, col.end(), CompareAlpha());
}

static void matrix_config_changed_cb(AW_root *awr) { // [CFG->AWARS]
    if (!in_matrix_awar_callback) {
        LocallyModify<bool> avoid_recursion(in_matrix_awar_callback, true);

        // parse config
        SaiOperatorPtr saiOp = createOpFromConfigAwar(SOP_MATRIX, awr->awar(AWAR_SC_MATRIX_CONFIG));
        if (saiOp.isSet()) {
            const SaiMatrixTranslator *matrix = DOWNCAST(SaiMatrixTranslator*, &*saiOp);

            // 1st clear all awars:
            for (int x = 0; x<MATRIX_AWARS; ++x) {
                for (int y = 0; y<MATRIX_AWARS; ++y) {
                    const char *awarname = awar_matrix_cell(x, y);
                    if (awarname) awr->awar(awarname)->write_string("");
                }
            }

            // calculate full matrix by combining all chars:
            const int MSIZE = 255*255;

            ConstStrArray in;
            {
                char *buffer = ARB_alloc<char>(2*(MSIZE+1)); // size for 2 input strings
                in.set_memblock(buffer);

                char *in1 = buffer;
                char *in2 = buffer+(MSIZE+1);

                for (int y = 0; y<255; ++y) {
                    for (int x = 0; x<255; ++x) {
                        int offset  = y*255+x;
                        in1[offset] = x+1;
                        in2[offset] = y+1;
                    }
                }

                in1[MSIZE] = 0;
                in2[MSIZE] = 0;

                in.put(in1);
                in.put(in2);
            }

            SaiCalcEnv env(in, NULp);

            ErrorOrString result = matrix->apply(env);
            if (result.hasError()) {
                aw_message(result.getError().deliver());
            }
            else {
                string       out = result.getValue();
                StringVector row, col; // each entry represents equal rows/columns.
                                       // the chars in each entry refer to the single rows/columns.

                detectEqualRowsAndColumns(out, row, col);

                sai_assert(row.size()<MATRIX_AWARS);
                sai_assert(col.size()<MATRIX_AWARS);

                // fill awars:
                for (size_t r = 1; r<row.size(); ++r) { // row headings
                    const char *awarname = awar_matrix_cell(0, r+1);
                    sai_assert(awarname);
                    awr->awar(awarname)->write_string(row[r].c_str());
                }
                for (size_t c = 1; c<col.size(); ++c) { // column headings
                    const char *awarname = awar_matrix_cell(c+1, 0);
                    sai_assert(awarname);
                    awr->awar(awarname)->write_string(col[c].c_str());
                }

                char globalDefault = 0;

                for (size_t c = 0; c<col.size(); ++c) {
                    int x = col[c][0]-1;

                    char defaultOfColumn = 0;

                    for (size_t r = 0; r<row.size(); ++r) {
                        int y = row[r][0]-1;

                        if (x>=0 && y>=0) {
                            char to[] = "x";
                            to[0]     = out[y*255+x];

                            if (to[0] != globalDefault && to[0] != defaultOfColumn) {
                                const char *awarname = awar_matrix_cell(c+1, r+1);
                                sai_assert(awarname);
                                awr->awar(awarname)->write_string(to);
                            }

                            if (r == 0) {
                                defaultOfColumn = to[0];
                                if (c == 0) globalDefault = to[0];
                            }
                        }
                    }
                }
            }
        }
    }
}

static void matrix_gui_changed_cb(AW_root *awr, int /*x*/, int /*y*/) { // [AWARS->OP->CFG]
    // @@@ implement parameters: use to decide how to resolve conflicts,
    // @@@ e.g. when a CHAR is added to 'from'-set = > CHAR has to be removed from all other 'from'-sets

    if (!in_matrix_awar_callback) {
        LocallyModify<bool> avoid_recursion(in_matrix_awar_callback, true);

        // create SaiMatrixTranslator from awars:
        SaiOperatorPtr columnTranslator = buildColumnTranslatorFromAwars(1, true);
        sai_assert(columnTranslator.isSet());

        SaiMatrixTranslator matrixTranslator(columnTranslator);

        for (int col = 2; col<MATRIX_AWARS; ++col) {
            const char *from = content_matrix_cell(col, 0);
            if (from && from[0]) {
                columnTranslator = buildColumnTranslatorFromAwars(col, false);
                if (columnTranslator.isSet()) {
                    matrixTranslator.addOperator(from, columnTranslator);
                }
            }
        }

        // ask SaiOperator to create config and store in config awar:
        string cfg = matrixTranslator.get_config();
        sai_assert(!cfg.empty());
        awr->awar(AWAR_SC_MATRIX_CONFIG)->write_string(cfg.c_str());
    }
}

// --------------------------------------------------------------------------------

static char firstCharOfAwarOrDefault(AW_root *awr, const char *awarname) {
    /*! read value of awar 'awarname'
     * return either
     * - first char of its value or (if empty)
     * - first char of its default value
     */

    AW_awar    *awar   = awr->awar(awarname);
    const char *value  = awar->read_char_pntr();
    char        result = value[0];

    if (!result) {
        char     *copyOfValue = awar->read_string();
        GB_ERROR  error       = awar->reset_to_default();
        if (!error) {
            value  = awar->read_char_pntr();
            result = value[0];
            sai_assert(result); // you have to define a non-empty default value for this awar!
        }
        if (error) {
            result = '?';
        }
        awar->write_string(copyOfValue);
        free(copyOfValue);
    }

    return result;
}

static bool in_boolchain_awar_callback = false;

static void bool_config_changed_cb(AW_root *awr) { // [CFG->AWARS]
    if (!in_boolchain_awar_callback) {
        LocallyModify<bool> avoid_recursion(in_boolchain_awar_callback, true);

        // parse config
        SaiOperatorPtr saiOp = createOpFromConfigAwar(SOP_BOOLCHAIN, awr->awar(AWAR_SC_BOOL_CONFIG));
        if (saiOp.isSet()) {
            const SaiBoolchainOperator *boolchain = DOWNCAST(SaiBoolchainOperator*, &*saiOp);

            // retrieve rules from 'boolchain':
            {
                size_t         ruleCount = boolchain->count_rules();
                vector<string> ruleString;
                ruleString.reserve(ruleCount);
                ConstStrArray  ruleArray;

                for (size_t r = 0; r<ruleCount; ++r) {
                    ruleString.push_back(boolchain->getRule(r).to_string());
                    ruleArray.put(ruleString.back().c_str());
                }

                update_rulesAwar(awr, ruleArray);
            }
            // retrieve output translation from 'boolchain':
            {
                char out[2] = "x";
                out[0]      = boolchain->getOutTrans(false); awr->awar(AWAR_SC_BOOL_OUT0)->write_string(out);
                out[0]      = boolchain->getOutTrans(true);  awr->awar(AWAR_SC_BOOL_OUT1)->write_string(out);
            }
        }
    }
}

static void boolchain_gui_changed_cb(AW_root *awr) { // [AWARS->OP->CFG]
    if (!in_boolchain_awar_callback) {
        LocallyModify<bool> avoid_recursion(in_boolchain_awar_callback, true);

        // create SaiBoolchainOperator from awars:
        ConstStrArray ruleArray;
        fill_boolrules_array_from_AWAR(awr, ruleArray);

        char c0 = firstCharOfAwarOrDefault(awr, AWAR_SC_BOOL_OUT0);
        char c1 = firstCharOfAwarOrDefault(awr, AWAR_SC_BOOL_OUT1);

        SaiBoolchainOperator boolchainOp(c0, c1);

        ARB_ERROR error;
        for (size_t r = 0; r<ruleArray.size() && !error; ++r) { // add rules from array to operator
            ErrorOrSaiBoolRulePtr rule = SaiBoolRule::make(ruleArray[r]);
            if (rule.hasError()) {
                error = rule.getError();
            }
            else {
                boolchainOp.addRule(*rule.getValue());
            }
        }
        if (!error) {
            // ask operator to create config and store in config awar:
            string cfg = boolchainOp.get_config();
            awr->awar(AWAR_SC_BOOL_CONFIG)->write_string(cfg.c_str());
        }

        aw_message_if(error);
    }
}
static void boolchain_rulesAwar_changed_cb(AW_root *awr) {
    boolchain_gui_changed_cb(awr);
    refill_boolrules_sellist_from_AWAR(awr);
}

static bool in_boolchain_inputCharset_awar_callback = false;

static void display_selected_rule_cb(AW_root *awr) {
    // fill gui awars from selected rule

    const char *selRule = awr->awar(AWAR_SC_BOOL_SEL_RULE)->read_char_pntr();
    if (selRule && selRule[0]) { // only update awars if rule is nonempty
        ErrorOrSaiBoolRulePtr product = SaiBoolRule::make(selRule);
        if (product.hasError()) {
            aw_message(product.getError().deliver());
        }
        else {
            const SaiBoolRule& rule = *product.getValue();

            SaiBoolOp op = rule.get_op();
            if (op != SBO_FIRST) { // when 1st rule is selected -> do not change operator type
                awr->awar(AWAR_SC_BOOL_OP)->write_int(op);
            }

            const char *trueChars  = "";
            const char *falseChars = "";

            (rule.specifiesTrueChars() ? trueChars : falseChars) = rule.get_chars();

            LocallyModify<bool> avoid_auto_correction(in_boolchain_inputCharset_awar_callback, true);
            awr->awar(AWAR_SC_BOOL_IN0)->write_string(falseChars);
            awr->awar(AWAR_SC_BOOL_IN1)->write_string(trueChars);
        }
    }
}

static void inputCharsetChanged_cb(AW_root *awr, bool defTrue) {
    if (!in_boolchain_inputCharset_awar_callback) {
        LocallyModify<bool> avoid_recursion(in_boolchain_inputCharset_awar_callback, true);

        const char *awarname_written = defTrue ? AWAR_SC_BOOL_IN1 : AWAR_SC_BOOL_IN0;
        const char *awarname_toReset = defTrue ? AWAR_SC_BOOL_IN0 : AWAR_SC_BOOL_IN1;

        if (awr->awar(awarname_written)->read_char_pntr()[0]) { // written awar is not empty
            awr->awar(awarname_toReset)->write_string("");
        }
    }
}

// --------------------------------------------------------------------------------

static bool in_aci_awar_callback = false;

static void aci_config_changed_cb(AW_root *awr) { // [CFG->AWARS]
    if (!in_aci_awar_callback) {
        LocallyModify<bool> avoid_recursion(in_aci_awar_callback, true);

        SaiOperatorPtr saiOp = createOpFromConfigAwar(SOP_ACI, awr->awar(AWAR_SC_ACI_CONFIG));
        if (saiOp.isSet()) {
            const SaiAciApplicator *aciOp = DOWNCAST(SaiAciApplicator*, &*saiOp);
            // set specific awars:
            awr->awar(AWAR_SC_ACI)->write_string(aciOp->get_aci().c_str());
        }
    }
}
static void aci_gui_changed_cb(AW_root *awr) { // [AWARS->OP->CFG]
    if (!in_aci_awar_callback) {
        LocallyModify<bool> avoid_recursion(in_aci_awar_callback, true);

        // create SaiAciApplicator from awars:
        const char       *aci = awr->awar(AWAR_SC_ACI)->read_char_pntr();
        SaiAciApplicator  aciOp(aci);

        // ask SaiOperator to create config and store in config awar:
        string cfg = aciOp.get_config();
        awr->awar(AWAR_SC_ACI_CONFIG)->write_string(cfg.c_str());
    }
}

// --------------------------------------------------------------------------------

static void calc_method_changed_cb(AW_root *awr) {
    SaiOperatorType type = SaiOperatorType(awr->awar(AWAR_SC_METHOD)->read_int());

    saicalc_edit_method_cb(awr, false); // switch config window (if any is shown)

    // map AWAR_SC_METHOD_CONFIG to type-specific awar:
    const char *currCfg = NULp;
    switch (type) {
        case SOP_ACI:
            currCfg = AWAR_SC_ACI_CONFIG;
            break;
        case SOP_MATRIX:
            currCfg = AWAR_SC_MATRIX_CONFIG;
            break;
        case SOP_BOOLCHAIN:
            currCfg = AWAR_SC_BOOL_CONFIG;
            break;
        case SOP_TRANSLATE:
            currCfg = AWAR_SC_TRANSLATE_CONFIG;
            break;
    }

    AW_awar *awar_cfg          = awr->awar(AWAR_SC_METHOD_CONFIG);
    AW_awar *awar_specific_cfg = currCfg ? awr->awar_no_error(currCfg) : NULp;

    if (awar_specific_cfg) {
        awar_cfg->map(awar_specific_cfg);
        awar_specific_cfg->touch(); // force reinit of temporary config awars (needed once for each method after startup)
    }
    else {
        awar_cfg->unmap();
    }
}

static void calculate_sai_cb(AW_window *aww, GBDATA *gb_main) {
    AW_root         *awr   = aww->get_root();
    SaiOperatorType  type  = SaiOperatorType(awr->awar(AWAR_SC_METHOD)->read_int());
    SaiAliScope      scope = SaiAliScope(awr->awar(AWAR_SC_SCOPE)->read_int());
    SaiOperatorPtr   saiOp = createOpFromConfigAwar(type, awr->awar(AWAR_SC_METHOD_CONFIG));

    if (saiOp.isSet()) { // otherwise createOpFromConfigAwar did show error message
        const char    *targetSaiName = awr->awar(AWAR_SC_TARGET_SAI)->read_char_pntr();
        ConstStrArray  inputSaiName;
        fill_with_source_sais(inputSaiName, awr);

        SaiCalculator calculator(gb_main, inputSaiName, *saiOp, targetSaiName, scope);
        if (calculator.hasError()) {
            aw_message(calculator.getError().deliver());
        }
    }
}

static void use_selected_as_target_cb(AW_window *aww) {
    AW_root *awr = aww->get_root();
    awr->awar(AWAR_SC_TARGET_SAI)->write_string(awr->awar(AWAR_SAI_NAME)->read_char_pntr());
}

static void SAI_init_calculator_awars(AW_root *awr) {
    awr->awar_string(AWAR_SC_TARGET_SAI,      "", AW_ROOT_DEFAULT);
    awr->awar_string(AWAR_SC_SOURCE_SAI_LIST, "", AW_ROOT_DEFAULT);
    awr->awar_string(AWAR_SC_METHOD_CONFIG,   "", AW_ROOT_DEFAULT); // no callback needed. only mapped to type-specific configs.

    awr->awar_int(AWAR_SC_METHOD, SOP_TRANSLATE, AW_ROOT_DEFAULT)->add_callback(calc_method_changed_cb);
    awr->awar_int(AWAR_SC_SCOPE,  SAS_SELECTED,  AW_ROOT_DEFAULT);

    // init translator awars:
    for (int i = 0; i<TRANSLATION_RULES; ++i) {
        awr->awar_string(awar_translate(true,  i), "", AW_ROOT_DEFAULT)->add_callback(makeRootCallback(translate_gui_changed_cb, true,  i));
        awr->awar_string(awar_translate(false, i), "", AW_ROOT_DEFAULT)->add_callback(makeRootCallback(translate_gui_changed_cb, false, i));
    }
    awr->awar_string(AWAR_SC_TRANSLATE_DEFAULT, "-", AW_ROOT_DEFAULT)->add_callback(makeRootCallback(translate_gui_changed_cb, false, -1));

    // init matrix awars:
    for (int x = 0; x<MATRIX_AWARS; ++x) {
        for (int y = 0; y<MATRIX_AWARS; ++y) {
            const char *awar_name = awar_matrix_cell(x, y);
            if (awar_name) {
                awr->awar_string(awar_name, "", AW_ROOT_DEFAULT)->add_callback(makeRootCallback(matrix_gui_changed_cb, x,  y));
            }
        }
    }

    // init boolchain awars:
    awr->awar_string(AWAR_SC_BOOL_IN0, "", AW_ROOT_DEFAULT)->add_callback(makeRootCallback(inputCharsetChanged_cb, false));
    awr->awar_string(AWAR_SC_BOOL_IN1, "", AW_ROOT_DEFAULT)->add_callback(makeRootCallback(inputCharsetChanged_cb, true));

    awr->awar_int(AWAR_SC_BOOL_OP, SBO_AND, AW_ROOT_DEFAULT);

    awr->awar_string(AWAR_SC_BOOL_OUT0,     "-", AW_ROOT_DEFAULT)->add_callback(boolchain_gui_changed_cb);
    awr->awar_string(AWAR_SC_BOOL_OUT1,     "x", AW_ROOT_DEFAULT)->add_callback(boolchain_gui_changed_cb);
    awr->awar_string(AWAR_SC_BOOL_RULES,    "",  AW_ROOT_DEFAULT)->add_callback(boolchain_rulesAwar_changed_cb);
    awr->awar_string(AWAR_SC_BOOL_SEL_RULE, "",  AW_ROOT_DEFAULT)->add_callback(display_selected_rule_cb);

    // init aci awars:
    awr->awar_string(AWAR_SC_ACI, "", AW_ROOT_DEFAULT)->add_callback(aci_gui_changed_cb);

    // config awars:
    // (to update the default values of the following awars, do the following (for each calculator method):
    // * edit the configuration of the method (change some awar into its default value) => config-awar gets updated from other awars
    // * store a managed config
    // * edit that config and copy the value of "~config" to the corresponding default below
    //   (backslashes have to be escaped!)
    // )
    awr->awar_string(AWAR_SC_TRANSLATE_CONFIG, "default='-'",                                                AW_ROOT_DEFAULT)->add_callback(translate_config_changed_cb);
    awr->awar_string(AWAR_SC_MATRIX_CONFIG,    "col0='default=\\'-\\'';columns='1';first='default=\\'A\\''", AW_ROOT_DEFAULT)->add_callback(matrix_config_changed_cb);
    awr->awar_string(AWAR_SC_BOOL_CONFIG,      "out='-x';rules='0'",                                         AW_ROOT_DEFAULT)->add_callback(bool_config_changed_cb);
    awr->awar_string(AWAR_SC_ACI_CONFIG,       "aci=''",                                                     AW_ROOT_DEFAULT)->add_callback(aci_config_changed_cb);

    calc_method_changed_cb(awr); // call once to initialize mapping
}

void SAI_popup_calculator_window(AW_window *awp, GBDATA *gb_main) {
    static AW_window *aww = NULp;

    if (!aww) {
        AW_window_simple *aws = new AW_window_simple;

        AW_root *awr = awp->get_root();
        SAI_init_calculator_awars(awr);

        aws->init(awr, "SAI_CALC", "SAI calculator");
        aws->load_xfig("saicalc.fig");

        aws->button_length(8);

        aws->at("close");
        aws->callback(AW_POPDOWN);
        aws->create_button("CLOSE", "CLOSE", "O");

        aws->at("help");
        aws->callback(makeHelpCallback("saicalc.hlp"));
        aws->create_button("HELP", "HELP");

        aws->at("avail");
        AW_awar      *awar_source_sai = awr->awar(AWAR_SC_SOURCE_SAI_LIST);
        SmartCharPtr  source_sai_list = awar_source_sai->read_string(); // temp. save value that was stored in properties (awt_create_subset_selection_list will reset awar content)

        AW_DB_selection *all_SAI      = awt_create_SAI_selection_list(gb_main, aws, AWAR_SAI_NAME);
        AW_selection    *selected_SAI = awt_create_subset_selection_list(aws, all_SAI->get_sellist(), "source", "add", "sort", true, sai_seletion_changed_cb);

        aws->at("target");
        aws->create_input_field(AWAR_SC_TARGET_SAI);

        aws->at("overwrite");
        aws->callback(use_selected_as_target_cb);
        aws->create_button("OVERWRITE", "Overwrite");

        aws->at("scope");
        aws->create_option_menu(AWAR_SC_SCOPE);
        aws->insert_default_option("Selected alignment",  "S", SAS_SELECTED);
        aws->insert_option        ("Existing alignments", "E", SAS_ALL);
        aws->insert_option        ("Common alignments",   "C", SAS_COMMON);
        aws->insert_option        ("Target alignments",   "C", SAS_TARGET);
        aws->update_option_menu();

        aws->at("cfg");
        AWT_insert_config_manager(aws, AW_ROOT_DEFAULT, "saicalc", saicalc_config_mapping, NULp, saicalc_predefined_configs);

        aws->at("method");
        aws->create_option_menu(AWAR_SC_METHOD);
        aws->insert_default_option(SaiOperator::type_name(SOP_TRANSLATE), "T", SOP_TRANSLATE);
        aws->insert_option        (SaiOperator::type_name(SOP_MATRIX), "M", SOP_MATRIX);
        aws->insert_option        (SaiOperator::type_name(SOP_BOOLCHAIN),   "B", SOP_BOOLCHAIN);
        aws->insert_option        (SaiOperator::type_name(SOP_ACI),      "A", SOP_ACI);
        aws->update_option_menu();

        aws->at("edmeth");
        aws->callback(RootAsWindowCallback::reuse(makeRootCallback(saicalc_edit_method_cb, true)));
        aws->create_button("EDIT", "EDIT");

        aws->at("calc");
        aws->callback(makeWindowCallback(calculate_sai_cb, gb_main));
        aws->highlight();
        aws->create_autosize_button("CALC", "Calculate");

        // @@@ add way to view result (e.g. link to SAI admin?)


        awar_source_sai->add_callback(makeRootCallback(source_sai_list_changed_cb, selected_SAI));
        awar_source_sai->write_string(&*source_sai_list); // refill list of selected source awars

        aww = aws;
    }

    aww->activate();
}