src/gigedit/ScriptPatchVars.cpp

/*
    Copyright (c) MMXX Christian Schoenebeck

    This file is part of "gigedit" and released under the terms of the
    GNU General Public License version 2.
*/

#include "ScriptPatchVars.h"

#define YELLOW "#c4950c"
#define MAGENTA "#790cc4"
#define LITE_GRAY "#bababa"

// Gtk treeview C callback if backspace key is hit while treeview has focus.
static gboolean onSelectCursorParent(GtkTreeView* treeview, gpointer userdata) {
    ScriptPatchVars* self = (ScriptPatchVars*) userdata;

    // This is a hack to prevent treeview from performing implied behaviour on
    // backspace key event. By default Gtk::TreeView would change current
    // selection whenever the user hits the backspace key (that is by navigating
    // to current node's parent). We don't want treeview doing that, since it
    // would prevent our custom backspace key handling (for reverting overridden
    // patch variables to their default value) from working correctly, because
    // our code relies on treeview's 'current selection' which would change
    // before our handler is triggered. Unfortunately there is currently no
    // official or cleaner way to prevent treeview from ignoring backspace key
    // events than the following hack.
    self->grab_focus();

    // Our key event handler would not be triggered automatically in this case,
    // so just call our handler directly instead.
    self->deleteSelectedRows();

    return false;
}

ScriptPatchVars::ScriptPatchVars() :
    m_ignoreTreeViewValueChange(false), m_instrument(NULL)/*, m_editing(false)*/
{
    // create treeview (including its data model)
    m_treeStore = VarsTreeStore::create(m_treeModel);
    m_treeView.set_model(m_treeStore);
    m_treeView.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
    {
        Gtk::CellRendererText* cellrenderer = Gtk::manage(new Gtk::CellRendererText());
        m_treeView.append_column(_("Name"), *cellrenderer);
        m_treeView.get_column(0)->add_attribute(cellrenderer->property_markup(), m_treeModel.m_col_name);
    }
    m_treeView.append_column(_("Type"), m_treeModel.m_col_type);
    Gtk::TreeViewColumn* valueColumn = new Gtk::TreeViewColumn(_("Value"));
    valueColumn->pack_start(m_valueCellRenderer);
    m_treeView.append_column(*valueColumn);
    {
        Gtk::TreeView::Column* column = valueColumn;
        column->add_attribute(m_valueCellRenderer.property_markup(),
                              m_treeModel.m_col_value);
        column->add_attribute(m_valueCellRenderer.property_has_entry(),
                              m_treeModel.m_col_allowTextEntry);
        column->add_attribute(m_valueCellRenderer.property_editable(),
                              m_treeModel.m_col_editable);
        column->add_attribute(m_valueCellRenderer.property_model(),
                              m_treeModel.m_col_options);
    }
    m_valueCellRenderer.property_text_column() = 0;
    m_valueCellRenderer.signal_edited().connect(
        sigc::mem_fun(*this, &ScriptPatchVars::onValueCellEdited)
    );
    {
        Gtk::TreeViewColumn* column = m_treeView.get_column(0);
        Gtk::CellRendererText* cellrenderer =
            dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
        column->add_attribute(cellrenderer->property_foreground(), m_treeModel.m_col_name_color);
        column->add_attribute(cellrenderer->property_weight(), m_treeModel.m_col_name_weight);
    }
    {
        Gtk::TreeViewColumn* column = m_treeView.get_column(1);
        Gtk::CellRendererText* cellrenderer =
            dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
        cellrenderer->property_foreground().set_value(LITE_GRAY);
    }
    {
        Gtk::TreeViewColumn* column = m_treeView.get_column(2);
        Gtk::CellRendererText* cellrenderer =
            dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
        column->add_attribute(cellrenderer->property_foreground(), m_treeModel.m_col_value_color);
        column->add_attribute(cellrenderer->property_weight(), m_treeModel.m_col_value_weight);
    }
    m_treeView.set_headers_visible(true);
    m_treeView.get_selection()->signal_changed().connect(
        sigc::mem_fun(*this, &ScriptPatchVars::onTreeViewSelectionChanged)
    );
#if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
    m_treeView.signal_key_release_event().connect
#else
    m_treeView.signal_key_release_event().connect_notify
#endif
    (
        sigc::mem_fun(*this, &ScriptPatchVars::onTreeViewKeyRelease)
    );
    // Gtk "row-activated" signal (Gtkmm's signal_row_activated) is only fired
    // if this single click property is set to true
    //m_treeView.set_activate_on_single_click(true);
    m_treeView.signal_row_activated().connect(
        [this](const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn* column){
            printf("row activated !!!!\n");
            //m_editing = true; // so we can detect while user is editing some value
        }
    );
    m_treeView.set_has_tooltip(true);
    m_treeView.signal_query_tooltip().connect(
        sigc::mem_fun(*this, &ScriptPatchVars::onQueryTreeViewTooltip)
    );
    // this signal does not exist in the gtkmm C++ TreeView class, so use C API
    g_signal_connect(G_OBJECT(m_treeView.gobj()), "select-cursor-parent", G_CALLBACK(onSelectCursorParent), this);
    m_treeStore->signal_row_changed().connect(
        sigc::mem_fun(*this, &ScriptPatchVars::onTreeViewRowChanged)
    );

/* FIXME: This was an attempt to prevent Gtk's treeview from reacting on
          backspace key event to prevent undesired navigation change by
          treeview. Didn't work out for some reason.
    {
        GtkWidget* widget = gtk_tree_view_new();
        GtkTreeViewClass* klass = GTK_TREE_VIEW_GET_CLASS(widget);
        GtkBindingSet* bindingSet = gtk_binding_set_by_class(klass);
        gtk_binding_entry_remove(bindingSet, GDK_KEY_BackSpace, (GdkModifierType) 0);
        gtk_binding_entry_remove(bindingSet, GDK_KEY_BackSpace, GDK_CONTROL_MASK);
        gtk_widget_destroy(widget);
    }
*/

    // scroll view setup
    add(m_treeView);
    set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

#if HAS_GTKMM_SHOW_ALL_CHILDREN
    show_all_children();
#endif
}

