src/gigedit/paramedit.h

/*                                                         -*- c++ -*-
 * Copyright (C) 2006-2019 Andreas Persson
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with program; see the file COPYING. If not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA.
 */

#ifndef GIGEDIT_PARAMEDIT_H
#define GIGEDIT_PARAMEDIT_H

#ifdef LIBGIG_HEADER_FILE
# include LIBGIG_HEADER_FILE(gig.h)
#else
# include <gig.h>
#endif

#include <cmath>

#include "compat.h"

#include <glibmm/convert.h>
#include <gtkmm/box.h>
#include <gtkmm/adjustment.h>
#if HAS_GTKMM_ALIGNMENT
# include <gtkmm/alignment.h>
#endif
#include <gtkmm/checkbutton.h>
#include <gtkmm/comboboxtext.h>
#include <gtkmm/frame.h>
#include <gtkmm/label.h>
#include <gtkmm/scale.h>
#include <gtkmm/spinbutton.h>
#if USE_GTKMM_GRID
# include <gtkmm/grid.h>
#else
# include <gtkmm/table.h>
#endif
#include <gtkmm/textview.h>

#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 12) || GTKMM_MAJOR_VERSION < 2
#define OLD_TOOLTIPS
#include <gtkmm/tooltips.h>
#endif

int note_value(const Glib::ustring& note);
Glib::ustring note_str(int note);

void spin_button_show_notes(Gtk::SpinButton& spin_button);

class LabelWidget {
public:
    Gtk::Label label;
    Gtk::Widget& widget;

    LabelWidget(const char* labelText, Gtk::Widget& widget);
    void set_sensitive(bool sensitive = true);
    sigc::signal<void>& signal_value_changed() {
        return sig_changed;
    }
protected:
    virtual void on_show_tooltips_changed();
#ifdef OLD_TOOLTIPS
    Gtk::Tooltips tooltips;
#endif
    sigc::signal<void> sig_changed;
};

class ReadOnlyLabelWidget : public LabelWidget {
public:
    Gtk::Label text;

    ReadOnlyLabelWidget(const char* leftHandText);
    ReadOnlyLabelWidget(const char* leftHandText, const char* rightHandText);
};

class NumEntry : public LabelWidget {
protected:
#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
    Gtk::Adjustment adjust;
#else
    Glib::RefPtr<Gtk::Adjustment> adjust;
#endif
    HScale scale;
    Gtk::SpinButton spinbutton;
    HBox box;

    static int round_to_int(double x) {
        return int(x < 0.0 ? x - 0.5 : x + 0.5);
    }

public:
    NumEntry(const char* labelText, double lower = 0, double upper = 127,
             int decimals = 0);
    void set_tip(const Glib::ustring& tip_text) {
#ifdef OLD_TOOLTIPS
        tooltips.set_tip(spinbutton, tip_text);
#else
        spinbutton.set_tooltip_text(tip_text);
#endif
    }
    void set_upper(double upper) {
#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
        adjust.set_upper(upper);
#else
        adjust->set_upper(upper);
#endif
    }
    void on_show_tooltips_changed();
};

class NumEntryGain : public NumEntry {
private:
    int32_t value;
    void value_changed();
    double coeff;
    bool connected;
public:
    NumEntryGain(const char* labelText,
                 double lower, double upper, int decimals, double coeff);
    int32_t get_value() const { return value; }
    void set_value(int32_t value);
};

template<typename T>
class NumEntryTemp : public NumEntry {
private:
    T value;
    void value_changed();
public:
    NumEntryTemp(const char* labelText,
                 double lower = 0, double upper = 127, int decimals = 0);
    T get_value() const { return value; }
    void set_value(T value);
};

template<typename T>
NumEntryTemp<T>::NumEntryTemp(const char* labelText,
                              double lower, double upper, int decimals) :
    NumEntry(labelText, lower, upper, decimals),
    value(0)
{
    spinbutton.signal_value_changed().connect(
        sigc::mem_fun(*this, &NumEntryTemp::value_changed));
}

template<typename T>
void NumEntryTemp<T>::value_changed()
{
    const double f = pow(10, spinbutton.get_digits());
    int new_value = round_to_int(spinbutton.get_value() * f);
    if (new_value != round_to_int(value * f)) {
        value = T(new_value / f);
        sig_changed();
    }
}

