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

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

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

revision 1382 by schoenebeck, Thu Oct 4 23:29:22 2007 UTC revision 1673 by schoenebeck, Wed Feb 6 22:08:29 2008 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (C) 2006, 2007 Andreas Persson   * Copyright (C) 2006 - 2008 Andreas Persson
3   *   *
4   * This program is free software; you can redistribute it and/or   * This program is free software; you can redistribute it and/or
5   * modify it under the terms of the GNU General Public License as   * modify it under the terms of the GNU General Public License as
# Line 17  Line 17 
17   * 02110-1301 USA.   * 02110-1301 USA.
18   */   */
19    
 #include <libintl.h>  
20  #include <iostream>  #include <iostream>
21    
22  #include <gtkmm/filechooserdialog.h>  #include <gtkmm/filechooserdialog.h>
# Line 25  Line 24 
24  #include <gtkmm/stock.h>  #include <gtkmm/stock.h>
25  #include <gtkmm/targetentry.h>  #include <gtkmm/targetentry.h>
26  #include <gtkmm/main.h>  #include <gtkmm/main.h>
27    #include <gtkmm/toggleaction.h>
28    
29    #include "global.h"
30    
31  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 6) || GTKMM_MAJOR_VERSION > 2  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 6) || GTKMM_MAJOR_VERSION > 2
32  #define ABOUT_DIALOG  #define ABOUT_DIALOG
# Line 48  Glib::ustring filename_display_basename( Line 50  Glib::ustring filename_display_basename(
50    
51  #include "mainwindow.h"  #include "mainwindow.h"
52    
53  #define _(String) gettext(String)  #include "../../gfx/status_attached.xpm"
54    #include "../../gfx/status_detached.xpm"
55    
56  template<class T> inline std::string ToString(T o) {  template<class T> inline std::string ToString(T o) {
57      std::stringstream ss;      std::stringstream ss;
# Line 56  template<class T> inline std::string ToS Line 59  template<class T> inline std::string ToS
59      return ss.str();      return ss.str();
60  }  }
61    
62  MainWindow::MainWindow()  Table::Table(int x, int y) : Gtk::Table(x, y), rowno(0) {  }
63    
64    void Table::add(BoolEntry& boolentry)
65    {
66        attach(boolentry.widget, 0, 2, rowno, rowno + 1,
67               Gtk::FILL, Gtk::SHRINK);
68        rowno++;
69    }
70    
71    void Table::add(BoolEntryPlus6& boolentry)
72    {
73        attach(boolentry.widget, 0, 2, rowno, rowno + 1,
74               Gtk::FILL, Gtk::SHRINK);
75        rowno++;
76    }
77    
78    void Table::add(LabelWidget& prop)
79    {
80        attach(prop.label, 1, 2, rowno, rowno + 1,
81               Gtk::FILL, Gtk::SHRINK);
82        attach(prop.widget, 2, 3, rowno, rowno + 1,
83               Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
84        rowno++;
85    }
86    
87    MainWindow::MainWindow() :
88        dimreg_label(_("Changes apply to:")),
89        dimreg_all_regions(_("all regions")),
90        dimreg_all_dimregs(_("all dimension splits")),
91        dimreg_stereo(_("both channels"))
92  {  {
93  //    set_border_width(5);  //    set_border_width(5);
94  //    set_default_size(400, 200);  //    set_default_size(400, 200);
# Line 86  MainWindow::MainWindow() Line 118  MainWindow::MainWindow()
118      m_TreeViewNotebook.set_size_request(300);      m_TreeViewNotebook.set_size_request(300);
119    
120      m_HPaned.add1(m_TreeViewNotebook);      m_HPaned.add1(m_TreeViewNotebook);
121      m_HPaned.add2(dimreg_edit);      dimreg_hbox.add(dimreg_label);
122        dimreg_hbox.add(dimreg_all_regions);
123        dimreg_hbox.add(dimreg_all_dimregs);
124        dimreg_stereo.set_active();
125        dimreg_hbox.add(dimreg_stereo);
126        dimreg_vbox.add(dimreg_edit);
127        dimreg_vbox.pack_start(dimreg_hbox, Gtk::PACK_SHRINK);
128        m_HPaned.add2(dimreg_vbox);
129    
130    
131      m_TreeViewNotebook.append_page(m_ScrolledWindowSamples, "Samples");      m_TreeViewNotebook.append_page(m_ScrolledWindowSamples, "Samples");
# Line 127  MainWindow::MainWindow() Line 166  MainWindow::MainWindow()
166                           *this, &MainWindow::on_action_quit));                           *this, &MainWindow::on_action_quit));
167      actionGroup->add(Gtk::Action::create("MenuInstrument", _("_Instrument")));      actionGroup->add(Gtk::Action::create("MenuInstrument", _("_Instrument")));
168    
169        actionGroup->add(Gtk::Action::create("MenuView", _("_View")));
170        Glib::RefPtr<Gtk::ToggleAction> toggle_action =
171            Gtk::ToggleAction::create("Statusbar", _("_Statusbar"));
172        toggle_action->set_active(true);
173        actionGroup->add(toggle_action,
174                         sigc::mem_fun(
175                             *this, &MainWindow::on_action_view_status_bar));
176    
177      action = Gtk::Action::create("MenuHelp", Gtk::Stock::HELP);      action = Gtk::Action::create("MenuHelp", Gtk::Stock::HELP);
178      actionGroup->add(Gtk::Action::create("MenuHelp",      actionGroup->add(Gtk::Action::create("MenuHelp",
179                                           action->property_label()));                                           action->property_label()));
# Line 161  MainWindow::MainWindow() Line 208  MainWindow::MainWindow()
208          Gtk::Action::create("RemoveSample", Gtk::Stock::REMOVE),          Gtk::Action::create("RemoveSample", Gtk::Stock::REMOVE),
209          sigc::mem_fun(*this, &MainWindow::on_action_remove_sample)          sigc::mem_fun(*this, &MainWindow::on_action_remove_sample)
210      );      );
211        actionGroup->add(
212            Gtk::Action::create("ReplaceAllSamplesInAllGroups", _("Replace All Samples In All Groups")),
213            sigc::mem_fun(*this, &MainWindow::on_action_replace_all_samples_in_all_groups)
214        );
215    
216      uiManager = Gtk::UIManager::create();      uiManager = Gtk::UIManager::create();
217      uiManager->insert_action_group(actionGroup);      uiManager->insert_action_group(actionGroup);
# Line 182  MainWindow::MainWindow() Line 233  MainWindow::MainWindow()
233          "    </menu>"          "    </menu>"
234          "    <menu action='MenuInstrument'>"          "    <menu action='MenuInstrument'>"
235          "    </menu>"          "    </menu>"
236            "    <menu action='MenuView'>"
237            "      <menuitem action='Statusbar'/>"
238            "    </menu>"
239  #ifdef ABOUT_DIALOG  #ifdef ABOUT_DIALOG
240          "    <menu action='MenuHelp'>"          "    <menu action='MenuHelp'>"
241          "      <menuitem action='About'/>"          "      <menuitem action='About'/>"
# Line 198  MainWindow::MainWindow() Line 252  MainWindow::MainWindow()
252          "    <menuitem action='SampleProperties'/>"          "    <menuitem action='SampleProperties'/>"
253          "    <menuitem action='AddGroup'/>"          "    <menuitem action='AddGroup'/>"
254          "    <menuitem action='AddSample'/>"          "    <menuitem action='AddSample'/>"
255            "    <menuitem action='ReplaceAllSamplesInAllGroups' />"
256          "    <separator/>"          "    <separator/>"
257          "    <menuitem action='RemoveSample'/>"          "    <menuitem action='RemoveSample'/>"
258          "  </popup>"          "  </popup>"
# Line 210  MainWindow::MainWindow() Line 265  MainWindow::MainWindow()
265      m_VBox.pack_start(*menuBar, Gtk::PACK_SHRINK);      m_VBox.pack_start(*menuBar, Gtk::PACK_SHRINK);
266      m_VBox.pack_start(m_HPaned);      m_VBox.pack_start(m_HPaned);
267      m_VBox.pack_start(m_RegionChooser, Gtk::PACK_SHRINK);      m_VBox.pack_start(m_RegionChooser, Gtk::PACK_SHRINK);
268        m_VBox.pack_start(m_RegionChooser.m_VirtKeybPropsBox, Gtk::PACK_SHRINK);
269      m_VBox.pack_start(m_DimRegionChooser, Gtk::PACK_SHRINK);      m_VBox.pack_start(m_DimRegionChooser, Gtk::PACK_SHRINK);
270        m_VBox.pack_start(m_StatusBar, Gtk::PACK_SHRINK);
271    
272        // Status Bar:
273        m_StatusBar.pack_start(m_AttachedStateLabel, Gtk::PACK_SHRINK);
274        m_StatusBar.pack_start(m_AttachedStateImage, Gtk::PACK_SHRINK);
275        m_StatusBar.show();
276    
277      m_RegionChooser.signal_region_selected().connect(      m_RegionChooser.signal_region_selected().connect(
278          sigc::mem_fun(*this, &MainWindow::region_changed) );          sigc::mem_fun(*this, &MainWindow::region_changed) );
# Line 264  MainWindow::MainWindow() Line 326  MainWindow::MainWindow()
326          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
327      instrumentProps.signal_instrument_changed().connect(      instrumentProps.signal_instrument_changed().connect(
328          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
329        propDialog.signal_info_changed().connect(
330            sigc::mem_fun(*this, &MainWindow::file_changed));
331    
332      dimreg_edit.signal_dimreg_to_be_changed().connect(      dimreg_edit.signal_dimreg_to_be_changed().connect(
333          dimreg_to_be_changed_signal.make_slot());          dimreg_to_be_changed_signal.make_slot());
# Line 293  MainWindow::MainWindow() Line 357  MainWindow::MainWindow()
357      m_RegionChooser.signal_region_changed_signal().connect(      m_RegionChooser.signal_region_changed_signal().connect(
358          region_changed_signal.make_slot());          region_changed_signal.make_slot());
359    
360        note_on_signal.connect(
361            sigc::mem_fun(m_RegionChooser, &RegionChooser::on_note_on_event));
362        note_off_signal.connect(
363            sigc::mem_fun(m_RegionChooser, &RegionChooser::on_note_off_event));
364    
365        dimreg_all_regions.signal_toggled().connect(
366            sigc::mem_fun(*this, &MainWindow::update_dimregs));
367        dimreg_all_dimregs.signal_toggled().connect(
368            sigc::mem_fun(*this, &MainWindow::dimreg_all_dimregs_toggled));
369        dimreg_stereo.signal_toggled().connect(
370            sigc::mem_fun(*this, &MainWindow::update_dimregs));
371    
372      file = 0;      file = 0;
373      file_is_changed = false;      file_is_changed = false;
374      file_is_shared  = false;      set_file_is_shared(false);
375    
376      show_all_children();      show_all_children();
377    
# Line 323  void MainWindow::region_changed() Line 399  void MainWindow::region_changed()
399      m_DimRegionChooser.set_region(m_RegionChooser.get_region());      m_DimRegionChooser.set_region(m_RegionChooser.get_region());
400  }  }
401    
402  void MainWindow::dimreg_changed()  gig::Instrument* MainWindow::get_instrument()
 {  
     dimreg_edit.set_dim_region(m_DimRegionChooser.get_dimregion());  
 }  
   
 void MainWindow::on_sel_change()  
