src/gigedit/paramedit.cpp

/*
 * 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.
 */

#include "paramedit.h"

namespace {
    const char* const controlChangeTexts[] = {
        "none", "channelaftertouch", "velocity",
        0,
        "modwheel", // "Modulation Wheel or Lever",
        "breath", // "Breath Controller",
        0,
        "foot", // "Foot Controller",
        "portamentotime", // "Portamento Time",
        0, 0, 0, 0, 0, 0,
        "effect1", // "Effect Control 1",
        "effect2", // "Effect Control 2",
        0, 0,
        "genpurpose1", // "General Purpose Controller 1",
        "genpurpose2", // "General Purpose Controller 2",
        "genpurpose3", // "General Purpose Controller 3",
        "genpurpose4", // "General Purpose Controller 4",
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0,
        "sustainpedal", // "Damper Pedal on/off (Sustain)",
        "portamento", // "Portamento On/Off",
        "sostenuto", // "Sustenuto On/Off",
        "softpedal", // "Soft Pedal On/Off",
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        "genpurpose5", // "General Purpose Controller 5",
        "genpurpose6", // "General Purpose Controller 6",
        "genpurpose7", // "General Purpose Controller 7",
        "genpurpose8", // "General Purpose Controller 8",
        0, 0, 0, 0, 0, 0, 0,
        "effect1depth", // "Effects 1 Depth",
        "effect2depth", // "Effects 2 Depth",
        "effect3depth", // "Effects 3 Depth",
        "effect4depth", // "Effects 4 Depth",
        "effect5depth", // "Effects 5 Depth"
    };
}

LabelWidget::LabelWidget(const char* labelText, Gtk::Widget& widget) :
    label(Glib::ustring(labelText) + ":"),
    widget(widget)
{
    label.set_alignment(Gtk::ALIGN_LEFT);
}

void LabelWidget::set_sensitive(bool sensitive)
{
    label.set_sensitive(sensitive);
    widget.set_sensitive(sensitive);
}

NumEntry::NumEntry(const 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);
    spinbutton.set_value(0);
    scale.set_draw_value(false);
    box.pack_start(spinbutton, Gtk::PACK_SHRINK);
    box.add(scale);
}

NumEntryGain::NumEntryGain(const char* labelText,
                           double lower, double upper,
                           int decimals, double coeff) :
    NumEntry(labelText, lower, upper, decimals),
    coeff(coeff),
    value(0),
    connected(true)
{
    spinbutton.signal_value_changed().connect(
        sigc::mem_fun(*this, &NumEntryGain::value_changed));
}

void NumEntryGain::value_changed()
{
    if (!connected) return;

    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 / coeff * f)) {
        value = round_to_int(new_value / f * coeff);
        sig_changed();
    }
}

void NumEntryGain::set_value(int32_t value)
{
    if (value != this->value) {
        this->value = value;

        connected = false;
        bool plus6 = value < 0;
        spinbutton.set_value(plus6 ? 0 : value / coeff);
        set_sensitive(!plus6);
        connected = true;

        sig_changed();
    }
}


BoolEntryPlus6::BoolEntryPlus6(const char* labelText, NumEntryGain& eGain, int32_t plus6value) :
    LabelWidget(labelText, checkbutton),
    checkbutton(labelText),
    eGain(eGain),
    plus6value(plus6value)
{
    checkbutton.signal_toggled().connect(
        sigc::mem_fun(*this, &BoolEntryPlus6::value_changed));
}

void BoolEntryPlus6::value_changed()
{
    if (checkbutton.get_active()) eGain.set_value(plus6value);
    else if (eGain.get_value() < 0) eGain.set_value(0);
}

int32_t BoolEntryPlus6::get_value() const
{
    return eGain.get_value();
}

void BoolEntryPlus6::set_value(int32_t value)
{
    checkbutton.set_active(value < 0);
}

NumEntryPermille::NumEntryPermille(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, &NumEntryPermille::value_changed));
}

