src/gigedit/mainwindow.h

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

#ifndef GIGEDIT_MAINWINDOW_H
#define GIGEDIT_MAINWINDOW_H

#include <gig.h>

#include <gtkmm/actiongroup.h>
#include <gtkmm/buttonbox.h>
#include <gtkmm/dialog.h>
#include <gtkmm/liststore.h>
#include <gtkmm/paned.h>
#include <gtkmm/progressbar.h>
#include <gtkmm/scrolledwindow.h>
#include <gtkmm/treestore.h>
#include <gtkmm/uimanager.h>
#include <gtkmm/window.h>
#include <gtkmm/statusbar.h>
#include <gtkmm/image.h>

#include <sstream>

#include "regionchooser.h"
#include "dimregionchooser.h"
#include "dimregionedit.h"

class MainWindow;

class PropDialog : public Gtk::Window {
public:
    PropDialog();
    void set_info(DLS::Info* info);
protected:
    Gtk::Table table;
    Gtk::Label label[16];
    Gtk::Entry entry[16];
};

class InstrumentProps : public Gtk::Window {
public:
    InstrumentProps();
    void set_instrument(gig::Instrument* instrument);
    sigc::signal<void>& signal_instrument_changed();
protected:
    gig::Instrument* instrument;
    int update_model;

    template<typename T>
    void set_value(T value, sigc::slot<void, InstrumentProps*, T> setter) {
        if (update_model == 0) {
            setter(this, value);
            instrument_changed();
        }
    }

    template<typename C, typename T>
    void connect(C& widget, T gig::Instrument::* member) {
        widget.signal_value_changed().connect(
            sigc::compose(
                sigc::bind(sigc::mem_fun(*this, &InstrumentProps::set_value<T>),
                           sigc::bind(sigc::mem_fun(&InstrumentProps::set_member<T>), member)),
                sigc::mem_fun(widget, &C::get_value)));
    }

    template<typename C, typename T>
    void connect(C& widget, void (InstrumentProps::*setter)(T)) {
        widget.signal_value_changed().connect(
            sigc::compose(
                sigc::bind(sigc::mem_fun(*this, &InstrumentProps::set_value<T>),
                           sigc::mem_fun(setter)),
                sigc::mem_fun(widget, &C::get_value)));
    }

    template<typename T>
    void set_member(T value, T gig::Instrument::* member) {
        instrument->*member = value;
    }

    void set_IsDrum(bool value);
    void set_MIDIBank(uint16_t value);
    void set_MIDIProgram(uint32_t value);
    void set_DimensionKeyRange_low(uint8_t value);
    void set_DimensionKeyRange_high(uint8_t value);

    Gtk::VBox vbox;
    Gtk::HButtonBox buttonBox;
    Gtk::Button quitButton;
    Gtk::Table table;
    StringEntry eName;
    BoolEntry eIsDrum;
    NumEntryTemp<uint16_t> eMIDIBank;
    NumEntryTemp<uint32_t> eMIDIProgram;
    NumEntryGain eAttenuation;
    BoolEntryPlus6 eGainPlus6;
    NumEntryTemp<uint16_t> eEffectSend;
    NumEntryTemp<int16_t> eFineTune;
    NumEntryTemp<uint16_t> ePitchbendRange;
    BoolEntry ePianoReleaseMode;
    NoteEntry eDimensionKeyRangeLow;
    NoteEntry eDimensionKeyRangeHigh;
    int rowno;
    void add_prop(BoolEntry& prop);
    void add_prop(BoolEntryPlus6& prop);
    void add_prop(LabelWidget& prop);
    sigc::signal<void> instrument_changed;
};

class LoadDialog : public Gtk::Dialog {
public:
    LoadDialog(const Glib::ustring& title, Gtk::Window& parent);
    void set_fraction(float fraction) { progressBar.set_fraction(fraction); }
protected:
    Gtk::ProgressBar progressBar;
};

