src/gigedit/paramedit.h

/*                                                         -*- c++ -*-
 * Copyright (C) 2006-2017 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)
{
    combobox.remove_all();
    for (int i = 0 ; texts[i] ; i++) {
#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 24) || GTKMM_MAJOR_VERSION < 2
        combobox.append_text(texts[i]);
#else
        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 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	/* -- c++ --
2	* Copyright (C) 2006-2017 Andreas Persson
3	*
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	#ifdef LIBGIG_HEADER_FILE
24	# include LIBGIG_HEADER_FILE(gig.h)
25	#else
26	# include <gig.h>
27	#endif
28
29	#include <cmath>
30
31	#include "compat.h"
32
33	#include <glibmm/convert.h>
34	#include <gtkmm/box.h>
35	#include <gtkmm/adjustment.h>
36	#if HAS_GTKMM_ALIGNMENT
37	# include <gtkmm/alignment.h>
38	#endif
39	#include <gtkmm/checkbutton.h>
40	#include <gtkmm/comboboxtext.h>
41	#include <gtkmm/frame.h>
42	#include <gtkmm/label.h>
43	#include <gtkmm/scale.h>
44	#include <gtkmm/spinbutton.h>
45	#if USE_GTKMM_GRID
46	# include <gtkmm/grid.h>
47	#else
48	# include <gtkmm/table.h>
49	#endif
50	#include <gtkmm/textview.h>
51
52	#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 12) \|\| GTKMM_MAJOR_VERSION < 2
53	#define OLD_TOOLTIPS
54	#include <gtkmm/tooltips.h>
55	#endif
56
57	int note_value(const Glib::ustring& note);
58	Glib::ustring note_str(int note);
59
60	void spin_button_show_notes(Gtk::SpinButton& spin_button);
61
62	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	sigc::signal<void>& signal_value_changed() {
70	return sig_changed;
71	}
72	protected:
73	virtual void on_show_tooltips_changed();
74	#ifdef OLD_TOOLTIPS
75	Gtk::Tooltips tooltips;
76	#endif
77	sigc::signal<void> sig_changed;
78	};
79
80	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	class NumEntry : public LabelWidget {
89	protected:
90	#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) \|\| GTKMM_MAJOR_VERSION < 2
91	Gtk::Adjustment adjust;
92	#else
93	Glib::RefPtr<Gtk::Adjustment> adjust;
94	#endif
95	HScale scale;
96	Gtk::SpinButton spinbutton;
97	HBox box;
98
99	static int round_to_int(double x) {
100	return int(x < 0.0 ? x - 0.5 : x + 0.5);
101	}
102
103	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	#ifdef OLD_TOOLTIPS
108	tooltips.set_tip(spinbutton, tip_text);
109	#else
110	spinbutton.set_tooltip_text(tip_text);
111	#endif
112	}
113	void set_upper(double upper) {
114	#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) \|\| GTKMM_MAJOR_VERSION < 2
115	adjust.set_upper(upper);
116	#else
117	adjust->set_upper(upper);
118	#endif
119	}
120	void on_show_tooltips_changed();
121	};
122
123	class NumEntryGain : public NumEntry {
124	private:
125	int32_t value;
126	void value_changed();
127	double coeff;
128	bool connected;
129	public:
130	NumEntryGain(const char* labelText,
131	double lower, double upper, int decimals, double coeff);
132	int32_t get_value() const { return value; }
133	void set_value(int32_t value);
134	};
135
136	template<typename T>
137	class NumEntryTemp : public NumEntry {
138	private:
139	T value;
140	void value_changed();
141	public:
142	NumEntryTemp(const char* labelText,
143	double lower = 0, double upper = 127, int decimals = 0);
144	T get_value() const { return value; }
145	void set_value(T value);
146	};
147
148	template<typename T>
149	NumEntryTemp<T>::NumEntryTemp(const char* labelText,
150	double lower, double upper, int decimals) :
151	NumEntry(labelText, lower, upper, decimals),
152	value(0)
153	{
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	const double f = pow(10, spinbutton.get_digits());
162	int new_value = round_to_int(spinbutton.get_value() * f);
163	if (new_value != round_to_int(value * f)) {
164	value = T(new_value / f);
165	sig_changed();
166	}
167	}
168
169	template<typename T>
170	void NumEntryTemp<T>::set_value(T value)
171	{
172	#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) \|\| GTKMM_MAJOR_VERSION < 2
173	if (value > adjust.get_upper()) value = T(adjust.get_upper());
174	#else
175	if (value > adjust->get_upper()) value = T(adjust->get_upper());
176	#endif
177	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	}
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	uint16_t value;
200	void value_changed();
201	public:
202	NumEntryPermille(const char* labelText,
203	double lower = 0, double upper = 127, int decimals = 0);
204	uint16_t get_value() const { return value; }
205	void set_value(uint16_t value);
206	};
207
208	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
215	template<typename T>
216	class ChoiceEntry : public ChoiceEntryBase {
217	private:
218	#if HAS_GTKMM_ALIGNMENT
219	Gtk::Alignment align;
220	#endif
221	const T* values;
222	public:
223	ChoiceEntry(const char* labelText);
224	T get_value() const;
225	void set_value(T value);
226	void set_choices(const char** texts, const T* values);
227
228	void set_tip(const Glib::ustring& tip_text) {
229	#ifdef OLD_TOOLTIPS
230	tooltips.set_tip(combobox, tip_text);
231	#else
232	combobox.set_tooltip_text(tip_text);
233	#endif
234	}
235	};
236
237	template<typename T>
238	ChoiceEntry<T>::ChoiceEntry(const char* labelText) :
239	#if HAS_GTKMM_ALIGNMENT
240	ChoiceEntryBase(labelText, align),
241	align(0, 0, 0, 0),
242	#else
243	ChoiceEntryBase(labelText, combobox),
244	#endif
245	values(0)
246	{
247	combobox.signal_changed().connect(sig_changed.make_slot());
248	#if HAS_GTKMM_ALIGNMENT
249	align.add(combobox);
250	#endif
251	}
252
253	template<typename T>
254	void ChoiceEntry<T>::set_choices(const char** texts, const T* values)
255	{
256	combobox.remove_all();
257	for (int i = 0 ; texts[i] ; i++) {
258	#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 24) \|\| GTKMM_MAJOR_VERSION < 2
259	combobox.append_text(texts[i]);
260	#else
261	combobox.append(texts[i]);
262	#endif
263	}
264	this->values = values;
265	}
266
267	template<typename T>
268	T ChoiceEntry<T>::get_value() const
269	{
270	int rowno = combobox.get_active_row_number();
271	return values[rowno];
272	}
273
274	template<typename T>
275	void ChoiceEntry<T>::set_value(T value)
276	{
277	int row = 0;
278	int nb_rows = combobox.get_model()->children().size();
279	for (; row < nb_rows ; row++) {
280	if (value == values[row]) break;
281	}
282	combobox.set_active(row == nb_rows ? -1 : row);
283	}
284
285
286	class ChoiceEntryLeverageCtrl : public LabelWidget {
287	private:
288	gig::leverage_ctrl_t value;
289	Gtk::ComboBoxText combobox;
290	#if HAS_GTKMM_ALIGNMENT
291	Gtk::Alignment align;
292	#endif
293	void value_changed();
294	protected:
295	void on_show_tooltips_changed();
296	public:
297	ChoiceEntryLeverageCtrl(const char* labelText);
298	gig::leverage_ctrl_t get_value() const { return value; }
299	void set_value(gig::leverage_ctrl_t value);
300	void set_tip(const Glib::ustring& tip_text) {
301	combobox.set_tooltip_text(tip_text);
302	}
303	};
304
305
306	class BoolEntry : public LabelWidget {
307	private:
308	Gtk::CheckButton checkbutton;
309	public:
310	BoolEntry(const char* labelText);
311	bool get_value() const { return checkbutton.get_active(); }
312	void set_value(bool value) { checkbutton.set_active(value); }
313
314	void set_tip(const Glib::ustring& tip_text) {
315	#ifdef OLD_TOOLTIPS
316	tooltips.set_tip(checkbutton, tip_text);
317	#else
318	checkbutton.set_tooltip_text(tip_text);
319	#endif
320	}
321	};
322
323	class BoolBox : public Gtk::CheckButton {
324	public:
325	BoolBox(const char* labelText);
326	bool get_value() const { return get_active(); }
327	void set_value(bool value) { set_active(value); }
328	sigc::signal<void>& signal_value_changed() { return sig_changed; }
329	protected:
330	void on_show_tooltips_changed();
331
332	sigc::signal<void> sig_changed;
333	};
334
335
336	class BoolEntryPlus6 : public LabelWidget {
337	private:
338	Gtk::CheckButton checkbutton;
339	void value_changed();
340	NumEntryGain& eGain;
341	int32_t plus6value;
342	protected:
343	void on_show_tooltips_changed();
344	public:
345	BoolEntryPlus6(const char* labelText, NumEntryGain& eGain, int32_t plus6value);
346	int32_t get_value() const;
347	void set_value(int32_t value);
348	};
349
350
351	class StringEntry : public LabelWidget {
352	private:
353	Gtk::Entry entry;
354	public:
355	StringEntry(const char* labelText);
356	gig::String get_value() const;
357	void set_value(const gig::String& value);
358	void set_width_chars(int n_chars) { entry.set_width_chars(n_chars); }
359	};
360
361	class StringEntryMultiLine : public LabelWidget {
362	private:
363	Gtk::TextView text_view;
364	Glib::RefPtr<Gtk::TextBuffer> text_buffer;
365	Gtk::Frame frame;
366	protected:
367	void on_show_tooltips_changed();
368	public:
369	StringEntryMultiLine(const char* labelText);
370	gig::String get_value() const;
371	void set_value(const gig::String& value);
372	};
373
374
375	/**
376	* Container widget for LabelWidgets.
377	*/
378	class Table :
379	#if USE_GTKMM_GRID
380	public Gtk::Grid
381	#else
382	public Gtk::Table
383	#endif
384	{
385	public:
386	Table(int x, int y);
387	void add(BoolEntry& boolentry);
388	void add(BoolEntryPlus6& boolentry);
389	void add(LabelWidget& labelwidget);
390	private:
391	#if USE_GTKMM_GRID
392	int cols;
393	#endif
394	int rowno;
395	};
396
397
398	/**
399	* Base class for editor components that use LabelWidgets to edit
400	* member variables of the same class. By connecting the widgets to
401	* members of the model class, the model is automatically kept
402	* updated.
403	*/
404	template<class M>
405	class PropEditor {
406	public:
407	sigc::signal<void>& signal_changed() {
408	return sig_changed;
409	}
410	protected:
411	M* m;
412	int update_model; // to prevent infinite update loops
413	PropEditor() : m(0), update_model(0) { }
414	sigc::signal<void> sig_changed;
415
416	template<class C, typename T>
417	void connect(C& widget, T M::* member) {
418	// gcc 4.1.2 needs this temporary variable to resolve the
419	// address
420	void (PropEditor::f)(const C w, T M::* member) =
421	&PropEditor::set_member;
422	widget.signal_value_changed().connect(
423	sigc::bind(sigc::mem_fun(*this, f), &widget, member));
424
425	void (PropEditor::g)(C w, T M::* member) =
426	&PropEditor::get_member;
427	sig.connect(
428	sigc::bind(sigc::mem_fun(*this, g), &widget, member));
429	}
430
431	template<class C, class S, typename T>
432	void connect(C& widget, void (S::*setter)(T)) {
433	void (PropEditor::f)(const C w, void (S::*setter)(T)) =
434	&PropEditor<M>::call_setter;
435	widget.signal_value_changed().connect(
436	sigc::bind(sigc::mem_fun(*this, f), &widget, setter));
437	}
438
439	void connect(NoteEntry& eKeyRangeLow, NoteEntry& eKeyRangeHigh,
440	gig::range_t M::* range) {
441	eKeyRangeLow.signal_value_changed().connect(
442	sigc::bind(
443	sigc::mem_fun(*this, &PropEditor::key_range_low_changed),
444	&eKeyRangeLow, &eKeyRangeHigh, range));
445	eKeyRangeHigh.signal_value_changed().connect(
446	sigc::bind(
447	sigc::mem_fun(*this, &PropEditor::key_range_high_changed),
448	&eKeyRangeLow, &eKeyRangeHigh, range));
449	sig.connect(
450	sigc::bind(sigc::mem_fun(*this, &PropEditor::get_key_range),
451	&eKeyRangeLow, &eKeyRangeHigh, range));
452	}
453
454	void update(M* m) {
455	update_model++;
456	this->m = m;
457	sig.emit();
458	update_model--;
459	}
460
461	private:
462	sigc::signal<void> sig;
463
464	void key_range_low_changed(NoteEntry* eKeyRangeLow,
465	NoteEntry* eKeyRangeHigh,
466	gig::range_t M::* range) {
467	if (update_model == 0) {
468	uint8_t value = eKeyRangeLow->get_value();
469	(m->*range).low = value;
470	if (value > (m->*range).high) {
471	eKeyRangeHigh->set_value(value);
472	}
473	sig_changed();
474	}
475	}
476
477	void key_range_high_changed(NoteEntry* eKeyRangeLow,
478	NoteEntry* eKeyRangeHigh,
479	gig::range_t M::* range) {
480	if (update_model == 0) {
481	uint8_t value = eKeyRangeHigh->get_value();
482	(m->*range).high = value;
483	if (value < (m->*range).low) {
484	eKeyRangeLow->set_value(value);
485	}
486	sig_changed();
487	}
488	}
489
490	template<class C, typename T>
491	void set_member(const C* w, T M::* member) {
492	if (update_model == 0) {
493	m->*member = w->get_value();
494	sig_changed();
495	}
496	}
497
498	template<class C, typename T>
499	void get_member(C* w, T M::* member) {
500	w->set_value(m->*member);
501	}
502
503	void get_key_range(NoteEntry* eKeyRangeLow,
504	NoteEntry* eKeyRangeHigh,
505	gig::range_t M::* range) const {
506	eKeyRangeLow->set_value((m->*range).low);
507	eKeyRangeHigh->set_value((m->*range).high);
508	}
509
510	template<class C, class S, typename T>
511	void call_setter(const C* w, void (S::*setter)(T)) {
512	if (update_model == 0) {
513	(static_cast<S>(this)->setter)(w->get_value());
514	sig_changed();
515	}
516	}
517	};
518
519	#endif