src/gigedit/paramedit.cpp

/*
 * Copyright (C) 2006-2010 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 <cstring>

#include "paramedit.h"

#include "global.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) :
    LabelWidget(labelText, box),
    adjust(lower, lower, upper, 1, 10),
    scale(adjust),
    spinbutton(adjust)
{
    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),
    value(0),
    coeff(coeff),
    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) :
    LabelWidget(labelText, align),
    align(0, 0, 0, 0)
{
    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 (uint 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 (uint 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(sig_changed.make_slot());
}

StringEntryMultiLine::StringEntryMultiLine(const char* labelText) :
    LabelWidget(labelText, frame)
{
    text_buffer = text_view.get_buffer();
    frame.set_shadow_type(Gtk::SHADOW_IN);
    frame.add(text_view);
    text_buffer->signal_changed().connect(sig_changed.make_slot());
}

gig::String StringEntryMultiLine::get_value() const
{
    Glib::ustring value = text_buffer->get_text();
    for (int i = 0 ; (i = value.find("\x0a", i)) >= 0 ; i += 2)
        value.replace(i, 1, "\x0d\x0a");
    return value;
}

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