trunk/src/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(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);
}

NumEntryGain::NumEntryGain(char* labelText,
                           double lower = 0, double upper = 127,
                           int decimals = 0) :
    NumEntry<gig::DimensionRegion>(labelText, lower, upper, decimals)
{
    spinbutton.signal_value_changed().connect(
        sigc::mem_fun(*this, &NumEntryGain::value_changed));
}

void NumEntryGain::value_changed()
{
    if (dimreg && update_gui) {
      dimreg->Gain = int32_t(spinbutton.get_value() * -655360.0);
    }
}

void NumEntryGain::set_dimreg(gig::DimensionRegion* dimreg)
{
    this->dimreg = 0;
    set_value(dimreg->Gain / -655360.0);
    this->dimreg = dimreg;
}


NumEntryPermille::NumEntryPermille(char* labelText,
                                   uint16_t gig::DimensionRegion::* param,
                                   double lower, double upper, int decimals) :
    NumEntry<gig::DimensionRegion>(labelText, lower, upper, decimals),
    param(param)
{
    spinbutton.signal_value_changed().connect(
        sigc::mem_fun(*this, &NumEntryPermille::value_changed));
}

void NumEntryPermille::value_changed()
{
    if (dimreg && update_gui) {
        dimreg->*param = uint16_t(spinbutton.get_value() * 10 + 0.5);
    }
}

void NumEntryPermille::set_dimreg(gig::DimensionRegion* dimreg)
{
    this->dimreg = 0;
    set_value(dimreg->*param / 10.0);
    this->dimreg = dimreg;
}


NoteEntry::NoteEntry(char* labelText, uint8_t& (*access)(gig::DimensionRegion*)) :
    NumEntryX<uint8_t>(labelText, access)
{
    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());
    char buf[10];
    sprintf(buf, "%s%d", notes[x % 12], x / 12 - 1);
    spinbutton.set_text(buf);
    return true;
}

BoolEntry::BoolEntry(char* labelText, bool gig::DimensionRegion::* param) :
    LabelWidget(labelText, checkbutton),
    param(param)
{
    checkbutton.signal_toggled().connect(
        sigc::mem_fun(*this, &BoolEntry::value_changed));
}

void BoolEntry::value_changed()
{
    if (dimreg && update_gui) {
        dimreg->*param = checkbutton.get_active();
    }
}

void BoolEntry::set_dimreg(gig::DimensionRegion* dimreg)
{
    this->dimreg = 0;
    checkbutton.set_active(dimreg->*param);
    this->dimreg = dimreg;
}

ChoiceEntryLeverageCtrl::ChoiceEntryLeverageCtrl(
    char* labelText,
    gig::leverage_ctrl_t gig::DimensionRegion::* param) :
    align(0, 0, 0, 0),
    LabelWidget(labelText, align),
    param(param)
{
    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 (dimreg && update_gui) {
        int rowno = combobox.get_active_row_number();
        switch (rowno)
        {
        case -1:
            break;
        case 0:
            (dimreg->*param).type = gig::leverage_ctrl_t::type_none;
            break;
        case 1:
            (dimreg->*param).type =
                gig::leverage_ctrl_t::type_channelaftertouch;
            break;
        case 2:
            (dimreg->*param).type = gig::leverage_ctrl_t::type_velocity;
            break;
        default:
            (dimreg->*param).type = gig::leverage_ctrl_t::type_controlchange;
            int x = 3;
            for (int cc = 0 ; cc < 96 ; cc++) {
                if (controlChangeTexts[cc + 3]) {
                    if (rowno == x) {
                        (dimreg->*param).controller_number = cc;
                        break;
                    }
                    x++;
                }
            }
            break;
        }
    }
}

