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);
    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)
{
    spinbutton.signal_value_changed().connect(
        sigc::mem_fun(*this, &NumEntryGain::value_changed));
}

void NumEntryGain::value_changed()
{
    const double f = pow(10, spinbutton.get_digits());
    int new_value = round_to_int(spinbutton.get_value() * f);
    if (ptr) {
        if (new_value != round_to_int(*ptr / coeff * f))
        {
            sig_to_be_changed.emit();
            *ptr = round_to_int(new_value / f * coeff);
            sig_val_changed.emit(new_value);
            sig_changed.emit();
        }
    } else {
        sig_to_be_changed.emit();
        sig_val_changed.emit(new_value);
        sig_changed.emit();
    }
}

void NumEntryGain::set_ptr(int32_t* ptr)
{
    this->ptr = 0;
    bool plus6 = *ptr < 0;
    set_value(plus6 ? 0 : *ptr / coeff);
    set_sensitive(!plus6);
    this->ptr = ptr;
}


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 (ptr) {
        bool plus6 = checkbutton.get_active();
        if (plus6) {
            eGain.set_value(0);
            *ptr = plus6value;
            sig_changed();
        } else {
            if (*ptr < 0) {
                *ptr = 0;
                sig_changed();
            }
        }
        eGain.set_sensitive(!plus6);
    }
}

void BoolEntryPlus6::set_ptr(int32_t* ptr)
{
    this->ptr = 0;
    checkbutton.set_active(*ptr < 0);
    this->ptr = ptr;
}

NumEntryPermille::NumEntryPermille(const char* labelText,
                                   double lower, double upper, int decimals) :
    NumEntry(labelText, lower, upper, decimals)
{
    spinbutton.signal_value_changed().connect(
        sigc::mem_fun(*this, &NumEntryPermille::value_changed));
}

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

void NumEntryPermille::set_ptr(uint16_t* ptr)
{
    this->ptr = 0;
    set_value(*ptr / 10.0);
    this->ptr = ptr;
}


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);
}

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

void ChoiceEntryLeverageCtrl::set_ptr(gig::leverage_ctrl_t* ptr)
{
    this->ptr = 0;
    int x;
    switch (ptr->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 (ptr->controller_number == cc) {
                    x += 3;
                    break;
                }
            }
        }
        break;
    default:
        x = -1;
        break;
    }
    combobox.set_active(x);
    this->ptr = ptr;
}


BoolEntry::BoolEntry(const char* labelText) :
    LabelWidget(labelText, checkbutton),
    checkbutton(labelText),
    ptr(0)
{
    checkbutton.signal_toggled().connect(
        sigc::mem_fun(*this, &BoolEntry::value_changed));
}

void BoolEntry::value_changed()
{
    if (ptr) {
        *ptr = checkbutton.get_active();
        sig_changed();
    }
}

