/[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 1322 by schoenebeck, Tue Sep 4 11:04:56 2007 UTC revision 1714 by persson, Thu Mar 6 20:50:04 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    #include <cstring>
22    
23  #include <gtkmm/filechooserdialog.h>  #include <gtkmm/filechooserdialog.h>
24  #include <gtkmm/messagedialog.h>  #include <gtkmm/messagedialog.h>
25  #include <gtkmm/stock.h>  #include <gtkmm/stock.h>
26  #include <gtkmm/targetentry.h>  #include <gtkmm/targetentry.h>
27  #include <gtkmm/main.h>  #include <gtkmm/main.h>
28    #include <gtkmm/toggleaction.h>
29    
30    #include "global.h"
31    
32  #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
33  #define ABOUT_DIALOG  #define ABOUT_DIALOG
# Line 48  Glib::ustring filename_display_basename( Line 51  Glib::ustring filename_display_basename(
51    
52  #include "mainwindow.h"  #include "mainwindow.h"
53    
54  #define _(String) gettext(String)  #include "../../gfx/status_attached.xpm"
55    #include "../../gfx/status_detached.xpm"
56    
57  template<class T> inline std::string ToString(T o) {  template<class T> inline std::string ToString(T o) {
58      std::stringstream ss;      std::stringstream ss;
# Line 56  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 86  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 127  MainWindow::MainWindow() Line 167  MainWindow::MainWindow()
167                           *this, &MainWindow::on_action_quit));                           *this, &MainWindow::on_action_quit));
168      actionGroup->add(Gtk::Action::create("MenuInstrument", _("_Instrument")));      actionGroup->add(Gtk::Action::create("MenuInstrument", _("_Instrument")));
169    
170        actionGroup->add(Gtk::Action::create("MenuView", _("_View")));
171        Glib::RefPtr<Gtk::ToggleAction> toggle_action =
172            Gtk::ToggleAction::create("Statusbar", _("_Statusbar"));
173        toggle_action->set_active(true);
174        actionGroup->add(toggle_action,
175                         sigc::mem_fun(
176                             *this, &MainWindow::on_action_view_status_bar));
177    
178      action = Gtk::Action::create("MenuHelp", Gtk::Stock::HELP);      action = Gtk::Action::create("MenuHelp", Gtk::Stock::HELP);
179      actionGroup->add(Gtk::Action::create("MenuHelp",      actionGroup->add(Gtk::Action::create("MenuHelp",
180                                           action->property_label()));                                           action->property_label()));
# Line 161  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 182  MainWindow::MainWindow() Line 234  MainWindow::MainWindow()
234          "    </menu>"          "    </menu>"
235          "    <menu action='MenuInstrument'>"          "    <menu action='MenuInstrument'>"
236          "    </menu>"          "    </menu>"
237            "    <menu action='MenuView'>"
238            "      <menuitem action='Statusbar'/>"
239            "    </menu>"
240  #ifdef ABOUT_DIALOG  #ifdef ABOUT_DIALOG
241          "    <menu action='MenuHelp'>"          "    <menu action='MenuHelp'>"
242          "      <menuitem action='About'/>"          "      <menuitem action='About'/>"
# Line 198  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 210  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);
272    
273        // Status Bar:
274        m_StatusBar.pack_start(m_AttachedStateLabel, Gtk::PACK_SHRINK);
275        m_StatusBar.pack_start(m_AttachedStateImage, Gtk::PACK_SHRINK);
276        m_StatusBar.show();
277    
278      m_RegionChooser.signal_region_selected().connect(      m_RegionChooser.signal_region_selected().connect(
279          sigc::mem_fun(*this, &MainWindow::region_changed) );          sigc::mem_fun(*this, &MainWindow::region_changed) );
# Line 264  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 293  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);
376    
377      show_all_children();      show_all_children();
378    
# Line 308  MainWindow::~MainWindow() Line 386  MainWindow::~MainWindow()
386    
387  bool MainWindow::on_delete_event(GdkEventAny* event)  bool MainWindow::on_delete_event(GdkEventAny* event)
388  {  {
389      return file_is_changed && !close_confirmation_dialog();      return !file_is_shared && file_is_changed && !close_confirmation_dialog();
390  }  }
391    
392  void MainWindow::on_action_quit()  void MainWindow::on_action_quit()
393  {  {
394      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
395      hide();      hide();
396  }  }
397    
# Line 322  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    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 {
425            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          m_RegionChooser.set_instrument(row[m_Columns.m_col_instr]);      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 {      } else {
446          m_RegionChooser.set_instrument(0);          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 427  void MainWindow::__clear() { Line 552  void MainWindow::__clear() {
552      m_refTreeModel->clear();      m_refTreeModel->clear();
553      m_refSamplesTreeModel->clear();      m_refSamplesTreeModel->clear();
554      // free libgig's gig::File instance      // free libgig's gig::File instance
555      if (file) {      if (file && !file_is_shared) delete file;
556          delete file;      file = NULL;
557          file = NULL;      set_file_is_shared(false);
     }  
558  }  }
559    
560  void MainWindow::on_action_file_new()  void MainWindow::on_action_file_new()
561  {  {
562      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
563    
564        if (file_is_shared && !leaving_shared_mode_dialog()) return;
565    
566      // clear all GUI elements      // clear all GUI elements
567      __clear();      __clear();
# Line 467  bool MainWindow::close_confirmation_dial Line 593  bool MainWindow::close_confirmation_dial
593      return response != Gtk::RESPONSE_CANCEL;      return response != Gtk::RESPONSE_CANCEL;
594  }  }
595    
596    bool MainWindow::leaving_shared_mode_dialog() {
597        Glib::ustring msg = _("Detach from sampler and proceed working stand-alone?");
598        Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
599    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 6) || GTKMM_MAJOR_VERSION > 2
600        dialog.set_secondary_text(
601            _("If you proceed to work on another instrument file, it won't be "
602              "used by the sampler until you tell the sampler explicitly to "
603              "load it.")
604       );
605    #endif
606        dialog.add_button(_("_Yes, Detach"), Gtk::RESPONSE_YES);
607        dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
608        dialog.set_default_response(Gtk::RESPONSE_CANCEL);
609        int response = dialog.run();
610        dialog.hide();
611        return response == Gtk::RESPONSE_YES;
612    }
613    
614  void MainWindow::on_action_file_open()  void MainWindow::on_action_file_open()
615  {  {
616      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
617    
618        if (file_is_shared && !leaving_shared_mode_dialog()) return;
619    
620      Gtk::FileChooserDialog dialog(*this, _("Open file"));      Gtk::FileChooserDialog dialog(*this, _("Open file"));
621      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
# Line 510  void MainWindow::load_instrument(gig::In Line 656  void MainWindow::load_instrument(gig::In
656          msg.run();          msg.run();
657          Gtk::Main::quit();          Gtk::Main::quit();
658      }      }
659        // clear all GUI elements
660        __clear();
661        // load the instrument
662      gig::File* pFile = (gig::File*) instr->GetParent();      gig::File* pFile = (gig::File*) instr->GetParent();
663      load_gig(pFile, 0 /*file name*/);      load_gig(pFile, 0 /*file name*/, true /*shared instrument*/);
664      //TODO: automatically select the given instrument      //TODO: automatically select the given instrument
665  }  }
666    
# Line 560  bool MainWindow::check_if_savable() Line 709  bool MainWindow::check_if_savable()
709  bool MainWindow::file_save()  bool MainWindow::file_save()
710  {  {
711      if (!check_if_savable()) return false;      if (!check_if_savable()) return false;
712      if (!file_has_name) return file_save_as();      if (!file_is_shared && !file_has_name) return file_save_as();
713    
714      std::cout << "Saving file\n" << std::flush;      std::cout << "Saving file\n" << std::flush;
715      file_structure_to_be_changed_signal.emit(this->file);      file_structure_to_be_changed_signal.emit(this->file);
# Line 572  bool MainWindow::file_save() Line 721  bool MainWindow::file_save()
721          }          }
722      } catch (RIFF::Exception e) {      } catch (RIFF::Exception e) {
723          file_structure_changed_signal.emit(this->file);          file_structure_changed_signal.emit(this->file);
724          Glib::ustring txt = "Could not save file: " + e.Message;          Glib::ustring txt = _("Could not save file: ") + e.Message;
725          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
726          msg.run();          msg.run();
727          return false;          return false;
# Line 604  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_dir != "") dialog.set_current_folder(current_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 627  bool MainWindow::file_save_as() Line 805  bool MainWindow::file_save_as()
805              file_is_changed = false;              file_is_changed = false;
806          } catch (RIFF::Exception e) {          } catch (RIFF::Exception e) {
807              file_structure_changed_signal.emit(this->file);              file_structure_changed_signal.emit(this->file);
808              Glib::ustring txt = "Could not save file: " + e.Message;              Glib::ustring txt = _("Could not save file: ") + e.Message;
809              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
810              msg.run();              msg.run();
811              return false;              return false;
# Line 724  void MainWindow::__import_queued_samples Line 902  void MainWindow::__import_queued_samples
902      }      }
903      // show error message box when some sample(s) could not be imported      // show error message box when some sample(s) could not be imported
904      if (error_files.size()) {      if (error_files.size()) {
905          Glib::ustring txt = "Could not import the following sample(s):\n" + error_files;          Glib::ustring txt = _("Could not import the following sample(s):\n") + error_files;
906          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
907          msg.run();          msg.run();
908      }      }
# Line 741  void MainWindow::on_action_help_about() Line 919  void MainWindow::on_action_help_about()
919  #ifdef ABOUT_DIALOG  #ifdef ABOUT_DIALOG
920      Gtk::AboutDialog dialog;      Gtk::AboutDialog dialog;
921      dialog.set_version(VERSION);      dialog.set_version(VERSION);
922        dialog.set_copyright("Copyright (C) 2006,2007 Andreas Persson");
923        dialog.set_comments(
924            "Released under the GNU General Public License.\n"
925            "\n"
926            "Please notice that this is still a very young instrument editor. "
927            "So better backup your Gigasampler files before editing them with "
928            "this application.\n"
929            "\n"
930            "Please report bugs to: http://bugs.linuxsampler.org"
931        );
932        dialog.set_website("http://www.linuxsampler.org");
933        dialog.set_website_label("http://www.linuxsampler.org");
934      dialog.run();      dialog.run();
935  #endif  #endif
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 840  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 888  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;
     eIsDrum.set_ptr(&instrument->IsDrum);  
     eMIDIBank.set_ptr(&instrument->MIDIBank);  
     eMIDIProgram.set_ptr(&instrument->MIDIProgram);  
     eAttenuation.set_ptr(&instrument->Attenuation);  
     eGainPlus6.set_ptr(&instrument->Attenuation);  
     eEffectSend.set_ptr(&instrument->EffectSend);  
     eFineTune.set_ptr(&instrument->FineTune);  
     ePitchbendRange.set_ptr(&instrument->PitchbendRange);  
     ePianoReleaseMode.set_ptr(&instrument->PianoReleaseMode);  
     eDimensionKeyRangeLow.set_ptr(0);  
     eDimensionKeyRangeHigh.set_ptr(0);  
     eDimensionKeyRangeLow.set_ptr(&instrument->DimensionKeyRange.low);  
     eDimensionKeyRangeHigh.set_ptr(&instrument->DimensionKeyRange.high);  
 }  
   
 void InstrumentProps::key_range_low_changed()  
 {  
     double l = eDimensionKeyRangeLow.get_value();  
     double h = eDimensionKeyRangeHigh.get_value();  
     if (h < l) eDimensionKeyRangeHigh.set_value(l);  
 }  