template<typename T>
void NumEntryTemp<T>::set_value(T value)
{
#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
    if (value > adjust.get_upper()) value = T(adjust.get_upper());
#else
    if (value > adjust->get_upper()) value = T(adjust->get_upper());
#endif
    if (this->value != value) {
        this->value = value;
        const double f = pow(10, spinbutton.get_digits());
        if (round_to_int(spinbutton.get_value() * f) != round_to_int(value * f)) {
            spinbutton.set_value(value);
        }
        sig_changed();
    }
}


class NoteEntry : public NumEntryTemp<uint8_t> {
public:
    NoteEntry(const char* labelText);
private:
    int on_input(double* new_value);
    bool on_output();
};


class NumEntryPermille : public NumEntry {
private:
    uint16_t value;
    void value_changed();
public:
    NumEntryPermille(const char* labelText,
                     double lower = 0, double upper = 127, int decimals = 0);
    uint16_t get_value() const { return value; }
    void set_value(uint16_t value);
};

class ChoiceEntryBase : public LabelWidget {
protected:
    ChoiceEntryBase(const char* labelText, Gtk::Widget& widget) : LabelWidget(labelText, widget) {};
    Gtk::ComboBoxText combobox;
    void on_show_tooltips_changed();
};

template<typename T>
class ChoiceEntry : public ChoiceEntryBase {
private:
#if HAS_GTKMM_ALIGNMENT
    Gtk::Alignment align;
#endif
    const T* values;
public:
    ChoiceEntry(const char* labelText);
    T get_value() const;
    void set_value(T value);
    void set_choices(const char** texts, const T* values);

    void set_tip(const Glib::ustring& tip_text) {
#ifdef OLD_TOOLTIPS
        tooltips.set_tip(combobox, tip_text);
#else
        combobox.set_tooltip_text(tip_text);
#endif
    }
};

template<typename T>
ChoiceEntry<T>::ChoiceEntry(const char* labelText) :
#if HAS_GTKMM_ALIGNMENT
    ChoiceEntryBase(labelText, align),
    align(0, 0, 0, 0),
#else
    ChoiceEntryBase(labelText, combobox),
#endif
    values(0)
{
    combobox.signal_changed().connect(sig_changed.make_slot());
#if HAS_GTKMM_ALIGNMENT
    align.add(combobox);
#endif
}

template<typename T>
void ChoiceEntry<T>::set_choices(const char** texts, const T* values)
{
#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 24) || GTKMM_MAJOR_VERSION < 2
    combobox.clear_items();
    for (int i = 0 ; texts[i] ; i++) {
        combobox.append_text(texts[i]);
    }
#else
    combobox.remove_all();
    for (int i = 0 ; texts[i] ; i++) {
        combobox.append(texts[i]);
    }
#endif
    this->values = values;
}

template<typename T>
T ChoiceEntry<T>::get_value() const
{
    int rowno = combobox.get_active_row_number();
    return values[rowno];
}

template<typename T>
void ChoiceEntry<T>::set_value(T value)
{
    int row = 0;
    int nb_rows = combobox.get_model()->children().size();
    for (; row < nb_rows ; row++) {
        if (value == values[row]) break;
    }
    combobox.set_active(row == nb_rows ? -1 : row);
}


class ChoiceEntryLeverageCtrl : public LabelWidget {
private:
    gig::leverage_ctrl_t value;
    Gtk::ComboBoxText combobox;
#if HAS_GTKMM_ALIGNMENT
    Gtk::Alignment align;
#endif
    void value_changed();
protected:
    void on_show_tooltips_changed();
public:
    ChoiceEntryLeverageCtrl(const char* labelText);
    gig::leverage_ctrl_t get_value() const { return value; }
    void set_value(gig::leverage_ctrl_t value);
    void set_tip(const Glib::ustring& tip_text) {
        combobox.set_tooltip_text(tip_text);
    }
};

class ChoiceEntryLfoWave : public LabelWidget {
private:
    gig::lfo_wave_t value;
    Gtk::ComboBoxText combobox;
#if HAS_GTKMM_ALIGNMENT
    Gtk::Alignment align;
#endif
    void value_changed();
protected:
    void on_show_tooltips_changed();
public:
    ChoiceEntryLfoWave(const char* labelText);
    gig::lfo_wave_t get_value() const { return value; }
    void set_value(gig::lfo_wave_t value);
    void set_tip(const Glib::ustring& tip_text) {
        combobox.set_tooltip_text(tip_text);
    }
};


class BoolEntry : public LabelWidget {
private:
    Gtk::CheckButton checkbutton;
public:
    BoolEntry(const char* labelText);
    bool get_value() const { return checkbutton.get_active(); }
    void set_value(bool value) { checkbutton.set_active(value); }