class Loader : public sigc::trackable {
public:
    Loader(const char* filename);
    void launch();
    Glib::Dispatcher& signal_progress();
    Glib::Dispatcher& signal_finished();
    void progress_callback(float fraction);
    float get_progress();
    const char* filename;
    gig::File* gig;

private:
    Glib::Thread* thread;
    void thread_function();
    Glib::Dispatcher finished_dispatcher;
    Glib::Dispatcher progress_dispatcher;
    Glib::Mutex progressMutex;
    float progress;
};

class MainWindow : public Gtk::Window {
public:
    MainWindow();
    virtual ~MainWindow();
    void load_file(const char* name);
    void load_instrument(gig::Instrument* instr);
    void file_changed();
    sigc::signal<void, gig::File*>& signal_file_structure_to_be_changed();
    sigc::signal<void, gig::File*>& signal_file_structure_changed();
    sigc::signal<void, std::list<gig::Sample*> >& signal_samples_to_be_removed();
    sigc::signal<void>& signal_samples_removed();
    sigc::signal<void, gig::Region*>& signal_region_to_be_changed();
    sigc::signal<void, gig::Region*>& signal_region_changed();
    sigc::signal<void, gig::DimensionRegion*>& signal_dimreg_to_be_changed();
    sigc::signal<void, gig::DimensionRegion*>& signal_dimreg_changed();
    sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/>& signal_sample_ref_changed();

protected:
    Glib::RefPtr<Gtk::ActionGroup> actionGroup;
    Glib::RefPtr<Gtk::UIManager> uiManager;

    Gtk::Statusbar m_StatusBar;
    Gtk::Label     m_AttachedStateLabel;
    Gtk::Image     m_AttachedStateImage;

    RegionChooser m_RegionChooser;
    DimRegionChooser m_DimRegionChooser;

    PropDialog propDialog;
    InstrumentProps instrumentProps;

    sigc::signal<void, gig::File*> file_structure_to_be_changed_signal;
    sigc::signal<void, gig::File*> file_structure_changed_signal;
    sigc::signal<void, std::list<gig::Sample*> > samples_to_be_removed_signal;
    sigc::signal<void> samples_removed_signal;
    sigc::signal<void, gig::Region*> region_to_be_changed_signal;
    sigc::signal<void, gig::Region*> region_changed_signal;
    sigc::signal<void, gig::DimensionRegion*> dimreg_to_be_changed_signal;
    sigc::signal<void, gig::DimensionRegion*> dimreg_changed_signal;
    sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/> sample_ref_changed_signal;

    void on_instrument_selection_change(int index);
    void on_sel_change();
    void region_changed();
    void dimreg_changed();
    void on_loader_progress();
    void on_loader_finished();
    void dimreg_all_dimregs_toggled();
    gig::Instrument* get_instrument();
    void add_region_to_dimregs(gig::Region* region, bool stereo, bool all_dimregs);
    void update_dimregs();

    class ModelColumns : public Gtk::TreeModel::ColumnRecord {
    public:
        ModelColumns() {
          add(m_col_name);
          add(m_col_instr);
        }

        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
        Gtk::TreeModelColumn<gig::Instrument*> m_col_instr;
    } m_Columns;

    Gtk::VBox m_VBox;
    Gtk::HPaned m_HPaned;

    Gtk::ScrolledWindow m_ScrolledWindow;

    Gtk::TreeView m_TreeView;
    Glib::RefPtr<Gtk::ListStore> m_refTreeModel;

    class SamplesModel : public Gtk::TreeModel::ColumnRecord {
    public:
        SamplesModel() {
            add(m_col_name);
            add(m_col_sample);
            add(m_col_group);
        }

        Gtk::TreeModelColumn<Glib::ustring> m_col_name;
        Gtk::TreeModelColumn<gig::Sample*> m_col_sample;
        Gtk::TreeModelColumn<gig::Group*> m_col_group;
    } m_SamplesModel;

