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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1099 by schoenebeck, Wed Mar 14 23:19:26 2007 UTC revision 1100 by persson, Sat Mar 17 09:20:19 2007 UTC
# Line 23  Line 23 
23  #include <gig.h>  #include <gig.h>
24    
25  #include <gtkmm/actiongroup.h>  #include <gtkmm/actiongroup.h>
 #include <gtkmm/alignment.h>  
 #include <gtkmm/box.h>  
26  #include <gtkmm/buttonbox.h>  #include <gtkmm/buttonbox.h>
 #include <gtkmm/combobox.h>  
 #include <gtkmm/comboboxtext.h>  
27  #include <gtkmm/dialog.h>  #include <gtkmm/dialog.h>
 #include <gtkmm/entry.h>  
 #include <gtkmm/label.h>  
28  #include <gtkmm/liststore.h>  #include <gtkmm/liststore.h>
 #include <gtkmm/notebook.h>  
29  #include <gtkmm/paned.h>  #include <gtkmm/paned.h>
30  #include <gtkmm/progressbar.h>  #include <gtkmm/progressbar.h>
 #include <gtkmm/scale.h>  
31  #include <gtkmm/scrolledwindow.h>  #include <gtkmm/scrolledwindow.h>
 #include <gtkmm/spinbutton.h>  
 #include <gtkmm/table.h>  
32  #include <gtkmm/treestore.h>  #include <gtkmm/treestore.h>
 #include <gtkmm/treeview.h>  
33  #include <gtkmm/uimanager.h>  #include <gtkmm/uimanager.h>
34  #include <gtkmm/window.h>  #include <gtkmm/window.h>
 #include <gtkmm/menuitem.h>  
 #include <gtkmm/treemodel.h>  
35    
36  #include <sstream>  #include <sstream>
37    
38  #include "regionchooser.h"  #include "regionchooser.h"
39  #include "dimregionchooser.h"  #include "dimregionchooser.h"
40    #include "dimregionedit.h"
 extern bool update_gui;  
