/[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 1265 by persson, Sun Jul 29 13:44:59 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 17  Line 17 
17   * 02110-1301 USA.   * 02110-1301 USA.
18   */   */
19    
 #include <libintl.h>  
20  #include <iostream>  #include <iostream>
21    
22  #include <gtkmm/filechooserdialog.h>  #include <gtkmm/filechooserdialog.h>
# Line 25  Line 24 
24  #include <gtkmm/stock.h>  #include <gtkmm/stock.h>
25  #include <gtkmm/targetentry.h>  #include <gtkmm/targetentry.h>
26  #include <gtkmm/main.h>  #include <gtkmm/main.h>
27    #include <gtkmm/toggleaction.h>
28    
29    #include "global.h"
30    
31  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 6) || GTKMM_MAJOR_VERSION > 2  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 6) || GTKMM_MAJOR_VERSION > 2
32  #define ABOUT_DIALOG  #define ABOUT_DIALOG
33  #include <gtkmm/aboutdialog.h>  #include <gtkmm/aboutdialog.h>
34  #endif  #endif
35    
36    #if (GLIBMM_MAJOR_VERSION == 2 && GLIBMM_MINOR_VERSION < 6) || GLIBMM_MAJOR_VERSION < 2
37    namespace Glib {
38    Glib::ustring filename_display_basename(const std::string& filename)
39    {
40        gchar* gstr = g_path_get_basename(filename.c_str());
41        Glib::ustring str(gstr);
42        g_free(gstr);
43        return Glib::filename_to_utf8(str);
44    }
45    }
46    #endif
47    
48  #include <stdio.h>  #include <stdio.h>
49  #include <sndfile.h>  #include <sndfile.h>
50    
51  #include "mainwindow.h"  #include "mainwindow.h"
52    
53  #define _(String) gettext(String)  #include "../../gfx/status_attached.xpm"
54    #include "../../gfx/status_detached.xpm"
55    
56  template<class T> inline std::string ToString(T o) {  template<class T> inline std::string ToString(T o) {
57      std::stringstream ss;      std::stringstream ss;
# Line 44  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 74  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 115  MainWindow::MainWindow() Line 166  MainWindow::MainWindow()
166                           *this, &MainWindow::on_action_quit));                           *this, &MainWindow::on_action_quit));
167      actionGroup->add(Gtk::Action::create("MenuInstrument", _("_Instrument")));      actionGroup->add(Gtk::Action::create("MenuInstrument", _("_Instrument")));
168    
169        actionGroup->add(Gtk::Action::create("MenuView", _("_View")));
170        Glib::RefPtr<Gtk::ToggleAction> toggle_action =
171            Gtk::ToggleAction::create("Statusbar", _("_Statusbar"));
172        toggle_action->set_active(true);
173        actionGroup->add(toggle_action,
174                         sigc::mem_fun(
175                             *this, &MainWindow::on_action_view_status_bar));
176    
177      action = Gtk::Action::create("MenuHelp", Gtk::Stock::HELP);      action = Gtk::Action::create("MenuHelp", Gtk::Stock::HELP);
178      actionGroup->add(Gtk::Action::create("MenuHelp",      actionGroup->add(Gtk::Action::create("MenuHelp",
179                                           action->property_label()));                                           action->property_label()));
# Line 149  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 170  MainWindow::MainWindow() Line 233  MainWindow::MainWindow()
233          "    </menu>"          "    </menu>"
234          "    <menu action='MenuInstrument'>"          "    <menu action='MenuInstrument'>"
235          "    </menu>"          "    </menu>"
236            "    <menu action='MenuView'>"
237            "      <menuitem action='Statusbar'/>"
238            "    </menu>"
239  #ifdef ABOUT_DIALOG  #ifdef ABOUT_DIALOG
240          "    <menu action='MenuHelp'>"          "    <menu action='MenuHelp'>"
241          "      <menuitem action='About'/>"          "      <menuitem action='About'/>"
# Line 186  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 198  MainWindow::MainWindow() Line 265  MainWindow::MainWindow()
265      m_VBox.pack_start(*menuBar, Gtk::PACK_SHRINK);      m_VBox.pack_start(*menuBar, Gtk::PACK_SHRINK);
266      m_VBox.pack_start(m_HPaned);      m_VBox.pack_start(m_HPaned);
267      m_VBox.pack_start(m_RegionChooser, Gtk::PACK_SHRINK);      m_VBox.pack_start(m_RegionChooser, Gtk::PACK_SHRINK);
268        m_VBox.pack_start(m_RegionChooser.m_VirtKeybPropsBox, Gtk::PACK_SHRINK);
269      m_VBox.pack_start(m_DimRegionChooser, Gtk::PACK_SHRINK);      m_VBox.pack_start(m_DimRegionChooser, Gtk::PACK_SHRINK);
270        m_VBox.pack_start(m_StatusBar, Gtk::PACK_SHRINK);
271    
272        // Status Bar:
273        m_StatusBar.pack_start(m_AttachedStateLabel, Gtk::PACK_SHRINK);
274        m_StatusBar.pack_start(m_AttachedStateImage, Gtk::PACK_SHRINK);
275        m_StatusBar.show();
276    
277      m_RegionChooser.signal_region_selected().connect(      m_RegionChooser.signal_region_selected().connect(
278          sigc::mem_fun(*this, &MainWindow::region_changed) );          sigc::mem_fun(*this, &MainWindow::region_changed) );
# Line 234  MainWindow::MainWindow() Line 308  MainWindow::MainWindow()
308      std::list<Gtk::TargetEntry> drag_target_gig_sample;      std::list<Gtk::TargetEntry> drag_target_gig_sample;
309      drag_target_gig_sample.push_back( Gtk::TargetEntry("gig::Sample") );      drag_target_gig_sample.push_back( Gtk::TargetEntry("gig::Sample") );
310      m_TreeViewSamples.drag_source_set(drag_target_gig_sample);      m_TreeViewSamples.drag_source_set(drag_target_gig_sample);
311        m_TreeViewSamples.signal_drag_begin().connect(
312            sigc::mem_fun(*this, &MainWindow::on_sample_treeview_drag_begin)
313        );
314      m_TreeViewSamples.signal_drag_data_get().connect(      m_TreeViewSamples.signal_drag_data_get().connect(
315          sigc::mem_fun(*this, &MainWindow::on_sample_treeview_drag_data_get)          sigc::mem_fun(*this, &MainWindow::on_sample_treeview_drag_data_get)
316      );      );
# Line 242  MainWindow::MainWindow() Line 319  MainWindow::MainWindow()
319          sigc::mem_fun(*this, &MainWindow::on_sample_label_drop_drag_data_received)          sigc::mem_fun(*this, &MainWindow::on_sample_label_drop_drag_data_received)
320      );      );
321      dimreg_edit.signal_dimreg_changed().connect(      dimreg_edit.signal_dimreg_changed().connect(
322          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::hide(sigc::mem_fun(*this, &MainWindow::file_changed)));
323      m_RegionChooser.signal_instrument_changed().connect(      m_RegionChooser.signal_instrument_changed().connect(
324          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
325      m_DimRegionChooser.signal_region_changed().connect(      m_DimRegionChooser.signal_region_changed().connect(
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(
333            dimreg_to_be_changed_signal.make_slot());
334        dimreg_edit.signal_dimreg_changed().connect(
335            dimreg_changed_signal.make_slot());
336        dimreg_edit.signal_sample_ref_changed().connect(
337            sample_ref_changed_signal.make_slot());
338    
339        m_RegionChooser.signal_instrument_struct_to_be_changed().connect(
340            sigc::hide(
341                sigc::bind(
342                    file_structure_to_be_changed_signal.make_slot(),
343                    sigc::ref(this->file)
344                )
345            )
346        );
347        m_RegionChooser.signal_instrument_struct_changed().connect(
348            sigc::hide(
349                sigc::bind(
350                    file_structure_changed_signal.make_slot(),
351                    sigc::ref(this->file)
352                )
353            )
354        );
355        m_RegionChooser.signal_region_to_be_changed().connect(
356            region_to_be_changed_signal.make_slot());
357        m_RegionChooser.signal_region_changed_signal().connect(
358            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);
375    
376      show_all_children();      show_all_children();
377    
378        // start with a new gig file by default
379        on_action_file_new();
380  }  }
381    
382  MainWindow::~MainWindow()  MainWindow::~MainWindow()
# Line 261  MainWindow::~MainWindow() Line 385  MainWindow::~MainWindow()
385    
386  bool MainWindow::on_delete_event(GdkEventAny* event)  bool MainWindow::on_delete_event(GdkEventAny* event)
387  {  {
388      return file_is_changed && !close_confirmation_dialog();      return !file_is_shared && file_is_changed && !close_confirmation_dialog();
389  }  }
390    
391  void MainWindow::on_action_quit()  void MainWindow::on_action_quit()
392  {  {
393      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
394      hide();      hide();
395  }  }
396    
# Line 275  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 380  void MainWindow::__clear() { Line 551  void MainWindow::__clear() {
551      m_refTreeModel->clear();      m_refTreeModel->clear();
552      m_refSamplesTreeModel->clear();      m_refSamplesTreeModel->clear();
553      // free libgig's gig::File instance      // free libgig's gig::File instance
554      if (file) {      if (file && !file_is_shared) delete file;
555          delete file;      file = NULL;
556          file = NULL;      set_file_is_shared(false);
     }  
557  }  }
558    
559  void MainWindow::on_action_file_new()  void MainWindow::on_action_file_new()
560  {  {
561      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
562    
563        if (file_is_shared && !leaving_shared_mode_dialog()) return;
564    
565      // clear all GUI elements      // clear all GUI elements
566      __clear();      __clear();
# Line 407  bool MainWindow::close_confirmation_dial Line 579  bool MainWindow::close_confirmation_dial
579                                   Glib::filename_display_basename(filename).c_str());                                   Glib::filename_display_basename(filename).c_str());
580      Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);      Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
581      g_free(msg);      g_free(msg);
582    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 6) || GTKMM_MAJOR_VERSION > 2
583      dialog.set_secondary_text(_("If you close without saving, your changes will be lost."));      dialog.set_secondary_text(_("If you close without saving, your changes will be lost."));
584    #endif
585      dialog.add_button(_("Close _Without Saving"), Gtk::RESPONSE_NO);      dialog.add_button(_("Close _Without Saving"), Gtk::RESPONSE_NO);
586      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
587      dialog.add_button(file_has_name ? Gtk::Stock::SAVE : Gtk::Stock::SAVE_AS, Gtk::RESPONSE_YES);      dialog.add_button(file_has_name ? Gtk::Stock::SAVE : Gtk::Stock::SAVE_AS, Gtk::RESPONSE_YES);
588      dialog.set_default_response(Gtk::RESPONSE_YES);      dialog.set_default_response(Gtk::RESPONSE_YES);
589      int response = dialog.run();      int response = dialog.run();
590        dialog.hide();
591      if (response == Gtk::RESPONSE_YES) return file_save();      if (response == Gtk::RESPONSE_YES) return file_save();
592      return response != Gtk::RESPONSE_CANCEL;      return response != Gtk::RESPONSE_CANCEL;
593  }  }
594    
595    bool MainWindow::leaving_shared_mode_dialog() {
596        Glib::ustring msg = _("Detach from sampler and proceed working stand-alone?");
597        Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
598    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 6) || GTKMM_MAJOR_VERSION > 2
599        dialog.set_secondary_text(
600            _("If you proceed to work on another instrument file, it won't be "
601              "used by the sampler until you tell the sampler explicitly to "
602              "load it.")
603       );
604    #endif
605        dialog.add_button(_("_Yes, Detach"), Gtk::RESPONSE_YES);
606        dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
607        dialog.set_default_response(Gtk::RESPONSE_CANCEL);
608        int response = dialog.run();
609        dialog.hide();
610        return response == Gtk::RESPONSE_YES;
611    }
612    
613  void MainWindow::on_action_file_open()  void MainWindow::on_action_file_open()
614  {  {
615      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
616    
617        if (file_is_shared && !leaving_shared_mode_dialog()) return;
618    
619      Gtk::FileChooserDialog dialog(*this, _("Open file"));      Gtk::FileChooserDialog dialog(*this, _("Open file"));
620      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
# Line 434  void MainWindow::on_action_file_open() Line 629  void MainWindow::on_action_file_open()
629      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
630          std::string filename = dialog.get_filename();          std::string filename = dialog.get_filename();
631          printf("filename=%s\n", filename.c_str());          printf("filename=%s\n", filename.c_str());
         __clear();  
632          printf("on_action_file_open self=%x\n", Glib::Thread::self());          printf("on_action_file_open self=%x\n", Glib::Thread::self());
633          load_file(filename.c_str());          load_file(filename.c_str());
634          current_dir = Glib::path_get_dirname(filename);          current_dir = Glib::path_get_dirname(filename);
# Line 443  void MainWindow::on_action_file_open() Line 637  void MainWindow::on_action_file_open()
637    
638  void MainWindow::load_file(const char* name)  void MainWindow::load_file(const char* name)
639  {  {
640        __clear();
641      load_dialog = new LoadDialog("Loading...", *this);      load_dialog = new LoadDialog("Loading...", *this);
642      load_dialog->show_all();      load_dialog->show_all();
643      loader = new Loader(strdup(name));      loader = new Loader(strdup(name));
# Line 460  void MainWindow::load_instrument(gig::In Line 655  void MainWindow::load_instrument(gig::In
655          msg.run();          msg.run();
656          Gtk::Main::quit();          Gtk::Main::quit();
657      }      }
658        // clear all GUI elements
659        __clear();
660        // load the instrument
661      gig::File* pFile = (gig::File*) instr->GetParent();      gig::File* pFile = (gig::File*) instr->GetParent();
662      load_gig(pFile, 0 /*file name*/);      load_gig(pFile, 0 /*file name*/, true /*shared instrument*/);
663      //TODO: automatically select the given instrument      //TODO: automatically select the given instrument
664  }  }
665    
# Line 483  void MainWindow::on_action_file_save() Line 681  void MainWindow::on_action_file_save()
681      file_save();      file_save();
682  }  }
683    
684  bool MainWindow::file_save()  bool MainWindow::check_if_savable()
685  {  {
686      if (!file) return false;      if (!file) return false;
687      if (!file_has_name) return file_save_as();  
688        if (!file->GetFirstSample()) {
689            Gtk::MessageDialog(*this, _("The file could not be saved "
690                                        "because it contains no samples"),
691                               false, Gtk::MESSAGE_ERROR).run();
692            return false;
693        }
694    
695        for (gig::Instrument* instrument = file->GetFirstInstrument() ; instrument ;
696             instrument = file->GetNextInstrument()) {
697            if (!instrument->GetFirstRegion()) {
698                Gtk::MessageDialog(*this, _("The file could not be saved "
699                                            "because there are instruments "
700                                            "that have no regions"),
701                                   false, Gtk::MESSAGE_ERROR).run();
702                return false;
703            }
704        }
705        return true;
706    }
707    
708    bool MainWindow::file_save()
709    {
710        if (!check_if_savable()) return false;
711        if (!file_is_shared && !file_has_name) return file_save_as();
712    
713      std::cout << "Saving file\n" << std::flush;      std::cout << "Saving file\n" << std::flush;
714        file_structure_to_be_changed_signal.emit(this->file);
715      try {      try {
716          file->Save();          file->Save();
717          if (file_is_changed) {          if (file_is_changed) {
# Line 496  bool MainWindow::file_save() Line 719  bool MainWindow::file_save()
719              file_is_changed = false;              file_is_changed = false;
720          }          }
721      } catch (RIFF::Exception e) {      } catch (RIFF::Exception e) {
722          Glib::ustring txt = "Could not save file: " + e.Message;          file_structure_changed_signal.emit(this->file);
723            Glib::ustring txt = _("Could not save file: ") + e.Message;
724          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
725          msg.run();          msg.run();
726          return false;          return false;
727      }      }
728      std::cout << "Saving file done\n" << std::flush;      std::cout << "Saving file done\n" << std::flush;
729      __import_queued_samples();      __import_queued_samples();
730        file_structure_changed_signal.emit(this->file);
731      return true;      return true;
732  }  }
733    
734  void MainWindow::on_action_file_save_as()  void MainWindow::on_action_file_save_as()
735  {  {
736        if (!check_if_savable()) return;
737      file_save_as();      file_save_as();
738  }  }
739    
740  bool MainWindow::file_save_as()  bool MainWindow::file_save_as()
741  {  {
     if (!file) return false;  
742      Gtk::FileChooserDialog dialog(*this, _("Save as"), Gtk::FILE_CHOOSER_ACTION_SAVE);      Gtk::FileChooserDialog dialog(*this, _("Save as"), Gtk::FILE_CHOOSER_ACTION_SAVE);
743      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
744      dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);      dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);
# Line 527  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);
793          try {          try {
794              std::string filename = dialog.get_filename();              std::string filename = dialog.get_filename();
795              if (!Glib::str_has_suffix(filename, ".gig")) {              if (!Glib::str_has_suffix(filename, ".gig")) {
# Line 548  bool MainWindow::file_save_as() Line 803  bool MainWindow::file_save_as()
803              file_has_name = true;              file_has_name = true;
804              file_is_changed = false;              file_is_changed = false;
805          } catch (RIFF::Exception e) {          } catch (RIFF::Exception e) {
806              Glib::ustring txt = "Could not save file: " + e.Message;              file_structure_changed_signal.emit(this->file);
807                Glib::ustring txt = _("Could not save file: ") + e.Message;
808              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
809              msg.run();              msg.run();
810              return false;              return false;
811          }          }
812          __import_queued_samples();          __import_queued_samples();
813            file_structure_changed_signal.emit(this->file);
814          return true;          return true;
815      }      }
816      return false;      return false;
# Line 644  void MainWindow::__import_queued_samples Line 901  void MainWindow::__import_queued_samples
901      }      }
902      // show error message box when some sample(s) could not be imported      // show error message box when some sample(s) could not be imported
903      if (error_files.size()) {      if (error_files.size()) {
904          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;
905          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
906          msg.run();          msg.run();
907      }      }
# Line 661  void MainWindow::on_action_help_about() Line 918  void MainWindow::on_action_help_about()
918  #ifdef ABOUT_DIALOG  #ifdef ABOUT_DIALOG
919      Gtk::AboutDialog dialog;      Gtk::AboutDialog dialog;
920      dialog.set_version(VERSION);      dialog.set_version(VERSION);
921        dialog.set_copyright("Copyright (C) 2006,2007 Andreas Persson");
922        dialog.set_comments(
923            "Released under the GNU General Public License.\n"
924            "\n"
925            "Please notice that this is still a very young instrument editor. "
926            "So better backup your Gigasampler files before editing them with "
927            "this application.\n"
928            "\n"
929            "Please report bugs to: http://bugs.linuxsampler.org"
930        );
931        dialog.set_website("http://www.linuxsampler.org");
932        dialog.set_website_label("http://www.linuxsampler.org");
933      dialog.run();      dialog.run();
934  #endif  #endif
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 760  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 808  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;
     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);  
 }  
