/[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 1436 by schoenebeck, Mon Oct 15 15:29:58 2007 UTC revision 1679 by schoenebeck, Tue Feb 12 14:13:46 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 59  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 89  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 172  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 212  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 224  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);      m_VBox.pack_start(m_StatusBar, Gtk::PACK_SHRINK);
271    
# Line 284  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 313  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      set_file_is_shared(false);      set_file_is_shared(false);
# Line 343  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          m_RegionChooser.set_instrument(row[m_Columns.m_col_instr]);  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 {      } else {
424          m_RegionChooser.set_instrument(0);          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        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 {
445            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 649  bool MainWindow::file_save_as() Line 752  bool MainWindow::file_save_as()
752      filter.add_pattern("*.gig");      filter.add_pattern("*.gig");
753      dialog.set_filter(filter);      dialog.set_filter(filter);
754    
755      if (Glib::path_is_absolute(filename)) {      // set initial dir and filename of the Save As dialog
756          dialog.set_filename(filename);      // and prepare that initial filename as a copy of the gig
757      } else if (current_dir != "") {      {
758          dialog.set_current_folder(current_dir);          std::string basename = Glib::path_get_basename(filename);
759            std::string dir = Glib::path_get_dirname(filename);
760            basename = std::string("copy_of_") + basename;
761            Glib::ustring copyFileName = Glib::build_filename(dir, basename);
762            if (Glib::path_is_absolute(filename)) {
763                dialog.set_filename(copyFileName);
764            } else {
765                if (current_dir != "") dialog.set_current_folder(current_dir);
766            }
767            dialog.set_current_name(Glib::filename_display_basename(copyFileName));
768      }      }
769      dialog.set_current_name(Glib::filename_display_basename(filename));  
770        // show warning in the dialog
771        Gtk::HBox descriptionArea;
772        descriptionArea.set_spacing(15);
773        Gtk::Image warningIcon(Gtk::Stock::DIALOG_WARNING, Gtk::IconSize(Gtk::ICON_SIZE_DIALOG));
774        descriptionArea.pack_start(warningIcon, Gtk::PACK_SHRINK);
775        warningIcon.show();
776        Gtk::Label description;
777        description.set_markup(
778            _("\n<b>CAUTION:</b> You <b>MUST</b> use the "
779              "<span style=\"italic\">\"Save\"</span> dialog instead of "
780              "<span style=\"italic\">\"Save As...\"</span> if you want to save "
781              "to the same .gig file. Using "
782              "<span style=\"italic\">\"Save As...\"</span> for writing to the "
783              "same .gig file will end up in corrupted sample wave data!\n")
784        );
785        description.set_line_wrap(true);
786        descriptionArea.pack_start(description, Gtk::PACK_SHRINK);
787        description.show();
788        dialog.get_vbox()->pack_start(descriptionArea, Gtk::PACK_SHRINK);
789        descriptionArea.show();
790    
791      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
792          file_structure_to_be_changed_signal.emit(this->file);          file_structure_to_be_changed_signal.emit(this->file);
# Line 803  void MainWindow::on_action_help_about() Line 935  void MainWindow::on_action_help_about()
935  }  }
936    
937  PropDialog::PropDialog()  PropDialog::PropDialog()
938      : table(2,1)      : table(2,1),
939          eName("Name"),
940          eCreationDate("Creation date"),
941          eComments("Comments"),
942          eProduct("Product"),
943          eCopyright("Copyright"),
944          eArtists("Artists"),
945          eGenre("Genre"),
946          eKeywords("Keywords"),
947          eEngineer("Engineer"),
948          eTechnician("Technician"),
949          eSoftware("Software"),
950          eMedium("Medium"),
951          eSource("Source"),
952          eSourceForm("Source form"),
953          eCommissioned("Commissioned"),
954          eSubject("Subject"),
955          quitButton(Gtk::Stock::CLOSE),
956          update_model(0)
957  {  {
958        set_title("File Properties");
959        eName.set_width_chars(50);
960    
961        connect(eName, &DLS::Info::Name);
962        connect(eCreationDate, &DLS::Info::CreationDate);
963        connect(eComments, &DLS::Info::Comments);
964        connect(eProduct, &DLS::Info::Product);
965        connect(eCopyright, &DLS::Info::Copyright);
966        connect(eArtists, &DLS::Info::Artists);
967        connect(eGenre, &DLS::Info::Genre);
968        connect(eKeywords, &DLS::Info::Keywords);
969        connect(eEngineer, &DLS::Info::Engineer);
970        connect(eTechnician, &DLS::Info::Technician);
971        connect(eSoftware, &DLS::Info::Software);
972        connect(eMedium, &DLS::Info::Medium);
973        connect(eSource, &DLS::Info::Source);
974        connect(eSourceForm, &DLS::Info::SourceForm);
975        connect(eCommissioned, &DLS::Info::Commissioned);
976        connect(eSubject, &DLS::Info::Subject);
977    
978        table.add(eName);
979        table.add(eCreationDate);
980        table.add(eComments);
981        table.add(eProduct);
982        table.add(eCopyright);
983        table.add(eArtists);
984        table.add(eGenre);
985        table.add(eKeywords);
986        table.add(eEngineer);
987        table.add(eTechnician);
988        table.add(eSoftware);
989        table.add(eMedium);
990        table.add(eSource);
991        table.add(eSourceForm);
992        table.add(eCommissioned);
993        table.add(eSubject);
994    
995      table.set_col_spacings(5);      table.set_col_spacings(5);
996      const char* propLabels[] = {      add(vbox);
997          "Name:",      table.set_border_width(5);
998          "CreationDate:",      vbox.add(table);
999          "Comments:", // TODO: multiline      vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);
1000          "Product:",      buttonBox.set_layout(Gtk::BUTTONBOX_END);
1001          "Copyright:",      buttonBox.set_border_width(5);
1002          "Artists:",      buttonBox.show();
1003          "Genre:",      buttonBox.pack_start(quitButton);
1004          "Keywords:",      quitButton.set_flags(Gtk::CAN_DEFAULT);
1005          "Engineer:",      quitButton.grab_focus();
1006          "Technician:",      quitButton.signal_clicked().connect(
1007          "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);  
     }  
1008    
1009      add(table);      quitButton.show();
1010      // add_button(Gtk::Stock::CANCEL, 0);      vbox.show();
     // add_button(Gtk::Stock::OK, 1);  
1011      show_all_children();      show_all_children();
1012  }  }
1013    
1014  void PropDialog::set_info(DLS::Info* info)  void PropDialog::set_info(DLS::Info* info)
1015  {  {
1016      entry[0].set_text(info->Name);      this->info = info;
1017      entry[1].set_text(info->CreationDate);      update_model++;
1018      entry[2].set_text(Glib::convert(info->Comments, "UTF-8", "ISO-8859-1"));      eName.set_value(info->Name);
1019      entry[3].set_text(info->Product);      eCreationDate.set_value(info->CreationDate);
1020      entry[4].set_text(info->Copyright);      eComments.set_value(info->Comments);
1021      entry[5].set_text(info->Artists);      eProduct.set_value(info->Product);
1022      entry[6].set_text(info->Genre);      eCopyright.set_value(info->Copyright);
1023      entry[7].set_text(info->Keywords);      eArtists.set_value(info->Artists);
1024      entry[8].set_text(info->Engineer);      eGenre.set_value(info->Genre);
1025      entry[9].set_text(info->Technician);      eKeywords.set_value(info->Keywords);
1026      entry[10].set_text(info->Software);      eEngineer.set_value(info->Engineer);
1027      entry[11].set_text(info->Medium);      eTechnician.set_value(info->Technician);
1028      entry[12].set_text(info->Source);      eSoftware.set_value(info->Software);
1029      entry[13].set_text(info->SourceForm);      eMedium.set_value(info->Medium);
1030      entry[14].set_text(info->Commissioned);      eSource.set_value(info->Source);
1031      entry[15].set_text(info->Subject);      eSourceForm.set_value(info->SourceForm);
1032        eCommissioned.set_value(info->Commissioned);
1033        eSubject.set_value(info->Subject);
1034        update_model--;
1035  }  }
1036    
1037  void InstrumentProps::add_prop(BoolEntry& boolentry)  sigc::signal<void>& PropDialog::signal_info_changed()
1038  {  {
1039      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());  
1040  }  }
1041    
1042  void InstrumentProps::add_prop(BoolEntryPlus6& boolentry)  void InstrumentProps::set_IsDrum(bool value)
1043  {  {
1044      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());  
1045  }  }
1046    
1047  void InstrumentProps::add_prop(LabelWidget& prop)  void InstrumentProps::set_MIDIBank(uint16_t value)
1048  {  {
1049      table.attach(prop.label, 0, 1, rowno, rowno + 1,      instrument->MIDIBank = value;
1050                   Gtk::FILL, Gtk::SHRINK);  }
1051      table.attach(prop.widget, 1, 2, rowno, rowno + 1,  
1052                   Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK);  void InstrumentProps::set_MIDIProgram(uint32_t value)
1053      rowno++;  {
1054      prop.signal_changed_by_user().connect(instrument_changed.make_slot());      instrument->MIDIProgram = value;
1055    }
1056    
1057    void InstrumentProps::set_DimensionKeyRange_low(uint8_t value)
1058    {
1059        instrument->DimensionKeyRange.low = value;
1060        if (value > instrument->DimensionKeyRange.high) {
1061            eDimensionKeyRangeHigh.set_value(value);
1062        }
1063    }
1064    
1065    void InstrumentProps::set_DimensionKeyRange_high(uint8_t value)
1066    {
1067        instrument->DimensionKeyRange.high = value;
1068        if (value < instrument->DimensionKeyRange.low) {
1069            eDimensionKeyRangeLow.set_value(value);
1070        }
1071  }  }
1072    
1073  InstrumentProps::InstrumentProps()  InstrumentProps::InstrumentProps()
# Line 897  InstrumentProps::InstrumentProps() Line 1083  InstrumentProps::InstrumentProps()
1083        eFineTune("Fine tune", -8400, 8400),        eFineTune("Fine tune", -8400, 8400),
1084        ePitchbendRange("Pitchbend range", 0, 12),        ePitchbendRange("Pitchbend range", 0, 12),
1085        ePianoReleaseMode("Piano release mode"),        ePianoReleaseMode("Piano release mode"),
1086        eDimensionKeyRangeLow("Dimension key range low"),        eDimensionKeyRangeLow("Keyswitching range low"),
1087        eDimensionKeyRangeHigh("Dimension key range high")        eDimensionKeyRangeHigh("Keyswitching range high"),
1088  {        update_model(0)
1089      set_title("Instrument properties");  {
1090        set_title("Instrument Properties");
1091    
1092        eDimensionKeyRangeLow.set_tip(
1093            _("start of the keyboard area which should switch the "
1094              "\"keyswitching\" dimension")
1095        );
1096        eDimensionKeyRangeHigh.set_tip(
1097            _("end of the keyboard area which should switch the "
1098              "\"keyswitching\" dimension")
1099        );
1100    
1101        connect(eIsDrum, &InstrumentProps::set_IsDrum);
1102        connect(eMIDIBank, &InstrumentProps::set_MIDIBank);
1103        connect(eMIDIProgram, &InstrumentProps::set_MIDIProgram);
1104        connect(eAttenuation, &gig::Instrument::Attenuation);
1105        connect(eGainPlus6, &gig::Instrument::Attenuation);
1106        connect(eEffectSend, &gig::Instrument::EffectSend);
1107        connect(eFineTune, &gig::Instrument::FineTune);
1108        connect(ePitchbendRange, &gig::Instrument::PitchbendRange);
1109        connect(ePianoReleaseMode, &gig::Instrument::PianoReleaseMode);
1110        connect(eDimensionKeyRangeLow,
1111                &InstrumentProps::set_DimensionKeyRange_low);
1112        connect(eDimensionKeyRangeHigh,
1113                &InstrumentProps::set_DimensionKeyRange_high);
1114    
     rowno = 0;  
1115      table.set_col_spacings(5);      table.set_col_spacings(5);
1116    
1117      add_prop(eName);      table.add(eName);
1118      add_prop(eIsDrum);      table.add(eIsDrum);
1119      add_prop(eMIDIBank);      table.add(eMIDIBank);
1120      add_prop(eMIDIProgram);      table.add(eMIDIProgram);
1121      add_prop(eAttenuation);      table.add(eAttenuation);
1122      add_prop(eGainPlus6);      table.add(eGainPlus6);
1123      add_prop(eEffectSend);      table.add(eEffectSend);
1124      add_prop(eFineTune);      table.add(eFineTune);
1125      add_prop(ePitchbendRange);      table.add(ePitchbendRange);
1126      add_prop(ePianoReleaseMode);      table.add(ePianoReleaseMode);
1127      add_prop(eDimensionKeyRangeLow);      table.add(eDimensionKeyRangeLow);
1128      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));  
1129    
1130      add(vbox);      add(vbox);
1131      table.set_border_width(5);      table.set_border_width(5);
# Line 945  InstrumentProps::InstrumentProps() Line 1149  InstrumentProps::InstrumentProps()
1149    
1150  void InstrumentProps::set_instrument(gig::Instrument* instrument)  void InstrumentProps::set_instrument(gig::Instrument* instrument)
1151  {  {
1152      eName.set_ptr(&instrument->pInfo->Name);      this->instrument = instrument;
1153      eIsDrum.set_ptr(&instrument->IsDrum);  
1154      eMIDIBank.set_ptr(&instrument->MIDIBank);      update_model++;
1155      eMIDIProgram.set_ptr(&instrument->MIDIProgram);      eName.set_value(instrument->pInfo->Name);
1156      eAttenuation.set_ptr(&instrument->Attenuation);      eIsDrum.set_value(instrument->IsDrum);
1157      eGainPlus6.set_ptr(&instrument->Attenuation);      eMIDIBank.set_value(instrument->MIDIBank);
1158      eEffectSend.set_ptr(&instrument->EffectSend);      eMIDIProgram.set_value(instrument->MIDIProgram);
1159      eFineTune.set_ptr(&instrument->FineTune);      eAttenuation.set_value(instrument->Attenuation);
1160      ePitchbendRange.set_ptr(&instrument->PitchbendRange);      eGainPlus6.set_value(instrument->Attenuation);
1161      ePianoReleaseMode.set_ptr(&instrument->PianoReleaseMode);      eEffectSend.set_value(instrument->EffectSend);
1162      eDimensionKeyRangeLow.set_ptr(0);      eFineTune.set_value(instrument->FineTune);
1163      eDimensionKeyRangeHigh.set_ptr(0);      ePitchbendRange.set_value(instrument->PitchbendRange);
1164      eDimensionKeyRangeLow.set_ptr(&instrument->DimensionKeyRange.low);      ePianoReleaseMode.set_value(instrument->PianoReleaseMode);
1165      eDimensionKeyRangeHigh.set_ptr(&instrument->DimensionKeyRange.high);      eDimensionKeyRangeLow.set_value(instrument->DimensionKeyRange.low);
1166  }      eDimensionKeyRangeHigh.set_value(instrument->DimensionKeyRange.high);
1167        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);  
1168  }  }
1169    
1170  sigc::signal<void>& InstrumentProps::signal_instrument_changed()  sigc::signal<void>& InstrumentProps::signal_instrument_changed()
# Line 1054  void MainWindow::load_gig(gig::File* gig Line 1246  void MainWindow::load_gig(gig::File* gig
1246    
1247  void MainWindow::show_instr_props()  void MainWindow::show_instr_props()
1248  {  {
1249      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();      gig::Instrument* instrument = get_instrument();
1250      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();      if (instrument)
     if (it)  
1251      {      {
1252          Gtk::TreeModel::Row row = *it;          instrumentProps.set_instrument(instrument);
1253          if (row[m_Columns.m_col_instr])          instrumentProps.show();
1254          {          instrumentProps.deiconify();
             instrumentProps.set_instrument(row[m_Columns.m_col_instr]);  
             instrumentProps.show();  
             instrumentProps.deiconify();  
         }  
1255      }      }
1256  }  }
1257    
# Line 1340  void MainWindow::on_action_add_sample() Line 1527  void MainWindow::on_action_add_sample()
1527      }      }
1528  }  }
1529    
1530    void MainWindow::on_action_replace_all_samples_in_all_groups()
1531    {
1532        if (!file) return;
1533        Gtk::FileChooserDialog dialog(*this, _("Select Folder"),
1534                                      Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
1535        Gtk::Label description(
1536            _("This is a very specific function. It tries to replace all samples "
1537              "in the current gig file by samples located in the directory chosen "
1538              "by you above.\n\n"
1539              "It works like this: For each sample in the gig file it tries to "
1540              "find a sample file in the selected directory with the same name as "
1541              "the sample in the gig file. Optionally you can add a filename "
1542              "postfix below, which will be added to the filename expected to be "
1543              "found. That is, assume you have a gig file with a sample called "
1544              "'Snare', if you enter '.wav' below (like it's done by default), it "
1545              "assumes to find a sample file called 'Snare.wav' and will replace "
1546              "the sample in the gig file accordingly. If you don't need such a "
1547              "postfix, blank the field below. Any gig sample where no "
1548              "appropriate sample file could be found, will be reported and left "
1549              "untouched.\n\n")
1550        );
1551        description.set_line_wrap(true);
1552        Gtk::HBox entryArea;
1553        Gtk::Label entryLabel( _("Add Filename Extension: "), Gtk::ALIGN_RIGHT);
1554        Gtk::Entry postfixEntryBox;
1555        postfixEntryBox.set_text(".wav");
1556        entryArea.pack_start(entryLabel);
1557        entryArea.pack_start(postfixEntryBox);
1558        dialog.get_vbox()->pack_start(description, Gtk::PACK_SHRINK);
1559        dialog.get_vbox()->pack_start(entryArea, Gtk::PACK_SHRINK);
1560        description.show();
1561        entryLabel.show();
1562        postfixEntryBox.show();
1563        entryArea.show();
1564        dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1565        dialog.add_button(_("Select"), Gtk::RESPONSE_OK);
1566        dialog.set_select_multiple(false);
1567        // fix label width (because Gtk by design doesn't
1568        // know anything about the parent's size)
1569    #if 0 //FIXME: doesn't work
1570        int dialogW, dialogH, labelW, labelH;
1571        dialog.get_size_request(dialogW, dialogH);
1572        description.get_size_request(labelW, labelH);
1573        std::cout << "dialog(" << dialogW << "," << dialogH << ")\nlabel(" << labelW << "," << labelH << ")\n" << std::flush;
1574        description.set_size_request(dialogW, labelH);
1575    #endif
1576        if (dialog.run() == Gtk::RESPONSE_OK)
1577        {
1578            Glib::ustring error_files;
1579            Glib::ustring folder = dialog.get_filename();
1580            for (gig::Sample* sample = file->GetFirstSample();
1581                 sample; sample = file->GetNextSample())
1582            {
1583                std::string filename =
1584                    folder + G_DIR_SEPARATOR_S + sample->pInfo->Name +
1585                    postfixEntryBox.get_text().raw();
1586                SF_INFO info;
1587                info.format = 0;
1588                SNDFILE* hFile = sf_open(filename.c_str(), SFM_READ, &info);
1589                try
1590                {
1591                    if (!hFile) throw std::string("could not open file");
1592                    int bitdepth;
1593                    switch (info.format & 0xff) {
1594                        case SF_FORMAT_PCM_S8:
1595                        case SF_FORMAT_PCM_16:
1596                        case SF_FORMAT_PCM_U8:
1597                            bitdepth = 16;
1598                            break;
1599                        case SF_FORMAT_PCM_24:
1600                        case SF_FORMAT_PCM_32:
1601                        case SF_FORMAT_FLOAT:
1602                        case SF_FORMAT_DOUBLE:
1603                            bitdepth = 24;
1604                            break;
1605                        default:
1606                            sf_close(hFile);
1607                            throw std::string("format not supported");
1608                    }
1609                    SampleImportItem sched_item;
1610                    sched_item.gig_sample  = sample;
1611                    sched_item.sample_path = filename;
1612                    m_SampleImportQueue.push_back(sched_item);
1613                    sf_close(hFile);
1614                    file_changed();
1615                }
1616                catch (std::string what)
1617                {
1618                    if (error_files.size()) error_files += "\n";
1619                        error_files += filename += " (" + what + ")";
1620                }
1621            }
1622            // show error message box when some file(s) could not be opened / added
1623            if (error_files.size()) {
1624                Glib::ustring txt =
1625                    _("Could not replace the following sample(s):\n") + error_files;
1626                Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
1627                msg.run();
1628            }
1629        }
1630    }
1631    
1632  void MainWindow::on_action_remove_sample() {  void MainWindow::on_action_remove_sample() {
1633      if (!file) return;      if (!file) return;
1634      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
# Line 1506  void MainWindow::on_sample_label_drop_dr Line 1795  void MainWindow::on_sample_label_drop_dr
1795          // notify we're done with altering          // notify we're done with altering
1796          region_changed_signal.emit(region);          region_changed_signal.emit(region);
1797    
1798            file_changed();
1799    
1800          return;          return;
1801      }      }
1802      // drop failed      // drop failed
# Line 1597  sigc::signal<void, gig::DimensionRegion* Line 1888  sigc::signal<void, gig::DimensionRegion*
1888  sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {  sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {
1889      return dimreg_changed_signal;      return dimreg_changed_signal;
1890  }  }
1891    
1892    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_on() {
1893        return note_on_signal;
1894    }
1895    
1896    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_off() {
1897        return note_off_signal;
1898    }
1899    
1900    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_hit() {
1901        return m_RegionChooser.signal_keyboard_key_hit();
1902    }
1903    
1904    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_released() {
1905        return m_RegionChooser.signal_keyboard_key_released();
1906    }
Legend:
Removed from v.1436  
changed lines
  Added in v.1679
  ViewVC Help
Powered by ViewVC