trunk/src/paramedit.h

/*                                                         -*- c++ -*-
 * Copyright (C) 2006, 2007 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

#include <gig.h>

#include <gtkmm/adjustment.h>
#include <gtkmm/alignment.h>
#include <gtkmm/box.h>
#include <gtkmm/comboboxtext.h>
#include <gtkmm/label.h>
#include <gtkmm/scale.h>
#include <gtkmm/spinbutton.h>

extern bool update_gui;

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

    LabelWidget(char* labelText, Gtk::Widget& widget);
    void set_sensitive(bool sensitive = true);
};

template<typename T2>
class NumEntry : public LabelWidget {
protected:
    Gtk::Adjustment adjust;
    Gtk::HScale scale;
    Gtk::SpinButton spinbutton;
    Gtk::HBox box;
    T2* dimreg;
public:
    NumEntry(char* labelText, double lower = 0, double upper = 127,
             int decimals = 0);
    void set_value(double value) {
        spinbutton.set_value(value);
    }
    Glib::SignalProxy0<void> signal_value_changed() {
        return spinbutton.signal_value_changed();
    }
    double get_value() const {
        return spinbutton.get_value();
    }
};

template<typename T2>
NumEntry<T2>::NumEntry(char* labelText, double lower, double upper,
                       int decimals) :
    adjust(lower, lower, upper, 1, 10),
    scale(adjust),
    spinbutton(adjust),
    LabelWidget(labelText, box)
{
    spinbutton.set_digits(decimals);
    scale.set_draw_value(false);
    box.pack_start(spinbutton, Gtk::PACK_SHRINK);
    box.add(scale);
}

class NumEntryGain : public NumEntry<gig::DimensionRegion> {
private:
    void value_changed();
public:
    NumEntryGain(char* labelText,
                 double lower, double upper, int decimals);
    void set_dimreg(gig::DimensionRegion* dimreg);
};

template<typename T>
class NumEntryX : public NumEntry<gig::DimensionRegion> {
private:
    T& (*access)(gig::DimensionRegion*);
    void value_changed();
public:
    NumEntryX(char* labelText, T& (*access)(gig::DimensionRegion*),
              double lower = 0, double upper = 127, int decimals = 0);
    void set_dimreg(gig::DimensionRegion* dimreg);
};

template<typename T>
NumEntryX<T>::NumEntryX(char* labelText, T& (*access)(gig::DimensionRegion*),
                        double lower, double upper, int decimals) :
    NumEntry<gig::DimensionRegion>(labelText, lower, upper, decimals),
    access(access)
{
    spinbutton.signal_value_changed().connect(
        sigc::mem_fun(*this, &NumEntryX::value_changed));
}

template<typename T>
void NumEntryX<T>::value_changed()
{
    if (dimreg && update_gui) {
        access(dimreg) = T(spinbutton.get_value());
    }
}

template<typename T>
void NumEntryX<T>::set_dimreg(gig::DimensionRegion* dimreg)
{
    this->dimreg = 0;
    set_value(access(dimreg));
    this->dimreg = dimreg;
}


class NoteEntry : public NumEntryX<uint8_t> {
public:
    NoteEntry(char* labelText, uint8_t& (*access)(gig::DimensionRegion*));
private:
    int on_input(double* new_value);
    bool on_output();
};


template<typename T, typename T2 = gig::DimensionRegion>
class NumEntryTemp : public NumEntry<T2> {
    using NumEntry<T2>::spinbutton;
    using NumEntry<T2>::dimreg;
private:
    T T2::* param;
    void value_changed();
public:
    NumEntryTemp(char* labelText, T T2::* param,
                 double lower = 0, double upper = 127, int decimals = 0);
    void set_dimreg(gig::DimensionRegion* dimreg);
};

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

template<typename T, typename T2>
void NumEntryTemp<T, T2>::value_changed()
{
    if (dimreg && update_gui) {
        dimreg->*param = T(spinbutton.get_value());
    }
}

template<typename T, typename T2>
void NumEntryTemp<T, T2>::set_dimreg(gig::DimensionRegion* dimreg)
{
    this->dimreg = 0;
    set_value(dimreg->*param);
    this->dimreg = dimreg;
}


class NumEntryPermille : public NumEntry<gig::DimensionRegion> {
private:
    uint16_t gig::DimensionRegion::* param;
    void value_changed();
public:
    NumEntryPermille(char* labelText, uint16_t gig::DimensionRegion::* param,
                     double lower = 0, double upper = 127, int decimals = 0);
    void set_dimreg(gig::DimensionRegion* dimreg);
};


template<typename T>
class ChoiceEntry : public LabelWidget {
private:
    Gtk::ComboBoxText combobox;
    Gtk::Alignment align;
    T gig::DimensionRegion::* param;
    gig::DimensionRegion* dimreg;
    void value_changed();
    const T* values;
public:
    ChoiceEntry(char* labelText,
                T gig::DimensionRegion::* param);
    void set_choices(char** texts, const T* values);
    void set_dimreg(gig::DimensionRegion* dimreg);
    int get_active_row_number() { return combobox.get_active_row_number(); }
    Glib::SignalProxy0<void> signal_changed() {
        return combobox.signal_changed();
    }
};

template<typename T>
ChoiceEntry<T>::ChoiceEntry(char* labelText,
                            T gig::DimensionRegion::* param) :
    align(0, 0, 0, 0),
    LabelWidget(labelText, align),
    param(param)
{
    combobox.signal_changed().connect(
        sigc::mem_fun(*this, &ChoiceEntry::value_changed));
    align.add(combobox);
}

template<typename T>
void ChoiceEntry<T>::set_choices(char** texts, const T* values)
{
    for (int i = 0 ; texts[i] ; i++) {
        combobox.append_text(texts[i]);
    }
    this->values = values;
}

template<typename T>
void ChoiceEntry<T>::value_changed()
{
    if (dimreg && update_gui) {
        int rowno = combobox.get_active_row_number();
        if (rowno != -1) dimreg->*param = values[rowno];
    }
}

template<typename T>
void ChoiceEntry<T>::set_dimreg(gig::DimensionRegion* dimreg)
{
    this->dimreg = 0;
    T value = dimreg->*param;
    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);
    this->dimreg = dimreg;
}


class ChoiceEntryLeverageCtrl : public LabelWidget {
private:
    Gtk::ComboBoxText combobox;
    Gtk::Alignment align;
    gig::leverage_ctrl_t gig::DimensionRegion::* param;
    gig::DimensionRegion* dimreg;
    void value_changed();
public:
    ChoiceEntryLeverageCtrl(char* labelText,
                            gig::leverage_ctrl_t gig::DimensionRegion::* param);
    void set_dimreg(gig::DimensionRegion* dimreg);
    int get_active_row_number() { return combobox.get_active_row_number(); }
    Glib::SignalProxy0<void> signal_changed() {
        return combobox.signal_changed();
    }
};


class BoolEntry : public LabelWidget {
private:
    Gtk::CheckButton checkbutton;
    bool gig::DimensionRegion::* param;
    gig::DimensionRegion* dimreg;
    void value_changed();
public:
    BoolEntry(char* labelText, bool gig::DimensionRegion::* param);
    void set_dimreg(gig::DimensionRegion* dimreg);
    bool get_active() { return checkbutton.get_active(); }
    Glib::SignalProxy0<void> signal_toggled() {
        return checkbutton.signal_toggled();
    }
};

#endif
1	persson	1100	/* -- c++ --
2			* Copyright (C) 2006, 2007 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			#include <gig.h>
24
25			#include <gtkmm/adjustment.h>
26			#include <gtkmm/alignment.h>
27			#include <gtkmm/box.h>
28			#include <gtkmm/comboboxtext.h>
29			#include <gtkmm/label.h>
30			#include <gtkmm/scale.h>
31			#include <gtkmm/spinbutton.h>
32
33			extern bool update_gui;
34
35			class LabelWidget {
36			public:
37			Gtk::Label label;
38			Gtk::Widget& widget;
39
40			LabelWidget(char* labelText, Gtk::Widget& widget);
41			void set_sensitive(bool sensitive = true);
42			};
43
44			template<typename T2>
45			class NumEntry : public LabelWidget {
46			protected:
47			Gtk::Adjustment adjust;
48			Gtk::HScale scale;
49			Gtk::SpinButton spinbutton;
50			Gtk::HBox box;
51			T2* dimreg;
52			public:
53			NumEntry(char* labelText, double lower = 0, double upper = 127,
54			int decimals = 0);
55			void set_value(double value) {
56			spinbutton.set_value(value);
57			}
58			Glib::SignalProxy0<void> signal_value_changed() {
59			return spinbutton.signal_value_changed();
60			}
61			double get_value() const {
62			return spinbutton.get_value();
63			}
64			};
65
66			template<typename T2>
67			NumEntry<T2>::NumEntry(char* labelText, double lower, double upper,
68			int decimals) :
69			adjust(lower, lower, upper, 1, 10),
70			scale(adjust),
71			spinbutton(adjust),
72			LabelWidget(labelText, box)
73			{
74			spinbutton.set_digits(decimals);
75			scale.set_draw_value(false);
76			box.pack_start(spinbutton, Gtk::PACK_SHRINK);
77			box.add(scale);
78			}
79
80			class NumEntryGain : public NumEntry<gig::DimensionRegion> {
81			private:
82			void value_changed();
83			public:
84			NumEntryGain(char* labelText,
85			double lower, double upper, int decimals);
86			void set_dimreg(gig::DimensionRegion* dimreg);
87			};
88
89			template<typename T>
90			class NumEntryX : public NumEntry<gig::DimensionRegion> {
91			private:
92			T& (access)(gig::DimensionRegion);
93			void value_changed();
94			public:
95			NumEntryX(char* labelText, T& (access)(gig::DimensionRegion),
96			double lower = 0, double upper = 127, int decimals = 0);
97			void set_dimreg(gig::DimensionRegion* dimreg);
98			};
99
100			template<typename T>
101			NumEntryX<T>::NumEntryX(char* labelText, T& (access)(gig::DimensionRegion),
102			double lower, double upper, int decimals) :
103			NumEntry<gig::DimensionRegion>(labelText, lower, upper, decimals),
104			access(access)
105			{
106			spinbutton.signal_value_changed().connect(
107			sigc::mem_fun(*this, &NumEntryX::value_changed));
108			}
109
110			template<typename T>
111			void NumEntryX<T>::value_changed()
112			{
113			if (dimreg && update_gui) {
114			access(dimreg) = T(spinbutton.get_value());
115			}
116			}
117
118			template<typename T>
119			void NumEntryX<T>::set_dimreg(gig::DimensionRegion* dimreg)
120			{
121			this->dimreg = 0;
122			set_value(access(dimreg));
123			this->dimreg = dimreg;
124			}
125
126
127			class NoteEntry : public NumEntryX<uint8_t> {
128			public:
129			NoteEntry(char* labelText, uint8_t& (access)(gig::DimensionRegion));
130			private:
131			int on_input(double* new_value);
132			bool on_output();
133			};
134
135
136			template<typename T, typename T2 = gig::DimensionRegion>
137			class NumEntryTemp : public NumEntry<T2> {
138			using NumEntry<T2>::spinbutton;
139			using NumEntry<T2>::dimreg;
140			private:
141			T T2::* param;
142			void value_changed();
143			public:
144			NumEntryTemp(char* labelText, T T2::* param,
145			double lower = 0, double upper = 127, int decimals = 0);
146			void set_dimreg(gig::DimensionRegion* dimreg);
147			};
148
149			template<typename T, typename T2>
150			NumEntryTemp<T, T2>::NumEntryTemp(char* labelText, T T2::* param,
151			double lower, double upper, int decimals) :
152			NumEntry<T2>(labelText, lower, upper, decimals),
153			param(param)
154			{
155			spinbutton.signal_value_changed().connect(
156			sigc::mem_fun(*this, &NumEntryTemp<T, T2>::value_changed));
157			}
158
159			template<typename T, typename T2>
160			void NumEntryTemp<T, T2>::value_changed()
161			{
162			if (dimreg && update_gui) {
163			dimreg->*param = T(spinbutton.get_value());
164			}
165			}
166
167			template<typename T, typename T2>
168			void NumEntryTemp<T, T2>::set_dimreg(gig::DimensionRegion* dimreg)
169			{
170			this->dimreg = 0;
171			set_value(dimreg->*param);
172			this->dimreg = dimreg;
173			}
174
175
176
177			class NumEntryPermille : public NumEntry<gig::DimensionRegion> {
178			private:
179			uint16_t gig::DimensionRegion::* param;
180			void value_changed();
181			public:
182			NumEntryPermille(char* labelText, uint16_t gig::DimensionRegion::* param,
183			double lower = 0, double upper = 127, int decimals = 0);
184			void set_dimreg(gig::DimensionRegion* dimreg);
185			};
186
187
188			template<typename T>
189			class ChoiceEntry : public LabelWidget {
190			private:
191			Gtk::ComboBoxText combobox;
192			Gtk::Alignment align;
193			T gig::DimensionRegion::* param;
194			gig::DimensionRegion* dimreg;
195			void value_changed();
196			const T* values;
197			public:
198			ChoiceEntry(char* labelText,
199			T gig::DimensionRegion::* param);
200			void set_choices(char** texts, const T* values);
201			void set_dimreg(gig::DimensionRegion* dimreg);
202			int get_active_row_number() { return combobox.get_active_row_number(); }
203			Glib::SignalProxy0<void> signal_changed() {
204			return combobox.signal_changed();
205			}
206			};
207
208			template<typename T>
209			ChoiceEntry<T>::ChoiceEntry(char* labelText,
210			T gig::DimensionRegion::* param) :
211			align(0, 0, 0, 0),
212			LabelWidget(labelText, align),
213			param(param)
214			{
215			combobox.signal_changed().connect(
216			sigc::mem_fun(*this, &ChoiceEntry::value_changed));
217			align.add(combobox);
218			}
219
220			template<typename T>
221			void ChoiceEntry<T>::set_choices(char** texts, const T* values)
222			{
223			for (int i = 0 ; texts[i] ; i++) {
224			combobox.append_text(texts[i]);
225			}
226			this->values = values;
227			}
228
229			template<typename T>
230			void ChoiceEntry<T>::value_changed()
231			{
232			if (dimreg && update_gui) {
233			int rowno = combobox.get_active_row_number();
234			if (rowno != -1) dimreg->*param = values[rowno];
235			}
236			}
237
238			template<typename T>
239			void ChoiceEntry<T>::set_dimreg(gig::DimensionRegion* dimreg)
240			{
241			this->dimreg = 0;
242			T value = dimreg->*param;
243			int row = 0;
244			int nb_rows = combobox.get_model()->children().size();
245			for (; row < nb_rows ; row++) {
246			if (value == values[row]) break;
247			}
248			combobox.set_active(row == nb_rows ? -1 : row);
249			this->dimreg = dimreg;
250			}
251
252
253			class ChoiceEntryLeverageCtrl : public LabelWidget {
254			private:
255			Gtk::ComboBoxText combobox;
256			Gtk::Alignment align;
257			gig::leverage_ctrl_t gig::DimensionRegion::* param;
258			gig::DimensionRegion* dimreg;
259			void value_changed();
260			public:
261			ChoiceEntryLeverageCtrl(char* labelText,
262			gig::leverage_ctrl_t gig::DimensionRegion::* param);
263			void set_dimreg(gig::DimensionRegion* dimreg);
264			int get_active_row_number() { return combobox.get_active_row_number(); }
265			Glib::SignalProxy0<void> signal_changed() {
266			return combobox.signal_changed();
267			}
268			};
269
270
271			class BoolEntry : public LabelWidget {
272			private:
273			Gtk::CheckButton checkbutton;
274			bool gig::DimensionRegion::* param;
275			gig::DimensionRegion* dimreg;
276			void value_changed();
277			public:
278			BoolEntry(char* labelText, bool gig::DimensionRegion::* param);
279			void set_dimreg(gig::DimensionRegion* dimreg);
280			bool get_active() { return checkbutton.get_active(); }
281			Glib::SignalProxy0<void> signal_toggled() {
282			return checkbutton.signal_toggled();
283			}
284			};
285
286			#endif