/[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 1725 by persson, Sat Apr 26 08:52:15 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 18  Line 18 
18   */   */
19    
20  #include <iostream>  #include <iostream>
21    #include <cstring>
22    
23  #include <gtkmm/filechooserdialog.h>  #include <gtkmm/filechooserdialog.h>
24  #include <gtkmm/messagedialog.h>  #include <gtkmm/messagedialog.h>
# Line 59  template<class T> inline std::string ToS Line 60  template<class T> inline std::string ToS
60      return ss.str();      return ss.str();
61  }  }
62    
63  MainWindow::MainWindow()  Table::Table(int x, int y) : Gtk::Table(x, y), rowno(0) {  }
64    
65    void Table::add(BoolEntry& boolentry)
66    {
67        attach(boolentry.widget, 0, 2, rowno, rowno + 1,
68               Gtk::FILL, Gtk::SHRINK);
69        rowno++;
70    }
71    
72    void Table::add(BoolEntryPlus6& boolentry)
73    {
74        attach(boolentry.widget, 0, 2, rowno, rowno + 1,
75               Gtk::FILL, Gtk::SHRINK);
76        rowno++;
77    }
78    
79    void Table::add(LabelWidget& prop)
80    {
81        attach(prop.label, 1, 2, rowno, rowno + 1,
82               Gtk::FILL, Gtk::SHRINK);
83        attach(prop.widget, 2, 3, rowno, rowno + 1,
84               Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
85        rowno++;
86    }
87    
88    MainWindow::MainWindow() :
89        dimreg_label(_("Changes apply to:")),
90        dimreg_all_regions(_("all regions")),
91        dimreg_all_dimregs(_("all dimension splits")),
92        dimreg_stereo(_("both channels"))
93  {  {
94  //    set_border_width(5);  //    set_border_width(5);
95  //    set_default_size(400, 200);  //    set_default_size(400, 200);
# Line 89  MainWindow::MainWindow() Line 119  MainWindow::MainWindow()
119      m_TreeViewNotebook.set_size_request(300);      m_TreeViewNotebook.set_size_request(300);
120    
121      m_HPaned.add1(m_TreeViewNotebook);      m_HPaned.add1(m_TreeViewNotebook);
122      m_HPaned.add2(dimreg_edit);      dimreg_hbox.add(dimreg_label);
123        dimreg_hbox.add(dimreg_all_regions);
124        dimreg_hbox.add(dimreg_all_dimregs);
125        dimreg_stereo.set_active();
126        dimreg_hbox.add(dimreg_stereo);
127        dimreg_vbox.add(dimreg_edit);
128        dimreg_vbox.pack_start(dimreg_hbox, Gtk::PACK_SHRINK);
129        m_HPaned.add2(dimreg_vbox);
130    
131    
132      m_TreeViewNotebook.append_page(m_ScrolledWindowSamples, "Samples");      m_TreeViewNotebook.append_page(m_ScrolledWindowSamples, "Samples");
# Line 172  MainWindow::MainWindow() Line 209  MainWindow::MainWindow()
209          Gtk::Action::create("RemoveSample", Gtk::Stock::REMOVE),          Gtk::Action::create("RemoveSample", Gtk::Stock::REMOVE),
210          sigc::mem_fun(*this, &MainWindow::on_action_remove_sample)          sigc::mem_fun(*this, &MainWindow::on_action_remove_sample)
211      );      );
212        actionGroup->add(
213            Gtk::Action::create("ReplaceAllSamplesInAllGroups", _("Replace All Samples In All Groups")),
214            sigc::mem_fun(*this, &MainWindow::on_action_replace_all_samples_in_all_groups)
215        );
216    
217      uiManager = Gtk::UIManager::create();      uiManager = Gtk::UIManager::create();
218      uiManager->insert_action_group(actionGroup);      uiManager->insert_action_group(actionGroup);
# Line 212  MainWindow::MainWindow() Line 253  MainWindow::MainWindow()
253          "    <menuitem action='SampleProperties'/>"          "    <menuitem action='SampleProperties'/>"
254          "    <menuitem action='AddGroup'/>"          "    <menuitem action='AddGroup'/>"
255          "    <menuitem action='AddSample'/>"          "    <menuitem action='AddSample'/>"
256            "    <menuitem action='ReplaceAllSamplesInAllGroups' />"
257          "    <separator/>"          "    <separator/>"
258          "    <menuitem action='RemoveSample'/>"          "    <menuitem action='RemoveSample'/>"
259          "  </popup>"          "  </popup>"
# Line 224  MainWindow::MainWindow() Line 266  MainWindow::MainWindow()
266      m_VBox.pack_start(*menuBar, Gtk::PACK_SHRINK);      m_VBox.pack_start(*menuBar, Gtk::PACK_SHRINK);
267      m_VBox.pack_start(m_HPaned);      m_VBox.pack_start(m_HPaned);
268      m_VBox.pack_start(m_RegionChooser, Gtk::PACK_SHRINK);      m_VBox.pack_start(m_RegionChooser, Gtk::PACK_SHRINK);
269        m_VBox.pack_start(m_RegionChooser.m_VirtKeybPropsBox, Gtk::PACK_SHRINK);
270      m_VBox.pack_start(m_DimRegionChooser, Gtk::PACK_SHRINK);      m_VBox.pack_start(m_DimRegionChooser, Gtk::PACK_SHRINK);
271      m_VBox.pack_start(m_StatusBar, Gtk::PACK_SHRINK);      m_VBox.pack_start(m_StatusBar, Gtk::PACK_SHRINK);
272    
# Line 284  MainWindow::MainWindow() Line 327  MainWindow::MainWindow()
327          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
328      instrumentProps.signal_instrument_changed().connect(      instrumentProps.signal_instrument_changed().connect(
329          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
330        propDialog.signal_info_changed().connect(
331            sigc::mem_fun(*this, &MainWindow::file_changed));
332    
333      dimreg_edit.signal_dimreg_to_be_changed().connect(      dimreg_edit.signal_dimreg_to_be_changed().connect(
334          dimreg_to_be_changed_signal.make_slot());          dimreg_to_be_changed_signal.make_slot());
# Line 313  MainWindow::MainWindow() Line 358  MainWindow::MainWindow()
358      m_RegionChooser.signal_region_changed_signal().connect(      m_RegionChooser.signal_region_changed_signal().connect(
359          region_changed_signal.make_slot());          region_changed_signal.make_slot());
360    
361        note_on_signal.connect(
362            sigc::mem_fun(m_RegionChooser, &RegionChooser::on_note_on_event));
363        note_off_signal.connect(
364            sigc::mem_fun(m_RegionChooser, &RegionChooser::on_note_off_event));
365    
366        dimreg_all_regions.signal_toggled().connect(
367            sigc::mem_fun(*this, &MainWindow::update_dimregs));
368        dimreg_all_dimregs.signal_toggled().connect(
369            sigc::mem_fun(*this, &MainWindow::dimreg_all_dimregs_toggled));
370        dimreg_stereo.signal_toggled().connect(
371            sigc::mem_fun(*this, &MainWindow::update_dimregs));
372    
373      file = 0;      file = 0;
374      file_is_changed = false;      file_is_changed = false;
375      set_file_is_shared(false);      set_file_is_shared(false);
# Line 343  void MainWindow::region_changed() Line 400  void MainWindow::region_changed()
400      m_DimRegionChooser.set_region(m_RegionChooser.get_region());      m_DimRegionChooser.set_region(m_RegionChooser.get_region());
401  }  }
402    
403  void MainWindow::dimreg_changed()  gig::Instrument* MainWindow::get_instrument()
 {  
     dimreg_edit.set_dim_region(m_DimRegionChooser.get_dimregion());  
 }  
   
 void MainWindow::on_sel_change()  
404  {  {
405        gig::Instrument* instrument = 0;
406      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();
407    
408      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();
409      if (it) {      if (it) {
410          Gtk::TreeModel::Row row = *it;          Gtk::TreeModel::Row row = *it;
411          std::cout << row[m_Columns.m_col_name] << std::endl;          instrument = row[m_Columns.m_col_instr];
412        }
413        return instrument;
414    }
415    
416          m_RegionChooser.set_instrument(row[m_Columns.m_col_instr]);  void MainWindow::add_region_to_dimregs(gig::Region* region, bool stereo, bool all_dimregs)
417    {
418        if (all_dimregs) {
419            for (int i = 0 ; i < region->DimensionRegions ; i++) {
420                if (region->pDimensionRegions[i]) {
421                    dimreg_edit.dimregs.insert(region->pDimensionRegions[i]);
422                }
423            }
424      } else {      } else {
425          m_RegionChooser.set_instrument(0);          m_DimRegionChooser.get_dimregions(region, stereo, dimreg_edit.dimregs);
426        }
427    }
428    
429    void MainWindow::update_dimregs()
430    {
431        dimreg_edit.dimregs.clear();
432        bool all_regions = dimreg_all_regions.get_active();
433        bool stereo = dimreg_stereo.get_active();
434        bool all_dimregs = dimreg_all_dimregs.get_active();
435    
436        if (all_regions) {
437            gig::Instrument* instrument = get_instrument();
438            if (instrument) {
439                for (gig::Region* region = instrument->GetFirstRegion() ;
440                     region ;
441                     region = instrument->GetNextRegion()) {
442                    add_region_to_dimregs(region, stereo, all_dimregs);
443                }
444            }
445        } else {
446            gig::Region* region = m_RegionChooser.get_region();
447            if (region) {
448                add_region_to_dimregs(region, stereo, all_dimregs);
449            }
450      }      }
451  }  }
452    
453    void MainWindow::dimreg_all_dimregs_toggled()
454    {
455        dimreg_stereo.set_sensitive(!dimreg_all_dimregs.get_active());
456        update_dimregs();
457    }
458    
459    void MainWindow::dimreg_changed()
460    {
461        update_dimregs();
462        dimreg_edit.set_dim_region(m_DimRegionChooser.get_dimregion());
463    }
464    
465    void MainWindow::on_sel_change()
466    {
467        m_RegionChooser.set_instrument(get_instrument());
468    }
469    
470  void loader_progress_callback(gig::progress_t* progress)  void loader_progress_callback(gig::progress_t* progress)
471  {  {
472      Loader* loader = static_cast<Loader*>(progress->custom);      Loader* loader = static_cast<Loader*>(progress->custom);
# Line 520  void MainWindow::on_action_file_open() Line 624  void MainWindow::on_action_file_open()
624      Gtk::FileFilter filter;      Gtk::FileFilter filter;
625      filter.add_pattern("*.gig");      filter.add_pattern("*.gig");
626      dialog.set_filter(filter);      dialog.set_filter(filter);
627      if (current_dir != "") {      if (current_gig_dir != "") {
628          dialog.set_current_folder(current_dir);          dialog.set_current_folder(current_gig_dir);
629      }      }
630      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
631          std::string filename = dialog.get_filename();          std::string filename = dialog.get_filename();
632          printf("filename=%s\n", filename.c_str());          printf("filename=%s\n", filename.c_str());
633          printf("on_action_file_open self=%x\n", Glib::Thread::self());          printf("on_action_file_open self=%x\n", Glib::Thread::self());
634          load_file(filename.c_str());          load_file(filename.c_str());
635          current_dir = Glib::path_get_dirname(filename);          current_gig_dir = Glib::path_get_dirname(filename);
636      }      }
637  }  }
638    
# Line 649  bool MainWindow::file_save_as() Line 753  bool MainWindow::file_save_as()
753      filter.add_pattern("*.gig");      filter.add_pattern("*.gig");
754      dialog.set_filter(filter);      dialog.set_filter(filter);
755    
756      if (Glib::path_is_absolute(filename)) {      // set initial dir and filename of the Save As dialog
757          dialog.set_filename(filename);      // and prepare that initial filename as a copy of the gig
758      } else if (current_dir != "") {      {
759          dialog.set_current_folder(current_dir);          std::string basename = Glib::path_get_basename(filename);
760            std::string dir = Glib::path_get_dirname(filename);
761            basename = std::string("copy_of_") + basename;
762            Glib::ustring copyFileName = Glib::build_filename(dir, basename);
763            if (Glib::path_is_absolute(filename)) {
764                dialog.set_filename(copyFileName);
765            } else {
766                if (current_gig_dir != "") dialog.set_current_folder(current_gig_dir);
767            }
768            dialog.set_current_name(Glib::filename_display_basename(copyFileName));
769      }      }
770      dialog.set_current_name(Glib::filename_display_basename(filename));  
771        // show warning in the dialog
772        Gtk::HBox descriptionArea;
773        descriptionArea.set_spacing(15);
774        Gtk::Image warningIcon(Gtk::Stock::DIALOG_WARNING, Gtk::IconSize(Gtk::ICON_SIZE_DIALOG));
775        descriptionArea.pack_start(warningIcon, Gtk::PACK_SHRINK);
776        warningIcon.show();
777        Gtk::Label description;
778        description.set_markup(
779            _("\n<b>CAUTION:</b> You <b>MUST</b> use the "
780              "<span style=\"italic\">\"Save\"</span> dialog instead of "
781              "<span style=\"italic\">\"Save As...\"</span> if you want to save "
782              "to the same .gig file. Using "
783              "<span style=\"italic\">\"Save As...\"</span> for writing to the "
784              "same .gig file will end up in corrupted sample wave data!\n")
785        );
786        description.set_line_wrap(true);
787        descriptionArea.pack_start(description, Gtk::PACK_SHRINK);
788        description.show();
789        dialog.get_vbox()->pack_start(descriptionArea, Gtk::PACK_SHRINK);
790        descriptionArea.show();
791    
792      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
793          file_structure_to_be_changed_signal.emit(this->file);          file_structure_to_be_changed_signal.emit(this->file);
# Line 666  bool MainWindow::file_save_as() Line 799  bool MainWindow::file_save_as()
799              printf("filename=%s\n", filename.c_str());              printf("filename=%s\n", filename.c_str());
800              file->Save(filename);              file->Save(filename);
801              this->filename = filename;              this->filename = filename;
802              current_dir = Glib::path_get_dirname(filename);              current_gig_dir = Glib::path_get_dirname(filename);
803              set_title(Glib::filename_display_basename(filename));              set_title(Glib::filename_display_basename(filename));
804              file_has_name = true;              file_has_name = true;
805              file_is_changed = false;              file_is_changed = false;
# Line 803  void MainWindow::on_action_help_about() Line 936  void MainWindow::on_action_help_about()
936  }  }
937    
938  PropDialog::PropDialog()  PropDialog::PropDialog()
939      : table(2,1)      : table(2,1),
940          eName("Name"),
941          eCreationDate("Creation date"),
942          eComments("Comments"),
943          eProduct("Product"),
944          eCopyright("Copyright"),
945          eArtists("Artists"),
946          eGenre("Genre"),
947          eKeywords("Keywords"),
948          eEngineer("Engineer"),
949          eTechnician("Technician"),
950          eSoftware("Software"),
951          eMedium("Medium"),
952          eSource("Source"),
953          eSourceForm("Source form"),
954          eCommissioned("Commissioned"),
955          eSubject("Subject"),
956          quitButton(Gtk::Stock::CLOSE),
957          update_model(0)
958  {  {
959        set_title("File Properties");
960        eName.set_width_chars(50);
961    
962        connect(eName, &DLS::Info::Name);
963        connect(eCreationDate, &DLS::Info::CreationDate);
964        connect(eComments, &DLS::Info::Comments);
965        connect(eProduct, &DLS::Info::Product);
966        connect(eCopyright, &DLS::Info::Copyright);
967        connect(eArtists, &DLS::Info::Artists);
968        connect(eGenre, &DLS::Info::Genre);
969        connect(eKeywords, &DLS::Info::Keywords);
970        connect(eEngineer, &DLS::Info::Engineer);
971        connect(eTechnician, &DLS::Info::Technician);
972        connect(eSoftware, &DLS::Info::Software);
973        connect(eMedium, &DLS::Info::Medium);
974        connect(eSource, &DLS::Info::Source);
975        connect(eSourceForm, &DLS::Info::SourceForm);
976        connect(eCommissioned, &DLS::Info::Commissioned);
977        connect(eSubject, &DLS::Info::Subject);
978    
979        table.add(eName);
980        table.add(eCreationDate);
981        table.add(eComments);
982        table.add(eProduct);
983        table.add(eCopyright);
984        table.add(eArtists);
985        table.add(eGenre);
986        table.add(eKeywords);
987        table.add(eEngineer);
988        table.add(eTechnician);
989        table.add(eSoftware);
990        table.add(eMedium);
991        table.add(eSource);
992        table.add(eSourceForm);
993        table.add(eCommissioned);
994        table.add(eSubject);
995    
996      table.set_col_spacings(5);      table.set_col_spacings(5);
997      const char* propLabels[] = {      add(vbox);
998          "Name:",      table.set_border_width(5);
999          "CreationDate:",      vbox.add(table);
1000          "Comments:", // TODO: multiline      vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);
1001          "Product:",      buttonBox.set_layout(Gtk::BUTTONBOX_END);
1002          "Copyright:",      buttonBox.set_border_width(5);
1003          "Artists:",      buttonBox.show();
1004          "Genre:",      buttonBox.pack_start(quitButton);
1005          "Keywords:",      quitButton.set_flags(Gtk::CAN_DEFAULT);
1006          "Engineer:",      quitButton.grab_focus();
1007          "Technician:",      quitButton.signal_clicked().connect(
1008          "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);  
     }  
1009    
1010      add(table);      quitButton.show();
1011      // add_button(Gtk::Stock::CANCEL, 0);      vbox.show();
     // add_button(Gtk::Stock::OK, 1);  
1012      show_all_children();      show_all_children();
1013  }  }
1014    
1015  void PropDialog::set_info(DLS::Info* info)  void PropDialog::set_info(DLS::Info* info)
1016  {  {
1017      entry[0].set_text(info->Name);      this->info = info;
1018      entry[1].set_text(info->CreationDate);      update_model++;
1019      entry[2].set_text(Glib::convert(info->Comments, "UTF-8", "ISO-8859-1"));      eName.set_value(info->Name);
1020      entry[3].set_text(info->Product);      eCreationDate.set_value(info->CreationDate);
1021      entry[4].set_text(info->Copyright);      eComments.set_value(info->Comments);
1022      entry[5].set_text(info->Artists);      eProduct.set_value(info->Product);
1023      entry[6].set_text(info->Genre);      eCopyright.set_value(info->Copyright);
1024      entry[7].set_text(info->Keywords);      eArtists.set_value(info->Artists);
1025      entry[8].set_text(info->Engineer);      eGenre.set_value(info->Genre);
1026      entry[9].set_text(info->Technician);      eKeywords.set_value(info->Keywords);
1027      entry[10].set_text(info->Software);      eEngineer.set_value(info->Engineer);
1028      entry[11].set_text(info->Medium);      eTechnician.set_value(info->Technician);
1029      entry[12].set_text(info->Source);      eSoftware.set_value(info->Software);
1030      entry[13].set_text(info->SourceForm);      eMedium.set_value(info->Medium);
1031      entry[14].set_text(info->Commissioned);      eSource.set_value(info->Source);
1032      entry[15].set_text(info->Subject);      eSourceForm.set_value(info->SourceForm);
1033        eCommissioned.set_value(info->Commissioned);
1034        eSubject.set_value(info->Subject);
1035        update_model--;
1036  }  }
1037    
1038  void InstrumentProps::add_prop(BoolEntry& boolentry)  sigc::signal<void>& PropDialog::signal_info_changed()
1039  {  {
1040      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());  
1041  }  }
1042    
1043  void InstrumentProps::add_prop(BoolEntryPlus6& boolentry)  void InstrumentProps::set_IsDrum(bool value)
1044  {  {
1045      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());  
1046  }  }
1047    
1048  void InstrumentProps::add_prop(LabelWidget& prop)  void InstrumentProps::set_MIDIBank(uint16_t value)
1049  {  {
1050      table.attach(prop.label, 0, 1, rowno, rowno + 1,      instrument->MIDIBank = value;
1051                   Gtk::FILL, Gtk::SHRINK);  }
1052      table.attach(prop.widget, 1, 2, rowno, rowno + 1,  
1053                   Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK);  void InstrumentProps::set_MIDIProgram(uint32_t value)
1054      rowno++;  {
1055      prop.signal_changed_by_user().connect(instrument_changed.make_slot());      instrument->MIDIProgram = value;
1056    }
1057    
1058    void InstrumentProps::set_DimensionKeyRange_low(uint8_t value)
1059    {
1060        instrument->DimensionKeyRange.low = value;
1061        if (value > instrument->DimensionKeyRange.high) {
1062            eDimensionKeyRangeHigh.set_value(value);
1063        }
1064    }
1065    
1066    void InstrumentProps::set_DimensionKeyRange_high(uint8_t value)
1067    {
1068        instrument->DimensionKeyRange.high = value;
1069        if (value < instrument->DimensionKeyRange.low) {
1070            eDimensionKeyRangeLow.set_value(value);
1071        }
1072  }  }
1073    
1074  InstrumentProps::InstrumentProps()  InstrumentProps::InstrumentProps()
# Line 897  InstrumentProps::InstrumentProps() Line 1084  InstrumentProps::InstrumentProps()
1084        eFineTune("Fine tune", -8400, 8400),        eFineTune("Fine tune", -8400, 8400),
1085        ePitchbendRange("Pitchbend range", 0, 12),        ePitchbendRange("Pitchbend range", 0, 12),
1086        ePianoReleaseMode("Piano release mode"),        ePianoReleaseMode("Piano release mode"),
1087        eDimensionKeyRangeLow("Dimension key range low"),        eDimensionKeyRangeLow("Keyswitching range low"),
1088        eDimensionKeyRangeHigh("Dimension key range high")        eDimensionKeyRangeHigh("Keyswitching range high"),
1089  {        update_model(0)
1090      set_title("Instrument properties");  {
1091        set_title("Instrument Properties");
1092    
1093        eDimensionKeyRangeLow.set_tip(
1094            _("start of the keyboard area which should switch the "
1095              "\"keyswitching\" dimension")
1096        );
1097        eDimensionKeyRangeHigh.set_tip(
1098            _("end of the keyboard area which should switch the "
1099              "\"keyswitching\" dimension")
1100        );
1101    
1102        connect(eIsDrum, &InstrumentProps::set_IsDrum);
1103        connect(eMIDIBank, &InstrumentProps::set_MIDIBank);
1104        connect(eMIDIProgram, &InstrumentProps::set_MIDIProgram);
1105        connect(eAttenuation, &gig::Instrument::Attenuation);
1106        connect(eGainPlus6, &gig::Instrument::Attenuation);
1107        connect(eEffectSend, &gig::Instrument::EffectSend);
1108        connect(eFineTune, &gig::Instrument::FineTune);
1109        connect(ePitchbendRange, &gig::Instrument::PitchbendRange);
1110        connect(ePianoReleaseMode, &gig::Instrument::PianoReleaseMode);
1111        connect(eDimensionKeyRangeLow,
1112                &InstrumentProps::set_DimensionKeyRange_low);
1113        connect(eDimensionKeyRangeHigh,
1114                &InstrumentProps::set_DimensionKeyRange_high);
1115    
     rowno = 0;  
1116      table.set_col_spacings(5);      table.set_col_spacings(5);
1117    
1118      add_prop(eName);      table.add(eName);
1119      add_prop(eIsDrum);      table.add(eIsDrum);
1120      add_prop(eMIDIBank);      table.add(eMIDIBank);
1121      add_prop(eMIDIProgram);      table.add(eMIDIProgram);
1122      add_prop(eAttenuation);      table.add(eAttenuation);
1123      add_prop(eGainPlus6);      table.add(eGainPlus6);
1124      add_prop(eEffectSend);      table.add(eEffectSend);
1125      add_prop(eFineTune);      table.add(eFineTune);
1126      add_prop(ePitchbendRange);      table.add(ePitchbendRange);
1127      add_prop(ePianoReleaseMode);      table.add(ePianoReleaseMode);
1128      add_prop(eDimensionKeyRangeLow);      table.add(eDimensionKeyRangeLow);
1129      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));  
1130    
1131      add(vbox);      add(vbox);
1132      table.set_border_width(5);      table.set_border_width(5);
# Line 945  InstrumentProps::InstrumentProps() Line 1150  InstrumentProps::InstrumentProps()
1150    
1151  void InstrumentProps::set_instrument(gig::Instrument* instrument)  void InstrumentProps::set_instrument(gig::Instrument* instrument)
1152  {  {
1153      eName.set_ptr(&instrument->pInfo->Name);      this->instrument = instrument;
1154      eIsDrum.set_ptr(&instrument->IsDrum);  
1155      eMIDIBank.set_ptr(&instrument->MIDIBank);      update_model++;
1156      eMIDIProgram.set_ptr(&instrument->MIDIProgram);      eName.set_value(instrument->pInfo->Name);
1157      eAttenuation.set_ptr(&instrument->Attenuation);      eIsDrum.set_value(instrument->IsDrum);
1158      eGainPlus6.set_ptr(&instrument->Attenuation);      eMIDIBank.set_value(instrument->MIDIBank);
1159      eEffectSend.set_ptr(&instrument->EffectSend);      eMIDIProgram.set_value(instrument->MIDIProgram);
1160      eFineTune.set_ptr(&instrument->FineTune);      eAttenuation.set_value(instrument->Attenuation);
1161      ePitchbendRange.set_ptr(&instrument->PitchbendRange);      eGainPlus6.set_value(instrument->Attenuation);
1162      ePianoReleaseMode.set_ptr(&instrument->PianoReleaseMode);      eEffectSend.set_value(instrument->EffectSend);
1163      eDimensionKeyRangeLow.set_ptr(0);      eFineTune.set_value(instrument->FineTune);
1164      eDimensionKeyRangeHigh.set_ptr(0);      ePitchbendRange.set_value(instrument->PitchbendRange);
1165      eDimensionKeyRangeLow.set_ptr(&instrument->DimensionKeyRange.low);      ePianoReleaseMode.set_value(instrument->PianoReleaseMode);
1166      eDimensionKeyRangeHigh.set_ptr(&instrument->DimensionKeyRange.high);      eDimensionKeyRangeLow.set_value(instrument->DimensionKeyRange.low);
1167  }      eDimensionKeyRangeHigh.set_value(instrument->DimensionKeyRange.high);
1168        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);  
1169  }  }
1170    
1171  sigc::signal<void>& InstrumentProps::signal_instrument_changed()  sigc::signal<void>& InstrumentProps::signal_instrument_changed()
# Line 1054  void MainWindow::load_gig(gig::File* gig Line 1247  void MainWindow::load_gig(gig::File* gig
1247    
1248  void MainWindow::show_instr_props()  void MainWindow::show_instr_props()
1249  {  {
1250      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();      gig::Instrument* instrument = get_instrument();
1251      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();      if (instrument)
     if (it)  
1252      {      {
1253          Gtk::TreeModel::Row row = *it;          instrumentProps.set_instrument(instrument);
1254          if (row[m_Columns.m_col_instr])          instrumentProps.show();
1255          {          instrumentProps.deiconify();
             instrumentProps.set_instrument(row[m_Columns.m_col_instr]);  
             instrumentProps.show();  
             instrumentProps.deiconify();  
         }  
1256      }      }
1257  }  }
1258    
# Line 1227  void MainWindow::on_action_add_sample() Line 1415  void MainWindow::on_action_add_sample()
1415      allpassfilter.set_name("All Files");      allpassfilter.set_name("All Files");
1416      dialog.add_filter(soundfilter);      dialog.add_filter(soundfilter);
1417      dialog.add_filter(allpassfilter);      dialog.add_filter(allpassfilter);
1418        if (current_sample_dir != "") {
1419            dialog.set_current_folder(current_sample_dir);
1420        }
1421      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
1422            current_sample_dir = dialog.get_current_folder();
1423          Glib::ustring error_files;          Glib::ustring error_files;
1424          Glib::SListHandle<Glib::ustring> filenames = dialog.get_filenames();          Glib::SListHandle<Glib::ustring> filenames = dialog.get_filenames();
1425          for (Glib::SListHandle<Glib::ustring>::iterator iter = filenames.begin();          for (Glib::SListHandle<Glib::ustring>::iterator iter = filenames.begin();
# Line 1340  void MainWindow::on_action_add_sample() Line 1532  void MainWindow::on_action_add_sample()
1532      }      }
1533  }  }
1534    
1535    void MainWindow::on_action_replace_all_samples_in_all_groups()
1536    {
1537        if (!file) return;
1538        Gtk::FileChooserDialog dialog(*this, _("Select Folder"),
1539                                      Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
1540        Gtk::Label description(
1541            _("This is a very specific function. It tries to replace all samples "
1542              "in the current gig file by samples located in the directory chosen "
1543              "by you above.\n\n"
1544              "It works like this: For each sample in the gig file it tries to "
1545              "find a sample file in the selected directory with the same name as "
1546              "the sample in the gig file. Optionally you can add a filename "
1547              "postfix below, which will be added to the filename expected to be "
1548              "found. That is, assume you have a gig file with a sample called "
1549              "'Snare', if you enter '.wav' below (like it's done by default), it "
1550              "assumes to find a sample file called 'Snare.wav' and will replace "
1551              "the sample in the gig file accordingly. If you don't need such a "
1552              "postfix, blank the field below. Any gig sample where no "
1553              "appropriate sample file could be found, will be reported and left "
1554              "untouched.\n\n")
1555        );
1556        description.set_line_wrap(true);
1557        Gtk::HBox entryArea;
1558        Gtk::Label entryLabel( _("Add Filename Extension: "), Gtk::ALIGN_RIGHT);
1559        Gtk::Entry postfixEntryBox;
1560        postfixEntryBox.set_text(".wav");
1561        entryArea.pack_start(entryLabel);
1562        entryArea.pack_start(postfixEntryBox);
1563        dialog.get_vbox()->pack_start(description, Gtk::PACK_SHRINK);
1564        dialog.get_vbox()->pack_start(entryArea, Gtk::PACK_SHRINK);
1565        description.show();
1566        entryLabel.show();
1567        postfixEntryBox.show();
1568        entryArea.show();
1569        dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1570        dialog.add_button(_("Select"), Gtk::RESPONSE_OK);
1571        dialog.set_select_multiple(false);
1572        if (current_sample_dir != "") {
1573            dialog.set_current_folder(current_sample_dir);
1574        }
1575        // fix label width (because Gtk by design doesn't
1576        // know anything about the parent's size)
1577    #if 0 //FIXME: doesn't work
1578        int dialogW, dialogH, labelW, labelH;
1579        dialog.get_size_request(dialogW, dialogH);
1580        description.get_size_request(labelW, labelH);
1581        std::cout << "dialog(" << dialogW << "," << dialogH << ")\nlabel(" << labelW << "," << labelH << ")\n" << std::flush;
1582        description.set_size_request(dialogW, labelH);
1583    #endif
1584        if (dialog.run() == Gtk::RESPONSE_OK)
1585        {
1586            current_sample_dir = dialog.get_current_folder();
1587            Glib::ustring error_files;
1588            Glib::ustring folder = dialog.get_filename();
1589            for (gig::Sample* sample = file->GetFirstSample();
1590                 sample; sample = file->GetNextSample())
1591            {
1592                std::string filename =
1593                    folder + G_DIR_SEPARATOR_S + sample->pInfo->Name +
1594                    postfixEntryBox.get_text().raw();
1595                SF_INFO info;
1596                info.format = 0;
1597                SNDFILE* hFile = sf_open(filename.c_str(), SFM_READ, &info);
1598                try
1599                {
1600                    if (!hFile) throw std::string("could not open file");
1601                    int bitdepth;
1602                    switch (info.format & 0xff) {
1603                        case SF_FORMAT_PCM_S8:
1604                        case SF_FORMAT_PCM_16:
1605                        case SF_FORMAT_PCM_U8:
1606                            bitdepth = 16;
1607                            break;
1608                        case SF_FORMAT_PCM_24:
1609                        case SF_FORMAT_PCM_32:
1610                        case SF_FORMAT_FLOAT:
1611                        case SF_FORMAT_DOUBLE:
1612                            bitdepth = 24;
1613                            break;
1614                        default:
1615                            sf_close(hFile);
1616                            throw std::string("format not supported");
1617                    }
1618                    SampleImportItem sched_item;
1619                    sched_item.gig_sample  = sample;
1620                    sched_item.sample_path = filename;
1621                    m_SampleImportQueue.push_back(sched_item);
1622                    sf_close(hFile);
1623                    file_changed();
1624                }
1625                catch (std::string what)
1626                {
1627                    if (error_files.size()) error_files += "\n";
1628                        error_files += filename += " (" + what + ")";
1629                }
1630            }
1631            // show error message box when some file(s) could not be opened / added
1632            if (error_files.size()) {
1633                Glib::ustring txt =
1634                    _("Could not replace the following sample(s):\n") + error_files;
1635                Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
1636                msg.run();
1637            }
1638        }
1639    }
1640    
1641  void MainWindow::on_action_remove_sample() {  void MainWindow::on_action_remove_sample() {
1642      if (!file) return;      if (!file) return;
1643      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 1804  void MainWindow::on_sample_label_drop_dr
1804          // notify we're done with altering          // notify we're done with altering
1805          region_changed_signal.emit(region);          region_changed_signal.emit(region);
1806    
1807            file_changed();
1808    
1809          return;          return;
1810      }      }
1811      // drop failed      // drop failed
# Line 1597  sigc::signal<void, gig::DimensionRegion* Line 1897  sigc::signal<void, gig::DimensionRegion*
1897  sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {  sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {
1898      return dimreg_changed_signal;      return dimreg_changed_signal;
1899  }  }
1900    
1901    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_on() {
1902        return note_on_signal;
1903    }
1904    
1905    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_off() {
1906        return note_off_signal;
1907    }
1908    
1909    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_hit() {
1910        return m_RegionChooser.signal_keyboard_key_hit();
1911    }
1912    
1913    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_released() {
1914        return m_RegionChooser.signal_keyboard_key_released();
1915    }
Legend:
Removed from v.1436  
changed lines
  Added in v.1725
  ViewVC Help
Powered by ViewVC