41    
42  class MainWindow;  class MainWindow;
43    
# Line 81  protected: Line 67  protected:
67    
68  class LoadDialog : public Gtk::Dialog {  class LoadDialog : public Gtk::Dialog {
69  public:  public:
70      LoadDialog();      LoadDialog(const Glib::ustring& title, Gtk::Window& parent);
71      void set_fraction(float fraction) { progressBar.set_fraction(fraction); }      void set_fraction(float fraction) { progressBar.set_fraction(fraction); }
72  protected:  protected:
73      Gtk::ProgressBar progressBar;      Gtk::ProgressBar progressBar;
# Line 107  private: Line 93  private:
93      float progress;      float progress;
94  };  };
95    
 class LabelWidget {  
 public:  
     Gtk::Label label;  
     Gtk::Widget& widget;  
   
     LabelWidget(char* labelText, Gtk::Widget& widget);  
     void set_sensitive(bool sensitive = true);  
 };  
   
   
 template<typename T2>  
 class NumEntry : public LabelWidget {  
 protected:  
     Gtk::Adjustment adjust;  
     Gtk::HScale scale;  
     Gtk::SpinButton spinbutton;  
     Gtk::HBox box;  
     T2* dimreg;  
 public:  
     NumEntry(char* labelText, double lower = 0, double upper = 127,  
              int decimals = 0);  
     void set_value(double value) {  
         spinbutton.set_value(value);  
     }  
     Glib::SignalProxy0<void> signal_value_changed() {  
         return spinbutton.signal_value_changed();  
     }  
     double get_value() const {  
         return spinbutton.get_value();  
     }  
 };  
   
 template<typename T2>  
 NumEntry<T2>::NumEntry(char* labelText, double lower, double upper,  
                        int decimals) :  
     adjust(lower, lower, upper, 1, 10),  
     scale(adjust),  
     spinbutton(adjust),  
     LabelWidget(labelText, box)  
 {  
     spinbutton.set_digits(decimals);  
     scale.set_draw_value(false);  
     box.pack_start(spinbutton, Gtk::PACK_SHRINK);  
     box.add(scale);  
 }  
   
 class NumEntryGain : public NumEntry<gig::DimensionRegion> {  
 private:  
     void value_changed();  
 public:  
     NumEntryGain(char* labelText,  
                  double lower, double upper, int decimals);  
     void set_dimreg(gig::DimensionRegion* dimreg);  
 };  
   
 template<typename T>  
 class NumEntryX : public NumEntry<gig::DimensionRegion> {  
 private:  
     T& (*access)(gig::DimensionRegion*);  
     void value_changed();  
 public:  
     NumEntryX(char* labelText, T& (*access)(gig::DimensionRegion*),  
               double lower = 0, double upper = 127, int decimals = 0);  
     void set_dimreg(gig::DimensionRegion* dimreg);  
 };  
   
 template<typename T>  
 NumEntryX<T>::NumEntryX(char* labelText, T& (*access)(gig::DimensionRegion*),  
                         double lower, double upper, int decimals) :  
     NumEntry<gig::DimensionRegion>(labelText, lower, upper, decimals),  
     access(access)  
 {  
     spinbutton.signal_value_changed().connect(  
         sigc::mem_fun(*this, &NumEntryX::value_changed));  
 }  
   
 template<typename T>  
 void NumEntryX<T>::value_changed()  
 {  
     if (dimreg && update_gui) {  
         access(dimreg) = T(spinbutton.get_value());  
     }  
 }  
   
 template<typename T>  
 void NumEntryX<T>::set_dimreg(gig::DimensionRegion* dimreg)  
 {  
     this->dimreg = 0;  
     set_value(access(dimreg));  
     this->dimreg = dimreg;  
 }  
   
   
 class NoteEntry : public NumEntryX<uint8_t> {  
 public:  
     NoteEntry(char* labelText, uint8_t& (*access)(gig::DimensionRegion*));  
 private:  
     int on_input(double* new_value);  
     bool on_output();  
 };  
   
   
 template<typename T, typename T2 = gig::DimensionRegion>  
 class NumEntryTemp : public NumEntry<T2> {  
     using NumEntry<T2>::spinbutton;  
     using NumEntry<T2>::dimreg;  
 private:  
     T T2::* param;  
     void value_changed();  
 public:  
     NumEntryTemp(char* labelText, T T2::* param,  
                  double lower = 0, double upper = 127, int decimals = 0);  
     void set_dimreg(gig::DimensionRegion* dimreg);  
 };  
   
 template<typename T, typename T2>  
 NumEntryTemp<T, T2>::NumEntryTemp(char* labelText, T T2::* param,  
                                   double lower, double upper, int decimals) :  
     NumEntry<T2>(labelText, lower, upper, decimals),  
     param(param)  
 {  
     spinbutton.signal_value_changed().connect(  
         sigc::mem_fun(*this, &NumEntryTemp<T, T2>::value_changed));  
 }  
   
 template<typename T, typename T2>  
 void NumEntryTemp<T, T2>::value_changed()  
 {  
     if (dimreg && update_gui) {  
         dimreg->*param = T(spinbutton.get_value());  
     }  
 }  
   
 template<typename T, typename T2>  
 void NumEntryTemp<T, T2>::set_dimreg(gig::DimensionRegion* dimreg)  
 {  
     this->dimreg = 0;  
     set_value(dimreg->*param);  
     this->dimreg = dimreg;  
 }  
   
   
   
 class NumEntryPermille : public NumEntry<gig::DimensionRegion> {  
 private:  
     uint16_t gig::DimensionRegion::* param;  
     void value_changed();  
 public:  
     NumEntryPermille(char* labelText, uint16_t gig::DimensionRegion::* param,  
                      double lower = 0, double upper = 127, int decimals = 0);  
     void set_dimreg(gig::DimensionRegion* dimreg);  
 };  
   
   
 template<typename T>  
 class ChoiceEntry : public LabelWidget {  
 private:  
     Gtk::ComboBoxText combobox;  
     Gtk::Alignment align;  
     T gig::DimensionRegion::* param;  
     gig::DimensionRegion* dimreg;  
     void value_changed();  
     const T* values;  
 public:  
     ChoiceEntry(char* labelText,  
                 T gig::DimensionRegion::* param);  
     void set_choices(char** texts, const T* values);  
     void set_dimreg(gig::DimensionRegion* dimreg);  
     int get_active_row_number() { return combobox.get_active_row_number(); }  
     Glib::SignalProxy0<void> signal_changed() {  
         return combobox.signal_changed();  
     }  
 };  
   
 template<typename T>  
 ChoiceEntry<T>::ChoiceEntry(char* labelText,  
                             T gig::DimensionRegion::* param) :  
     align(0, 0, 0, 0),  
     LabelWidget(labelText, align),  
     param(param)  
 {  
     combobox.signal_changed().connect(  
         sigc::mem_fun(*this, &ChoiceEntry::value_changed));  
     align.add(combobox);  
 }  
   
 template<typename T>  
 void ChoiceEntry<T>::set_choices(char** texts, const T* values)  
 {  
     for (int i = 0 ; texts[i] ; i++) {  
         combobox.append_text(texts[i]);  
     }  
     this->values = values;  
 }  
   
 template<typename T>  
 void ChoiceEntry<T>::value_changed()  
 {  
     if (dimreg && update_gui) {  
         int rowno = combobox.get_active_row_number();  
         if (rowno != -1) dimreg->*param = values[rowno];  
     }  
 }  
   
 template<typename T>  
 void ChoiceEntry<T>::set_dimreg(gig::DimensionRegion* dimreg)  
 {  
     this->dimreg = 0;  
     T value = dimreg->*param;  
     int row = 0;  
     int nb_rows = combobox.get_model()->children().size();  
     for (; row < nb_rows ; row++) {  
         if (value == values[row]) break;  
     }  
     combobox.set_active(row == nb_rows ? -1 : row);  
     this->dimreg = dimreg;  
 }  
   
   
 class ChoiceEntryLeverageCtrl : public LabelWidget {  
 private:  
     Gtk::ComboBoxText combobox;  
     Gtk::Alignment align;  
     gig::leverage_ctrl_t gig::DimensionRegion::* param;  
     gig::DimensionRegion* dimreg;  
     void value_changed();  
 public:  
     ChoiceEntryLeverageCtrl(char* labelText,  
                             gig::leverage_ctrl_t gig::DimensionRegion::* param);  
     void set_dimreg(gig::DimensionRegion* dimreg);  
     int get_active_row_number() { return combobox.get_active_row_number(); }  
     Glib::SignalProxy0<void> signal_changed() {  
         return combobox.signal_changed();  
     }  
 };  
   
   
   
 class BoolEntry : public LabelWidget {  
 private:  
     Gtk::CheckButton checkbutton;  
     bool gig::DimensionRegion::* param;  
     gig::DimensionRegion* dimreg;  
     void value_changed();  
 public:  
     BoolEntry(char* labelText, bool gig::DimensionRegion::* param);  
     void set_dimreg(gig::DimensionRegion* dimreg);  
     bool get_active() { return checkbutton.get_active(); }  
     Glib::SignalProxy0<void> signal_toggled() {  
         return checkbutton.signal_toggled();  
     }  
 };  
   