    class SamplesTreeStore : public Gtk::TreeStore {
    public:
        static Glib::RefPtr<SamplesTreeStore> create(const SamplesModel& columns) {
            return Glib::RefPtr<SamplesTreeStore>( new SamplesTreeStore(columns) );
        }
    protected:
        SamplesTreeStore(const SamplesModel& columns) : Gtk::TreeStore(columns) {}
    };

    Gtk::ScrolledWindow m_ScrolledWindowSamples;
    Gtk::TreeView m_TreeViewSamples;
    Glib::RefPtr<SamplesTreeStore> m_refSamplesTreeModel;

    Gtk::VBox dimreg_vbox;
    Gtk::HBox dimreg_hbox;
    Gtk::Label dimreg_label;
    Gtk::CheckButton dimreg_all_regions;
    Gtk::CheckButton dimreg_all_dimregs;
    Gtk::CheckButton dimreg_stereo;
    DimRegionEdit dimreg_edit;

    Gtk::Notebook m_Notebook;
    Gtk::Notebook m_TreeViewNotebook;

    struct SampleImportItem {
        gig::Sample*  gig_sample;  // pointer to the gig::Sample to
                                   // which the sample data should be
                                   // imported to
        Glib::ustring sample_path; // file name of the sample to be
                                   // imported
    };
    std::list<SampleImportItem> m_SampleImportQueue;


    void on_action_file_new();
    void on_action_file_open();
    void on_action_file_save();
    void on_action_file_save_as();
    void on_action_file_properties();
    void on_action_quit();
    void show_instr_props();
    void on_action_view_status_bar();
    void on_action_help_about();

    // sample right-click popup actions
    void on_sample_treeview_button_release(GdkEventButton* button);
    void on_action_sample_properties();
    void on_action_add_group();
    void on_action_add_sample();
    void on_action_remove_sample();

    void on_action_add_instrument();
    void on_action_remove_instrument();

    LoadDialog* load_dialog;
    Loader* loader;
    void load_gig(gig::File* gig, const char* filename, bool isSharedInstrument = false);

    gig::File* file;
    bool file_is_shared;
    bool file_has_name;
    bool file_is_changed;
    std::string filename;
    std::string current_dir;

    void set_file_is_shared(bool);

    bool file_save();
    bool file_save_as();
    bool check_if_savable();

    void on_button_release(GdkEventButton* button);
    void on_sample_treeview_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context);
    void on_sample_treeview_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&,
                                          Gtk::SelectionData& selection_data, guint, guint);
    void on_sample_label_drop_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context,
                                                 int, int,
                                                 const Gtk::SelectionData& selection_data,
                                                 guint, guint time);

    void sample_name_changed(const Gtk::TreeModel::Path& path,
                             const Gtk::TreeModel::iterator& iter);
    void instrument_name_changed(const Gtk::TreeModel::Path& path,
                                 const Gtk::TreeModel::iterator& iter);

    void __import_queued_samples();
    void __clear();

    bool close_confirmation_dialog();
    bool leaving_shared_mode_dialog();

    Gtk::Menu* popup_menu;

    bool on_delete_event(GdkEventAny* event);

    bool first_call_to_drag_data_get;
};