    void set_tip(const Glib::ustring& tip_text) {
#ifdef OLD_TOOLTIPS
        tooltips.set_tip(checkbutton, tip_text);
#else
        checkbutton.set_tooltip_text(tip_text);
#endif
    }
};

class BoolBox : public Gtk::CheckButton {
public:
    BoolBox(const char* labelText);
    bool get_value() const { return get_active(); }
    void set_value(bool value) { set_active(value); }
    sigc::signal<void>& signal_value_changed() { return sig_changed; }
protected:
    void on_show_tooltips_changed();

    sigc::signal<void> sig_changed;
};


class BoolEntryPlus6 : public LabelWidget {
private:
    Gtk::CheckButton checkbutton;
    void value_changed();
    NumEntryGain& eGain;
    int32_t plus6value;
protected:
    void on_show_tooltips_changed();
public:
    BoolEntryPlus6(const char* labelText, NumEntryGain& eGain, int32_t plus6value);
    int32_t get_value() const;
    void set_value(int32_t value);
};


class StringEntry : public LabelWidget {
private:
    Gtk::Entry entry;
public:
    StringEntry(const char* labelText);
    gig::String get_value() const;
    void set_value(const gig::String& value);
    void set_width_chars(int n_chars) { entry.set_width_chars(n_chars); }
};

class StringEntryMultiLine : public LabelWidget {
private:
    Gtk::TextView text_view;
    Glib::RefPtr<Gtk::TextBuffer> text_buffer;
    Gtk::Frame frame;
protected:
    void on_show_tooltips_changed();
public:
    StringEntryMultiLine(const char* labelText);
    gig::String get_value() const;
    void set_value(const gig::String& value);
};


/**
 * Container widget for LabelWidgets.
 */
class Table :
#if USE_GTKMM_GRID
    public Gtk::Grid
#else
    public Gtk::Table
#endif
{
public:
    Table(int x, int y);
    void add(BoolEntry& boolentry);
    void add(BoolEntryPlus6& boolentry);
    void add(LabelWidget& labelwidget);
private:
#if USE_GTKMM_GRID
    int cols;
#endif
    int rowno;
};


/**
 * Base class for editor components that use LabelWidgets to edit
 * member variables of the same class. By connecting the widgets to
 * members of the model class, the model is automatically kept
 * updated.
 */
template<class M>
class PropEditor {
public:
    sigc::signal<void>& signal_changed() {
        return sig_changed;
    }
protected:
    M* m;
    int update_model; // to prevent infinite update loops
    PropEditor() : m(0), update_model(0) { }
    sigc::signal<void> sig_changed;

    template<class C, typename T>
    void connect(C& widget, T M::* member) {
        // gcc 4.1.2 needs this temporary variable to resolve the
        // address
        void (PropEditor::*f)(const C* w, T M::* member) =
            &PropEditor::set_member;
        widget.signal_value_changed().connect(
            sigc::bind(sigc::mem_fun(*this, f), &widget, member));

        void (PropEditor::*g)(C* w, T M::* member) =
            &PropEditor::get_member;
        sig.connect(
            sigc::bind(sigc::mem_fun(*this, g), &widget, member));
    }

    template<class C, class S, typename T>
    void connect(C& widget, void (S::*setter)(T)) {
        void (PropEditor::*f)(const C* w, void (S::*setter)(T)) =
            &PropEditor<M>::call_setter;
        widget.signal_value_changed().connect(
            sigc::bind(sigc::mem_fun(*this, f), &widget, setter));
    }

    void connect(NoteEntry& eKeyRangeLow, NoteEntry& eKeyRangeHigh,
                 gig::range_t M::* range) {
        eKeyRangeLow.signal_value_changed().connect(
            sigc::bind(
                sigc::mem_fun(*this, &PropEditor::key_range_low_changed),
                &eKeyRangeLow, &eKeyRangeHigh, range));
        eKeyRangeHigh.signal_value_changed().connect(
            sigc::bind(
                sigc::mem_fun(*this, &PropEditor::key_range_high_changed),
                &eKeyRangeLow, &eKeyRangeHigh, range));
        sig.connect(
            sigc::bind(sigc::mem_fun(*this, &PropEditor::get_key_range),
                       &eKeyRangeLow, &eKeyRangeHigh, range));
    }

    void update(M* m) {
        update_model++;
        this->m = m;
        sig.emit();
        update_model--;
    }

private:
    sigc::signal<void> sig;