403  {  {
404        gig::Instrument* instrument = 0;
405      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();
406    
407      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();
408      if (it) {      if (it) {
409          Gtk::TreeModel::Row row = *it;          Gtk::TreeModel::Row row = *it;
410          std::cout << row[m_Columns.m_col_name] << std::endl;          instrument = row[m_Columns.m_col_instr];
411        }
412        return instrument;
413    }
414    
415    void MainWindow::add_region_to_dimregs(gig::Region* region, bool stereo, bool all_dimregs)
416    {
417        if (all_dimregs) {
418            for (int i = 0 ; i < region->DimensionRegions ; i++) {
419                if (region->pDimensionRegions[i]) {
420                    dimreg_edit.dimregs.insert(region->pDimensionRegions[i]);
421                }
422            }
423        } else {
424            m_DimRegionChooser.get_dimregions(region, stereo, dimreg_edit.dimregs);
425        }
426    }
427    
428    void MainWindow::update_dimregs()
429    {
430        dimreg_edit.dimregs.clear();
431        bool all_regions = dimreg_all_regions.get_active();
432        bool stereo = dimreg_stereo.get_active();
433        bool all_dimregs = dimreg_all_dimregs.get_active();
434    
435          m_RegionChooser.set_instrument(row[m_Columns.m_col_instr]);      if (all_regions) {
436            gig::Instrument* instrument = get_instrument();
437            if (instrument) {
438                for (gig::Region* region = instrument->GetFirstRegion() ;
439                     region ;
440                     region = instrument->GetNextRegion()) {
441                    add_region_to_dimregs(region, stereo, all_dimregs);
442                }
443            }
444      } else {      } else {
445          m_RegionChooser.set_instrument(0);          gig::Region* region = m_RegionChooser.get_region();
446            if (region) {
447                add_region_to_dimregs(region, stereo, all_dimregs);
448            }
449      }      }
450  }  }
451    
452    void MainWindow::dimreg_all_dimregs_toggled()
453    {
454        dimreg_stereo.set_sensitive(!dimreg_all_dimregs.get_active());
455        update_dimregs();
456    }
457    
458    void MainWindow::dimreg_changed()
459    {
460        update_dimregs();
461        dimreg_edit.set_dim_region(m_DimRegionChooser.get_dimregion());
462    }
463    
464    void MainWindow::on_sel_change()
465    {
466        m_RegionChooser.set_instrument(get_instrument());
467    }
468    
469  void loader_progress_callback(gig::progress_t* progress)  void loader_progress_callback(gig::progress_t* progress)
470  {  {
471      Loader* loader = static_cast<Loader*>(progress->custom);      Loader* loader = static_cast<Loader*>(progress->custom);
# Line 430  void MainWindow::__clear() { Line 553  void MainWindow::__clear() {
553      // free libgig's gig::File instance      // free libgig's gig::File instance
554      if (file && !file_is_shared) delete file;      if (file && !file_is_shared) delete file;
555      file = NULL;      file = NULL;
556      file_is_shared = false;      set_file_is_shared(false);
557  }  }
558    
559  void MainWindow::on_action_file_new()  void MainWindow::on_action_file_new()
# Line 766  void MainWindow::on_action_help_about() Line 889  void MainWindow::on_action_help_about()
889  #ifdef ABOUT_DIALOG  #ifdef ABOUT_DIALOG
890      Gtk::AboutDialog dialog;      Gtk::AboutDialog dialog;
891      dialog.set_version(VERSION);      dialog.set_version(VERSION);
892        dialog.set_copyright("Copyright (C) 2006,2007 Andreas Persson");
893        dialog.set_comments(
894            "Released under the GNU General Public License.\n"
895            "\n"
896            "Please notice that this is still a very young instrument editor. "
897            "So better backup your Gigasampler files before editing them with "
898            "this application.\n"
899            "\n"
900            "Please report bugs to: http://bugs.linuxsampler.org"
901        );
902        dialog.set_website("http://www.linuxsampler.org");
903        dialog.set_website_label("http://www.linuxsampler.org");
904      dialog.run();      dialog.run();
905  #endif  #endif
906  }  }
907    
908  PropDialog::PropDialog()  PropDialog::PropDialog()
909      : table(2,1)      : table(2,1),
910          eName("Name"),
911          eCreationDate("Creation date"),
912          eComments("Comments"),
913          eProduct("Product"),
914          eCopyright("Copyright"),
915          eArtists("Artists"),
916          eGenre("Genre"),
917          eKeywords("Keywords"),
918          eEngineer("Engineer"),
919          eTechnician("Technician"),
920          eSoftware("Software"),
921          eMedium("Medium"),
922          eSource("Source"),
923          eSourceForm("Source form"),
924          eCommissioned("Commissioned"),
925          eSubject("Subject"),
926          quitButton(Gtk::Stock::CLOSE),
927          update_model(0)
928  {  {
929        set_title("File Properties");
930        eName.set_width_chars(50);
931    
932        connect(eName, &DLS::Info::Name);
933        connect(eCreationDate, &DLS::Info::CreationDate);
934        connect(eComments, &DLS::Info::Comments);
935        connect(eProduct, &DLS::Info::Product);
936        connect(eCopyright, &DLS::Info::Copyright);
937        connect(eArtists, &DLS::Info::Artists);
938        connect(eGenre, &DLS::Info::Genre);
939        connect(eKeywords, &DLS::Info::Keywords);
940        connect(eEngineer, &DLS::Info::Engineer);
941        connect(eTechnician, &DLS::Info::Technician);
942        connect(eSoftware, &DLS::Info::Software);
943        connect(eMedium, &DLS::Info::Medium);
944        connect(eSource, &DLS::Info::Source);
945        connect(eSourceForm, &DLS::Info::SourceForm);
946        connect(eCommissioned, &DLS::Info::Commissioned);
947        connect(eSubject, &DLS::Info::Subject);
948    
949        table.add(eName);
950        table.add(eCreationDate);
951        table.add(eComments);
952        table.add(eProduct);
953        table.add(eCopyright);
954        table.add(eArtists);
955        table.add(eGenre);
956        table.add(eKeywords);
957        table.add(eEngineer);
958        table.add(eTechnician);
959        table.add(eSoftware);
960        table.add(eMedium);
961        table.add(eSource);
962        table.add(eSourceForm);
963        table.add(eCommissioned);
964        table.add(eSubject);
965    
966      table.set_col_spacings(5);      table.set_col_spacings(5);
967      const char* propLabels[] = {      add(vbox);
968          "Name:",      table.set_border_width(5);
969          "CreationDate:",      vbox.add(table);
970          "Comments:", // TODO: multiline      vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);
971          "Product:",      buttonBox.set_layout(Gtk::BUTTONBOX_END);
972          "Copyright:",      buttonBox.set_border_width(5);
973          "Artists:",      buttonBox.show();
974          "Genre:",      buttonBox.pack_start(quitButton);
975          "Keywords:",      quitButton.set_flags(Gtk::CAN_DEFAULT);
976          "Engineer:",      quitButton.grab_focus();
977          "Technician:",      quitButton.signal_clicked().connect(
978          "Software:", // TODO: readonly          sigc::mem_fun(*this, &PropDialog::hide));
         "Medium:",  
         "Source:",  
         "SourceForm:",  
         "Commissioned:",  
         "Subject:"  
     };  
     for (int i = 0 ; i < sizeof(propLabels) / sizeof(char*) ; i++) {  
         label[i].set_text(propLabels[i]);  
         label[i].set_alignment(Gtk::ALIGN_LEFT);  
         table.attach(label[i], 0, 1, i, i + 1, Gtk::FILL, Gtk::SHRINK);  
         table.attach(entry[i], 1, 2, i, i + 1, Gtk::FILL | Gtk::EXPAND,  
                      Gtk::SHRINK);  
     }  
979    
980      add(table);      quitButton.show();
981      // add_button(Gtk::Stock::CANCEL, 0);      vbox.show();
     // add_button(Gtk::Stock::OK, 1);  
982      show_all_children();      show_all_children();
983  }  }
984    
985  void PropDialog::set_info(DLS::Info* info)  void PropDialog::set_info(DLS::Info* info)
986  {  {
987      entry[0].set_text(info->Name);      this->info = info;
988      entry[1].set_text(info->CreationDate);      update_model++;
989      entry[2].set_text(Glib::convert(info->Comments, "UTF-8", "ISO-8859-1"));      eName.set_value(info->Name);
990      entry[3].set_text(info->Product);      eCreationDate.set_value(info->CreationDate);
991      entry[4].set_text(info->Copyright);      eComments.set_value(info->Comments);
992      entry[5].set_text(info->Artists);      eProduct.set_value(info->Product);
993      entry[6].set_text(info->Genre);      eCopyright.set_value(info->Copyright);
994      entry[7].set_text(info->Keywords);      eArtists.set_value(info->Artists);
995      entry[8].set_text(info->Engineer);      eGenre.set_value(info->Genre);
996      entry[9].set_text(info->Technician);      eKeywords.set_value(info->Keywords);
997      entry[10].set_text(info->Software);      eEngineer.set_value(info->Engineer);
998      entry[11].set_text(info->Medium);      eTechnician.set_value(info->Technician);
999      entry[12].set_text(info->Source);      eSoftware.set_value(info->Software);
1000      entry[13].set_text(info->SourceForm);      eMedium.set_value(info->Medium);
1001      entry[14].set_text(info->Commissioned);      eSource.set_value(info->Source);
1002      entry[15].set_text(info->Subject);      eSourceForm.set_value(info->SourceForm);
1003        eCommissioned.set_value(info->Commissioned);
1004        eSubject.set_value(info->Subject);
1005        update_model--;
1006  }  }
1007    
1008  void InstrumentProps::add_prop(BoolEntry& boolentry)  sigc::signal<void>& PropDialog::signal_info_changed()
1009  {  {
1010      table.attach(boolentry.widget, 0, 2, rowno, rowno + 1,      return info_changed;
                  Gtk::FILL, Gtk::SHRINK);  
     rowno++;  
     boolentry.signal_changed_by_user().connect(instrument_changed.make_slot());  
1011  }  }
1012    
1013  void InstrumentProps::add_prop(BoolEntryPlus6& boolentry)  void InstrumentProps::set_IsDrum(bool value)
1014  {  {
1015      table.attach(boolentry.widget, 0, 2, rowno, rowno + 1,      instrument->IsDrum = value;
                  Gtk::FILL, Gtk::SHRINK);  
     rowno++;  
     boolentry.signal_changed_by_user().connect(instrument_changed.make_slot());  
1016  }  }
1017    
1018  void InstrumentProps::add_prop(LabelWidget& prop)  void InstrumentProps::set_MIDIBank(uint16_t value)
1019  {  {
1020      table.attach(prop.label, 0, 1, rowno, rowno + 1,      instrument->MIDIBank = value;
1021                   Gtk::FILL, Gtk::SHRINK);  }
1022      table.attach(prop.widget, 1, 2, rowno, rowno + 1,  
1023                   Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK);  void InstrumentProps::set_MIDIProgram(uint32_t value)
1024      rowno++;  {
1025      prop.signal_changed_by_user().connect(instrument_changed.make_slot());      instrument->MIDIProgram = value;
1026    }
1027    
1028    void InstrumentProps::set_DimensionKeyRange_low(uint8_t value)
1029    {
1030        instrument->DimensionKeyRange.low = value;
1031        if (value > instrument->DimensionKeyRange.high) {
1032            eDimensionKeyRangeHigh.set_value(value);
1033        }
1034    }
1035    
1036    void InstrumentProps::set_DimensionKeyRange_high(uint8_t value)
1037    {
1038        instrument->DimensionKeyRange.high = value;
1039        if (value < instrument->DimensionKeyRange.low) {
1040            eDimensionKeyRangeLow.set_value(value);
1041        }
1042  }  }
1043    
1044  InstrumentProps::InstrumentProps()  InstrumentProps::InstrumentProps()
# Line 865  InstrumentProps::InstrumentProps() Line 1054  InstrumentProps::InstrumentProps()
1054        eFineTune("Fine tune", -8400, 8400),        eFineTune("Fine tune", -8400, 8400),
1055        ePitchbendRange("Pitchbend range", 0, 12),        ePitchbendRange("Pitchbend range", 0, 12),
1056        ePianoReleaseMode("Piano release mode"),        ePianoReleaseMode("Piano release mode"),
1057        eDimensionKeyRangeLow("Dimension key range low"),        eDimensionKeyRangeLow("Keyswitching range low"),
1058        eDimensionKeyRangeHigh("Dimension key range high")        eDimensionKeyRangeHigh("Keyswitching range high"),
1059  {        update_model(0)
1060      set_title("Instrument properties");  {
1061        set_title("Instrument Properties");
1062    
1063        eDimensionKeyRangeLow.set_tip(
1064            _("start of the keyboard area which should switch the "
1065              "\"keyswitching\" dimension")
1066        );
1067        eDimensionKeyRangeHigh.set_tip(
1068            _("end of the keyboard area which should switch the "
1069              "\"keyswitching\" dimension")
1070        );
1071    
1072        connect(eIsDrum, &InstrumentProps::set_IsDrum);
1073        connect(eMIDIBank, &InstrumentProps::set_MIDIBank);
1074        connect(eMIDIProgram, &InstrumentProps::set_MIDIProgram);
1075        connect(eAttenuation, &gig::Instrument::Attenuation);
1076        connect(eGainPlus6, &gig::Instrument::Attenuation);
1077        connect(eEffectSend, &gig::Instrument::EffectSend);
1078        connect(eFineTune, &gig::Instrument::FineTune);
1079        connect(ePitchbendRange, &gig::Instrument::PitchbendRange);
1080        connect(ePianoReleaseMode, &gig::Instrument::PianoReleaseMode);
1081        connect(eDimensionKeyRangeLow,
1082                &InstrumentProps::set_DimensionKeyRange_low);
1083        connect(eDimensionKeyRangeHigh,
1084                &InstrumentProps::set_DimensionKeyRange_high);
1085    
     rowno = 0;  
1086      table.set_col_spacings(5);      table.set_col_spacings(5);
1087    
1088      add_prop(eName);      table.add(eName);
1089      add_prop(eIsDrum);      table.add(eIsDrum);
1090      add_prop(eMIDIBank);      table.add(eMIDIBank);
1091      add_prop(eMIDIProgram);      table.add(eMIDIProgram);
1092      add_prop(eAttenuation);      table.add(eAttenuation);
1093      add_prop(eGainPlus6);      table.add(eGainPlus6);
1094      add_prop(eEffectSend);      table.add(eEffectSend);
1095      add_prop(eFineTune);      table.add(eFineTune);
1096      add_prop(ePitchbendRange);      table.add(ePitchbendRange);
1097      add_prop(ePianoReleaseMode);      table.add(ePianoReleaseMode);
1098      add_prop(eDimensionKeyRangeLow);      table.add(eDimensionKeyRangeLow);
1099      add_prop(eDimensionKeyRangeHigh);      table.add(eDimensionKeyRangeHigh);
   
     eDimensionKeyRangeLow.signal_changed_by_user().connect(  
         sigc::mem_fun(*this, &InstrumentProps::key_range_low_changed));  
     eDimensionKeyRangeHigh.signal_changed_by_user().connect(  
         sigc::mem_fun(*this, &InstrumentProps::key_range_high_changed));  
1100    
1101      add(vbox);      add(vbox);
1102      table.set_border_width(5);      table.set_border_width(5);
# Line 913  InstrumentProps::InstrumentProps() Line 1120  InstrumentProps::InstrumentProps()
1120    
1121  void InstrumentProps::set_instrument(gig::Instrument* instrument)  void InstrumentProps::set_instrument(gig::Instrument* instrument)
1122  {  {
1123      eName.set_ptr(&instrument->pInfo->Name);      this->instrument = instrument;
1124      eIsDrum.set_ptr(&instrument->IsDrum);  
1125      eMIDIBank.set_ptr(&instrument->MIDIBank);      update_model++;
1126      eMIDIProgram.set_ptr(&instrument->MIDIProgram);      eName.set_value(instrument->pInfo->Name);
1127      eAttenuation.set_ptr(&instrument->Attenuation);      eIsDrum.set_value(instrument->IsDrum);
1128      eGainPlus6.set_ptr(&instrument->Attenuation);      eMIDIBank.set_value(instrument->MIDIBank);
1129      eEffectSend.set_ptr(&instrument->EffectSend);      eMIDIProgram.set_value(instrument->MIDIProgram);
1130      eFineTune.set_ptr(&instrument->FineTune);      eAttenuation.set_value(instrument->Attenuation);
1131      ePitchbendRange.set_ptr(&instrument->PitchbendRange);      eGainPlus6.set_value(instrument->Attenuation);
1132      ePianoReleaseMode.set_ptr(&instrument->PianoReleaseMode);      eEffectSend.set_value(instrument->EffectSend);
1133      eDimensionKeyRangeLow.set_ptr(0);      eFineTune.set_value(instrument->FineTune);
1134      eDimensionKeyRangeHigh.set_ptr(0);      ePitchbendRange.set_value(instrument->PitchbendRange);
1135      eDimensionKeyRangeLow.set_ptr(&instrument->DimensionKeyRange.low);      ePianoReleaseMode.set_value(instrument->PianoReleaseMode);
1136      eDimensionKeyRangeHigh.set_ptr(&instrument->DimensionKeyRange.high);      eDimensionKeyRangeLow.set_value(instrument->DimensionKeyRange.low);
1137  }      eDimensionKeyRangeHigh.set_value(instrument->DimensionKeyRange.high);
1138        update_model--;
 void InstrumentProps::key_range_low_changed()  
 {  
     double l = eDimensionKeyRangeLow.get_value();  
     double h = eDimensionKeyRangeHigh.get_value();  
     if (h < l) eDimensionKeyRangeHigh.set_value(l);  
 }  
   
 void InstrumentProps::key_range_high_changed()  
 {  
     double l = eDimensionKeyRangeLow.get_value();  
     double h = eDimensionKeyRangeHigh.get_value();  
     if (h < l) eDimensionKeyRangeLow.set_value(h);  
1139  }  }
1140    
1141  sigc::signal<void>& InstrumentProps::signal_instrument_changed()  sigc::signal<void>& InstrumentProps::signal_instrument_changed()
# Line 959  void MainWindow::file_changed() Line 1154  void MainWindow::file_changed()
1154  void MainWindow::load_gig(gig::File* gig, const char* filename, bool isSharedInstrument)  void MainWindow::load_gig(gig::File* gig, const char* filename, bool isSharedInstrument)
1155  {  {
1156      file = 0;      file = 0;
1157      file_is_shared = isSharedInstrument;      set_file_is_shared(isSharedInstrument);
1158    
1159      this->filename = filename ? filename : _("Unsaved Gig File");      this->filename = filename ? filename : _("Unsaved Gig File");
1160      set_title(Glib::filename_display_basename(this->filename));      set_title(Glib::filename_display_basename(this->filename));
# Line 1022  void MainWindow::load_gig(gig::File* gig Line 1217  void MainWindow::load_gig(gig::File* gig
1217    
1218  void MainWindow::show_instr_props()  void MainWindow::show_instr_props()
1219  {  {
1220      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();      gig::Instrument* instrument = get_instrument();
1221      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();      if (instrument)
     if (it)  
1222      {      {
1223          Gtk::TreeModel::Row row = *it;          instrumentProps.set_instrument(instrument);
1224          if (row[m_Columns.m_col_instr])          instrumentProps.show();
1225          {          instrumentProps.deiconify();
1226              instrumentProps.set_instrument(row[m_Columns.m_col_instr]);      }
1227              instrumentProps.show();  }
1228              instrumentProps.deiconify();  
1229          }  void MainWindow::on_action_view_status_bar() {
1230        Gtk::CheckMenuItem* item =
1231            dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/Statusbar"));
1232        if (!item) {
1233            std::cerr << "/MenuBar/MenuView/Statusbar == NULL\n";
1234            return;
1235      }      }
1236        if (item->get_active()) m_StatusBar.show();
1237        else                    m_StatusBar.hide();
1238  }  }
1239    
1240  void MainWindow::on_button_release(GdkEventButton* button)  void MainWindow::on_button_release(GdkEventButton* button)
# Line 1297  void MainWindow::on_action_add_sample() Line 1498  void MainWindow::on_action_add_sample()
1498      }      }
1499  }  }
1500    
1501    void MainWindow::on_action_replace_all_samples_in_all_groups()
1502    {
1503        if (!file) return;
1504        Gtk::FileChooserDialog dialog(*this, _("Select Folder"),
1505                                      Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
1506        Gtk::Label description(
1507            _("This is a very specific function. It tries to replace all samples "
1508              "in the current gig file by samples located in the directory chosen "
1509              "by you above.\n\n"
1510              "It works like this: For each sample in the gig file it tries to "
1511              "find a sample file in the selected directory with the same name as "
1512              "the sample in the gig file. Optionally you can add a filename "
1513              "postfix below, which will be added to the filename expected to be "
1514              "found. That is, assume you have a gig file with a sample called "
1515              "'Snare', if you enter '.wav' below (like it's done by default), it "
1516              "assumes to find a sample file called 'Snare.wav' and will replace "
1517              "the sample in the gig file accordingly. If you don't need such a "
1518              "postfix, blank the field below. Any gig sample where no "
1519              "appropriate sample file could be found, will be reported and left "
1520              "untouched.\n\n")
1521        );
1522        description.set_line_wrap(true);
1523        Gtk::HBox entryArea;
1524        Gtk::Label entryLabel( _("Add Filename Extension: "), Gtk::ALIGN_RIGHT);
1525        Gtk::Entry postfixEntryBox;
1526        postfixEntryBox.set_text(".wav");
1527        entryArea.pack_start(entryLabel);
1528        entryArea.pack_start(postfixEntryBox);
1529        dialog.get_vbox()->pack_start(description, Gtk::PACK_SHRINK);
1530        dialog.get_vbox()->pack_start(entryArea, Gtk::PACK_SHRINK);
1531        description.show();
1532        entryLabel.show();
1533        postfixEntryBox.show();
1534        entryArea.show();
1535        dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1536        dialog.add_button(_("Select"), Gtk::RESPONSE_OK);
1537        dialog.set_select_multiple(false);
1538        // fix label width (because Gtk by design doesn't
1539        // know anything about the parent's size)
1540    #if 0 //FIXME: doesn't work
1541        int dialogW, dialogH, labelW, labelH;
1542        dialog.get_size_request(dialogW, dialogH);
1543        description.get_size_request(labelW, labelH);
1544        std::cout << "dialog(" << dialogW << "," << dialogH << ")\nlabel(" << labelW << "," << labelH << ")\n" << std::flush;
1545        description.set_size_request(dialogW, labelH);
1546    #endif
1547        if (dialog.run() == Gtk::RESPONSE_OK)
1548        {
1549            Glib::ustring error_files;
1550            Glib::ustring folder = dialog.get_filename();
1551            for (gig::Sample* sample = file->GetFirstSample();
1552                 sample; sample = file->GetNextSample())
1553            {
1554                std::string filename =
1555                    folder + G_DIR_SEPARATOR_S + sample->pInfo->Name +
1556                    postfixEntryBox.get_text().raw();
1557                SF_INFO info;
1558                info.format = 0;
1559                SNDFILE* hFile = sf_open(filename.c_str(), SFM_READ, &info);
1560                try
1561                {
1562                    if (!hFile) throw std::string("could not open file");
1563                    int bitdepth;
1564                    switch (info.format & 0xff) {
1565                        case SF_FORMAT_PCM_S8:
1566                        case SF_FORMAT_PCM_16:
1567                        case SF_FORMAT_PCM_U8:
1568                            bitdepth = 16;
1569                            break;
1570                        case SF_FORMAT_PCM_24:
1571                        case SF_FORMAT_PCM_32:
1572                        case SF_FORMAT_FLOAT:
1573                        case SF_FORMAT_DOUBLE:
1574                            bitdepth = 24;
1575                            break;
1576                        default:
1577                            sf_close(hFile);
1578                            throw std::string("format not supported");
1579                    }
1580                    SampleImportItem sched_item;
1581                    sched_item.gig_sample  = sample;
1582                    sched_item.sample_path = filename;
1583                    m_SampleImportQueue.push_back(sched_item);
1584                    sf_close(hFile);
1585                    file_changed();
1586                }
1587                catch (std::string what)
1588                {
1589                    if (error_files.size()) error_files += "\n";
1590                        error_files += filename += " (" + what + ")";
1591                }
1592            }
1593            // show error message box when some file(s) could not be opened / added
1594            if (error_files.size()) {
1595                Glib::ustring txt =
1596                    _("Could not replace the following sample(s):\n") + error_files;
1597                Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
1598                msg.run();
1599            }
1600        }
1601    }
1602    
1603  void MainWindow::on_action_remove_sample() {  void MainWindow::on_action_remove_sample() {
1604      if (!file) return;      if (!file) return;
1605      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
# Line 1463  void MainWindow::on_sample_label_drop_dr Line 1766  void MainWindow::on_sample_label_drop_dr
1766          // notify we're done with altering          // notify we're done with altering
1767          region_changed_signal.emit(region);          region_changed_signal.emit(region);
1768    
1769            file_changed();
1770    
1771          return;          return;
1772      }      }
1773      // drop failed      // drop failed
# Line 1503  void MainWindow::instrument_name_changed Line 1808  void MainWindow::instrument_name_changed
1808      }      }
1809  }  }
1810    
1811    void MainWindow::set_file_is_shared(bool b) {
1812        this->file_is_shared = b;
1813    
1814        if (file_is_shared) {
1815            m_AttachedStateLabel.set_label(_("live-mode"));
1816            m_AttachedStateImage.set(
1817                Gdk::Pixbuf::create_from_xpm_data(status_attached_xpm)
1818            );
1819        } else {
1820            m_AttachedStateLabel.set_label(_("stand-alone"));
1821            m_AttachedStateImage.set(
1822                Gdk::Pixbuf::create_from_xpm_data(status_detached_xpm)
1823            );
1824        }
1825    }
1826    
1827  sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_to_be_changed() {  sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_to_be_changed() {
1828      return file_structure_to_be_changed_signal;      return file_structure_to_be_changed_signal;
1829  }  }
# Line 1538  sigc::signal<void, gig::DimensionRegion* Line 1859  sigc::signal<void, gig::DimensionRegion*
1859  sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {  sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {
1860      return dimreg_changed_signal;      return dimreg_changed_signal;
1861  }  }
1862    
1863    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_on() {
1864        return note_on_signal;
1865    }
1866    
1867    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_off() {
1868        return note_off_signal;
1869    }
1870    
1871    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_hit() {
1872        return m_RegionChooser.signal_keyboard_key_hit();
1873    }
1874    
1875    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_released() {
1876        return m_RegionChooser.signal_keyboard_key_released();
1877    }
Legend:
Removed from v.1382  
changed lines
  Added in v.1673
  ViewVC Help
Powered by ViewVC