void NumEntryPermille::value_changed()
{
    uint16_t new_value = uint16_t(spinbutton.get_value() * 10 + 0.5);
    if (new_value != value) {
        value = uint16_t(spinbutton.get_value() * 10 + 0.5);
        sig_changed();
    }
}

void NumEntryPermille::set_value(uint16_t value)
{
    if (value != this->value) {
        spinbutton.set_value(value / 10.0);
    }
}


NoteEntry::NoteEntry(const char* labelText) :
    NumEntryTemp<uint8_t>(labelText)
{
    spinbutton.signal_input().connect(
        sigc::mem_fun(*this, &NoteEntry::on_input));
    spinbutton.signal_output().connect(
        sigc::mem_fun(*this, &NoteEntry::on_output));
}

const char* notes[] = {
    "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"
};


// Convert the Entry text to a number
int NoteEntry::on_input(double* new_value)
{
    const char* str = spinbutton.get_text().c_str();

    int i;
    for (i = 11 ; i >= 0 ; i--) {
        if (strncmp(str, notes[i], strlen(notes[i])) == 0) break;
    }
    if (i >= 0) {
        char* endptr;
        long x = strtol(str + strlen(notes[i]), &endptr, 10);
        if (endptr != str + strlen(notes[i])) {
            *new_value = i + (x + 1) * 12;
            return true;
        }
    }
    return Gtk::INPUT_ERROR;
}

// Convert the Adjustment position to text
bool NoteEntry::on_output()
{
    int x = int(spinbutton.get_adjustment()->get_value() + 0.5);
    char buf[10];
    sprintf(buf, "%s%d", notes[x % 12], x / 12 - 1);
    spinbutton.set_text(buf);
    return true;
}

ChoiceEntryLeverageCtrl::ChoiceEntryLeverageCtrl(const char* labelText) :
    align(0, 0, 0, 0),
    LabelWidget(labelText, align)
{
    for (int i = 0 ; i < 99 ; i++) {
        if (controlChangeTexts[i]) {
            combobox.append_text(controlChangeTexts[i]);
        }
    }
    combobox.signal_changed().connect(
        sigc::mem_fun(*this, &ChoiceEntryLeverageCtrl::value_changed));
    align.add(combobox);
    value.type = gig::leverage_ctrl_t::type_none;
    value.controller_number = 0;
}

void ChoiceEntryLeverageCtrl::value_changed()
{
    int rowno = combobox.get_active_row_number();
    switch (rowno)
    {
    case -1:
        break;
    case 0:
        value.type = gig::leverage_ctrl_t::type_none;
        break;
    case 1:
        value.type = gig::leverage_ctrl_t::type_channelaftertouch;
        break;
    case 2:
        value.type = gig::leverage_ctrl_t::type_velocity;
        break;
    default:
        value.type = gig::leverage_ctrl_t::type_controlchange;
        int x = 3;
        for (int cc = 0 ; cc < 96 ; cc++) {
            if (controlChangeTexts[cc + 3]) {
                if (rowno == x) {
                    value.controller_number = cc;
                    break;
                }
                x++;
            }
        }
        break;
    }
    if (rowno >= 0) sig_changed();
}

void ChoiceEntryLeverageCtrl::set_value(gig::leverage_ctrl_t value)
{
    int x;
    switch (value.type)
    {
    case gig::leverage_ctrl_t::type_none:
        x = 0;
        break;
    case gig::leverage_ctrl_t::type_channelaftertouch:
        x = 1;
        break;
    case gig::leverage_ctrl_t::type_velocity:
        x = 2;
        break;
    case gig::leverage_ctrl_t::type_controlchange:
        x = -1;
        for (int cc = 0 ; cc < 96 ; cc++) {
            if (controlChangeTexts[cc + 3]) {
                x++;
                if (value.controller_number == cc) {
                    x += 3;
                    break;
                }
            }
        }
        break;
    default:
        x = -1;
        break;
    }
    combobox.set_active(x);
}


BoolEntry::BoolEntry(const char* labelText) :
    LabelWidget(labelText, checkbutton),
    checkbutton(labelText)
{
    checkbutton.signal_toggled().connect(sig_changed.make_slot());
}