static std::map<std::string,std::string> getDefaultValues(gig::Script* script) {
    std::map<std::string,std::string> vars;
    LinuxSampler::ScriptVM* vm = LinuxSampler::ScriptVMFactory::Create("gig");
    LinuxSampler::VMParserContext* ctx = vm->loadScript(
        script->GetScriptAsText(), std::map<String,String>(), &vars
    );
    if (ctx) delete ctx;
    if (vm) delete vm;
    return vars;
}

struct PatchVar {
    LinuxSampler::optional<std::string> defaultValue;
    LinuxSampler::optional<std::string> overrideValue;

    std::string value() const {
        if (overrideValue) return *overrideValue;
        if (defaultValue) return *defaultValue;
        return "";
    }

    bool isObsolete() const {
        return overrideValue && !defaultValue;
    }
};

static std::map<std::string,PatchVar> getPatchVars(gig::Instrument* instrument, int iScriptSlot) {
    std::map<std::string,PatchVar> vars;
    gig::Script* script = instrument->GetScriptOfSlot(iScriptSlot);
    if (!script) return vars;
    std::map<std::string,std::string> defaultValues = getDefaultValues(script);
    for (const auto& var : defaultValues) {
        vars[var.first].defaultValue = (std::string) trim(var.second);
    }
    std::map<std::string,std::string> overriddenValues =
        instrument->GetScriptPatchVariables(iScriptSlot);
    for (const auto& var : overriddenValues) {
        vars[var.first].overrideValue = var.second;
    }
    return vars;
}

static std::string varTypeStr(const std::string& varName) {
    if (varName.length() >= 1) {
        const char c = varName[0];
        switch (c) {
            case '$': return "Integer";
            case '%': return "Integer Array";
            case '~': return "Real";
            case '?': return "Real Array";
            case '@': return "String";
            case '!': return "String Array";
        }
    }
    return "";
}

void ScriptPatchVars::buildTreeViewVar(const Gtk::TreeModel::Row& parentRow,
                                       int iScriptSlot, gig::Script* script,
                                       const std::string name,
                                       const struct PatchVar* var)
{
#if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
    //HACK: on GTKMM 3.9x append() below requires TreeNodeChildren, parentRow.children() returns TreeNodeConstChildren though, probably going to be fixed before final GTKMM4 release though.
    const Gtk::TreeNodeConstChildren& children = parentRow.children();
    Gtk::TreeNodeChildren* const pChildren = (Gtk::TreeNodeChildren* const) &children;
    Gtk::TreeModel::iterator iterRow = m_treeStore->append(*pChildren);
#else
    Gtk::TreeModel::iterator iterRow = m_treeStore->append(parentRow.children());
#endif
    Gtk::TreeModel::Row row = *iterRow;
    row[m_treeModel.m_col_name] = name;
    row[m_treeModel.m_col_name_color] = (var->isObsolete()) ? "red" : MAGENTA;
    if (var->overrideValue)
        row[m_treeModel.m_col_name_weight] = PANGO_WEIGHT_BOLD;
    row[m_treeModel.m_col_type] = varTypeStr(name) + " Variable";
    row[m_treeModel.m_col_slot] = iScriptSlot;
    row[m_treeModel.m_col_value] = var->value();
    row[m_treeModel.m_col_value_color] =
        (var->isObsolete()) ? "red" : (var->overrideValue) ? YELLOW : "gray";
    row[m_treeModel.m_col_value_tooltip] =
        (var->overrideValue && var->defaultValue) ?
            std::string("Default: ") + *var->defaultValue : "";
    if (var->overrideValue)
        row[m_treeModel.m_col_value_weight] = PANGO_WEIGHT_BOLD;
    row[m_treeModel.m_col_allowTextEntry] = true;
    row[m_treeModel.m_col_editable] = true;
    row[m_treeModel.m_col_script] = script;

    //TODO: syntax highlighting for values like e.g.:
    //row[m_treeModel.m_col_value] = "4<span foreground='#50BC00'>s</span>";
    //row[m_treeModel.m_col_value] = "0.3<span foreground='#50BC00'>s</span>";
    //row[m_treeModel.m_col_value] = "-6.3<span foreground='black'>d</span><span foreground='#50BC00'>B</span>";

    //TODO: in future we might add combo boxes for certain value selections
    // (would probably require some kind of NKSP language extension first)
    //const char** allKeys = gig::enumKeys(object.type().customTypeName());
    //if (allKeys) {
    //    Glib::RefPtr<Gtk::ListStore> refOptions = createComboOptions(allKeys);
    //    row[m_treeModelMacro.m_col_options] = refOptions;
    //}
    //Glib::RefPtr<Gtk::ListStore> refOptions = createComboOptions(_boolOptions);
    //row[m_treeModelMacro.m_col_options] = refOptions;
}