    void key_range_low_changed(NoteEntry* eKeyRangeLow,
                               NoteEntry* eKeyRangeHigh,
                               gig::range_t M::* range) {
        if (update_model == 0) {
            uint8_t value = eKeyRangeLow->get_value();
            (m->*range).low = value;
            if (value > (m->*range).high) {
                eKeyRangeHigh->set_value(value);
            }
            sig_changed();
        }
    }

    void key_range_high_changed(NoteEntry* eKeyRangeLow,
                                NoteEntry* eKeyRangeHigh,
                                gig::range_t M::* range) {
        if (update_model == 0) {
            uint8_t value = eKeyRangeHigh->get_value();
            (m->*range).high = value;
            if (value < (m->*range).low) {
                eKeyRangeLow->set_value(value);
            }
            sig_changed();
        }
    }

    template<class C, typename T>
    void set_member(const C* w, T M::* member) {
        if (update_model == 0) {
            m->*member = w->get_value();
            sig_changed();
        }
    }

    template<class C, typename T>
    void get_member(C* w, T M::* member) {
        w->set_value(m->*member);
    }

    void get_key_range(NoteEntry* eKeyRangeLow,
                       NoteEntry* eKeyRangeHigh,
                       gig::range_t M::* range) const {
        eKeyRangeLow->set_value((m->*range).low);
        eKeyRangeHigh->set_value((m->*range).high);
    }

    template<class C, class S, typename T>
    void call_setter(const C* w, void (S::*setter)(T)) {
        if (update_model == 0) {
            (static_cast<S*>(this)->*setter)(w->get_value());
            sig_changed();
        }
    }
};