StringEntry::StringEntry(const char* labelText) :
    LabelWidget(labelText, entry)
{
    entry.signal_changed().connect(
        sigc::mem_fun(*this, &StringEntry::value_changed));
}

void StringEntry::value_changed()
{
    if (ptr) {
        *ptr = entry.get_text();
        sig_changed();
    }
}

void StringEntry::set_ptr(gig::String* ptr)
{
    this->ptr = 0;
    entry.set_text(*ptr);
    this->ptr = ptr;
}
1	schoenebeck	1225	/*
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			#include "paramedit.h"
21
22			namespace {
23			const char* const controlChangeTexts[] = {
24			"none", "channelaftertouch", "velocity",
25			0,
26			"modwheel", // "Modulation Wheel or Lever",
27			"breath", // "Breath Controller",
28			0,
29			"foot", // "Foot Controller",
30			"portamentotime", // "Portamento Time",
31			0, 0, 0, 0, 0, 0,
32			"effect1", // "Effect Control 1",
33			"effect2", // "Effect Control 2",
34			0, 0,
35			"genpurpose1", // "General Purpose Controller 1",
36			"genpurpose2", // "General Purpose Controller 2",
37			"genpurpose3", // "General Purpose Controller 3",
38			"genpurpose4", // "General Purpose Controller 4",
39			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
40			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
41			0, 0, 0, 0, 0, 0,
42			"sustainpedal", // "Damper Pedal on/off (Sustain)",
43			"portamento", // "Portamento On/Off",
44			"sostenuto", // "Sustenuto On/Off",
45			"softpedal", // "Soft Pedal On/Off",
46			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
47			"genpurpose5", // "General Purpose Controller 5",
48			"genpurpose6", // "General Purpose Controller 6",
49			"genpurpose7", // "General Purpose Controller 7",
50			"genpurpose8", // "General Purpose Controller 8",
51			0, 0, 0, 0, 0, 0, 0,
52			"effect1depth", // "Effects 1 Depth",
53			"effect2depth", // "Effects 2 Depth",
54			"effect3depth", // "Effects 3 Depth",
55			"effect4depth", // "Effects 4 Depth",
56			"effect5depth", // "Effects 5 Depth"
57			};
58			}
59
60			LabelWidget::LabelWidget(const char* labelText, Gtk::Widget& widget) :
61			label(Glib::ustring(labelText) + ":"),
62			widget(widget)
63			{
64			label.set_alignment(Gtk::ALIGN_LEFT);
65			}
66
67			void LabelWidget::set_sensitive(bool sensitive)
68			{
69			label.set_sensitive(sensitive);
70			widget.set_sensitive(sensitive);
71			}
72
73			NumEntry::NumEntry(const char* labelText, double lower, double upper,
74			int decimals) :
75			adjust(lower, lower, upper, 1, 10),
76			scale(adjust),
77			spinbutton(adjust),
78			LabelWidget(labelText, box)
79			{
80			spinbutton.set_digits(decimals);
81	persson	1460	spinbutton.set_value(0);
82	schoenebeck	1225	scale.set_draw_value(false);
83			box.pack_start(spinbutton, Gtk::PACK_SHRINK);
84			box.add(scale);
85			}
86
87			NumEntryGain::NumEntryGain(const char* labelText,
88			double lower, double upper,
89			int decimals, double coeff) :
90			NumEntry(labelText, lower, upper, decimals),
91	persson	1460	coeff(coeff),
92			value(0),
93			connected(true)
94	schoenebeck	1225	{
95			spinbutton.signal_value_changed().connect(
96			sigc::mem_fun(*this, &NumEntryGain::value_changed));
97			}
98
99			void NumEntryGain::value_changed()
100			{
101	persson	1460	if (!connected) return;
102
103	schoenebeck	1359	const double f = pow(10, spinbutton.get_digits());
104			int new_value = round_to_int(spinbutton.get_value() * f);
105	persson	1460	if (new_value != round_to_int(value / coeff * f)) {
106			value = round_to_int(new_value / f * coeff);
107			sig_changed();
108	schoenebeck	1225	}
109			}
110
111	persson	1460	void NumEntryGain::set_value(int32_t value)
112	schoenebeck	1225	{
113	persson	1460	if (value != this->value) {
114			this->value = value;
115
116			connected = false;
117			bool plus6 = value < 0;
118			spinbutton.set_value(plus6 ? 0 : value / coeff);
119			set_sensitive(!plus6);
120			connected = true;
121
122			sig_changed();
123			}
124	schoenebeck	1225	}
125
126
127			BoolEntryPlus6::BoolEntryPlus6(const char* labelText, NumEntryGain& eGain, int32_t plus6value) :
128			LabelWidget(labelText, checkbutton),
129	persson	1262	checkbutton(labelText),
130	schoenebeck	1225	eGain(eGain),
131			plus6value(plus6value)
132			{
133			checkbutton.signal_toggled().connect(
134			sigc::mem_fun(*this, &BoolEntryPlus6::value_changed));
135			}
136
137			void BoolEntryPlus6::value_changed()
138			{
139	persson	1460	if (checkbutton.get_active()) eGain.set_value(plus6value);
140			else if (eGain.get_value() < 0) eGain.set_value(0);
141	schoenebeck	1225	}
142
143	persson	1460	int32_t BoolEntryPlus6::get_value() const
144	schoenebeck	1225	{
145	persson	1460	return eGain.get_value();
146	schoenebeck	1225	}
147
148	persson	1460	void BoolEntryPlus6::set_value(int32_t value)
149			{
150			checkbutton.set_active(value < 0);
151			}
152
153	schoenebeck	1225	NumEntryPermille::NumEntryPermille(const char* labelText,
154			double lower, double upper, int decimals) :
155	persson	1460	NumEntry(labelText, lower, upper, decimals),
156			value(0)
157	schoenebeck	1225	{
158			spinbutton.signal_value_changed().connect(
159			sigc::mem_fun(*this, &NumEntryPermille::value_changed));
160			}
161
162			void NumEntryPermille::value_changed()
163			{
164	persson	1460	uint16_t new_value = uint16_t(spinbutton.get_value() * 10 + 0.5);
165			if (new_value != value) {
166			value = uint16_t(spinbutton.get_value() * 10 + 0.5);
167			sig_changed();
168	schoenebeck	1225	}
169			}
170
171	persson	1460	void NumEntryPermille::set_value(uint16_t value)
172	schoenebeck	1225	{
173	persson	1460	if (value != this->value) {
174			spinbutton.set_value(value / 10.0);
175			}
176	schoenebeck	1225	}
177
178
179			NoteEntry::NoteEntry(const char* labelText) :
180			NumEntryTemp<uint8_t>(labelText)
181			{
182			spinbutton.signal_input().connect(
183			sigc::mem_fun(*this, &NoteEntry::on_input));
184			spinbutton.signal_output().connect(
185			sigc::mem_fun(*this, &NoteEntry::on_output));
186			}
187
188			const char* notes[] = {
189			"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"
190			};
191
192
193			// Convert the Entry text to a number
194			int NoteEntry::on_input(double* new_value)
195			{
196			const char* str = spinbutton.get_text().c_str();
197
198			int i;
199			for (i = 11 ; i >= 0 ; i--) {
200			if (strncmp(str, notes[i], strlen(notes[i])) == 0) break;
201			}
202			if (i >= 0) {
203			char* endptr;
204			long x = strtol(str + strlen(notes[i]), &endptr, 10);
205			if (endptr != str + strlen(notes[i])) {
206			new_value = i + (x + 1) 12;
207			return true;
208			}
209			}
210			return Gtk::INPUT_ERROR;
211			}
212
213			// Convert the Adjustment position to text
214			bool NoteEntry::on_output()
215			{
216	persson	1261	int x = int(spinbutton.get_adjustment()->get_value() + 0.5);
217	schoenebeck	1225	char buf[10];
218			sprintf(buf, "%s%d", notes[x % 12], x / 12 - 1);
219			spinbutton.set_text(buf);
220			return true;
221			}
222
223			ChoiceEntryLeverageCtrl::ChoiceEntryLeverageCtrl(const char* labelText) :
224			align(0, 0, 0, 0),
225			LabelWidget(labelText, align)
226			{
227			for (int i = 0 ; i < 99 ; i++) {
228			if (controlChangeTexts[i]) {
229			combobox.append_text(controlChangeTexts[i]);
230			}
231			}
232			combobox.signal_changed().connect(
233			sigc::mem_fun(*this, &ChoiceEntryLeverageCtrl::value_changed));
234			align.add(combobox);
235	persson	1460	value.type = gig::leverage_ctrl_t::type_none;
236			value.controller_number = 0;
237	schoenebeck	1225	}
238
239			void ChoiceEntryLeverageCtrl::value_changed()
240			{
241	persson	1460	int rowno = combobox.get_active_row_number();
242			switch (rowno)
243			{
244			case -1:
245			break;
246			case 0:
247			value.type = gig::leverage_ctrl_t::type_none;
248			break;
249			case 1:
250			value.type = gig::leverage_ctrl_t::type_channelaftertouch;
251			break;
252			case 2:
253			value.type = gig::leverage_ctrl_t::type_velocity;
254			break;
255			default:
256			value.type = gig::leverage_ctrl_t::type_controlchange;
257			int x = 3;
258			for (int cc = 0 ; cc < 96 ; cc++) {
259			if (controlChangeTexts[cc + 3]) {
260			if (rowno == x) {
261			value.controller_number = cc;
262			break;
263	schoenebeck	1225	}
264	persson	1460	x++;
265	schoenebeck	1225	}
266			}
267	persson	1460	break;
268	schoenebeck	1225	}
269	persson	1460	if (rowno >= 0) sig_changed();
270	schoenebeck	1225	}
271
272	persson	1460	void ChoiceEntryLeverageCtrl::set_value(gig::leverage_ctrl_t value)
273	schoenebeck	1225	{
274			int x;
275	persson	1460	switch (value.type)
276	schoenebeck	1225	{
277			case gig::leverage_ctrl_t::type_none:
278			x = 0;
279			break;
280			case gig::leverage_ctrl_t::type_channelaftertouch:
281			x = 1;
282			break;
283			case gig::leverage_ctrl_t::type_velocity:
284			x = 2;
285			break;
286			case gig::leverage_ctrl_t::type_controlchange:
287			x = -1;
288			for (int cc = 0 ; cc < 96 ; cc++) {
289			if (controlChangeTexts[cc + 3]) {
290			x++;
291	persson	1460	if (value.controller_number == cc) {
292	schoenebeck	1225	x += 3;
293			break;
294			}
295			}
296			}
297			break;
298			default:
299			x = -1;
300			break;
301			}
302			combobox.set_active(x);
303			}
304
305
306			BoolEntry::BoolEntry(const char* labelText) :
307			LabelWidget(labelText, checkbutton),
308	persson	1460	checkbutton(labelText)
309	schoenebeck	1225	{
310	persson	1460	checkbutton.signal_toggled().connect(sig_changed.make_slot());
311	schoenebeck	1225	}
312
313
314			StringEntry::StringEntry(const char* labelText) :
315			LabelWidget(labelText, entry)
316			{
317			entry.signal_changed().connect(
318			sigc::mem_fun(*this, &StringEntry::value_changed));
319			}
320
321			void StringEntry::value_changed()
322			{
323	persson	1261	if (ptr) {
324	schoenebeck	1225	*ptr = entry.get_text();
325	persson	1261	sig_changed();
326	schoenebeck	1225	}
327			}
328
329			void StringEntry::set_ptr(gig::String* ptr)
330			{
331			this->ptr = 0;
332			entry.set_text(*ptr);
333			this->ptr = ptr;
334			}