src/gigedit/mainwindow.h

/*                                                         -*- c++ -*-
 * Copyright (C) 2006 - 2013 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/menu.h>
#include <gtkmm/paned.h>
#include <gtkmm/progressbar.h>
#include <gtkmm/radiomenuitem.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"
#ifndef OLD_THREADS
#include <glibmm/threads.h>
#endif

class MainWindow;

class PropDialog : public Gtk::Window,
                   public PropEditor<DLS::Info> {
public:
    PropDialog();
    void set_info(DLS::Info* info);
protected:
    StringEntry eName;
    StringEntry eCreationDate;
    StringEntryMultiLine eComments;
    StringEntry eProduct;
    StringEntry eCopyright;
    StringEntry eArtists;
    StringEntry eGenre;
    StringEntry eKeywords;
    StringEntry eEngineer;
    StringEntry eTechnician;
    StringEntry eSoftware;
    StringEntry eMedium;
    StringEntry eSource;
    StringEntry eSourceForm;
    StringEntry eCommissioned;
    StringEntry eSubject;
    Gtk::VBox vbox;
    Gtk::HButtonBox buttonBox;
    Gtk::Button quitButton;
    Table table;
};

class InstrumentProps : public Gtk::Window,
                        public PropEditor<gig::Instrument> {
public:
    InstrumentProps();
    void set_instrument(gig::Instrument* instrument);
protected:
    void set_IsDrum(bool value);
    void set_MIDIBank(uint16_t value);
    void set_MIDIProgram(uint32_t value);

    Gtk::VBox vbox;
    Gtk::HButtonBox buttonBox;
    Gtk::Button quitButton;
    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;
};

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::Threads::Thread* thread;
    void thread_function();
    Glib::Dispatcher finished_dispatcher;
    Glib::Dispatcher progress_dispatcher;
    Glib::Threads::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*>& signal_sample_changed();
    sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/>& signal_sample_ref_changed();

    sigc::signal<void, int/*key*/, int/*velocity*/>& signal_note_on();
    sigc::signal<void, int/*key*/, int/*velocity*/>& signal_note_off();

    sigc::signal<void, int/*key*/, int/*velocity*/>& signal_keyboard_key_hit();
    sigc::signal<void, int/*key*/, int/*velocity*/>& signal_keyboard_key_released();

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*> sample_changed_signal;
    sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/> sample_ref_changed_signal;

    sigc::signal<void, int/*key*/, int/*velocity*/> note_on_signal;
    sigc::signal<void, int/*key*/, int/*velocity*/> note_off_signal;

    void on_instrument_selection_change(Gtk::RadioMenuItem* item);
    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;

    Gtk::Menu* instrument_menu;

    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_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_replace_all_samples_in_all_groups();
    void on_action_remove_sample();

    void on_action_add_instrument();
    void on_action_duplicate_instrument();
    void on_action_remove_instrument();

    void add_instrument(gig::Instrument* instrument);
    Gtk::RadioMenuItem* add_instrument_to_menu(const Glib::ustring& name,
                                               int position = -1);
    void remove_instrument_from_menu(int index);

    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_gig_dir;
    std::string current_sample_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);
    sigc::connection instrument_name_connection;

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