void BoolEntry::set_ptr(bool* ptr)
{
    this->ptr = 0;
    checkbutton.set_active(*ptr);
    this->ptr = ptr;
}


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	/*
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	scale.set_draw_value(false);
82	box.pack_start(spinbutton, Gtk::PACK_SHRINK);
83	box.add(scale);
84	}
85
86	NumEntryGain::NumEntryGain(const char* labelText,
87	double lower, double upper,
88	int decimals, double coeff) :
89	NumEntry(labelText, lower, upper, decimals),
90	coeff(coeff)
91	{
92	spinbutton.signal_value_changed().connect(
93	sigc::mem_fun(*this, &NumEntryGain::value_changed));
94	}
95
96	void NumEntryGain::value_changed()
97	{
98	const double f = pow(10, spinbutton.get_digits());
99	int new_value = round_to_int(spinbutton.get_value() * f);
100	if (ptr) {
101	if (new_value != round_to_int(ptr / coeff f))
102	{
103	sig_to_be_changed.emit();
104	ptr = round_to_int(new_value / f coeff);
105	sig_val_changed.emit(new_value);
106	sig_changed.emit();
107	}
108	} else {
109	sig_to_be_changed.emit();
110	sig_val_changed.emit(new_value);
111	sig_changed.emit();
112	}
113	}
114
115	void NumEntryGain::set_ptr(int32_t* ptr)
116	{
117	this->ptr = 0;
118	bool plus6 = *ptr < 0;
119	set_value(plus6 ? 0 : *ptr / coeff);
120	set_sensitive(!plus6);
121	this->ptr = ptr;
122	}
123
124
125	BoolEntryPlus6::BoolEntryPlus6(const char* labelText, NumEntryGain& eGain, int32_t plus6value) :
126	LabelWidget(labelText, checkbutton),
127	checkbutton(labelText),
128	eGain(eGain),
129	plus6value(plus6value)
130	{
131	checkbutton.signal_toggled().connect(
132	sigc::mem_fun(*this, &BoolEntryPlus6::value_changed));
133	}
134
135	void BoolEntryPlus6::value_changed()
136	{
137	if (ptr) {
138	bool plus6 = checkbutton.get_active();
139	if (plus6) {
140	eGain.set_value(0);
141	*ptr = plus6value;
142	sig_changed();
143	} else {
144	if (*ptr < 0) {
145	*ptr = 0;
146	sig_changed();
147	}
148	}
149	eGain.set_sensitive(!plus6);
150	}
151	}
152
153	void BoolEntryPlus6::set_ptr(int32_t* ptr)
154	{
155	this->ptr = 0;
156	checkbutton.set_active(*ptr < 0);
157	this->ptr = ptr;
158	}
159
160	NumEntryPermille::NumEntryPermille(const char* labelText,
161	double lower, double upper, int decimals) :
162	NumEntry(labelText, lower, upper, decimals)
163	{
164	spinbutton.signal_value_changed().connect(
165	sigc::mem_fun(*this, &NumEntryPermille::value_changed));
166	}
167
168	void NumEntryPermille::value_changed()
169	{
170	if (ptr) {
171	uint16_t new_value = uint16_t(spinbutton.get_value() * 10 + 0.5);
172	if (new_value != *ptr) {
173	ptr = uint16_t(spinbutton.get_value() 10 + 0.5);
174	sig_changed();
175	}
176	}
177	}
178
179	void NumEntryPermille::set_ptr(uint16_t* ptr)
180	{
181	this->ptr = 0;
182	set_value(*ptr / 10.0);
183	this->ptr = ptr;
184	}
185
186
187	NoteEntry::NoteEntry(const char* labelText) :
188	NumEntryTemp<uint8_t>(labelText)
189	{
190	spinbutton.signal_input().connect(
191	sigc::mem_fun(*this, &NoteEntry::on_input));
192	spinbutton.signal_output().connect(
193	sigc::mem_fun(*this, &NoteEntry::on_output));
194	}
195
196	const char* notes[] = {
197	"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"
198	};
199
200
201	// Convert the Entry text to a number
202	int NoteEntry::on_input(double* new_value)
203	{
204	const char* str = spinbutton.get_text().c_str();
205
206	int i;
207	for (i = 11 ; i >= 0 ; i--) {
208	if (strncmp(str, notes[i], strlen(notes[i])) == 0) break;
209	}
210	if (i >= 0) {
211	char* endptr;
212	long x = strtol(str + strlen(notes[i]), &endptr, 10);
213	if (endptr != str + strlen(notes[i])) {
214	new_value = i + (x + 1) 12;
215	return true;
216	}
217	}
218	return Gtk::INPUT_ERROR;
219	}
220
221	// Convert the Adjustment position to text
222	bool NoteEntry::on_output()
223	{
224	int x = int(spinbutton.get_adjustment()->get_value() + 0.5);
225	char buf[10];
226	sprintf(buf, "%s%d", notes[x % 12], x / 12 - 1);
227	spinbutton.set_text(buf);
228	return true;
229	}
230
231	ChoiceEntryLeverageCtrl::ChoiceEntryLeverageCtrl(const char* labelText) :
232	align(0, 0, 0, 0),
233	LabelWidget(labelText, align)
234	{
235	for (int i = 0 ; i < 99 ; i++) {
236	if (controlChangeTexts[i]) {
237	combobox.append_text(controlChangeTexts[i]);
238	}
239	}
240	combobox.signal_changed().connect(
241	sigc::mem_fun(*this, &ChoiceEntryLeverageCtrl::value_changed));
242	align.add(combobox);
243	}
244
245	void ChoiceEntryLeverageCtrl::value_changed()
246	{
247	if (ptr) {
248	int rowno = combobox.get_active_row_number();
249	switch (rowno)
250	{
251	case -1:
252	break;
253	case 0:
254	ptr->type = gig::leverage_ctrl_t::type_none;
255	break;
256	case 1:
257	ptr->type = gig::leverage_ctrl_t::type_channelaftertouch;
258	break;
259	case 2:
260	ptr->type = gig::leverage_ctrl_t::type_velocity;
261	break;
262	default:
263	ptr->type = gig::leverage_ctrl_t::type_controlchange;
264	int x = 3;
265	for (int cc = 0 ; cc < 96 ; cc++) {
266	if (controlChangeTexts[cc + 3]) {
267	if (rowno == x) {
268	ptr->controller_number = cc;
269	break;
270	}
271	x++;
272	}
273	}
274	break;
275	}
276	if (rowno >= 0) sig_changed();
277	}
278	}
279
280	void ChoiceEntryLeverageCtrl::set_ptr(gig::leverage_ctrl_t* ptr)
281	{
282	this->ptr = 0;
283	int x;
284	switch (ptr->type)
285	{
286	case gig::leverage_ctrl_t::type_none:
287	x = 0;
288	break;
289	case gig::leverage_ctrl_t::type_channelaftertouch:
290	x = 1;
291	break;
292	case gig::leverage_ctrl_t::type_velocity:
293	x = 2;
294	break;
295	case gig::leverage_ctrl_t::type_controlchange:
296	x = -1;
297	for (int cc = 0 ; cc < 96 ; cc++) {
298	if (controlChangeTexts[cc + 3]) {
299	x++;
300	if (ptr->controller_number == cc) {
301	x += 3;
302	break;
303	}
304	}
305	}
306	break;
307	default:
308	x = -1;
309	break;
310	}
311	combobox.set_active(x);
312	this->ptr = ptr;
313	}
314
315
316	BoolEntry::BoolEntry(const char* labelText) :
317	LabelWidget(labelText, checkbutton),
318	checkbutton(labelText),
319	ptr(0)
320	{
321	checkbutton.signal_toggled().connect(
322	sigc::mem_fun(*this, &BoolEntry::value_changed));
323	}
324
325	void BoolEntry::value_changed()
326	{
327	if (ptr) {
328	*ptr = checkbutton.get_active();
329	sig_changed();
330	}
331	}
332
333	void BoolEntry::set_ptr(bool* ptr)
334	{
335	this->ptr = 0;
336	checkbutton.set_active(*ptr);
337	this->ptr = ptr;
338	}
339
340
341	StringEntry::StringEntry(const char* labelText) :
342	LabelWidget(labelText, entry)
343	{
344	entry.signal_changed().connect(
345	sigc::mem_fun(*this, &StringEntry::value_changed));
346	}
347
348	void StringEntry::value_changed()
349	{
350	if (ptr) {
351	*ptr = entry.get_text();
352	sig_changed();
353	}
354	}
355
356	void StringEntry::set_ptr(gig::String* ptr)
357	{
358	this->ptr = 0;
359	entry.set_text(*ptr);
360	this->ptr = ptr;
361	}