void ScriptPatchVars::buildTreeViewSlot(const Gtk::TreeModel::Row& parentRow, int iScriptSlot) {
#if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
    //HACK: on GTKMM 3.9x append() below requires TreeNodeChildren, parentRow.children() returns TreeNodeConstChildren though, probably going to be fixed before final GTKMM4 release though.
    const Gtk::TreeNodeConstChildren& children = parentRow.children();
    Gtk::TreeNodeChildren* const pChildren = (Gtk::TreeNodeChildren* const) &children;
    Gtk::TreeModel::iterator iterRow = m_treeStore->append(*pChildren);
#else
    Gtk::TreeModel::iterator iterRow = m_treeStore->append(parentRow.children());
#endif
    gig::Script* pScript = m_instrument->GetScriptOfSlot(iScriptSlot);

    Gtk::TreeModel::Row row = *iterRow;
    row[m_treeModel.m_col_name] = pScript->Name + " <sup>Slot " + ToString(iScriptSlot+1) + "</sup>";
    row[m_treeModel.m_col_name_weight] = PANGO_WEIGHT_BOLD;
    row[m_treeModel.m_col_type] = "Script";
    row[m_treeModel.m_col_value] = "";
    row[m_treeModel.m_col_slot]  = -1;
    row[m_treeModel.m_col_allowTextEntry] = false;
    row[m_treeModel.m_col_editable] = false;
    row[m_treeModel.m_col_script] = NULL;
    row[m_treeModel.m_col_value_tooltip] = "";

    std::map<std::string,PatchVar> vars = getPatchVars(m_instrument, iScriptSlot);
    for (const auto& var : vars) {
        buildTreeViewVar(row, iScriptSlot, pScript, var.first, &var.second);
    }
}

void ScriptPatchVars::reloadTreeView() {
    m_ignoreTreeViewValueChange = true;

    m_treeStore->clear();
    if (!m_instrument) return;

    Gtk::TreeModel::iterator iterRoot = m_treeStore->append();
    Gtk::TreeModel::Row rowRoot = *iterRoot;
    rowRoot[m_treeModel.m_col_name]  = m_instrument->pInfo->Name;
    rowRoot[m_treeModel.m_col_name_weight] = PANGO_WEIGHT_BOLD;
    rowRoot[m_treeModel.m_col_type]  = "Instrument";
    rowRoot[m_treeModel.m_col_value] = "";
    rowRoot[m_treeModel.m_col_slot]  = -1;
    rowRoot[m_treeModel.m_col_allowTextEntry] = false;
    rowRoot[m_treeModel.m_col_editable] = false;
    rowRoot[m_treeModel.m_col_script] = NULL;
    rowRoot[m_treeModel.m_col_value_tooltip] = "";

    for (int i = 0; i < m_instrument->ScriptSlotCount(); ++i)
        buildTreeViewSlot(rowRoot, i);

    m_treeView.expand_all();

    m_ignoreTreeViewValueChange = false;
}

void ScriptPatchVars::onTreeViewSelectionChanged() {
}

bool ScriptPatchVars::onQueryTreeViewTooltip(int x, int y, bool keyboardTip,
                                             const Glib::RefPtr<Gtk::Tooltip>& tooltip)
{
    Gtk::TreeModel::iterator iter;
    if (!m_treeView.get_tooltip_context_iter(x, y, keyboardTip, iter)) {
        return false;
    }
    Gtk::TreeModel::Path path(iter);
    Gtk::TreeModel::Row row = *iter;
    Gtk::TreeViewColumn* pointedColumn = NULL;
    // resolve the precise table column the mouse points to
    {
        Gtk::TreeModel::Path path; // unused
        int cellX, cellY; // unused
        m_treeView.get_path_at_pos(x, y, path, pointedColumn, cellX, cellY);
    }
    Gtk::TreeViewColumn* valueColumn = m_treeView.get_column(2);
    if (pointedColumn == valueColumn) { // mouse hovers value column ...
        const Glib::ustring tip = row[m_treeModel.m_col_value_tooltip];
        if (tip.empty()) return false; // don't show tooltip
        // show model / cell's assigned tooltip
        tooltip->set_markup(tip);
        m_treeView.set_tooltip_cell(tooltip, &path, valueColumn, NULL);
        return true; // show tooltip
    }
    return false; // don't show tooltip
}