1153    
1154  void InstrumentProps::key_range_high_changed()      update_model++;
1155  {      eName.set_value(instrument->pInfo->Name);
1156      double l = eDimensionKeyRangeLow.get_value();      eIsDrum.set_value(instrument->IsDrum);
1157      double h = eDimensionKeyRangeHigh.get_value();      eMIDIBank.set_value(instrument->MIDIBank);
1158      if (h < l) eDimensionKeyRangeLow.set_value(h);      eMIDIProgram.set_value(instrument->MIDIProgram);
1159        eAttenuation.set_value(instrument->Attenuation);
1160        eGainPlus6.set_value(instrument->Attenuation);
1161        eEffectSend.set_value(instrument->EffectSend);
1162        eFineTune.set_value(instrument->FineTune);
1163        ePitchbendRange.set_value(instrument->PitchbendRange);
1164        ePianoReleaseMode.set_value(instrument->PianoReleaseMode);
1165        eDimensionKeyRangeLow.set_value(instrument->DimensionKeyRange.low);
1166        eDimensionKeyRangeHigh.set_value(instrument->DimensionKeyRange.high);
1167        update_model--;
1168  }  }
1169    
1170  sigc::signal<void> InstrumentProps::signal_instrument_changed()  sigc::signal<void>& InstrumentProps::signal_instrument_changed()
1171  {  {
1172      return instrument_changed;      return instrument_changed;
1173  }  }
# Line 851  void MainWindow::file_changed() Line 1180  void MainWindow::file_changed()
1180      }      }
1181  }  }
1182    
1183  void MainWindow::load_gig(gig::File* gig, const char* filename)  void MainWindow::load_gig(gig::File* gig, const char* filename, bool isSharedInstrument)
1184  {  {
1185      file = 0;      file = 0;
1186        set_file_is_shared(isSharedInstrument);
1187    
1188      this->filename = filename ? filename : _("Unsaved Gig File");      this->filename = filename ? filename : _("Unsaved Gig File");
1189      set_title(Glib::filename_display_basename(this->filename));      set_title(Glib::filename_display_basename(this->filename));
# Line 916  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();
1255              instrumentProps.set_instrument(row[m_Columns.m_col_instr]);      }
1256              instrumentProps.show();  }
1257              instrumentProps.deiconify();  
1258          }  void MainWindow::on_action_view_status_bar() {
1259        Gtk::CheckMenuItem* item =
1260            dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/Statusbar"));
1261        if (!item) {
1262            std::cerr << "/MenuBar/MenuView/Statusbar == NULL\n";
1263            return;
1264      }      }
1265        if (item->get_active()) m_StatusBar.show();
1266        else                    m_StatusBar.hide();
1267  }  }
1268    
1269  void MainWindow::on_button_release(GdkEventButton* button)  void MainWindow::on_button_release(GdkEventButton* button)
# Line 987  void MainWindow::on_action_add_instrumen Line 1323  void MainWindow::on_action_add_instrumen
1323    
1324  void MainWindow::on_action_remove_instrument() {  void MainWindow::on_action_remove_instrument() {
1325      if (!file) return;      if (!file) return;
1326        if (file_is_shared) {
1327            Gtk::MessageDialog msg(
1328                *this,
1329                 _("You cannot delete an instrument from this file, since it's "
1330                   "currently used by the sampler."),
1331                 false, Gtk::MESSAGE_INFO
1332            );
1333            msg.run();
1334            return;
1335        }
1336    
1337      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
1338      Gtk::TreeModel::iterator it = sel->get_selected();      Gtk::TreeModel::iterator it = sel->get_selected();
1339      if (it) {      if (it) {
# Line 1122  void MainWindow::on_action_add_sample() Line 1469  void MainWindow::on_action_add_sample()
1469                  {                  {
1470                      sample->MIDIUnityNote = instrument.basenote;                      sample->MIDIUnityNote = instrument.basenote;
1471    
1472    #if HAVE_SF_INSTRUMENT_LOOPS
1473                      if (instrument.loop_count && instrument.loops[0].mode != SF_LOOP_NONE) {                      if (instrument.loop_count && instrument.loops[0].mode != SF_LOOP_NONE) {
1474                          sample->Loops = 1;                          sample->Loops = 1;
1475    
# Line 1141  void MainWindow::on_action_add_sample() Line 1489  void MainWindow::on_action_add_sample()
1489                          sample->LoopPlayCount = instrument.loops[0].count;                          sample->LoopPlayCount = instrument.loops[0].count;
1490                          sample->LoopSize = sample->LoopEnd - sample->LoopStart + 1;                          sample->LoopSize = sample->LoopEnd - sample->LoopStart + 1;
1491                      }                      }
1492    #endif
1493                  }                  }
1494    
1495                  // schedule resizing the sample (which will be done                  // schedule resizing the sample (which will be done
# Line 1171  void MainWindow::on_action_add_sample() Line 1520  void MainWindow::on_action_add_sample()
1520          }          }
1521          // 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
1522          if (error_files.size()) {          if (error_files.size()) {
1523              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;
1524                Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
1525                msg.run();
1526            }
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);              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
1627              msg.run();              msg.run();
1628          }          }
# Line 1197  void MainWindow::on_action_remove_sample Line 1648  void MainWindow::on_action_remove_sample
1648                       pSample; pSample = group->GetNextSample()) {                       pSample; pSample = group->GetNextSample()) {
1649                      members.push_back(pSample);                      members.push_back(pSample);
1650                  }                  }
1651                    // notify everybody that we're going to remove these samples
1652                    samples_to_be_removed_signal.emit(members);
1653                  // delete the group in the .gig file including the                  // delete the group in the .gig file including the
1654                  // samples that belong to the group                  // samples that belong to the group
1655                  file->DeleteGroup(group);                  file->DeleteGroup(group);
1656                    // notify that we're done with removal
1657                    samples_removed_signal.emit();
1658                  // if sample(s) were just previously added, remove                  // if sample(s) were just previously added, remove
1659                  // them from the import queue                  // them from the import queue
1660                  for (std::list<gig::Sample*>::iterator member = members.begin();                  for (std::list<gig::Sample*>::iterator member = members.begin();
# Line 1216  void MainWindow::on_action_remove_sample Line 1671  void MainWindow::on_action_remove_sample
1671                  }                  }
1672                  file_changed();                  file_changed();
1673              } else if (sample) {              } else if (sample) {
1674                    // notify everybody that we're going to remove this sample
1675                    std::list<gig::Sample*> lsamples;
1676                    lsamples.push_back(sample);
1677                    samples_to_be_removed_signal.emit(lsamples);
1678                  // remove sample from the .gig file                  // remove sample from the .gig file
1679                  file->DeleteSample(sample);                  file->DeleteSample(sample);
1680                    // notify that we're done with removal
1681                    samples_removed_signal.emit();
1682                  // if sample was just previously added, remove it from                  // if sample was just previously added, remove it from
1683                  // the import queue                  // the import queue
1684                  for (std::list<SampleImportItem>::iterator iter = m_SampleImportQueue.begin();                  for (std::list<SampleImportItem>::iterator iter = m_SampleImportQueue.begin();
# Line 1229  void MainWindow::on_action_remove_sample Line 1690  void MainWindow::on_action_remove_sample
1690                          break;                          break;
1691                      }                      }
1692                  }                  }
1693                    dimreg_changed();
1694                  file_changed();                  file_changed();
1695              }              }
1696              // remove respective row(s) from samples tree view              // remove respective row(s) from samples tree view
1697              m_refSamplesTreeModel->erase(it);              m_refSamplesTreeModel->erase(it);
1698          } catch (RIFF::Exception e) {          } catch (RIFF::Exception e) {
1699                // pretend we're done with removal (i.e. to avoid dead locks)
1700                samples_removed_signal.emit();
1701                // show error message
1702              Gtk::MessageDialog msg(*this, e.Message.c_str(), false, Gtk::MESSAGE_ERROR);              Gtk::MessageDialog msg(*this, e.Message.c_str(), false, Gtk::MESSAGE_ERROR);
1703              msg.run();              msg.run();
1704          }          }
1705      }      }
1706  }  }
1707    
1708    // For some reason drag_data_get gets called two times for each
1709    // drag'n'drop (at least when target is an Entry). This work-around
1710    // makes sure the code in drag_data_get and drop_drag_data_received is
1711    // only executed once, as drag_begin only gets called once.
1712    void MainWindow::on_sample_treeview_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
1713    {
1714        first_call_to_drag_data_get = true;
1715    }
1716    
1717  void MainWindow::on_sample_treeview_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&,  void MainWindow::on_sample_treeview_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&,
1718                                                    Gtk::SelectionData& selection_data, guint, guint)                                                    Gtk::SelectionData& selection_data, guint, guint)
1719  {  {
1720        if (!first_call_to_drag_data_get) return;
1721        first_call_to_drag_data_get = false;
1722    
1723      // get selected sample      // get selected sample
1724      gig::Sample* sample = NULL;      gig::Sample* sample = NULL;
1725      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
# Line 1263  void MainWindow::on_sample_label_drop_dr Line 1740  void MainWindow::on_sample_label_drop_dr
1740      gig::Sample* sample = *((gig::Sample**) selection_data.get_data());      gig::Sample* sample = *((gig::Sample**) selection_data.get_data());
1741    
1742      if (sample && selection_data.get_length() == sizeof(gig::Sample*)) {      if (sample && selection_data.get_length() == sizeof(gig::Sample*)) {
1743          if (dimreg_edit.set_sample(sample)) {          std::cout << "Drop received sample \"" <<
1744              std::cout << "Drop received sample \"" <<              sample->pInfo->Name << "\"" << std::endl;
1745                  sample->pInfo->Name << "\"" << std::endl;          // drop success
1746              // drop success          context->drop_reply(true, time);
1747              context->drop_reply(true, time);  
1748              return;          //TODO: we should better move most of the following code to DimRegionEdit::set_sample()
1749    
1750            // notify everybody that we're going to alter the region
1751            gig::Region* region = m_RegionChooser.get_region();
1752            region_to_be_changed_signal.emit(region);
1753    
1754            // find the samplechannel dimension
1755            gig::dimension_def_t* stereo_dimension = 0;
1756            for (int i = 0 ; i < region->Dimensions ; i++) {
1757                if (region->pDimensionDefinitions[i].dimension ==
1758                    gig::dimension_samplechannel) {
1759                    stereo_dimension = &region->pDimensionDefinitions[i];
1760                    break;
1761                }
1762            }
1763            bool channels_changed = false;
1764            if (sample->Channels == 1 && stereo_dimension) {
1765                // remove the samplechannel dimension
1766                region->DeleteDimension(stereo_dimension);
1767                channels_changed = true;
1768                region_changed();
1769          }          }
1770            dimreg_edit.set_sample(sample);
1771    
1772            if (sample->Channels == 2 && !stereo_dimension) {
1773                // add samplechannel dimension
1774                gig::dimension_def_t dim;
1775                dim.dimension = gig::dimension_samplechannel;
1776                dim.bits = 1;
1777                dim.zones = 2;
1778                region->AddDimension(&dim);
1779                channels_changed = true;
1780                region_changed();
1781            }
1782            if (channels_changed) {
1783                // unmap all samples with wrong number of channels
1784                // TODO: maybe there should be a warning dialog for this
1785                for (int i = 0 ; i < region->DimensionRegions ; i++) {
1786                    gig::DimensionRegion* d = region->pDimensionRegions[i];
1787                    if (d->pSample && d->pSample->Channels != sample->Channels) {
1788                        gig::Sample* oldref = d->pSample;
1789                        d->pSample = NULL;
1790                        sample_ref_changed_signal.emit(oldref, NULL);
1791                    }
1792                }
1793            }
1794    
1795            // notify we're done with altering
1796            region_changed_signal.emit(region);
1797    
1798            file_changed();
1799    
1800            return;
1801      }      }
1802      // drop failed      // drop failed
1803      context->drop_reply(false, time);      context->drop_reply(false, time);
# Line 1308  void MainWindow::instrument_name_changed Line 1836  void MainWindow::instrument_name_changed
1836          file_changed();          file_changed();
1837      }      }
1838  }  }
1839    
1840    void MainWindow::set_file_is_shared(bool b) {
1841        this->file_is_shared = b;
1842    
1843        if (file_is_shared) {
1844            m_AttachedStateLabel.set_label(_("live-mode"));
1845            m_AttachedStateImage.set(
1846                Gdk::Pixbuf::create_from_xpm_data(status_attached_xpm)
1847            );
1848        } else {
1849            m_AttachedStateLabel.set_label(_("stand-alone"));
1850            m_AttachedStateImage.set(
1851                Gdk::Pixbuf::create_from_xpm_data(status_detached_xpm)
1852            );
1853        }
1854    }
1855    
1856    sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_to_be_changed() {
1857        return file_structure_to_be_changed_signal;
1858    }
1859    
1860    sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_changed() {
1861        return file_structure_changed_signal;
1862    }
1863    
1864    sigc::signal<void, std::list<gig::Sample*> >& MainWindow::signal_samples_to_be_removed() {
1865        return samples_to_be_removed_signal;
1866    }
1867    
1868    sigc::signal<void>& MainWindow::signal_samples_removed() {
1869        return samples_removed_signal;
1870    }
1871    
1872    sigc::signal<void, gig::Region*>& MainWindow::signal_region_to_be_changed() {
1873        return region_to_be_changed_signal;
1874    }
1875    
1876    sigc::signal<void, gig::Region*>& MainWindow::signal_region_changed() {
1877        return region_changed_signal;
1878    }
1879    
1880    sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/>& MainWindow::signal_sample_ref_changed() {
1881        return sample_ref_changed_signal;
1882    }
1883    
1884    sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_to_be_changed() {
1885        return dimreg_to_be_changed_signal;
1886    }
1887    
1888    sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {
1889        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.1265  
changed lines
  Added in v.1679
  ViewVC Help
Powered by ViewVC