void ChoiceEntryLeverageCtrl::set_dimreg(gig::DimensionRegion* dimreg)
{
    this->dimreg = 0;
    gig::leverage_ctrl_t c = dimreg->*param;
    int x;
    switch (c.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 (c.controller_number == cc) {
                    x += 3;
                    break;
                }
            }
        }
        break;
    default:
        x = -1;
        break;
    }
    combobox.set_active(x);
    this->dimreg = dimreg;
}
1	persson	1100	/*
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(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			NumEntryGain::NumEntryGain(char* labelText,
74			double lower = 0, double upper = 127,
75			int decimals = 0) :
76			NumEntry<gig::DimensionRegion>(labelText, lower, upper, decimals)
77			{
78			spinbutton.signal_value_changed().connect(
79			sigc::mem_fun(*this, &NumEntryGain::value_changed));
80			}
81
82			void NumEntryGain::value_changed()
83			{
84			if (dimreg && update_gui) {
85			dimreg->Gain = int32_t(spinbutton.get_value() * -655360.0);
86			}
87			}
88
89			void NumEntryGain::set_dimreg(gig::DimensionRegion* dimreg)
90			{
91			this->dimreg = 0;
92			set_value(dimreg->Gain / -655360.0);
93			this->dimreg = dimreg;
94			}
95
96
97			NumEntryPermille::NumEntryPermille(char* labelText,
98			uint16_t gig::DimensionRegion::* param,
99			double lower, double upper, int decimals) :
100			NumEntry<gig::DimensionRegion>(labelText, lower, upper, decimals),
101			param(param)
102			{
103			spinbutton.signal_value_changed().connect(
104			sigc::mem_fun(*this, &NumEntryPermille::value_changed));
105			}
106
107			void NumEntryPermille::value_changed()
108			{
109			if (dimreg && update_gui) {
110			dimreg->param = uint16_t(spinbutton.get_value() 10 + 0.5);
111			}
112			}
113
114			void NumEntryPermille::set_dimreg(gig::DimensionRegion* dimreg)
115			{
116			this->dimreg = 0;
117			set_value(dimreg->*param / 10.0);
118			this->dimreg = dimreg;
119			}
120
121
122			NoteEntry::NoteEntry(char* labelText, uint8_t& (access)(gig::DimensionRegion)) :
123			NumEntryX<uint8_t>(labelText, access)
124			{
125			spinbutton.signal_input().connect(
126			sigc::mem_fun(*this, &NoteEntry::on_input));
127			spinbutton.signal_output().connect(
128			sigc::mem_fun(*this, &NoteEntry::on_output));
129			}
130
131			const char* notes[] = {
132			"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"
133			};
134
135
136			// Convert the Entry text to a number
137			int NoteEntry::on_input(double* new_value)
138			{
139			const char* str = spinbutton.get_text().c_str();
140
141			int i;
142			for (i = 11 ; i >= 0 ; i--) {
143			if (strncmp(str, notes[i], strlen(notes[i])) == 0) break;
144			}
145			if (i >= 0) {
146			char* endptr;
147			long x = strtol(str + strlen(notes[i]), &endptr, 10);
148			if (endptr != str + strlen(notes[i])) {
149			new_value = i + (x + 1) 12;
150			return true;
151			}
152			}
153			return Gtk::INPUT_ERROR;
154			}
155
156			// Convert the Adjustment position to text
157			bool NoteEntry::on_output()
158			{
159			int x = int(spinbutton.get_adjustment()->get_value());
160			char buf[10];
161			sprintf(buf, "%s%d", notes[x % 12], x / 12 - 1);
162			spinbutton.set_text(buf);
163			return true;
164			}
165
166			BoolEntry::BoolEntry(char* labelText, bool gig::DimensionRegion::* param) :
167			LabelWidget(labelText, checkbutton),
168			param(param)
169			{
170			checkbutton.signal_toggled().connect(
171			sigc::mem_fun(*this, &BoolEntry::value_changed));
172			}
173
174			void BoolEntry::value_changed()
175			{
176			if (dimreg && update_gui) {
177			dimreg->*param = checkbutton.get_active();
178			}
179			}
180
181			void BoolEntry::set_dimreg(gig::DimensionRegion* dimreg)
182			{
183			this->dimreg = 0;
184			checkbutton.set_active(dimreg->*param);
185			this->dimreg = dimreg;
186			}
187
188			ChoiceEntryLeverageCtrl::ChoiceEntryLeverageCtrl(
189			char* labelText,
190			gig::leverage_ctrl_t gig::DimensionRegion::* param) :
191			align(0, 0, 0, 0),
192			LabelWidget(labelText, align),
193			param(param)
194			{
195			for (int i = 0 ; i < 99 ; i++) {
196			if (controlChangeTexts[i]) {
197			combobox.append_text(controlChangeTexts[i]);
198			}
199			}
200			combobox.signal_changed().connect(
201			sigc::mem_fun(*this, &ChoiceEntryLeverageCtrl::value_changed));
202			align.add(combobox);
203			}
204
205			void ChoiceEntryLeverageCtrl::value_changed()
206			{
207			if (dimreg && update_gui) {
208			int rowno = combobox.get_active_row_number();
209			switch (rowno)
210			{
211			case -1:
212			break;
213			case 0:
214			(dimreg->*param).type = gig::leverage_ctrl_t::type_none;
215			break;
216			case 1:
217			(dimreg->*param).type =
218			gig::leverage_ctrl_t::type_channelaftertouch;
219			break;
220			case 2:
221			(dimreg->*param).type = gig::leverage_ctrl_t::type_velocity;
222			break;
223			default:
224			(dimreg->*param).type = gig::leverage_ctrl_t::type_controlchange;
225			int x = 3;
226			for (int cc = 0 ; cc < 96 ; cc++) {
227			if (controlChangeTexts[cc + 3]) {
228			if (rowno == x) {
229			(dimreg->*param).controller_number = cc;
230			break;
231			}
232			x++;
233			}
234			}
235			break;
236			}
237			}
238			}
239
240			void ChoiceEntryLeverageCtrl::set_dimreg(gig::DimensionRegion* dimreg)
241			{
242			this->dimreg = 0;
243			gig::leverage_ctrl_t c = dimreg->*param;
244			int x;
245			switch (c.type)
246			{
247			case gig::leverage_ctrl_t::type_none:
248			x = 0;
249			break;
250			case gig::leverage_ctrl_t::type_channelaftertouch:
251			x = 1;
252			break;
253			case gig::leverage_ctrl_t::type_velocity:
254			x = 2;
255			break;
256			case gig::leverage_ctrl_t::type_controlchange:
257			x = -1;
258			for (int cc = 0 ; cc < 96 ; cc++) {
259			if (controlChangeTexts[cc + 3]) {
260			x++;
261			if (c.controller_number == cc) {
262			x += 3;
263			break;
264			}
265			}
266			}
267			break;
268			default:
269			x = -1;
270			break;
271			}
272			combobox.set_active(x);
273			this->dimreg = dimreg;
274			}