#if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
bool ScriptPatchVars::onTreeViewKeyRelease(Gdk::EventKey& _key) {
    GdkEventKey* key = _key.gobj();
#else
void ScriptPatchVars::onTreeViewKeyRelease(GdkEventKey* key) {
#endif
    if (key->keyval == GDK_KEY_BackSpace || key->keyval == GDK_KEY_Delete) {
        printf("DELETE on script treeview row\n");
        deleteSelectedRows();
    }
out:
    ; // noop
#if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
    return false;
#endif
}

void ScriptPatchVars::deleteSelectedRows() {
    Glib::RefPtr<Gtk::TreeSelection> sel = m_treeView.get_selection();
    std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
    deleteRows(rows);
}

void ScriptPatchVars::deleteRows(const std::vector<Gtk::TreeModel::Path>& rows) {
    // ignore the backspace key here while user is editing some value
    if (m_ignoreTreeViewValueChange /*|| m_editing*/) return;
    if (!m_instrument) return; // just to be sure

    m_ignoreTreeViewValueChange = true;

    signal_vars_to_be_changed.emit(m_instrument);

    for (ssize_t r = rows.size() - 1; r >= 0; --r) {
        Gtk::TreeModel::iterator it = m_treeStore->get_iter(rows[r]);
        if (!it) continue;
        Gtk::TreeModel::Row row = *it;
        gig::Script* script = row[m_treeModel.m_col_script];
        int slot = row[m_treeModel.m_col_slot];
        if (!script || slot == -1) continue; // prohibit deleting meta nodes
        std::string name = (Glib::ustring) row[m_treeModel.m_col_name];
        m_instrument->UnsetScriptPatchVariable(slot, name);
    }

    signal_vars_changed.emit(m_instrument);

    reloadTreeView();

    m_ignoreTreeViewValueChange = false;
}

void ScriptPatchVars::onValueCellEdited(const Glib::ustring& sPath, const Glib::ustring& text) {
    //m_editing = false;
    Gtk::TreePath path(sPath);
    Gtk::TreeModel::iterator iter = m_treeStore->get_iter(path);
    onTreeViewRowValueChanged(path, iter, text);
}

void ScriptPatchVars::onTreeViewRowChanged(const Gtk::TreeModel::Path& path,
                                           const Gtk::TreeModel::iterator& iter)
{
    //m_editing = false;
    if (!iter) return;
    Gtk::TreeModel::Row row = *iter;
    Glib::ustring value = row[m_treeModel.m_col_value];
    onTreeViewRowValueChanged(path, iter, value);
}

void ScriptPatchVars::onTreeViewRowValueChanged(const Gtk::TreeModel::Path& path,
                                                const Gtk::TreeModel::iterator& iter,
                                                const Glib::ustring value)
{
    //m_editing = false;
    if (m_ignoreTreeViewValueChange || !m_instrument) return;

    Gtk::TreeModel::Row row = *iter;
    gig::Script* script = row[m_treeModel.m_col_script];
    int slot = row[m_treeModel.m_col_slot];
    if (!script || slot == -1) return; // prohibit altering meta nodes
    std::string name = (Glib::ustring) row[m_treeModel.m_col_name];

    signal_vars_to_be_changed.emit(m_instrument);

    m_instrument->SetScriptPatchVariable(slot, name, value);

    signal_vars_changed.emit(m_instrument);

    reloadTreeView();
}

void ScriptPatchVars::setInstrument(gig::Instrument* pInstrument, bool forceUpdate) {
    if (m_instrument == pInstrument && !forceUpdate)
        return;
    m_instrument = pInstrument;
    reloadTreeView();
}
1	schoenebeck	3737	/*
2			Copyright (c) MMXX Christian Schoenebeck
3
4			This file is part of "gigedit" and released under the terms of the
5			GNU General Public License version 2.
6			*/
7
8			#include "ScriptPatchVars.h"
9
10			#define YELLOW "#c4950c"
11			#define MAGENTA "#790cc4"
12			#define LITE_GRAY "#bababa"
13
14			// Gtk treeview C callback if backspace key is hit while treeview has focus.
15			static gboolean onSelectCursorParent(GtkTreeView* treeview, gpointer userdata) {
16			ScriptPatchVars* self = (ScriptPatchVars*) userdata;
17
18			// This is a hack to prevent treeview from performing implied behaviour on
19			// backspace key event. By default Gtk::TreeView would change current
20			// selection whenever the user hits the backspace key (that is by navigating
21			// to current node's parent). We don't want treeview doing that, since it
22			// would prevent our custom backspace key handling (for reverting overridden
23			// patch variables to their default value) from working correctly, because
24			// our code relies on treeview's 'current selection' which would change
25			// before our handler is triggered. Unfortunately there is currently no
26			// official or cleaner way to prevent treeview from ignoring backspace key
27			// events than the following hack.
28			self->grab_focus();
29
30			// Our key event handler would not be triggered automatically in this case,
31			// so just call our handler directly instead.
32			self->deleteSelectedRows();
33
34			return false;
35			}
36
37			ScriptPatchVars::ScriptPatchVars() :
38			m_ignoreTreeViewValueChange(false), m_instrument(NULL)/, m_editing(false)/
39			{
40			// create treeview (including its data model)
41			m_treeStore = VarsTreeStore::create(m_treeModel);
42			m_treeView.set_model(m_treeStore);
43			m_treeView.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
44			{
45			Gtk::CellRendererText* cellrenderer = Gtk::manage(new Gtk::CellRendererText());
46			m_treeView.append_column(_("Name"), *cellrenderer);
47			m_treeView.get_column(0)->add_attribute(cellrenderer->property_markup(), m_treeModel.m_col_name);
48			}
49			m_treeView.append_column(_("Type"), m_treeModel.m_col_type);
50			Gtk::TreeViewColumn* valueColumn = new Gtk::TreeViewColumn(_("Value"));
51			valueColumn->pack_start(m_valueCellRenderer);
52			m_treeView.append_column(*valueColumn);
53			{
54			Gtk::TreeView::Column* column = valueColumn;
55			column->add_attribute(m_valueCellRenderer.property_markup(),
56			m_treeModel.m_col_value);
57			column->add_attribute(m_valueCellRenderer.property_has_entry(),
58			m_treeModel.m_col_allowTextEntry);
59			column->add_attribute(m_valueCellRenderer.property_editable(),
60			m_treeModel.m_col_editable);
61			column->add_attribute(m_valueCellRenderer.property_model(),
62			m_treeModel.m_col_options);
63			}
64			m_valueCellRenderer.property_text_column() = 0;
65			m_valueCellRenderer.signal_edited().connect(
66			sigc::mem_fun(*this, &ScriptPatchVars::onValueCellEdited)
67			);
68			{
69			Gtk::TreeViewColumn* column = m_treeView.get_column(0);
70			Gtk::CellRendererText* cellrenderer =
71			dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
72			column->add_attribute(cellrenderer->property_foreground(), m_treeModel.m_col_name_color);
73			column->add_attribute(cellrenderer->property_weight(), m_treeModel.m_col_name_weight);
74			}
75			{
76			Gtk::TreeViewColumn* column = m_treeView.get_column(1);
77			Gtk::CellRendererText* cellrenderer =
78			dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
79			cellrenderer->property_foreground().set_value(LITE_GRAY);
80			}
81			{
82			Gtk::TreeViewColumn* column = m_treeView.get_column(2);
83			Gtk::CellRendererText* cellrenderer =
84			dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
85			column->add_attribute(cellrenderer->property_foreground(), m_treeModel.m_col_value_color);
86			column->add_attribute(cellrenderer->property_weight(), m_treeModel.m_col_value_weight);
87			}
88			m_treeView.set_headers_visible(true);
89			m_treeView.get_selection()->signal_changed().connect(
90			sigc::mem_fun(*this, &ScriptPatchVars::onTreeViewSelectionChanged)
91			);
92			#if GTKMM_MAJOR_VERSION > 3 \|\| (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 \|\| (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
93			m_treeView.signal_key_release_event().connect
94			#else
95			m_treeView.signal_key_release_event().connect_notify
96			#endif
97			(
98			sigc::mem_fun(*this, &ScriptPatchVars::onTreeViewKeyRelease)
99			);
100			// Gtk "row-activated" signal (Gtkmm's signal_row_activated) is only fired
101			// if this single click property is set to true
102			//m_treeView.set_activate_on_single_click(true);
103			m_treeView.signal_row_activated().connect(
104			[this](const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn* column){
105			printf("row activated !!!!\n");
106			//m_editing = true; // so we can detect while user is editing some value
107			}
108			);
109			m_treeView.set_has_tooltip(true);
110			m_treeView.signal_query_tooltip().connect(
111			sigc::mem_fun(*this, &ScriptPatchVars::onQueryTreeViewTooltip)
112			);
113			// this signal does not exist in the gtkmm C++ TreeView class, so use C API
114			g_signal_connect(G_OBJECT(m_treeView.gobj()), "select-cursor-parent", G_CALLBACK(onSelectCursorParent), this);
115			m_treeStore->signal_row_changed().connect(
116			sigc::mem_fun(*this, &ScriptPatchVars::onTreeViewRowChanged)
117			);
118
119			/* FIXME: This was an attempt to prevent Gtk's treeview from reacting on
120			backspace key event to prevent undesired navigation change by
121			treeview. Didn't work out for some reason.
122			{
123			GtkWidget* widget = gtk_tree_view_new();
124			GtkTreeViewClass* klass = GTK_TREE_VIEW_GET_CLASS(widget);
125			GtkBindingSet* bindingSet = gtk_binding_set_by_class(klass);
126			gtk_binding_entry_remove(bindingSet, GDK_KEY_BackSpace, (GdkModifierType) 0);
127			gtk_binding_entry_remove(bindingSet, GDK_KEY_BackSpace, GDK_CONTROL_MASK);
128			gtk_widget_destroy(widget);
129			}
130			*/
131
132			// scroll view setup
133			add(m_treeView);
134			set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
135
136			#if HAS_GTKMM_SHOW_ALL_CHILDREN
137			show_all_children();
138			#endif
139			}
140
141			static std::map<std::string,std::string> getDefaultValues(gig::Script* script) {
142			std::map<std::string,std::string> vars;
143			LinuxSampler::ScriptVM* vm = LinuxSampler::ScriptVMFactory::Create("gig");
144			LinuxSampler::VMParserContext* ctx = vm->loadScript(
145			script->GetScriptAsText(), std::map<String,String>(), &vars
146			);
147			if (ctx) delete ctx;
148			if (vm) delete vm;
149			return vars;
150			}
151
152			struct PatchVar {
153			LinuxSampler::optional<std::string> defaultValue;
154			LinuxSampler::optional<std::string> overrideValue;
155
156			std::string value() const {
157			if (overrideValue) return *overrideValue;
158			if (defaultValue) return *defaultValue;
159			return "";
160			}
161
162			bool isObsolete() const {
163			return overrideValue && !defaultValue;
164			}
165			};
166
167			static std::map<std::string,PatchVar> getPatchVars(gig::Instrument* instrument, int iScriptSlot) {
168			std::map<std::string,PatchVar> vars;
169			gig::Script* script = instrument->GetScriptOfSlot(iScriptSlot);
170			if (!script) return vars;
171			std::map<std::string,std::string> defaultValues = getDefaultValues(script);
172			for (const auto& var : defaultValues) {
173			vars[var.first].defaultValue = (std::string) trim(var.second);
174			}
175			std::map<std::string,std::string> overriddenValues =
176			instrument->GetScriptPatchVariables(iScriptSlot);
177			for (const auto& var : overriddenValues) {
178			vars[var.first].overrideValue = var.second;
179			}
180			return vars;
181			}
182
183			static std::string varTypeStr(const std::string& varName) {
184			if (varName.length() >= 1) {
185			const char c = varName[0];
186			switch (c) {
187			case '$': return "Integer";
188			case '%': return "Integer Array";
189			case '~': return "Real";
190			case '?': return "Real Array";
191			case '@': return "String";
192			case '!': return "String Array";
193			}
194			}
195			return "";
196			}
197
198			void ScriptPatchVars::buildTreeViewVar(const Gtk::TreeModel::Row& parentRow,
199			int iScriptSlot, gig::Script* script,
200			const std::string name,
201			const struct PatchVar* var)
202			{
203			#if GTKMM_MAJOR_VERSION > 3 \|\| (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
204			//HACK: on GTKMM 3.9x append() below requires TreeNodeChildren, parentRow.children() returns TreeNodeConstChildren though, probably going to be fixed before final GTKMM4 release though.
205			const Gtk::TreeNodeConstChildren& children = parentRow.children();
206			Gtk::TreeNodeChildren* const pChildren = (Gtk::TreeNodeChildren* const) &children;
207			Gtk::TreeModel::iterator iterRow = m_treeStore->append(*pChildren);
208			#else
209			Gtk::TreeModel::iterator iterRow = m_treeStore->append(parentRow.children());
210			#endif
211			Gtk::TreeModel::Row row = *iterRow;
212			row[m_treeModel.m_col_name] = name;
213			row[m_treeModel.m_col_name_color] = (var->isObsolete()) ? "red" : MAGENTA;
214			if (var->overrideValue)
215			row[m_treeModel.m_col_name_weight] = PANGO_WEIGHT_BOLD;
216			row[m_treeModel.m_col_type] = varTypeStr(name) + " Variable";
217			row[m_treeModel.m_col_slot] = iScriptSlot;
218			row[m_treeModel.m_col_value] = var->value();
219			row[m_treeModel.m_col_value_color] =
220			(var->isObsolete()) ? "red" : (var->overrideValue) ? YELLOW : "gray";
221			row[m_treeModel.m_col_value_tooltip] =
222			(var->overrideValue && var->defaultValue) ?
223			std::string("Default: ") + *var->defaultValue : "";
224			if (var->overrideValue)
225			row[m_treeModel.m_col_value_weight] = PANGO_WEIGHT_BOLD;
226			row[m_treeModel.m_col_allowTextEntry] = true;
227			row[m_treeModel.m_col_editable] = true;
228			row[m_treeModel.m_col_script] = script;
229
230			//TODO: syntax highlighting for values like e.g.:
231			//row[m_treeModel.m_col_value] = "4<span foreground='#50BC00'>s</span>";
232			//row[m_treeModel.m_col_value] = "0.3<span foreground='#50BC00'>s</span>";
233			//row[m_treeModel.m_col_value] = "-6.3<span foreground='black'>d</span><span foreground='#50BC00'>B</span>";
234
235			//TODO: in future we might add combo boxes for certain value selections
236			// (would probably require some kind of NKSP language extension first)
237			//const char** allKeys = gig::enumKeys(object.type().customTypeName());
238			//if (allKeys) {
239			// Glib::RefPtr<Gtk::ListStore> refOptions = createComboOptions(allKeys);
240			// row[m_treeModelMacro.m_col_options] = refOptions;
241			//}
242			//Glib::RefPtr<Gtk::ListStore> refOptions = createComboOptions(_boolOptions);
243			//row[m_treeModelMacro.m_col_options] = refOptions;
244			}
245
246			void ScriptPatchVars::buildTreeViewSlot(const Gtk::TreeModel::Row& parentRow, int iScriptSlot) {
247			#if GTKMM_MAJOR_VERSION > 3 \|\| (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
248			//HACK: on GTKMM 3.9x append() below requires TreeNodeChildren, parentRow.children() returns TreeNodeConstChildren though, probably going to be fixed before final GTKMM4 release though.
249			const Gtk::TreeNodeConstChildren& children = parentRow.children();
250			Gtk::TreeNodeChildren* const pChildren = (Gtk::TreeNodeChildren* const) &children;
251			Gtk::TreeModel::iterator iterRow = m_treeStore->append(*pChildren);
252			#else
253			Gtk::TreeModel::iterator iterRow = m_treeStore->append(parentRow.children());
254			#endif
255			gig::Script* pScript = m_instrument->GetScriptOfSlot(iScriptSlot);
256
257			Gtk::TreeModel::Row row = *iterRow;
258			row[m_treeModel.m_col_name] = pScript->Name + " <sup>Slot " + ToString(iScriptSlot+1) + "</sup>";
259			row[m_treeModel.m_col_name_weight] = PANGO_WEIGHT_BOLD;
260			row[m_treeModel.m_col_type] = "Script";
261			row[m_treeModel.m_col_value] = "";
262			row[m_treeModel.m_col_slot] = -1;
263			row[m_treeModel.m_col_allowTextEntry] = false;
264			row[m_treeModel.m_col_editable] = false;
265			row[m_treeModel.m_col_script] = NULL;
266			row[m_treeModel.m_col_value_tooltip] = "";
267
268			std::map<std::string,PatchVar> vars = getPatchVars(m_instrument, iScriptSlot);
269			for (const auto& var : vars) {
270			buildTreeViewVar(row, iScriptSlot, pScript, var.first, &var.second);
271			}
272			}
273
274			void ScriptPatchVars::reloadTreeView() {
275			m_ignoreTreeViewValueChange = true;
276
277			m_treeStore->clear();
278			if (!m_instrument) return;
279
280			Gtk::TreeModel::iterator iterRoot = m_treeStore->append();
281			Gtk::TreeModel::Row rowRoot = *iterRoot;
282			rowRoot[m_treeModel.m_col_name] = m_instrument->pInfo->Name;
283			rowRoot[m_treeModel.m_col_name_weight] = PANGO_WEIGHT_BOLD;
284			rowRoot[m_treeModel.m_col_type] = "Instrument";
285			rowRoot[m_treeModel.m_col_value] = "";
286			rowRoot[m_treeModel.m_col_slot] = -1;
287			rowRoot[m_treeModel.m_col_allowTextEntry] = false;
288			rowRoot[m_treeModel.m_col_editable] = false;
289			rowRoot[m_treeModel.m_col_script] = NULL;
290			rowRoot[m_treeModel.m_col_value_tooltip] = "";
291
292			for (int i = 0; i < m_instrument->ScriptSlotCount(); ++i)
293			buildTreeViewSlot(rowRoot, i);
294
295			m_treeView.expand_all();
296
297			m_ignoreTreeViewValueChange = false;
298			}
299
300			void ScriptPatchVars::onTreeViewSelectionChanged() {
301			}
302
303			bool ScriptPatchVars::onQueryTreeViewTooltip(int x, int y, bool keyboardTip,
304			const Glib::RefPtr<Gtk::Tooltip>& tooltip)
305			{
306			Gtk::TreeModel::iterator iter;
307			if (!m_treeView.get_tooltip_context_iter(x, y, keyboardTip, iter)) {
308			return false;
309			}
310			Gtk::TreeModel::Path path(iter);
311			Gtk::TreeModel::Row row = *iter;
312			Gtk::TreeViewColumn* pointedColumn = NULL;
313			// resolve the precise table column the mouse points to
314			{
315			Gtk::TreeModel::Path path; // unused
316			int cellX, cellY; // unused
317			m_treeView.get_path_at_pos(x, y, path, pointedColumn, cellX, cellY);
318			}
319			Gtk::TreeViewColumn* valueColumn = m_treeView.get_column(2);
320			if (pointedColumn == valueColumn) { // mouse hovers value column ...
321			const Glib::ustring tip = row[m_treeModel.m_col_value_tooltip];
322			if (tip.empty()) return false; // don't show tooltip
323			// show model / cell's assigned tooltip
324			tooltip->set_markup(tip);
325			m_treeView.set_tooltip_cell(tooltip, &path, valueColumn, NULL);
326			return true; // show tooltip
327			}
328			return false; // don't show tooltip
329			}
330
331			#if GTKMM_MAJOR_VERSION > 3 \|\| (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 \|\| (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
332			bool ScriptPatchVars::onTreeViewKeyRelease(Gdk::EventKey& _key) {
333			GdkEventKey* key = _key.gobj();
334			#else
335			void ScriptPatchVars::onTreeViewKeyRelease(GdkEventKey* key) {
336			#endif
337			if (key->keyval == GDK_KEY_BackSpace \|\| key->keyval == GDK_KEY_Delete) {
338			printf("DELETE on script treeview row\n");
339			deleteSelectedRows();
340			}
341			out:
342			; // noop
343			#if GTKMM_MAJOR_VERSION > 3 \|\| (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 \|\| (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
344			return false;
345			#endif
346			}
347
348			void ScriptPatchVars::deleteSelectedRows() {
349			Glib::RefPtr<Gtk::TreeSelection> sel = m_treeView.get_selection();
350			std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
351			deleteRows(rows);
352			}
353
354			void ScriptPatchVars::deleteRows(const std::vector<Gtk::TreeModel::Path>& rows) {
355			// ignore the backspace key here while user is editing some value
356			if (m_ignoreTreeViewValueChange /\|\| m_editing/) return;
357			if (!m_instrument) return; // just to be sure
358
359			m_ignoreTreeViewValueChange = true;
360
361			signal_vars_to_be_changed.emit(m_instrument);
362
363			for (ssize_t r = rows.size() - 1; r >= 0; --r) {
364			Gtk::TreeModel::iterator it = m_treeStore->get_iter(rows[r]);
365			if (!it) continue;
366			Gtk::TreeModel::Row row = *it;
367			gig::Script* script = row[m_treeModel.m_col_script];
368			int slot = row[m_treeModel.m_col_slot];
369			if (!script \|\| slot == -1) continue; // prohibit deleting meta nodes
370			std::string name = (Glib::ustring) row[m_treeModel.m_col_name];
371			m_instrument->UnsetScriptPatchVariable(slot, name);
372			}
373
374			signal_vars_changed.emit(m_instrument);
375
376			reloadTreeView();
377
378			m_ignoreTreeViewValueChange = false;
379			}
380
381			void ScriptPatchVars::onValueCellEdited(const Glib::ustring& sPath, const Glib::ustring& text) {
382			//m_editing = false;
383			Gtk::TreePath path(sPath);
384			Gtk::TreeModel::iterator iter = m_treeStore->get_iter(path);
385			onTreeViewRowValueChanged(path, iter, text);
386			}
387
388			void ScriptPatchVars::onTreeViewRowChanged(const Gtk::TreeModel::Path& path,
389			const Gtk::TreeModel::iterator& iter)
390			{
391			//m_editing = false;
392			if (!iter) return;
393			Gtk::TreeModel::Row row = *iter;
394			Glib::ustring value = row[m_treeModel.m_col_value];
395			onTreeViewRowValueChanged(path, iter, value);
396			}
397
398			void ScriptPatchVars::onTreeViewRowValueChanged(const Gtk::TreeModel::Path& path,
399			const Gtk::TreeModel::iterator& iter,
400			const Glib::ustring value)
401			{
402			//m_editing = false;
403			if (m_ignoreTreeViewValueChange \|\| !m_instrument) return;
404
405			Gtk::TreeModel::Row row = *iter;
406			gig::Script* script = row[m_treeModel.m_col_script];
407			int slot = row[m_treeModel.m_col_slot];
408			if (!script \|\| slot == -1) return; // prohibit altering meta nodes
409			std::string name = (Glib::ustring) row[m_treeModel.m_col_name];
410
411			signal_vars_to_be_changed.emit(m_instrument);
412
413			m_instrument->SetScriptPatchVariable(slot, name, value);
414
415			signal_vars_changed.emit(m_instrument);
416
417			reloadTreeView();
418			}
419
420			void ScriptPatchVars::setInstrument(gig::Instrument* pInstrument, bool forceUpdate) {
421			if (m_instrument == pInstrument && !forceUpdate)
422			return;
423			m_instrument = pInstrument;
424			reloadTreeView();
425			}