1154    
1155  void InstrumentProps::key_range_high_changed()      update_model++;
1156  {      eName.set_value(instrument->pInfo->Name);
1157      double l = eDimensionKeyRangeLow.get_value();      eIsDrum.set_value(instrument->IsDrum);
1158      double h = eDimensionKeyRangeHigh.get_value();      eMIDIBank.set_value(instrument->MIDIBank);
1159      if (h < l) eDimensionKeyRangeLow.set_value(h);      eMIDIProgram.set_value(instrument->MIDIProgram);
1160        eAttenuation.set_value(instrument->Attenuation);
1161        eGainPlus6.set_value(instrument->Attenuation);
1162        eEffectSend.set_value(instrument->EffectSend);
1163        eFineTune.set_value(instrument->FineTune);
1164        ePitchbendRange.set_value(instrument->PitchbendRange);
1165        ePianoReleaseMode.set_value(instrument->PianoReleaseMode);
1166        eDimensionKeyRangeLow.set_value(instrument->DimensionKeyRange.low);
1167        eDimensionKeyRangeHigh.set_value(instrument->DimensionKeyRange.high);
1168        update_model--;
1169  }  }
1170    
1171  sigc::signal<void> InstrumentProps::signal_instrument_changed()  sigc::signal<void>& InstrumentProps::signal_instrument_changed()
1172  {  {
1173      return instrument_changed;      return instrument_changed;
1174  }  }
# Line 931  void MainWindow::file_changed() Line 1181  void MainWindow::file_changed()
1181      }      }
1182  }  }
1183    
1184  void MainWindow::load_gig(gig::File* gig, const char* filename)  void MainWindow::load_gig(gig::File* gig, const char* filename, bool isSharedInstrument)
1185  {  {
1186      file = 0;      file = 0;
1187        set_file_is_shared(isSharedInstrument);
1188    
1189      this->filename = filename ? filename : _("Unsaved Gig File");      this->filename = filename ? filename : _("Unsaved Gig File");
1190      set_title(Glib::filename_display_basename(this->filename));      set_title(Glib::filename_display_basename(this->filename));
# Line 996  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();
1256              instrumentProps.set_instrument(row[m_Columns.m_col_instr]);      }
1257              instrumentProps.show();  }
1258              instrumentProps.deiconify();  
1259          }  void MainWindow::on_action_view_status_bar() {
1260        Gtk::CheckMenuItem* item =
1261            dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/Statusbar"));
1262        if (!item) {
1263            std::cerr << "/MenuBar/MenuView/Statusbar == NULL\n";
1264            return;
1265      }      }
1266        if (item->get_active()) m_StatusBar.show();
1267        else                    m_StatusBar.hide();
1268  }  }
1269    
1270  void MainWindow::on_button_release(GdkEventButton* button)  void MainWindow::on_button_release(GdkEventButton* button)
# Line 1067  void MainWindow::on_action_add_instrumen Line 1324  void MainWindow::on_action_add_instrumen
1324    
1325  void MainWindow::on_action_remove_instrument() {  void MainWindow::on_action_remove_instrument() {
1326      if (!file) return;      if (!file) return;
1327        if (file_is_shared) {
1328            Gtk::MessageDialog msg(
1329                *this,
1330                 _("You cannot delete an instrument from this file, since it's "
1331                   "currently used by the sampler."),
1332                 false, Gtk::MESSAGE_INFO
1333            );
1334            msg.run();
1335            return;
1336        }
1337    
1338      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
1339      Gtk::TreeModel::iterator it = sel->get_selected();      Gtk::TreeModel::iterator it = sel->get_selected();
1340      if (it) {      if (it) {
# Line 1253  void MainWindow::on_action_add_sample() Line 1521  void MainWindow::on_action_add_sample()
1521          }          }
1522          // show error message box when some file(s) could not be opened / added          // show error message box when some file(s) could not be opened / added
1523          if (error_files.size()) {          if (error_files.size()) {
1524              Glib::ustring txt = "Could not add the following sample(s):\n" + error_files;              Glib::ustring txt = _("Could not add the following sample(s):\n") + error_files;
1525                Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
1526                msg.run();
1527            }
1528        }
1529    }
1530    
1531    void MainWindow::on_action_replace_all_samples_in_all_groups()
1532    {
1533        if (!file) return;
1534        Gtk::FileChooserDialog dialog(*this, _("Select Folder"),
1535                                      Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
1536        Gtk::Label description(
1537            _("This is a very specific function. It tries to replace all samples "
1538              "in the current gig file by samples located in the directory chosen "
1539              "by you above.\n\n"
1540              "It works like this: For each sample in the gig file it tries to "
1541              "find a sample file in the selected directory with the same name as "
1542              "the sample in the gig file. Optionally you can add a filename "
1543              "postfix below, which will be added to the filename expected to be "
1544              "found. That is, assume you have a gig file with a sample called "
1545              "'Snare', if you enter '.wav' below (like it's done by default), it "
1546              "assumes to find a sample file called 'Snare.wav' and will replace "
1547              "the sample in the gig file accordingly. If you don't need such a "
1548              "postfix, blank the field below. Any gig sample where no "
1549              "appropriate sample file could be found, will be reported and left "
1550              "untouched.\n\n")
1551        );
1552        description.set_line_wrap(true);
1553        Gtk::HBox entryArea;
1554        Gtk::Label entryLabel( _("Add Filename Extension: "), Gtk::ALIGN_RIGHT);
1555        Gtk::Entry postfixEntryBox;
1556        postfixEntryBox.set_text(".wav");
1557        entryArea.pack_start(entryLabel);
1558        entryArea.pack_start(postfixEntryBox);
1559        dialog.get_vbox()->pack_start(description, Gtk::PACK_SHRINK);
1560        dialog.get_vbox()->pack_start(entryArea, Gtk::PACK_SHRINK);
1561        description.show();
1562        entryLabel.show();
1563        postfixEntryBox.show();
1564        entryArea.show();
1565        dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1566        dialog.add_button(_("Select"), Gtk::RESPONSE_OK);
1567        dialog.set_select_multiple(false);
1568        // fix label width (because Gtk by design doesn't
1569        // know anything about the parent's size)
1570    #if 0 //FIXME: doesn't work
1571        int dialogW, dialogH, labelW, labelH;
1572        dialog.get_size_request(dialogW, dialogH);
1573        description.get_size_request(labelW, labelH);
1574        std::cout << "dialog(" << dialogW << "," << dialogH << ")\nlabel(" << labelW << "," << labelH << ")\n" << std::flush;
1575        description.set_size_request(dialogW, labelH);
1576    #endif
1577        if (dialog.run() == Gtk::RESPONSE_OK)
1578        {
1579            Glib::ustring error_files;
1580            Glib::ustring folder = dialog.get_filename();
1581            for (gig::Sample* sample = file->GetFirstSample();
1582                 sample; sample = file->GetNextSample())
1583            {
1584                std::string filename =
1585                    folder + G_DIR_SEPARATOR_S + sample->pInfo->Name +
1586                    postfixEntryBox.get_text().raw();
1587                SF_INFO info;
1588                info.format = 0;
1589                SNDFILE* hFile = sf_open(filename.c_str(), SFM_READ, &info);
1590                try
1591                {
1592                    if (!hFile) throw std::string("could not open file");
1593                    int bitdepth;
1594                    switch (info.format & 0xff) {
1595                        case SF_FORMAT_PCM_S8:
1596                        case SF_FORMAT_PCM_16:
1597                        case SF_FORMAT_PCM_U8:
1598                            bitdepth = 16;
1599                            break;
1600                        case SF_FORMAT_PCM_24:
1601                        case SF_FORMAT_PCM_32:
1602                        case SF_FORMAT_FLOAT:
1603                        case SF_FORMAT_DOUBLE:
1604                            bitdepth = 24;
1605                            break;
1606                        default:
1607                            sf_close(hFile);
1608                            throw std::string("format not supported");
1609                    }
1610                    SampleImportItem sched_item;
1611                    sched_item.gig_sample  = sample;
1612                    sched_item.sample_path = filename;
1613                    m_SampleImportQueue.push_back(sched_item);
1614                    sf_close(hFile);
1615                    file_changed();
1616                }
1617                catch (std::string what)
1618                {
1619                    if (error_files.size()) error_files += "\n";
1620                        error_files += filename += " (" + what + ")";
1621                }
1622            }
1623            // show error message box when some file(s) could not be opened / added
1624            if (error_files.size()) {
1625                Glib::ustring txt =
1626                    _("Could not replace the following sample(s):\n") + error_files;
1627              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
1628              msg.run();              msg.run();
1629          }          }
# Line 1426  void MainWindow::on_sample_label_drop_dr Line 1796  void MainWindow::on_sample_label_drop_dr
1796          // notify we're done with altering          // notify we're done with altering
1797          region_changed_signal.emit(region);          region_changed_signal.emit(region);
1798    
1799            file_changed();
1800    
1801          return;          return;
1802      }      }
1803      // drop failed      // drop failed
# Line 1466  void MainWindow::instrument_name_changed Line 1838  void MainWindow::instrument_name_changed
1838      }      }
1839  }  }
1840    
1841  sigc::signal<void, gig::File*> MainWindow::signal_file_structure_to_be_changed() {  void MainWindow::set_file_is_shared(bool b) {
1842        this->file_is_shared = b;
1843    
1844        if (file_is_shared) {
1845            m_AttachedStateLabel.set_label(_("live-mode"));
1846            m_AttachedStateImage.set(
1847                Gdk::Pixbuf::create_from_xpm_data(status_attached_xpm)
1848            );
1849        } else {
1850            m_AttachedStateLabel.set_label(_("stand-alone"));
1851            m_AttachedStateImage.set(
1852                Gdk::Pixbuf::create_from_xpm_data(status_detached_xpm)
1853            );
1854        }
1855    }
1856    
1857    sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_to_be_changed() {
1858      return file_structure_to_be_changed_signal;      return file_structure_to_be_changed_signal;
1859  }  }
1860    
1861  sigc::signal<void, gig::File*> MainWindow::signal_file_structure_changed() {  sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_changed() {
1862      return file_structure_changed_signal;      return file_structure_changed_signal;
1863  }  }
1864    
1865  sigc::signal<void, std::list<gig::Sample*> > MainWindow::signal_samples_to_be_removed() {  sigc::signal<void, std::list<gig::Sample*> >& MainWindow::signal_samples_to_be_removed() {
1866      return samples_to_be_removed_signal;      return samples_to_be_removed_signal;
1867  }  }
1868    
1869  sigc::signal<void> MainWindow::signal_samples_removed() {  sigc::signal<void>& MainWindow::signal_samples_removed() {
1870      return samples_removed_signal;      return samples_removed_signal;
1871  }  }
1872    
1873  sigc::signal<void, gig::Region*> MainWindow::signal_region_to_be_changed() {  sigc::signal<void, gig::Region*>& MainWindow::signal_region_to_be_changed() {
1874      return region_to_be_changed_signal;      return region_to_be_changed_signal;
1875  }  }
1876    
1877  sigc::signal<void, gig::Region*> MainWindow::signal_region_changed() {  sigc::signal<void, gig::Region*>& MainWindow::signal_region_changed() {
1878      return region_changed_signal;      return region_changed_signal;
1879  }  }
1880    
1881  sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/> MainWindow::signal_sample_ref_changed() {  sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/>& MainWindow::signal_sample_ref_changed() {
1882      return sample_ref_changed_signal;      return sample_ref_changed_signal;
1883  }  }
1884    
1885  sigc::signal<void, gig::DimensionRegion*> MainWindow::signal_dimreg_to_be_changed() {  sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_to_be_changed() {
1886      return dimreg_to_be_changed_signal;      return dimreg_to_be_changed_signal;
1887  }  }
1888    
1889  sigc::signal<void, gig::DimensionRegion*> MainWindow::signal_dimreg_changed() {  sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {
1890      return dimreg_changed_signal;      return dimreg_changed_signal;
1891  }  }
1892    
1893    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_on() {
1894        return note_on_signal;
1895    }
1896    
1897    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_off() {
1898        return note_off_signal;
1899    }
1900    
1901    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_hit() {
1902        return m_RegionChooser.signal_keyboard_key_hit();
1903    }
1904    
1905    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_released() {
1906        return m_RegionChooser.signal_keyboard_key_released();
1907    }
Legend:
Removed from v.1322  
changed lines
  Added in v.1714
  ViewVC Help
Powered by ViewVC