96  class MainWindow : public Gtk::Window {  class MainWindow : public Gtk::Window {
97  public:  public:
98      MainWindow();      MainWindow();
99      virtual ~MainWindow();      virtual ~MainWindow();
100      void getInfo(const char* filename);      void load_file(const char* name);
101    
102  protected:  protected:
103      Glib::RefPtr<Gtk::ActionGroup> actionGroup;      Glib::RefPtr<Gtk::ActionGroup> actionGroup;
104      Glib::RefPtr<Gtk::UIManager> uiManager;      Glib::RefPtr<Gtk::UIManager> uiManager;
105    
     int rowno;  
     int pageno;  
     int firstRowInBlock;  
   
     NumEntryPermille eEG1PreAttack;  
     NumEntryTemp<double> eEG1Attack;  
     NumEntryTemp<double> eEG1Decay1;  
     NumEntryTemp<double> eEG1Decay2;  
     BoolEntry eEG1InfiniteSustain;  
     NumEntryPermille eEG1Sustain;  
     NumEntryTemp<double> eEG1Release;  
     BoolEntry eEG1Hold;  
     ChoiceEntryLeverageCtrl eEG1Controller;  
     BoolEntry eEG1ControllerInvert;  
     NumEntryTemp<uint8_t> eEG1ControllerAttackInfluence;  
     NumEntryTemp<uint8_t> eEG1ControllerDecayInfluence;  
     NumEntryTemp<uint8_t> eEG1ControllerReleaseInfluence;  
     NumEntryTemp<double> eLFO1Frequency;  
     NumEntryTemp<uint16_t> eLFO1InternalDepth;  
     NumEntryTemp<uint16_t> eLFO1ControlDepth;  
     ChoiceEntry<gig::lfo1_ctrl_t> eLFO1Controller;  
     BoolEntry eLFO1FlipPhase;  
     BoolEntry eLFO1Sync;  
     NumEntryPermille eEG2PreAttack;  
     NumEntryTemp<double> eEG2Attack;  
     NumEntryTemp<double> eEG2Decay1;  
     NumEntryTemp<double> eEG2Decay2;  
     BoolEntry eEG2InfiniteSustain;  
     NumEntryPermille eEG2Sustain;  
     NumEntryTemp<double> eEG2Release;  
     ChoiceEntryLeverageCtrl eEG2Controller;  
     BoolEntry eEG2ControllerInvert;  
     NumEntryTemp<uint8_t> eEG2ControllerAttackInfluence;  
     NumEntryTemp<uint8_t> eEG2ControllerDecayInfluence;  
     NumEntryTemp<uint8_t> eEG2ControllerReleaseInfluence;  
     NumEntryTemp<double> eLFO2Frequency;  
     NumEntryTemp<uint16_t> eLFO2InternalDepth;  
     NumEntryTemp<uint16_t> eLFO2ControlDepth;  
     ChoiceEntry<gig::lfo2_ctrl_t> eLFO2Controller;  
     BoolEntry eLFO2FlipPhase;  
     BoolEntry eLFO2Sync;  
     NumEntryTemp<double> eEG3Attack;  
     NumEntryTemp<int16_t> eEG3Depth;  
     NumEntryTemp<double> eLFO3Frequency;  
     NumEntryTemp<int16_t> eLFO3InternalDepth;  
     NumEntryTemp<int16_t> eLFO3ControlDepth;  
     ChoiceEntry<gig::lfo3_ctrl_t> eLFO3Controller;  
     BoolEntry eLFO3Sync;  
     BoolEntry eVCFEnabled;  
     ChoiceEntry<gig::vcf_type_t> eVCFType;  
     ChoiceEntry<gig::vcf_cutoff_ctrl_t> eVCFCutoffController;  
     BoolEntry eVCFCutoffControllerInvert;  
     NumEntryTemp<uint8_t> eVCFCutoff;  
     ChoiceEntry<gig::curve_type_t> eVCFVelocityCurve;  
     NumEntryTemp<uint8_t> eVCFVelocityScale;  
     NumEntryTemp<uint8_t> eVCFVelocityDynamicRange;  
     NumEntryTemp<uint8_t> eVCFResonance;  
     BoolEntry eVCFResonanceDynamic;  
     ChoiceEntry<gig::vcf_res_ctrl_t> eVCFResonanceController;  
     BoolEntry eVCFKeyboardTracking;  
     NumEntryTemp<uint8_t> eVCFKeyboardTrackingBreakpoint;  
     ChoiceEntry<gig::curve_type_t> eVelocityResponseCurve;  
     NumEntryTemp<uint8_t> eVelocityResponseDepth;  
     NumEntryTemp<uint8_t> eVelocityResponseCurveScaling;  
     ChoiceEntry<gig::curve_type_t> eReleaseVelocityResponseCurve;  
     NumEntryTemp<uint8_t> eReleaseVelocityResponseDepth;  
     NumEntryTemp<uint8_t> eReleaseTriggerDecay;  
     NumEntryX<uint8_t> eCrossfade_in_start;  
     NumEntryX<uint8_t> eCrossfade_in_end;  
     NumEntryX<uint8_t> eCrossfade_out_start;  
     NumEntryX<uint8_t> eCrossfade_out_end;  
     BoolEntry ePitchTrack;  
     ChoiceEntry<gig::dim_bypass_ctrl_t> eDimensionBypass;  
     NumEntryTemp<int8_t> ePan;  
     BoolEntry eSelfMask;  
     ChoiceEntryLeverageCtrl eAttenuationController;  
     BoolEntry eInvertAttenuationController;  
     NumEntryTemp<uint8_t> eAttenuationControllerThreshold;  
     NumEntryTemp<uint8_t> eChannelOffset;  
     BoolEntry eSustainDefeat;  
     BoolEntry eMSDecode;  
     NumEntryTemp<uint16_t> eSampleStartOffset;  
     // NumEntryX<uint8_t> eUnityNote;  
     NoteEntry eUnityNote;  
     NumEntryX<int16_t> eFineTune;  
     NumEntryGain eGain;  
     NumEntryX<uint32_t> eSampleLoops;  
   
     void addProp(LabelWidget& labelwidget);  
     void addString(char* labelText, Gtk::Label*& label,  
                    Gtk::Entry*& widget);  
     void addHeader(char* text);  
     void nextPage();  
   
106      RegionChooser m_RegionChooser;      RegionChooser m_RegionChooser;
107      DimRegionChooser m_DimRegionChooser;      DimRegionChooser m_DimRegionChooser;
108    
     void set_dim_region(gig::DimensionRegion* d);  
109      PropDialog propDialog;      PropDialog propDialog;
110      InstrumentProps instrumentProps;      InstrumentProps instrumentProps;
111    
# Line 480  protected: Line 118  protected:
118    
119      class ModelColumns : public Gtk::TreeModel::ColumnRecord {      class ModelColumns : public Gtk::TreeModel::ColumnRecord {
120      public:      public:
   
121          ModelColumns() {          ModelColumns() {
122            add(m_col_name);            add(m_col_name);
123            add(m_col_instr);            add(m_col_instr);
# Line 494  protected: Line 131  protected:
131      Gtk::HPaned m_HPaned;      Gtk::HPaned m_HPaned;
132    
133      Gtk::ScrolledWindow m_ScrolledWindow;      Gtk::ScrolledWindow m_ScrolledWindow;
134    
135      Gtk::TreeView m_TreeView;      Gtk::TreeView m_TreeView;
136      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;      Glib::RefPtr<Gtk::ListStore> m_refTreeModel;
137    
# Line 523  protected: Line 161  protected:
161      Gtk::TreeView m_TreeViewSamples;      Gtk::TreeView m_TreeViewSamples;
162      Glib::RefPtr<SamplesTreeStore> m_refSamplesTreeModel;      Glib::RefPtr<SamplesTreeStore> m_refSamplesTreeModel;
163    
164        DimRegionEdit dimreg_edit;
165    
166      Gtk::Notebook m_Notebook;      Gtk::Notebook m_Notebook;
167      Gtk::Notebook m_TreeViewNotebook;      Gtk::Notebook m_TreeViewNotebook;
168    
     Gtk::Table* table[5];  
   
     // dimensionregion parameter widgets  
     // TODO: remove:  
     Gtk::Label* lSample;  
     Gtk::Entry* wSample;  
   
169      struct SampleImportItem {      struct SampleImportItem {
170          gig::Sample*  gig_sample;  // pointer to the gig::Sample to which the sample data should be imported to          gig::Sample*  gig_sample;  // pointer to the gig::Sample to
171          Glib::ustring sample_path; // file name of the sample to be imported                                     // which the sample data should be
172                                       // imported to
173            Glib::ustring sample_path; // file name of the sample to be
174                                       // imported
175      };      };
176      std::list<SampleImportItem> m_SampleImportQueue;      std::list<SampleImportItem> m_SampleImportQueue;
177    
     void VCFEnabled_toggled();  
     void VCFCutoffController_changed();  
     void VCFResonanceController_changed();  
     void EG1InfiniteSustain_toggled();  
     void EG2InfiniteSustain_toggled();  
     void EG1Controller_changed();  
     void EG2Controller_changed();  
     void AttenuationController_changed();  
     void LFO1Controller_changed();  
     void LFO2Controller_changed();  
     void LFO3Controller_changed();  
     void crossfade1_changed();  
     void crossfade2_changed();  
     void crossfade3_changed();  
     void crossfade4_changed();  
178    
179      void on_action_file_new();      void on_action_file_new();
180      void on_action_file_open();      void on_action_file_open();
181      void on_action_file_save();      void on_action_file_save();
182      void on_action_file_save_as();      void on_action_file_save_as();
183      void on_action_file_properties();      void on_action_file_properties();
184        void show_instr_props();
185      void on_action_help_about();      void on_action_help_about();
186    
187      // sample right-click popup actions      // sample right-click popup actions
# Line 576  protected: Line 198  protected:
198      gig::File* file;      gig::File* file;
199    
200      void on_button_release(GdkEventButton* button);      void on_button_release(GdkEventButton* button);
201      void on_sample_treeview_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&, Gtk::SelectionData& selection_data, guint, guint);      void on_sample_treeview_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&,
202      void on_sample_label_drop_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int, int, const Gtk::SelectionData& selection_data, guint, guint time);                                            Gtk::SelectionData& selection_data, guint, guint);
203      void sample_name_changed(const Gtk::TreeModel::Path& path, const Gtk::TreeModel::iterator& iter);      void on_sample_label_drop_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context,
204      void instrument_name_changed(const Gtk::TreeModel::Path& path, const Gtk::TreeModel::iterator& iter);                                                   int, int,
205                                                     const Gtk::SelectionData& selection_data,
206                                                     guint, guint time);
207        void sample_name_changed(const Gtk::TreeModel::Path& path,
208                                 const Gtk::TreeModel::iterator& iter);
209        void instrument_name_changed(const Gtk::TreeModel::Path& path,
210                                     const Gtk::TreeModel::iterator& iter);
211    
212      void __import_queued_samples();      void __import_queued_samples();
213    
214    Gtk::Menu* popup_menu;      Gtk::Menu* popup_menu;
215  };  };
216    
217  #endif  #endif
Legend:
Removed from v.1099  
changed lines
  Added in v.1100
  ViewVC Help
Powered by ViewVC