/[svn]/gigedit/trunk/src/mainwindow.h
ViewVC logotype

Contents of /gigedit/trunk/src/mainwindow.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1080 - (show annotations) (download) (as text)
Tue Mar 6 23:16:18 2007 UTC (16 years, 11 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 16230 byte(s)
* listview on the left is now tabbed into "Instruments" and new: "Samples",
  the latter are displayed in their respective sample group

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/alignment.h>
27 #include <gtkmm/box.h>
28 #include <gtkmm/buttonbox.h>
29 #include <gtkmm/combobox.h>
30 #include <gtkmm/comboboxtext.h>
31 #include <gtkmm/dialog.h>
32 #include <gtkmm/entry.h>
33 #include <gtkmm/label.h>
34 #include <gtkmm/liststore.h>
35 #include <gtkmm/notebook.h>
36 #include <gtkmm/paned.h>
37 #include <gtkmm/progressbar.h>
38 #include <gtkmm/scale.h>
39 #include <gtkmm/scrolledwindow.h>
40 #include <gtkmm/spinbutton.h>
41 #include <gtkmm/table.h>
42 #include <gtkmm/treestore.h>
43 #include <gtkmm/treeview.h>
44 #include <gtkmm/uimanager.h>
45 #include <gtkmm/window.h>
46 #include <gtkmm/menuitem.h>
47
48 #include "regionchooser.h"
49 #include "dimregionchooser.h"
50
51 extern bool update_gui;
52
53 class MainWindow;
54
55 class PropDialog : public Gtk::Window {
56 public:
57 PropDialog();
58 void set_info(DLS::Info* info);
59 protected:
60 Gtk::Table table;
61 Gtk::Label label[16];
62 Gtk::Entry entry[16];
63 };
64
65 class InstrumentProps : public Gtk::Window {
66 public:
67 InstrumentProps();
68 void set_instrument(gig::Instrument* instrument);
69 protected:
70 Gtk::VBox vbox;
71 Gtk::HButtonBox buttonBox;
72 Gtk::Button quitButton;
73 Gtk::Table table;
74 Gtk::Label label[10];
75 Gtk::Entry entry[8];
76 Gtk::CheckButton check[2];
77 };
78
79 class LoadDialog : public Gtk::Dialog {
80 public:
81 LoadDialog();
82 void set_fraction(float fraction) { progressBar.set_fraction(fraction); }
83 protected:
84 Gtk::ProgressBar progressBar;
85 };
86
87 class Loader : public sigc::trackable {
88 public:
89 Loader(const char* filename);
90 void launch();
91 Glib::Dispatcher& signal_progress();
92 Glib::Dispatcher& signal_finished();
93 void progress_callback(float fraction);
94 float get_progress();
95 const char* filename;
96 gig::File* gig;
97
98 private:
99 Glib::Thread* thread;
100 void thread_function();
101 Glib::Dispatcher finished_dispatcher;
102 Glib::Dispatcher progress_dispatcher;
103 Glib::Mutex progressMutex;
104 float progress;
105 };
106
107 class LabelWidget {
108 public:
109 Gtk::Label label;
110 Gtk::Widget& widget;
111
112 LabelWidget(char* labelText, Gtk::Widget& widget);
113 void set_sensitive(bool sensitive = true);
114 };
115
116
117 template<typename T2>
118 class NumEntry : public LabelWidget {
119 protected:
120 Gtk::Adjustment adjust;
121 Gtk::HScale scale;
122 Gtk::SpinButton spinbutton;
123 Gtk::HBox box;
124 T2* dimreg;
125 public:
126 NumEntry(char* labelText, double lower = 0, double upper = 127,
127 int decimals = 0);
128 void set_value(double value) {
129 spinbutton.set_value(value);
130 }
131 Glib::SignalProxy0<void> signal_value_changed() {
132 return spinbutton.signal_value_changed();
133 }
134 double get_value() const {
135 return spinbutton.get_value();
136 }
137 };
138
139 template<typename T2>
140 NumEntry<T2>::NumEntry(char* labelText, double lower, double upper,
141 int decimals) :
142 adjust(lower, lower, upper, 1, 10),
143 scale(adjust),
144 spinbutton(adjust),
145 LabelWidget(labelText, box)
146 {
147 spinbutton.set_digits(decimals);
148 scale.set_draw_value(false);
149 box.pack_start(spinbutton, Gtk::PACK_SHRINK);
150 box.add(scale);
151 }
152
153 class NumEntryGain : public NumEntry<gig::DimensionRegion> {
154 private:
155 void value_changed();
156 public:
157 NumEntryGain(char* labelText,
158 double lower, double upper, int decimals);
159 void set_dimreg(gig::DimensionRegion* dimreg);
160 };
161
162 template<typename T>
163 class NumEntryX : public NumEntry<gig::DimensionRegion> {
164 private:
165 T& (*access)(gig::DimensionRegion*);
166 void value_changed();
167 public:
168 NumEntryX(char* labelText, T& (*access)(gig::DimensionRegion*),
169 double lower = 0, double upper = 127, int decimals = 0);
170 void set_dimreg(gig::DimensionRegion* dimreg);
171 };
172
173 template<typename T>
174 NumEntryX<T>::NumEntryX(char* labelText, T& (*access)(gig::DimensionRegion*),
175 double lower, double upper, int decimals) :
176 NumEntry<gig::DimensionRegion>(labelText, lower, upper, decimals),
177 access(access)
178 {
179 spinbutton.signal_value_changed().connect(
180 sigc::mem_fun(*this, &NumEntryX::value_changed));
181 }
182
183 template<typename T>
184 void NumEntryX<T>::value_changed()
185 {
186 if (dimreg && update_gui) {
187 access(dimreg) = T(spinbutton.get_value());
188 }
189 }
190
191 template<typename T>
192 void NumEntryX<T>::set_dimreg(gig::DimensionRegion* dimreg)
193 {
194 this->dimreg = 0;
195 set_value(access(dimreg));
196 this->dimreg = dimreg;
197 }
198
199
200 class NoteEntry : public NumEntryX<uint8_t> {
201 public:
202 NoteEntry(char* labelText, uint8_t& (*access)(gig::DimensionRegion*));
203 private:
204 int on_input(double* new_value);
205 bool on_output();
206 };
207
208
209 template<typename T, typename T2 = gig::DimensionRegion>
210 class NumEntryTemp : public NumEntry<T2> {
211 using NumEntry<T2>::spinbutton;
212 using NumEntry<T2>::dimreg;
213 private:
214 T T2::* param;
215 void value_changed();
216 public:
217 NumEntryTemp(char* labelText, T T2::* param,
218 double lower = 0, double upper = 127, int decimals = 0);
219 void set_dimreg(gig::DimensionRegion* dimreg);
220 };
221
222 template<typename T, typename T2>
223 NumEntryTemp<T, T2>::NumEntryTemp(char* labelText, T T2::* param,
224 double lower, double upper, int decimals) :
225 NumEntry<T2>(labelText, lower, upper, decimals),
226 param(param)
227 {
228 spinbutton.signal_value_changed().connect(
229 sigc::mem_fun(*this, &NumEntryTemp<T, T2>::value_changed));
230 }
231
232 template<typename T, typename T2>
233 void NumEntryTemp<T, T2>::value_changed()
234 {
235 if (dimreg && update_gui) {
236 dimreg->*param = T(spinbutton.get_value());
237 }
238 }
239
240 template<typename T, typename T2>
241 void NumEntryTemp<T, T2>::set_dimreg(gig::DimensionRegion* dimreg)
242 {
243 this->dimreg = 0;
244 set_value(dimreg->*param);
245 this->dimreg = dimreg;
246 }
247
248
249
250 class NumEntryPermille : public NumEntry<gig::DimensionRegion> {
251 private:
252 uint16_t gig::DimensionRegion::* param;
253 void value_changed();
254 public:
255 NumEntryPermille(char* labelText, uint16_t gig::DimensionRegion::* param,
256 double lower = 0, double upper = 127, int decimals = 0);
257 void set_dimreg(gig::DimensionRegion* dimreg);
258 };
259
260
261 template<typename T>
262 class ChoiceEntry : public LabelWidget {
263 private:
264 Gtk::ComboBoxText combobox;
265 Gtk::Alignment align;
266 T gig::DimensionRegion::* param;
267 gig::DimensionRegion* dimreg;
268 void value_changed();
269 const T* values;
270 public:
271 ChoiceEntry(char* labelText,
272 T gig::DimensionRegion::* param);
273 void set_choices(char** texts, const T* values);
274 void set_dimreg(gig::DimensionRegion* dimreg);
275 int get_active_row_number() { return combobox.get_active_row_number(); }
276 Glib::SignalProxy0<void> signal_changed() {
277 return combobox.signal_changed();
278 }
279 };
280
281 template<typename T>
282 ChoiceEntry<T>::ChoiceEntry(char* labelText,
283 T gig::DimensionRegion::* param) :
284 align(0, 0, 0, 0),
285 LabelWidget(labelText, align),
286 param(param)
287 {
288 combobox.signal_changed().connect(
289 sigc::mem_fun(*this, &ChoiceEntry::value_changed));
290 align.add(combobox);
291 }
292
293 template<typename T>
294 void ChoiceEntry<T>::set_choices(char** texts, const T* values)
295 {
296 for (int i = 0 ; texts[i] ; i++) {
297 combobox.append_text(texts[i]);
298 }
299 this->values = values;
300 }
301
302 template<typename T>
303 void ChoiceEntry<T>::value_changed()
304 {
305 if (dimreg && update_gui) {
306 int rowno = combobox.get_active_row_number();
307 if (rowno != -1) dimreg->*param = values[rowno];
308 }
309 }
310
311 template<typename T>
312 void ChoiceEntry<T>::set_dimreg(gig::DimensionRegion* dimreg)
313 {
314 this->dimreg = 0;
315 T value = dimreg->*param;
316 int row = 0;
317 int nb_rows = combobox.get_model()->children().size();
318 for (; row < nb_rows ; row++) {
319 if (value == values[row]) break;
320 }
321 combobox.set_active(row == nb_rows ? -1 : row);
322 this->dimreg = dimreg;
323 }
324
325
326 class ChoiceEntryLeverageCtrl : public LabelWidget {
327 private:
328 Gtk::ComboBoxText combobox;
329 Gtk::Alignment align;
330 gig::leverage_ctrl_t gig::DimensionRegion::* param;
331 gig::DimensionRegion* dimreg;
332 void value_changed();
333 public:
334 ChoiceEntryLeverageCtrl(char* labelText,
335 gig::leverage_ctrl_t gig::DimensionRegion::* param);
336 void set_dimreg(gig::DimensionRegion* dimreg);
337 int get_active_row_number() { return combobox.get_active_row_number(); }
338 Glib::SignalProxy0<void> signal_changed() {
339 return combobox.signal_changed();
340 }
341 };
342
343
344
345 class BoolEntry : public LabelWidget {
346 private:
347 Gtk::CheckButton checkbutton;
348 bool gig::DimensionRegion::* param;
349 gig::DimensionRegion* dimreg;
350 void value_changed();
351 public:
352 BoolEntry(char* labelText, bool gig::DimensionRegion::* param);
353 void set_dimreg(gig::DimensionRegion* dimreg);
354 bool get_active() { return checkbutton.get_active(); }
355 Glib::SignalProxy0<void> signal_toggled() {
356 return checkbutton.signal_toggled();
357 }
358 };
359
360 class MainWindow : public Gtk::Window {
361 public:
362 MainWindow();
363 virtual ~MainWindow();
364 void getInfo(const char* filename);
365
366 protected:
367 Glib::RefPtr<Gtk::ActionGroup> actionGroup;
368 Glib::RefPtr<Gtk::UIManager> uiManager;
369
370 int rowno;
371 int pageno;
372 int firstRowInBlock;
373
374 NumEntryTemp<uint8_t> eVelocityUpperLimit;
375 NumEntryPermille eEG1PreAttack;
376 NumEntryTemp<double> eEG1Attack;
377 NumEntryTemp<double> eEG1Decay1;
378 NumEntryTemp<double> eEG1Decay2;
379 BoolEntry eEG1InfiniteSustain;
380 NumEntryPermille eEG1Sustain;
381 NumEntryTemp<double> eEG1Release;
382 BoolEntry eEG1Hold;
383 ChoiceEntryLeverageCtrl eEG1Controller;
384 BoolEntry eEG1ControllerInvert;
385 NumEntryTemp<uint8_t> eEG1ControllerAttackInfluence;
386 NumEntryTemp<uint8_t> eEG1ControllerDecayInfluence;
387 NumEntryTemp<uint8_t> eEG1ControllerReleaseInfluence;
388 NumEntryTemp<double> eLFO1Frequency;
389 NumEntryTemp<uint16_t> eLFO1InternalDepth;
390 NumEntryTemp<uint16_t> eLFO1ControlDepth;
391 ChoiceEntry<gig::lfo1_ctrl_t> eLFO1Controller;
392 BoolEntry eLFO1FlipPhase;
393 BoolEntry eLFO1Sync;
394 NumEntryPermille eEG2PreAttack;
395 NumEntryTemp<double> eEG2Attack;
396 NumEntryTemp<double> eEG2Decay1;
397 NumEntryTemp<double> eEG2Decay2;
398 BoolEntry eEG2InfiniteSustain;
399 NumEntryPermille eEG2Sustain;
400 NumEntryTemp<double> eEG2Release;
401 ChoiceEntryLeverageCtrl eEG2Controller;
402 BoolEntry eEG2ControllerInvert;
403 NumEntryTemp<uint8_t> eEG2ControllerAttackInfluence;
404 NumEntryTemp<uint8_t> eEG2ControllerDecayInfluence;
405 NumEntryTemp<uint8_t> eEG2ControllerReleaseInfluence;
406 NumEntryTemp<double> eLFO2Frequency;
407 NumEntryTemp<uint16_t> eLFO2InternalDepth;
408 NumEntryTemp<uint16_t> eLFO2ControlDepth;
409 ChoiceEntry<gig::lfo2_ctrl_t> eLFO2Controller;
410 BoolEntry eLFO2FlipPhase;
411 BoolEntry eLFO2Sync;
412 NumEntryTemp<double> eEG3Attack;
413 NumEntryTemp<int16_t> eEG3Depth;
414 NumEntryTemp<double> eLFO3Frequency;
415 NumEntryTemp<int16_t> eLFO3InternalDepth;
416 NumEntryTemp<int16_t> eLFO3ControlDepth;
417 ChoiceEntry<gig::lfo3_ctrl_t> eLFO3Controller;
418 BoolEntry eLFO3Sync;
419 BoolEntry eVCFEnabled;
420 ChoiceEntry<gig::vcf_type_t> eVCFType;
421 ChoiceEntry<gig::vcf_cutoff_ctrl_t> eVCFCutoffController;
422 BoolEntry eVCFCutoffControllerInvert;
423 NumEntryTemp<uint8_t> eVCFCutoff;
424 ChoiceEntry<gig::curve_type_t> eVCFVelocityCurve;
425 NumEntryTemp<uint8_t> eVCFVelocityScale;
426 NumEntryTemp<uint8_t> eVCFVelocityDynamicRange;
427 NumEntryTemp<uint8_t> eVCFResonance;
428 BoolEntry eVCFResonanceDynamic;
429 ChoiceEntry<gig::vcf_res_ctrl_t> eVCFResonanceController;
430 BoolEntry eVCFKeyboardTracking;
431 NumEntryTemp<uint8_t> eVCFKeyboardTrackingBreakpoint;
432 ChoiceEntry<gig::curve_type_t> eVelocityResponseCurve;
433 NumEntryTemp<uint8_t> eVelocityResponseDepth;
434 NumEntryTemp<uint8_t> eVelocityResponseCurveScaling;
435 ChoiceEntry<gig::curve_type_t> eReleaseVelocityResponseCurve;
436 NumEntryTemp<uint8_t> eReleaseVelocityResponseDepth;
437 NumEntryTemp<uint8_t> eReleaseTriggerDecay;
438 NumEntryX<uint8_t> eCrossfade_in_start;
439 NumEntryX<uint8_t> eCrossfade_in_end;
440 NumEntryX<uint8_t> eCrossfade_out_start;
441 NumEntryX<uint8_t> eCrossfade_out_end;
442 BoolEntry ePitchTrack;
443 ChoiceEntry<gig::dim_bypass_ctrl_t> eDimensionBypass;
444 NumEntryTemp<int8_t> ePan;
445 BoolEntry eSelfMask;
446 ChoiceEntryLeverageCtrl eAttenuationController;
447 BoolEntry eInvertAttenuationController;
448 NumEntryTemp<uint8_t> eAttenuationControllerThreshold;
449 NumEntryTemp<uint8_t> eChannelOffset;
450 BoolEntry eSustainDefeat;
451 BoolEntry eMSDecode;
452 NumEntryTemp<uint16_t> eSampleStartOffset;
453 // NumEntryX<uint8_t> eUnityNote;
454 NoteEntry eUnityNote;
455 NumEntryX<int16_t> eFineTune;
456 NumEntryGain eGain;
457 NumEntryX<uint32_t> eSampleLoops;
458
459 void addProp(LabelWidget& labelwidget);
460 void addString(char* labelText, Gtk::Label*& label,
461 Gtk::Entry*& widget);
462 void addHeader(char* text);
463 void nextPage();
464
465 RegionChooser m_RegionChooser;
466 DimRegionChooser m_DimRegionChooser;
467
468 void set_dim_region(gig::DimensionRegion* d);
469 PropDialog propDialog;
470 InstrumentProps instrumentProps;
471
472 void on_instrument_selection_change(int index);
473 void on_sel_change();
474 void region_changed();
475 void dimreg_changed();
476 void on_loader_progress();
477 void on_loader_finished();
478
479 class ModelColumns : public Gtk::TreeModel::ColumnRecord {
480 public:
481
482 ModelColumns() {
483 add(m_col_name);
484 add(m_col_instr);
485 }
486
487 Gtk::TreeModelColumn<Glib::ustring> m_col_name;
488 Gtk::TreeModelColumn<gig::Instrument*> m_col_instr;
489 } m_Columns;
490
491 Gtk::VBox m_VBox;
492 Gtk::HPaned m_HPaned;
493
494 Gtk::ScrolledWindow m_ScrolledWindow;
495 Gtk::TreeView m_TreeView;
496 Glib::RefPtr<Gtk::ListStore> m_refTreeModel;
497
498 class SamplesModel : public Gtk::TreeModel::ColumnRecord {
499 public:
500 SamplesModel() {
501 add(m_col_name);
502 add(m_col_sample);
503 }
504
505 Gtk::TreeModelColumn<Glib::ustring> m_col_name;
506 Gtk::TreeModelColumn<void*> m_col_sample; // either pointing to gig::Group or gig::Sample
507 } m_SamplesModel;
508 Gtk::TreeView m_TreeViewSamples;
509 Glib::RefPtr<Gtk::TreeStore> m_refSamplesTreeModel;
510
511 Gtk::Notebook m_Notebook;
512 Gtk::Notebook m_TreeViewNotebook;
513
514 Gtk::Table* table[5];
515
516 // dimensionregion parameter widgets
517 // TODO: remove:
518 Gtk::Label* lSample;
519 Gtk::Entry* wSample;
520
521 void VCFEnabled_toggled();
522 void VCFCutoffController_changed();
523 void VCFResonanceController_changed();
524 void EG1InfiniteSustain_toggled();
525 void EG2InfiniteSustain_toggled();
526 void EG1Controller_changed();
527 void EG2Controller_changed();
528 void AttenuationController_changed();
529 void LFO1Controller_changed();
530 void LFO2Controller_changed();
531 void LFO3Controller_changed();
532 void crossfade1_changed();
533 void crossfade2_changed();
534 void crossfade3_changed();
535 void crossfade4_changed();
536
537 void on_action_file_new();
538 void on_action_file_open();
539 void on_action_file_save();
540 void on_action_file_save_as();
541 void on_action_file_properties();
542 void on_action_help_about();
543
544 LoadDialog* load_dialog;
545 Loader* loader;
546 void load_gig(gig::File* gig, const char* filename);
547
548 gig::File* file;
549
550 void on_button_release(GdkEventButton* button);
551
552 Gtk::Menu* popup_menu;
553 };
554
555 #endif

  ViewVC Help
Powered by ViewVC