#endif
1	/* -- c++ --
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	#ifndef GIGEDIT_MAINWINDOW_H
21	#define GIGEDIT_MAINWINDOW_H
22
23	#include <gig.h>
24
25	#include <gtkmm/actiongroup.h>
26	#include <gtkmm/buttonbox.h>
27	#include <gtkmm/dialog.h>
28	#include <gtkmm/liststore.h>
29	#include <gtkmm/paned.h>
30	#include <gtkmm/progressbar.h>
31	#include <gtkmm/scrolledwindow.h>
32	#include <gtkmm/treestore.h>
33	#include <gtkmm/uimanager.h>
34	#include <gtkmm/window.h>
35	#include <gtkmm/statusbar.h>
36	#include <gtkmm/image.h>
37
38	#include <sstream>
39
40	#include "regionchooser.h"
41	#include "dimregionchooser.h"
42	#include "dimregionedit.h"
43
44	class MainWindow;
45
46	class PropDialog : public Gtk::Window {
47	public:
48	PropDialog();
49	void set_info(DLS::Info* info);
50	protected:
51	Gtk::Table table;
52	Gtk::Label label[16];
53	Gtk::Entry entry[16];
54	};
55
56	class InstrumentProps : public Gtk::Window {
57	public:
58	InstrumentProps();
59	void set_instrument(gig::Instrument* instrument);
60	sigc::signal<void>& signal_instrument_changed();
61	protected:
62	gig::Instrument* instrument;
63	int update_model;
64
65	template<typename T>
66	void set_value(T value, sigc::slot<void, InstrumentProps*, T> setter) {
67	if (update_model == 0) {
68	setter(this, value);
69	instrument_changed();
70	}
71	}
72
73	template<typename C, typename T>
74	void connect(C& widget, T gig::Instrument::* member) {
75	widget.signal_value_changed().connect(
76	sigc::compose(
77	sigc::bind(sigc::mem_fun(*this, &InstrumentProps::set_value<T>),
78	sigc::bind(sigc::mem_fun(&InstrumentProps::set_member<T>), member)),
79	sigc::mem_fun(widget, &C::get_value)));
80	}
81
82	template<typename C, typename T>
83	void connect(C& widget, void (InstrumentProps::*setter)(T)) {
84	widget.signal_value_changed().connect(
85	sigc::compose(
86	sigc::bind(sigc::mem_fun(*this, &InstrumentProps::set_value<T>),
87	sigc::mem_fun(setter)),
88	sigc::mem_fun(widget, &C::get_value)));
89	}
90
91	template<typename T>
92	void set_member(T value, T gig::Instrument::* member) {
93	instrument->*member = value;
94	}
95
96	void set_IsDrum(bool value);
97	void set_MIDIBank(uint16_t value);
98	void set_MIDIProgram(uint32_t value);
99	void set_DimensionKeyRange_low(uint8_t value);
100	void set_DimensionKeyRange_high(uint8_t value);
101
102	Gtk::VBox vbox;
103	Gtk::HButtonBox buttonBox;
104	Gtk::Button quitButton;
105	Gtk::Table table;
106	StringEntry eName;
107	BoolEntry eIsDrum;
108	NumEntryTemp<uint16_t> eMIDIBank;
109	NumEntryTemp<uint32_t> eMIDIProgram;
110	NumEntryGain eAttenuation;
111	BoolEntryPlus6 eGainPlus6;
112	NumEntryTemp<uint16_t> eEffectSend;
113	NumEntryTemp<int16_t> eFineTune;
114	NumEntryTemp<uint16_t> ePitchbendRange;
115	BoolEntry ePianoReleaseMode;
116	NoteEntry eDimensionKeyRangeLow;
117	NoteEntry eDimensionKeyRangeHigh;
118	int rowno;
119	void add_prop(BoolEntry& prop);
120	void add_prop(BoolEntryPlus6& prop);
121	void add_prop(LabelWidget& prop);
122	sigc::signal<void> instrument_changed;
123	};
124
125	class LoadDialog : public Gtk::Dialog {
126	public:
127	LoadDialog(const Glib::ustring& title, Gtk::Window& parent);
128	void set_fraction(float fraction) { progressBar.set_fraction(fraction); }
129	protected:
130	Gtk::ProgressBar progressBar;
131	};
132
133	class Loader : public sigc::trackable {
134	public:
135	Loader(const char* filename);
136	void launch();
137	Glib::Dispatcher& signal_progress();
138	Glib::Dispatcher& signal_finished();
139	void progress_callback(float fraction);
140	float get_progress();
141	const char* filename;
142	gig::File* gig;
143
144	private:
145	Glib::Thread* thread;
146	void thread_function();
147	Glib::Dispatcher finished_dispatcher;
148	Glib::Dispatcher progress_dispatcher;
149	Glib::Mutex progressMutex;
150	float progress;
151	};
152
153	class MainWindow : public Gtk::Window {
154	public:
155	MainWindow();
156	virtual ~MainWindow();
157	void load_file(const char* name);
158	void load_instrument(gig::Instrument* instr);
159	void file_changed();
160	sigc::signal<void, gig::File*>& signal_file_structure_to_be_changed();
161	sigc::signal<void, gig::File*>& signal_file_structure_changed();
162	sigc::signal<void, std::list<gig::Sample*> >& signal_samples_to_be_removed();
163	sigc::signal<void>& signal_samples_removed();
164	sigc::signal<void, gig::Region*>& signal_region_to_be_changed();
165	sigc::signal<void, gig::Region*>& signal_region_changed();
166	sigc::signal<void, gig::DimensionRegion*>& signal_dimreg_to_be_changed();
167	sigc::signal<void, gig::DimensionRegion*>& signal_dimreg_changed();
168	sigc::signal<void, gig::Sample/old/, gig::Sample/new/>& signal_sample_ref_changed();
169
170	protected:
171	Glib::RefPtr<Gtk::ActionGroup> actionGroup;
172	Glib::RefPtr<Gtk::UIManager> uiManager;
173
174	Gtk::Statusbar m_StatusBar;
175	Gtk::Label m_AttachedStateLabel;
176	Gtk::Image m_AttachedStateImage;
177
178	RegionChooser m_RegionChooser;
179	DimRegionChooser m_DimRegionChooser;
180
181	PropDialog propDialog;
182	InstrumentProps instrumentProps;
183
184	sigc::signal<void, gig::File*> file_structure_to_be_changed_signal;
185	sigc::signal<void, gig::File*> file_structure_changed_signal;
186	sigc::signal<void, std::list<gig::Sample*> > samples_to_be_removed_signal;
187	sigc::signal<void> samples_removed_signal;
188	sigc::signal<void, gig::Region*> region_to_be_changed_signal;
189	sigc::signal<void, gig::Region*> region_changed_signal;
190	sigc::signal<void, gig::DimensionRegion*> dimreg_to_be_changed_signal;
191	sigc::signal<void, gig::DimensionRegion*> dimreg_changed_signal;
192	sigc::signal<void, gig::Sample/old/, gig::Sample/new/> sample_ref_changed_signal;
193
194	void on_instrument_selection_change(int index);
195	void on_sel_change();
196	void region_changed();
197	void dimreg_changed();
198	void on_loader_progress();
199	void on_loader_finished();
200	void dimreg_all_dimregs_toggled();
201	gig::Instrument* get_instrument();
202	void add_region_to_dimregs(gig::Region* region, bool stereo, bool all_dimregs);
203	void update_dimregs();
204
205	class ModelColumns : public Gtk::TreeModel::ColumnRecord {
206	public:
207	ModelColumns() {
208	add(m_col_name);
209	add(m_col_instr);
210	}
211
212	Gtk::TreeModelColumn<Glib::ustring> m_col_name;
213	Gtk::TreeModelColumn<gig::Instrument*> m_col_instr;
214	} m_Columns;
215
216	Gtk::VBox m_VBox;
217	Gtk::HPaned m_HPaned;
218
219	Gtk::ScrolledWindow m_ScrolledWindow;
220
221	Gtk::TreeView m_TreeView;
222	Glib::RefPtr<Gtk::ListStore> m_refTreeModel;
223
224	class SamplesModel : public Gtk::TreeModel::ColumnRecord {
225	public:
226	SamplesModel() {
227	add(m_col_name);
228	add(m_col_sample);
229	add(m_col_group);
230	}
231
232	Gtk::TreeModelColumn<Glib::ustring> m_col_name;
233	Gtk::TreeModelColumn<gig::Sample*> m_col_sample;
234	Gtk::TreeModelColumn<gig::Group*> m_col_group;
235	} m_SamplesModel;
236
237	class SamplesTreeStore : public Gtk::TreeStore {
238	public:
239	static Glib::RefPtr<SamplesTreeStore> create(const SamplesModel& columns) {
240	return Glib::RefPtr<SamplesTreeStore>( new SamplesTreeStore(columns) );
241	}
242	protected:
243	SamplesTreeStore(const SamplesModel& columns) : Gtk::TreeStore(columns) {}
244	};
245
246	Gtk::ScrolledWindow m_ScrolledWindowSamples;
247	Gtk::TreeView m_TreeViewSamples;
248	Glib::RefPtr<SamplesTreeStore> m_refSamplesTreeModel;
249
250	Gtk::VBox dimreg_vbox;
251	Gtk::HBox dimreg_hbox;
252	Gtk::Label dimreg_label;
253	Gtk::CheckButton dimreg_all_regions;
254	Gtk::CheckButton dimreg_all_dimregs;
255	Gtk::CheckButton dimreg_stereo;
256	DimRegionEdit dimreg_edit;
257
258	Gtk::Notebook m_Notebook;
259	Gtk::Notebook m_TreeViewNotebook;
260
261	struct SampleImportItem {
262	gig::Sample* gig_sample; // pointer to the gig::Sample to
263	// which the sample data should be
264	// imported to
265	Glib::ustring sample_path; // file name of the sample to be
266	// imported
267	};
268	std::list<SampleImportItem> m_SampleImportQueue;
269
270
271	void on_action_file_new();
272	void on_action_file_open();
273	void on_action_file_save();
274	void on_action_file_save_as();
275	void on_action_file_properties();
276	void on_action_quit();
277	void show_instr_props();
278	void on_action_view_status_bar();
279	void on_action_help_about();
280
281	// sample right-click popup actions
282	void on_sample_treeview_button_release(GdkEventButton* button);
283	void on_action_sample_properties();
284	void on_action_add_group();
285	void on_action_add_sample();
286	void on_action_remove_sample();
287
288	void on_action_add_instrument();
289	void on_action_remove_instrument();
290
291	LoadDialog* load_dialog;
292	Loader* loader;
293	void load_gig(gig::File* gig, const char* filename, bool isSharedInstrument = false);
294
295	gig::File* file;
296	bool file_is_shared;
297	bool file_has_name;
298	bool file_is_changed;
299	std::string filename;
300	std::string current_dir;
301
302	void set_file_is_shared(bool);
303
304	bool file_save();
305	bool file_save_as();
306	bool check_if_savable();
307
308	void on_button_release(GdkEventButton* button);
309	void on_sample_treeview_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context);
310	void on_sample_treeview_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&,
311	Gtk::SelectionData& selection_data, guint, guint);
312	void on_sample_label_drop_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context,
313	int, int,
314	const Gtk::SelectionData& selection_data,
315	guint, guint time);
316
317	void sample_name_changed(const Gtk::TreeModel::Path& path,
318	const Gtk::TreeModel::iterator& iter);
319	void instrument_name_changed(const Gtk::TreeModel::Path& path,
320	const Gtk::TreeModel::iterator& iter);
321
322	void __import_queued_samples();
323	void __clear();
324
325	bool close_confirmation_dialog();
326	bool leaving_shared_mode_dialog();
327
328	Gtk::Menu* popup_menu;
329
330	bool on_delete_event(GdkEventAny* event);
331
332	bool first_call_to_drag_data_get;
333	};
334
335	#endif