src/gigedit/midirules.h

/*                                                         -*- c++ -*-
 * Copyright (C) 2013-2016 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 of the
 * License, 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#ifndef GIGEDIT_MIDIRULES_H
#define GIGEDIT_MIDIRULES_H

#include <gig.h>

#include <gtkmm/box.h>
#include <gtkmm/button.h>
#include <gtkmm/buttonbox.h>
#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 12) || GTKMM_MAJOR_VERSION > 2
#include <gtkmm/cellrendererspin.h>
#endif
#include <gtkmm/comboboxtext.h>
#include <gtkmm/label.h>
#include <gtkmm/liststore.h>
#include <gtkmm/scrolledwindow.h>
#include <gtkmm/separatortoolitem.h>
#include <gtkmm/toolbar.h>
#include <gtkmm/toolbutton.h>
#include <gtkmm/treemodel.h>
#include <gtkmm/treeview.h>
#include <gtkmm/window.h>

#include "paramedit.h"
#include "compat.h"
#include "ManagedWindow.h"

class MidiRuleCtrlTrigger : public Gtk::VBox,
                            public PropEditor<gig::MidiRuleCtrlTrigger> {
public:
    MidiRuleCtrlTrigger();
    void set_rule(gig::MidiRuleCtrlTrigger* r);

protected:
    class ModelColumns : public Gtk::TreeModel::ColumnRecord {
    public:
        ModelColumns() {
            add(trigger_point);
            add(descending);
            add(vel_sensitivity);
            add(key);
            add(note_off);
            add(switch_logic);
            add(velocity);
            add(override_pedal);
        }

        Gtk::TreeModelColumn<int> trigger_point;
        Gtk::TreeModelColumn<bool> descending;
        Gtk::TreeModelColumn<int> vel_sensitivity;
        Gtk::TreeModelColumn<Glib::ustring> key;
        Gtk::TreeModelColumn<bool> note_off;
        Gtk::TreeModelColumn<bool> switch_logic;
        Gtk::TreeModelColumn<int> velocity;
        Gtk::TreeModelColumn<bool> override_pedal;
    } columns;

    int append_num_column(const char* title,
                          const Gtk::TreeModelColumn<int>& column,
                          int lower = 0, int upper = 127);
    int append_note_column(const char* title,
                           const Gtk::TreeModelColumn<Glib::ustring>& column);
    void num_editing_started(Gtk::CellEditable* editable,
                             const Glib::ustring& path,
                             Gtk::CellRendererSpin* renderer);
    void note_editing_started(Gtk::CellEditable* editable,
                              const Glib::ustring& path,
                              Gtk::CellRendererSpin* renderer);
    void num_edited(const Glib::ustring& path, const Glib::ustring& new_text,
                    const Gtk::TreeModelColumn<int>& column);
    void note_edited(const Glib::ustring& path, const Glib::ustring& new_text,
                     const Gtk::TreeModelColumn<Glib::ustring>& column);
    void row_changed(const Gtk::TreeModel::Path& path,
                     const Gtk::TreeModel::iterator& iter);
    void row_inserted(const Gtk::TreeModel::Path& path,
                      const Gtk::TreeModel::iterator& iter);
    void row_deleted(const Gtk::TreeModel::Path& path);

    Table table;
    NumEntryTemp<uint8_t> eControllerNumber;

    Gtk::VBox vbox;
    Glib::RefPtr<Gtk::ListStore> list_store;
    Gtk::TreeView tree_view;
    Gtk::ScrolledWindow scrolled_window;
#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
    Gtk::HButtonBox toolbar;
    Gtk::Button add_button;
    Gtk::Button remove_button;
#else
    Gtk::Toolbar toolbar;
    Gtk::ToolButton add_button;
    Gtk::ToolButton remove_button;
#endif

    void sel_changed();
    void add_row();
    void remove_row();
};


class MidiRuleLegato : public Table,
                       public PropEditor<gig::MidiRuleLegato> {
public:
    MidiRuleLegato();
    void set_rule(gig::MidiRuleLegato* r);

protected:
    BoolEntry eBypassUseController;
    NoteEntry eBypassKey;
    NumEntryTemp<uint8_t> eBypassController;
    NumEntryTemp<uint16_t> eThresholdTime;
    NumEntryTemp<uint16_t> eReleaseTime;
    NoteEntry eKeyRangeLow;
    NoteEntry eKeyRangeHigh;
    NoteEntry eReleaseTriggerKey;
    NoteEntry eAltSustain1Key;
    NoteEntry eAltSustain2Key;

    void BypassUseController_toggled();
};


class MidiRules : public ManagedWindow,
                  public PropEditor<gig::Instrument> {
public:
    MidiRules();
    void set_instrument(gig::Instrument* instrument);

    // implementation for abstract methods of interface class "ManagedWindow"
    virtual Settings::Property<int>* windowSettingX() { return &Settings::singleton()->midiRulesWindowX; }
    virtual Settings::Property<int>* windowSettingY() { return &Settings::singleton()->midiRulesWindowY; }
    virtual Settings::Property<int>* windowSettingWidth() { return &Settings::singleton()->midiRulesWindowW; }
    virtual Settings::Property<int>* windowSettingHeight() { return &Settings::singleton()->midiRulesWindowH; }

protected:
    enum {
        NONE = 0,
        CTRL_TRIGGER,
        LEGATO,
        NUMBER_OF_RULES
    };

    Gtk::VBox vbox;

    Gtk::Label label;
    Gtk::ComboBoxText combo;
    Gtk::HBox hbox;

    Gtk::HBox box;

    MidiRuleCtrlTrigger ctrl_trigger;
    MidiRuleLegato legato;

    Gtk::HButtonBox button_box;
    Gtk::Button quit_button;

    const Glib::ustring unknown;

    void combo_changed();
    bool remove_unknown_from_combo();
};

#endif
1	/* -- c++ --
2	* Copyright (C) 2013-2016 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 of the
7	* License, or (at 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 this program; if not, write to the Free Software
16	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17	* 02110-1301, USA.
18	*/
19
20	#ifndef GIGEDIT_MIDIRULES_H
21	#define GIGEDIT_MIDIRULES_H
22
23	#include <gig.h>
24
25	#include <gtkmm/box.h>
26	#include <gtkmm/button.h>
27	#include <gtkmm/buttonbox.h>
28	#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 12) \|\| GTKMM_MAJOR_VERSION > 2
29	#include <gtkmm/cellrendererspin.h>
30	#endif
31	#include <gtkmm/comboboxtext.h>
32	#include <gtkmm/label.h>
33	#include <gtkmm/liststore.h>
34	#include <gtkmm/scrolledwindow.h>
35	#include <gtkmm/separatortoolitem.h>
36	#include <gtkmm/toolbar.h>
37	#include <gtkmm/toolbutton.h>
38	#include <gtkmm/treemodel.h>
39	#include <gtkmm/treeview.h>
40	#include <gtkmm/window.h>
41
42	#include "paramedit.h"
43	#include "compat.h"
44	#include "ManagedWindow.h"
45
46	class MidiRuleCtrlTrigger : public Gtk::VBox,
47	public PropEditor<gig::MidiRuleCtrlTrigger> {
48	public:
49	MidiRuleCtrlTrigger();
50	void set_rule(gig::MidiRuleCtrlTrigger* r);
51
52	protected:
53	class ModelColumns : public Gtk::TreeModel::ColumnRecord {
54	public:
55	ModelColumns() {
56	add(trigger_point);
57	add(descending);
58	add(vel_sensitivity);
59	add(key);
60	add(note_off);
61	add(switch_logic);
62	add(velocity);
63	add(override_pedal);
64	}
65
66	Gtk::TreeModelColumn<int> trigger_point;
67	Gtk::TreeModelColumn<bool> descending;
68	Gtk::TreeModelColumn<int> vel_sensitivity;
69	Gtk::TreeModelColumn<Glib::ustring> key;
70	Gtk::TreeModelColumn<bool> note_off;
71	Gtk::TreeModelColumn<bool> switch_logic;
72	Gtk::TreeModelColumn<int> velocity;
73	Gtk::TreeModelColumn<bool> override_pedal;
74	} columns;
75
76	int append_num_column(const char* title,
77	const Gtk::TreeModelColumn<int>& column,
78	int lower = 0, int upper = 127);
79	int append_note_column(const char* title,
80	const Gtk::TreeModelColumn<Glib::ustring>& column);
81	void num_editing_started(Gtk::CellEditable* editable,
82	const Glib::ustring& path,
83	Gtk::CellRendererSpin* renderer);
84	void note_editing_started(Gtk::CellEditable* editable,
85	const Glib::ustring& path,
86	Gtk::CellRendererSpin* renderer);
87	void num_edited(const Glib::ustring& path, const Glib::ustring& new_text,
88	const Gtk::TreeModelColumn<int>& column);
89	void note_edited(const Glib::ustring& path, const Glib::ustring& new_text,
90	const Gtk::TreeModelColumn<Glib::ustring>& column);
91	void row_changed(const Gtk::TreeModel::Path& path,
92	const Gtk::TreeModel::iterator& iter);
93	void row_inserted(const Gtk::TreeModel::Path& path,
94	const Gtk::TreeModel::iterator& iter);
95	void row_deleted(const Gtk::TreeModel::Path& path);
96
97	Table table;
98	NumEntryTemp<uint8_t> eControllerNumber;
99
100	Gtk::VBox vbox;
101	Glib::RefPtr<Gtk::ListStore> list_store;
102	Gtk::TreeView tree_view;
103	Gtk::ScrolledWindow scrolled_window;
104	#if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) \|\| GTKMM_MAJOR_VERSION < 2
105	Gtk::HButtonBox toolbar;
106	Gtk::Button add_button;
107	Gtk::Button remove_button;
108	#else
109	Gtk::Toolbar toolbar;
110	Gtk::ToolButton add_button;
111	Gtk::ToolButton remove_button;
112	#endif
113
114	void sel_changed();
115	void add_row();
116	void remove_row();
117	};
118
119
120	class MidiRuleLegato : public Table,
121	public PropEditor<gig::MidiRuleLegato> {
122	public:
123	MidiRuleLegato();
124	void set_rule(gig::MidiRuleLegato* r);
125
126	protected:
127	BoolEntry eBypassUseController;
128	NoteEntry eBypassKey;
129	NumEntryTemp<uint8_t> eBypassController;
130	NumEntryTemp<uint16_t> eThresholdTime;
131	NumEntryTemp<uint16_t> eReleaseTime;
132	NoteEntry eKeyRangeLow;
133	NoteEntry eKeyRangeHigh;
134	NoteEntry eReleaseTriggerKey;
135	NoteEntry eAltSustain1Key;
136	NoteEntry eAltSustain2Key;
137
138	void BypassUseController_toggled();
139	};
140
141
142	class MidiRules : public ManagedWindow,
143	public PropEditor<gig::Instrument> {
144	public:
145	MidiRules();
146	void set_instrument(gig::Instrument* instrument);
147
148	// implementation for abstract methods of interface class "ManagedWindow"
149	virtual Settings::Property<int>* windowSettingX() { return &Settings::singleton()->midiRulesWindowX; }
150	virtual Settings::Property<int>* windowSettingY() { return &Settings::singleton()->midiRulesWindowY; }
151	virtual Settings::Property<int>* windowSettingWidth() { return &Settings::singleton()->midiRulesWindowW; }
152	virtual Settings::Property<int>* windowSettingHeight() { return &Settings::singleton()->midiRulesWindowH; }
153
154	protected:
155	enum {
156	NONE = 0,
157	CTRL_TRIGGER,
158	LEGATO,
159	NUMBER_OF_RULES
160	};
161
162	Gtk::VBox vbox;
163
164	Gtk::Label label;
165	Gtk::ComboBoxText combo;
166	Gtk::HBox hbox;
167
168	Gtk::HBox box;
169
170	MidiRuleCtrlTrigger ctrl_trigger;
171	MidiRuleLegato legato;
172
173	Gtk::HButtonBox button_box;
174	Gtk::Button quit_button;
175
176	const Glib::ustring unknown;
177
178	void combo_changed();
179	bool remove_unknown_from_combo();
180	};
181
182	#endif