#endif
1	schoenebeck	1225	/* -- c++ --
2	persson	3462	* Copyright (C) 2006-2019 Andreas Persson
3	schoenebeck	1225	*
4			* This program is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU General Public License as
6			* published by the Free Software Foundation; either version 2, or (at
7			* your option) any later version.
8			*
9			* This program is distributed in the hope that it will be useful, but
10			* WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12			* General Public License for more details.
13			*
14			* You should have received a copy of the GNU General Public License
15			* along with program; see the file COPYING. If not, write to the Free
16			* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
17			* 02110-1301 USA.
18			*/
19
20			#ifndef GIGEDIT_PARAMEDIT_H
21			#define GIGEDIT_PARAMEDIT_H
22
23	schoenebeck	3068	#ifdef LIBGIG_HEADER_FILE
24			# include LIBGIG_HEADER_FILE(gig.h)
25			#else
26			# include <gig.h>
27			#endif
28	schoenebeck	1225
29	persson	2151	#include <cmath>
30	schoenebeck	1300
31	schoenebeck	3364	#include "compat.h"
32
33	persson	2446	#include <glibmm/convert.h>
34	persson	2844	#include <gtkmm/box.h>
35	schoenebeck	1225	#include <gtkmm/adjustment.h>
36	schoenebeck	3364	#if HAS_GTKMM_ALIGNMENT
37			# include <gtkmm/alignment.h>
38			#endif
39	persson	2169	#include <gtkmm/checkbutton.h>
40	schoenebeck	1225	#include <gtkmm/comboboxtext.h>
41	persson	1582	#include <gtkmm/frame.h>
42	schoenebeck	1225	#include <gtkmm/label.h>
43			#include <gtkmm/scale.h>
44			#include <gtkmm/spinbutton.h>
45	schoenebeck	3364	#if USE_GTKMM_GRID
46			# include <gtkmm/grid.h>
47			#else
48			# include <gtkmm/table.h>
49			#endif
50	persson	1582	#include <gtkmm/textview.h>
51	persson	2151
52			#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 12) \|\| GTKMM_MAJOR_VERSION < 2
53			#define OLD_TOOLTIPS
54	schoenebeck	1225	#include <gtkmm/tooltips.h>
55	persson	2151	#endif
56	schoenebeck	1225
57	persson	2507	int note_value(const Glib::ustring& note);
58			Glib::ustring note_str(int note);
59	persson	2446
60	persson	2507	void spin_button_show_notes(Gtk::SpinButton& spin_button);
61
62	schoenebeck	1225	class LabelWidget {
63			public:
64			Gtk::Label label;
65			Gtk::Widget& widget;
66
67			LabelWidget(const char* labelText, Gtk::Widget& widget);
68			void set_sensitive(bool sensitive = true);
69	persson	1460	sigc::signal<void>& signal_value_changed() {
70	persson	1261	return sig_changed;
71			}
72	schoenebeck	1225	protected:
73	schoenebeck	3409	virtual void on_show_tooltips_changed();
74	persson	2151	#ifdef OLD_TOOLTIPS
75	schoenebeck	1225	Gtk::Tooltips tooltips;
76	persson	2151	#endif
77	persson	1261	sigc::signal<void> sig_changed;
78	schoenebeck	1225	};
79
80	schoenebeck	2690	class ReadOnlyLabelWidget : public LabelWidget {
81			public:
82			Gtk::Label text;
83
84			ReadOnlyLabelWidget(const char* leftHandText);
85			ReadOnlyLabelWidget(const char* leftHandText, const char* rightHandText);
86			};
87
88	schoenebeck	1225	class NumEntry : public LabelWidget {
89			protected:
90	persson	2169	#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) \|\| GTKMM_MAJOR_VERSION < 2
91	schoenebeck	1225	Gtk::Adjustment adjust;
92	persson	2169	#else
93			Glib::RefPtr<Gtk::Adjustment> adjust;
94			#endif
95	schoenebeck	3364	HScale scale;
96	schoenebeck	1225	Gtk::SpinButton spinbutton;
97	schoenebeck	3364	HBox box;
98	persson	1261
99	persson	2841	static int round_to_int(double x) {
100	persson	1261	return int(x < 0.0 ? x - 0.5 : x + 0.5);
101			}
102	schoenebeck	3409
103	schoenebeck	1225	public:
104			NumEntry(const char* labelText, double lower = 0, double upper = 127,
105			int decimals = 0);
106			void set_tip(const Glib::ustring& tip_text) {
107	persson	2151	#ifdef OLD_TOOLTIPS
108	schoenebeck	1225	tooltips.set_tip(spinbutton, tip_text);
109	persson	2151	#else
110			spinbutton.set_tooltip_text(tip_text);
111			#endif
112	schoenebeck	1225	}
113			void set_upper(double upper) {
114	persson	2169	#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) \|\| GTKMM_MAJOR_VERSION < 2
115	schoenebeck	1225	adjust.set_upper(upper);
116	persson	2169	#else
117			adjust->set_upper(upper);
118			#endif
119	schoenebeck	1225	}
120	schoenebeck	3409	void on_show_tooltips_changed();
121	schoenebeck	1225	};
122
123			class NumEntryGain : public NumEntry {
124			private:
125	persson	1460	int32_t value;
126	schoenebeck	1225	void value_changed();
127			double coeff;
128	persson	1460	bool connected;
129	schoenebeck	1225	public:
130			NumEntryGain(const char* labelText,
131			double lower, double upper, int decimals, double coeff);
132	persson	1460	int32_t get_value() const { return value; }
133			void set_value(int32_t value);
134	schoenebeck	1225	};
135
136			template<typename T>
137			class NumEntryTemp : public NumEntry {
138			private:
139	persson	1460	T value;
140	schoenebeck	1225	void value_changed();
141			public:
142			NumEntryTemp(const char* labelText,
143			double lower = 0, double upper = 127, int decimals = 0);
144	persson	1460	T get_value() const { return value; }
145			void set_value(T value);
146	schoenebeck	1225	};
147
148			template<typename T>
149			NumEntryTemp<T>::NumEntryTemp(const char* labelText,
150			double lower, double upper, int decimals) :
151	persson	1460	NumEntry(labelText, lower, upper, decimals),
152			value(0)
153	schoenebeck	1225	{
154			spinbutton.signal_value_changed().connect(
155			sigc::mem_fun(*this, &NumEntryTemp::value_changed));
156			}
157
158			template<typename T>
159			void NumEntryTemp<T>::value_changed()
160			{
161	schoenebeck	1359	const double f = pow(10, spinbutton.get_digits());
162			int new_value = round_to_int(spinbutton.get_value() * f);
163	persson	1460	if (new_value != round_to_int(value * f)) {
164			value = T(new_value / f);
165			sig_changed();
166	schoenebeck	1225	}
167			}
168
169			template<typename T>
170	persson	1460	void NumEntryTemp<T>::set_value(T value)
171	schoenebeck	1225	{
172	persson	2169	#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) \|\| GTKMM_MAJOR_VERSION < 2
173	persson	1460	if (value > adjust.get_upper()) value = T(adjust.get_upper());
174	persson	2169	#else
175			if (value > adjust->get_upper()) value = T(adjust->get_upper());
176			#endif
177	persson	1460	if (this->value != value) {
178			this->value = value;
179			const double f = pow(10, spinbutton.get_digits());
180			if (round_to_int(spinbutton.get_value() * f) != round_to_int(value * f)) {
181			spinbutton.set_value(value);
182			}
183			sig_changed();
184			}
185	schoenebeck	1225	}
186
187
188			class NoteEntry : public NumEntryTemp<uint8_t> {
189			public:
190			NoteEntry(const char* labelText);
191			private:
192			int on_input(double* new_value);
193			bool on_output();
194			};
195
196
197			class NumEntryPermille : public NumEntry {
198			private:
199	persson	1460	uint16_t value;
200	schoenebeck	1225	void value_changed();
201			public:
202			NumEntryPermille(const char* labelText,
203			double lower = 0, double upper = 127, int decimals = 0);
204	persson	1460	uint16_t get_value() const { return value; }
205			void set_value(uint16_t value);
206	schoenebeck	1225	};
207
208	schoenebeck	3409	class ChoiceEntryBase : public LabelWidget {
209			protected:
210			ChoiceEntryBase(const char* labelText, Gtk::Widget& widget) : LabelWidget(labelText, widget) {};
211			Gtk::ComboBoxText combobox;
212			void on_show_tooltips_changed();
213			};
214	schoenebeck	1225
215			template<typename T>
216	schoenebeck	3409	class ChoiceEntry : public ChoiceEntryBase {
217	schoenebeck	1225	private:
218	schoenebeck	3364	#if HAS_GTKMM_ALIGNMENT
219	schoenebeck	1225	Gtk::Alignment align;
220	schoenebeck	3364	#endif
221	schoenebeck	1225	const T* values;
222			public:
223			ChoiceEntry(const char* labelText);
224	persson	1460	T get_value() const;
225			void set_value(T value);
226	schoenebeck	1225	void set_choices(const char** texts, const T* values);
227	persson	1460
228	schoenebeck	1225	void set_tip(const Glib::ustring& tip_text) {
229	persson	2151	#ifdef OLD_TOOLTIPS
230			tooltips.set_tip(combobox, tip_text);
231			#else
232			combobox.set_tooltip_text(tip_text);
233			#endif
234	schoenebeck	1225	}
235			};
236
237			template<typename T>
238			ChoiceEntry<T>::ChoiceEntry(const char* labelText) :
239	schoenebeck	3364	#if HAS_GTKMM_ALIGNMENT
240	schoenebeck	3409	ChoiceEntryBase(labelText, align),
241	persson	2507	align(0, 0, 0, 0),
242	schoenebeck	3364	#else
243	schoenebeck	3409	ChoiceEntryBase(labelText, combobox),
244	schoenebeck	3364	#endif
245	persson	2507	values(0)
246	schoenebeck	1225	{
247	persson	1460	combobox.signal_changed().connect(sig_changed.make_slot());
248	schoenebeck	3364	#if HAS_GTKMM_ALIGNMENT
249	schoenebeck	1225	align.add(combobox);
250	schoenebeck	3364	#endif
251	schoenebeck	1225	}
252
253			template<typename T>
254			void ChoiceEntry<T>::set_choices(const char** texts, const T* values)
255			{
256	persson	3462	#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 24) \|\| GTKMM_MAJOR_VERSION < 2
257			combobox.clear_items();
258	schoenebeck	1225	for (int i = 0 ; texts[i] ; i++) {
259			combobox.append_text(texts[i]);
260	persson	3462	}
261	persson	2169	#else
262	persson	3462	combobox.remove_all();
263			for (int i = 0 ; texts[i] ; i++) {
264	persson	2169	combobox.append(texts[i]);
265	persson	3462	}
266	persson	2169	#endif
267	schoenebeck	1225	this->values = values;
268			}
269
270			template<typename T>
271	persson	1460	T ChoiceEntry<T>::get_value() const
272	schoenebeck	1225	{
273	schoenebeck	1359	int rowno = combobox.get_active_row_number();
274	persson	1460	return values[rowno];
275	schoenebeck	1225	}
276
277			template<typename T>
278	persson	1460	void ChoiceEntry<T>::set_value(T value)
279	schoenebeck	1225	{
280	persson	1460	int row = 0;
281			int nb_rows = combobox.get_model()->children().size();
282			for (; row < nb_rows ; row++) {
283			if (value == values[row]) break;
284			}
285			combobox.set_active(row == nb_rows ? -1 : row);
286	schoenebeck	1225	}
287
288
289			class ChoiceEntryLeverageCtrl : public LabelWidget {
290			private:
291	persson	1460	gig::leverage_ctrl_t value;
292	schoenebeck	1225	Gtk::ComboBoxText combobox;
293	schoenebeck	3364	#if HAS_GTKMM_ALIGNMENT
294	schoenebeck	1225	Gtk::Alignment align;
295	schoenebeck	3364	#endif
296	schoenebeck	1225	void value_changed();
297	schoenebeck	3409	protected:
298			void on_show_tooltips_changed();
299	schoenebeck	1225	public:
300			ChoiceEntryLeverageCtrl(const char* labelText);
301	persson	1460	gig::leverage_ctrl_t get_value() const { return value; }
302			void set_value(gig::leverage_ctrl_t value);
303	schoenebeck	2566	void set_tip(const Glib::ustring& tip_text) {
304			combobox.set_tooltip_text(tip_text);
305			}
306	schoenebeck	1225	};
307
308	schoenebeck	3624	class ChoiceEntryLfoWave : public LabelWidget {
309			private:
310			gig::lfo_wave_t value;
311			Gtk::ComboBoxText combobox;
312			#if HAS_GTKMM_ALIGNMENT
313			Gtk::Alignment align;
314			#endif
315			void value_changed();
316			protected:
317			void on_show_tooltips_changed();
318			public:
319			ChoiceEntryLfoWave(const char* labelText);
320			gig::lfo_wave_t get_value() const { return value; }
321			void set_value(gig::lfo_wave_t value);
322			void set_tip(const Glib::ustring& tip_text) {
323			combobox.set_tooltip_text(tip_text);
324			}
325			};
326	schoenebeck	1225
327	schoenebeck	3624
328	schoenebeck	1225	class BoolEntry : public LabelWidget {
329			private:
330			Gtk::CheckButton checkbutton;
331			public:
332			BoolEntry(const char* labelText);
333	persson	1460	bool get_value() const { return checkbutton.get_active(); }
334			void set_value(bool value) { checkbutton.set_active(value); }
335
336	schoenebeck	1225	void set_tip(const Glib::ustring& tip_text) {
337	persson	2151	#ifdef OLD_TOOLTIPS
338	schoenebeck	1225	tooltips.set_tip(checkbutton, tip_text);
339	persson	2151	#else
340			checkbutton.set_tooltip_text(tip_text);
341			#endif
342	schoenebeck	1225	}
343			};
344
345	schoenebeck	3329	class BoolBox : public Gtk::CheckButton {
346			public:
347	schoenebeck	3409	BoolBox(const char* labelText);
348	schoenebeck	3329	bool get_value() const { return get_active(); }
349			void set_value(bool value) { set_active(value); }
350			sigc::signal<void>& signal_value_changed() { return sig_changed; }
351			protected:
352	schoenebeck	3409	void on_show_tooltips_changed();
353
354	schoenebeck	3329	sigc::signal<void> sig_changed;
355			};
356	schoenebeck	1225
357	schoenebeck	3329
358	schoenebeck	1225	class BoolEntryPlus6 : public LabelWidget {
359			private:
360			Gtk::CheckButton checkbutton;
361			void value_changed();
362			NumEntryGain& eGain;
363			int32_t plus6value;
364	schoenebeck	3409	protected:
365			void on_show_tooltips_changed();
366	schoenebeck	1225	public:
367			BoolEntryPlus6(const char* labelText, NumEntryGain& eGain, int32_t plus6value);
368	persson	1460	int32_t get_value() const;
369			void set_value(int32_t value);
370	schoenebeck	1225	};
371
372	persson	2446
373	schoenebeck	1225	class StringEntry : public LabelWidget {
374			private:
375			Gtk::Entry entry;
376			public:
377			StringEntry(const char* labelText);
378	persson	2446	gig::String get_value() const;
379			void set_value(const gig::String& value);
380	persson	1582	void set_width_chars(int n_chars) { entry.set_width_chars(n_chars); }
381	schoenebeck	1225	};
382
383	persson	1582	class StringEntryMultiLine : public LabelWidget {
384			private:
385			Gtk::TextView text_view;
386			Glib::RefPtr<Gtk::TextBuffer> text_buffer;
387			Gtk::Frame frame;
388	schoenebeck	3409	protected:
389			void on_show_tooltips_changed();
390	persson	1582	public:
391			StringEntryMultiLine(const char* labelText);
392			gig::String get_value() const;
393	persson	2446	void set_value(const gig::String& value);
394	persson	1582	};
395	schoenebeck	1225
396	persson	1582
397	persson	2423	/**
398			* Container widget for LabelWidgets.
399			*/
400	schoenebeck	3364	class Table :
401			#if USE_GTKMM_GRID
402			public Gtk::Grid
403			#else
404			public Gtk::Table
405			#endif
406	persson	2423	{
407			public:
408			Table(int x, int y);
409			void add(BoolEntry& boolentry);
410			void add(BoolEntryPlus6& boolentry);
411			void add(LabelWidget& labelwidget);
412			private:
413	schoenebeck	3364	#if USE_GTKMM_GRID
414			int cols;
415			#endif
416	persson	2423	int rowno;
417			};
418
419
420			/**
421			* Base class for editor components that use LabelWidgets to edit
422			* member variables of the same class. By connecting the widgets to
423			* members of the model class, the model is automatically kept
424			* updated.
425			*/
426			template<class M>
427			class PropEditor {
428			public:
429			sigc::signal<void>& signal_changed() {
430			return sig_changed;
431			}
432			protected:
433			M* m;
434			int update_model; // to prevent infinite update loops
435	persson	2507	PropEditor() : m(0), update_model(0) { }
436	persson	2423	sigc::signal<void> sig_changed;
437
438			template<class C, typename T>
439			void connect(C& widget, T M::* member) {
440			// gcc 4.1.2 needs this temporary variable to resolve the
441			// address
442			void (PropEditor::f)(const C w, T M::* member) =
443			&PropEditor::set_member;
444			widget.signal_value_changed().connect(
445			sigc::bind(sigc::mem_fun(*this, f), &widget, member));
446
447			void (PropEditor::g)(C w, T M::* member) =
448			&PropEditor::get_member;
449			sig.connect(
450			sigc::bind(sigc::mem_fun(*this, g), &widget, member));
451			}
452
453			template<class C, class S, typename T>
454			void connect(C& widget, void (S::*setter)(T)) {
455			void (PropEditor::f)(const C w, void (S::*setter)(T)) =
456			&PropEditor<M>::call_setter;
457			widget.signal_value_changed().connect(
458			sigc::bind(sigc::mem_fun(*this, f), &widget, setter));
459			}
460
461			void connect(NoteEntry& eKeyRangeLow, NoteEntry& eKeyRangeHigh,
462			gig::range_t M::* range) {
463			eKeyRangeLow.signal_value_changed().connect(
464			sigc::bind(
465			sigc::mem_fun(*this, &PropEditor::key_range_low_changed),
466			&eKeyRangeLow, &eKeyRangeHigh, range));
467			eKeyRangeHigh.signal_value_changed().connect(
468			sigc::bind(
469			sigc::mem_fun(*this, &PropEditor::key_range_high_changed),
470			&eKeyRangeLow, &eKeyRangeHigh, range));
471			sig.connect(
472			sigc::bind(sigc::mem_fun(*this, &PropEditor::get_key_range),
473			&eKeyRangeLow, &eKeyRangeHigh, range));
474			}
475
476			void update(M* m) {
477			update_model++;
478			this->m = m;
479			sig.emit();
480			update_model--;
481			}
482
483			private:
484			sigc::signal<void> sig;
485
486			void key_range_low_changed(NoteEntry* eKeyRangeLow,
487			NoteEntry* eKeyRangeHigh,
488			gig::range_t M::* range) {
489			if (update_model == 0) {
490			uint8_t value = eKeyRangeLow->get_value();
491			(m->*range).low = value;
492			if (value > (m->*range).high) {
493			eKeyRangeHigh->set_value(value);
494			}
495			sig_changed();
496			}
497			}
498
499			void key_range_high_changed(NoteEntry* eKeyRangeLow,
500			NoteEntry* eKeyRangeHigh,
501			gig::range_t M::* range) {
502			if (update_model == 0) {
503			uint8_t value = eKeyRangeHigh->get_value();
504			(m->*range).high = value;
505			if (value < (m->*range).low) {
506			eKeyRangeLow->set_value(value);
507			}
508			sig_changed();
509			}
510			}
511
512			template<class C, typename T>
513			void set_member(const C* w, T M::* member) {
514			if (update_model == 0) {
515			m->*member = w->get_value();
516			sig_changed();
517			}
518			}
519
520			template<class C, typename T>
521			void get_member(C* w, T M::* member) {
522			w->set_value(m->*member);
523			}
524
525			void get_key_range(NoteEntry* eKeyRangeLow,
526			NoteEntry* eKeyRangeHigh,
527	persson	2841	gig::range_t M::* range) const {
528	persson	2423	eKeyRangeLow->set_value((m->*range).low);
529			eKeyRangeHigh->set_value((m->*range).high);
530			}
531
532			template<class C, class S, typename T>
533			void call_setter(const C* w, void (S::*setter)(T)) {
534			if (update_model == 0) {
535			(static_cast<S>(this)->setter)(w->get_value());
536			sig_changed();
537			}
538			}
539			};
540
541	schoenebeck	1225	#endif