/[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 1799 by persson, Sat Dec 6 13:49:26 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    #include "wrapLabel.hh"
30    
31    #include "global.h"
32    
33  #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
34  #define ABOUT_DIALOG  #define ABOUT_DIALOG
35  #include <gtkmm/aboutdialog.h>  #include <gtkmm/aboutdialog.h>
36  #endif  #endif
37    
38    #if (GLIBMM_MAJOR_VERSION == 2 && GLIBMM_MINOR_VERSION < 6) || GLIBMM_MAJOR_VERSION < 2
39    namespace Glib {
40    Glib::ustring filename_display_basename(const std::string& filename)
41    {
42        gchar* gstr = g_path_get_basename(filename.c_str());
43        Glib::ustring str(gstr);
44        g_free(gstr);
45        return Glib::filename_to_utf8(str);
46    }
47    }
48    #endif
49    
50  #include <stdio.h>  #include <stdio.h>
51  #include <sndfile.h>  #include <sndfile.h>
52    
53  #include "mainwindow.h"  #include "mainwindow.h"
54    
55  #define _(String) gettext(String)  #include "../../gfx/status_attached.xpm"
56    #include "../../gfx/status_detached.xpm"
57    
58  template<class T> inline std::string ToString(T o) {  template<class T> inline std::string ToString(T o) {
59      std::stringstream ss;      std::stringstream ss;
# Line 44  template<class T> inline std::string ToS Line 61  template<class T> inline std::string ToS
61      return ss.str();      return ss.str();
62  }  }
63    
64  MainWindow::MainWindow()  Table::Table(int x, int y) : Gtk::Table(x, y), rowno(0) {  }
65    
66    void Table::add(BoolEntry& boolentry)
67    {
68        attach(boolentry.widget, 0, 2, rowno, rowno + 1,
69               Gtk::FILL, Gtk::SHRINK);
70        rowno++;
71    }
72    
73    void Table::add(BoolEntryPlus6& boolentry)
74    {
75        attach(boolentry.widget, 0, 2, rowno, rowno + 1,
76               Gtk::FILL, Gtk::SHRINK);
77        rowno++;
78    }
79    
80    void Table::add(LabelWidget& prop)
81    {
82        attach(prop.label, 1, 2, rowno, rowno + 1,
83               Gtk::FILL, Gtk::SHRINK);
84        attach(prop.widget, 2, 3, rowno, rowno + 1,
85               Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK);
86        rowno++;
87    }
88    
89    MainWindow::MainWindow() :
90        dimreg_label(_("Changes apply to:")),
91        dimreg_all_regions(_("all regions")),
92        dimreg_all_dimregs(_("all dimension splits")),
93        dimreg_stereo(_("both channels"))
94  {  {
95  //    set_border_width(5);  //    set_border_width(5);
96  //    set_default_size(400, 200);  //    set_default_size(400, 200);
# Line 74  MainWindow::MainWindow() Line 120  MainWindow::MainWindow()
120      m_TreeViewNotebook.set_size_request(300);      m_TreeViewNotebook.set_size_request(300);
121    
122      m_HPaned.add1(m_TreeViewNotebook);      m_HPaned.add1(m_TreeViewNotebook);
123      m_HPaned.add2(dimreg_edit);      dimreg_hbox.add(dimreg_label);
124        dimreg_hbox.add(dimreg_all_regions);
125        dimreg_hbox.add(dimreg_all_dimregs);
126        dimreg_stereo.set_active();
127        dimreg_hbox.add(dimreg_stereo);
128        dimreg_vbox.add(dimreg_edit);
129        dimreg_vbox.pack_start(dimreg_hbox, Gtk::PACK_SHRINK);
130        m_HPaned.add2(dimreg_vbox);
131    
132    
133      m_TreeViewNotebook.append_page(m_ScrolledWindowSamples, "Samples");      m_TreeViewNotebook.append_page(m_ScrolledWindowSamples, "Samples");
# Line 115  MainWindow::MainWindow() Line 168  MainWindow::MainWindow()
168                           *this, &MainWindow::on_action_quit));                           *this, &MainWindow::on_action_quit));
169      actionGroup->add(Gtk::Action::create("MenuInstrument", _("_Instrument")));      actionGroup->add(Gtk::Action::create("MenuInstrument", _("_Instrument")));
170    
171        actionGroup->add(Gtk::Action::create("MenuView", _("_View")));
172        Glib::RefPtr<Gtk::ToggleAction> toggle_action =
173            Gtk::ToggleAction::create("Statusbar", _("_Statusbar"));
174        toggle_action->set_active(true);
175        actionGroup->add(toggle_action,
176                         sigc::mem_fun(
177                             *this, &MainWindow::on_action_view_status_bar));
178    
179      action = Gtk::Action::create("MenuHelp", Gtk::Stock::HELP);      action = Gtk::Action::create("MenuHelp", Gtk::Stock::HELP);
180      actionGroup->add(Gtk::Action::create("MenuHelp",      actionGroup->add(Gtk::Action::create("MenuHelp",
181                                           action->property_label()));                                           action->property_label()));
# Line 142  MainWindow::MainWindow() Line 203  MainWindow::MainWindow()
203          sigc::mem_fun(*this, &MainWindow::on_action_add_group)          sigc::mem_fun(*this, &MainWindow::on_action_add_group)
204      );      );
205      actionGroup->add(      actionGroup->add(
206          Gtk::Action::create("AddSample", _("Add _Sample(s)")),          Gtk::Action::create("AddSample", _("Add _Sample(s)...")),
207          sigc::mem_fun(*this, &MainWindow::on_action_add_sample)          sigc::mem_fun(*this, &MainWindow::on_action_add_sample)
208      );      );
209      actionGroup->add(      actionGroup->add(
210          Gtk::Action::create("RemoveSample", Gtk::Stock::REMOVE),          Gtk::Action::create("RemoveSample", Gtk::Stock::REMOVE),
211          sigc::mem_fun(*this, &MainWindow::on_action_remove_sample)          sigc::mem_fun(*this, &MainWindow::on_action_remove_sample)
212      );      );
213        actionGroup->add(
214            Gtk::Action::create("ReplaceAllSamplesInAllGroups",
215                                _("Replace All Samples in All Groups...")),
216            sigc::mem_fun(*this, &MainWindow::on_action_replace_all_samples_in_all_groups)
217        );
218    
219      uiManager = Gtk::UIManager::create();      uiManager = Gtk::UIManager::create();
220      uiManager->insert_action_group(actionGroup);      uiManager->insert_action_group(actionGroup);
# Line 170  MainWindow::MainWindow() Line 236  MainWindow::MainWindow()
236          "    </menu>"          "    </menu>"
237          "    <menu action='MenuInstrument'>"          "    <menu action='MenuInstrument'>"
238          "    </menu>"          "    </menu>"
239            "    <menu action='MenuView'>"
240            "      <menuitem action='Statusbar'/>"
241            "    </menu>"
242  #ifdef ABOUT_DIALOG  #ifdef ABOUT_DIALOG
243          "    <menu action='MenuHelp'>"          "    <menu action='MenuHelp'>"
244          "      <menuitem action='About'/>"          "      <menuitem action='About'/>"
# Line 186  MainWindow::MainWindow() Line 255  MainWindow::MainWindow()
255          "    <menuitem action='SampleProperties'/>"          "    <menuitem action='SampleProperties'/>"
256          "    <menuitem action='AddGroup'/>"          "    <menuitem action='AddGroup'/>"
257          "    <menuitem action='AddSample'/>"          "    <menuitem action='AddSample'/>"
258            "    <menuitem action='ReplaceAllSamplesInAllGroups' />"
259          "    <separator/>"          "    <separator/>"
260          "    <menuitem action='RemoveSample'/>"          "    <menuitem action='RemoveSample'/>"
261          "  </popup>"          "  </popup>"
# Line 198  MainWindow::MainWindow() Line 268  MainWindow::MainWindow()
268      m_VBox.pack_start(*menuBar, Gtk::PACK_SHRINK);      m_VBox.pack_start(*menuBar, Gtk::PACK_SHRINK);
269      m_VBox.pack_start(m_HPaned);      m_VBox.pack_start(m_HPaned);
270      m_VBox.pack_start(m_RegionChooser, Gtk::PACK_SHRINK);      m_VBox.pack_start(m_RegionChooser, Gtk::PACK_SHRINK);
271        m_VBox.pack_start(m_RegionChooser.m_VirtKeybPropsBox, Gtk::PACK_SHRINK);
272      m_VBox.pack_start(m_DimRegionChooser, Gtk::PACK_SHRINK);      m_VBox.pack_start(m_DimRegionChooser, Gtk::PACK_SHRINK);
273        m_VBox.pack_start(m_StatusBar, Gtk::PACK_SHRINK);
274    
275        // Status Bar:
276        m_StatusBar.pack_start(m_AttachedStateLabel, Gtk::PACK_SHRINK);
277        m_StatusBar.pack_start(m_AttachedStateImage, Gtk::PACK_SHRINK);
278        m_StatusBar.show();
279    
280      m_RegionChooser.signal_region_selected().connect(      m_RegionChooser.signal_region_selected().connect(
281          sigc::mem_fun(*this, &MainWindow::region_changed) );          sigc::mem_fun(*this, &MainWindow::region_changed) );
# Line 234  MainWindow::MainWindow() Line 311  MainWindow::MainWindow()
311      std::list<Gtk::TargetEntry> drag_target_gig_sample;      std::list<Gtk::TargetEntry> drag_target_gig_sample;
312      drag_target_gig_sample.push_back( Gtk::TargetEntry("gig::Sample") );      drag_target_gig_sample.push_back( Gtk::TargetEntry("gig::Sample") );
313      m_TreeViewSamples.drag_source_set(drag_target_gig_sample);      m_TreeViewSamples.drag_source_set(drag_target_gig_sample);
314        m_TreeViewSamples.signal_drag_begin().connect(
315            sigc::mem_fun(*this, &MainWindow::on_sample_treeview_drag_begin)
316        );
317      m_TreeViewSamples.signal_drag_data_get().connect(      m_TreeViewSamples.signal_drag_data_get().connect(
318          sigc::mem_fun(*this, &MainWindow::on_sample_treeview_drag_data_get)          sigc::mem_fun(*this, &MainWindow::on_sample_treeview_drag_data_get)
319      );      );
# Line 242  MainWindow::MainWindow() Line 322  MainWindow::MainWindow()
322          sigc::mem_fun(*this, &MainWindow::on_sample_label_drop_drag_data_received)          sigc::mem_fun(*this, &MainWindow::on_sample_label_drop_drag_data_received)
323      );      );
324      dimreg_edit.signal_dimreg_changed().connect(      dimreg_edit.signal_dimreg_changed().connect(
325          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::hide(sigc::mem_fun(*this, &MainWindow::file_changed)));
326      m_RegionChooser.signal_instrument_changed().connect(      m_RegionChooser.signal_instrument_changed().connect(
327          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
328      m_DimRegionChooser.signal_region_changed().connect(      m_DimRegionChooser.signal_region_changed().connect(
329          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
330      instrumentProps.signal_instrument_changed().connect(      instrumentProps.signal_instrument_changed().connect(
331          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
332        propDialog.signal_info_changed().connect(
333            sigc::mem_fun(*this, &MainWindow::file_changed));
334    
335        dimreg_edit.signal_dimreg_to_be_changed().connect(
336            dimreg_to_be_changed_signal.make_slot());
337        dimreg_edit.signal_dimreg_changed().connect(
338            dimreg_changed_signal.make_slot());
339        dimreg_edit.signal_sample_ref_changed().connect(
340            sample_ref_changed_signal.make_slot());
341    
342        m_RegionChooser.signal_instrument_struct_to_be_changed().connect(
343            sigc::hide(
344                sigc::bind(
345                    file_structure_to_be_changed_signal.make_slot(),
346                    sigc::ref(this->file)
347                )
348            )
349        );
350        m_RegionChooser.signal_instrument_struct_changed().connect(
351            sigc::hide(
352                sigc::bind(
353                    file_structure_changed_signal.make_slot(),
354                    sigc::ref(this->file)
355                )
356            )
357        );
358        m_RegionChooser.signal_region_to_be_changed().connect(
359            region_to_be_changed_signal.make_slot());
360        m_RegionChooser.signal_region_changed_signal().connect(
361            region_changed_signal.make_slot());
362    
363        note_on_signal.connect(
364            sigc::mem_fun(m_RegionChooser, &RegionChooser::on_note_on_event));
365        note_off_signal.connect(
366            sigc::mem_fun(m_RegionChooser, &RegionChooser::on_note_off_event));
367    
368        dimreg_all_regions.signal_toggled().connect(
369            sigc::mem_fun(*this, &MainWindow::update_dimregs));
370        dimreg_all_dimregs.signal_toggled().connect(
371            sigc::mem_fun(*this, &MainWindow::dimreg_all_dimregs_toggled));
372        dimreg_stereo.signal_toggled().connect(
373            sigc::mem_fun(*this, &MainWindow::update_dimregs));
374    
375      file = 0;      file = 0;
376      file_is_changed = false;      file_is_changed = false;
377        set_file_is_shared(false);
378    
379      show_all_children();      show_all_children();
380    
381        // start with a new gig file by default
382        on_action_file_new();
383  }  }
384    
385  MainWindow::~MainWindow()  MainWindow::~MainWindow()
# Line 261  MainWindow::~MainWindow() Line 388  MainWindow::~MainWindow()
388    
389  bool MainWindow::on_delete_event(GdkEventAny* event)  bool MainWindow::on_delete_event(GdkEventAny* event)
390  {  {
391      return file_is_changed && !close_confirmation_dialog();      return !file_is_shared && file_is_changed && !close_confirmation_dialog();
392  }  }
393    
394  void MainWindow::on_action_quit()  void MainWindow::on_action_quit()
395  {  {
396      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
397      hide();      hide();
398  }  }
399    
# Line 275  void MainWindow::region_changed() Line 402  void MainWindow::region_changed()
402      m_DimRegionChooser.set_region(m_RegionChooser.get_region());      m_DimRegionChooser.set_region(m_RegionChooser.get_region());
403  }  }
404    
405  void MainWindow::dimreg_changed()  gig::Instrument* MainWindow::get_instrument()
 {  
     dimreg_edit.set_dim_region(m_DimRegionChooser.get_dimregion());  
 }  
   
 void MainWindow::on_sel_change()  
406  {  {
407        gig::Instrument* instrument = 0;
408      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();
409    
410      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();
411      if (it) {      if (it) {
412          Gtk::TreeModel::Row row = *it;          Gtk::TreeModel::Row row = *it;
413          std::cout << row[m_Columns.m_col_name] << std::endl;          instrument = row[m_Columns.m_col_instr];
414        }
415        return instrument;
416    }
417    
418          m_RegionChooser.set_instrument(row[m_Columns.m_col_instr]);  void MainWindow::add_region_to_dimregs(gig::Region* region, bool stereo, bool all_dimregs)
419    {
420        if (all_dimregs) {
421            for (int i = 0 ; i < region->DimensionRegions ; i++) {
422                if (region->pDimensionRegions[i]) {
423                    dimreg_edit.dimregs.insert(region->pDimensionRegions[i]);
424                }
425            }
426      } else {      } else {
427          m_RegionChooser.set_instrument(0);          m_DimRegionChooser.get_dimregions(region, stereo, dimreg_edit.dimregs);
428      }      }
429  }  }
430    
431    void MainWindow::update_dimregs()
432    {
433        dimreg_edit.dimregs.clear();
434        bool all_regions = dimreg_all_regions.get_active();
435        bool stereo = dimreg_stereo.get_active();
436        bool all_dimregs = dimreg_all_dimregs.get_active();
437    
438        if (all_regions) {
439            gig::Instrument* instrument = get_instrument();
440            if (instrument) {
441                for (gig::Region* region = instrument->GetFirstRegion() ;
442                     region ;
443                     region = instrument->GetNextRegion()) {
444                    add_region_to_dimregs(region, stereo, all_dimregs);
445                }
446            }
447        } else {
448            gig::Region* region = m_RegionChooser.get_region();
449            if (region) {
450                add_region_to_dimregs(region, stereo, all_dimregs);
451            }
452        }
453    }
454    
455    void MainWindow::dimreg_all_dimregs_toggled()
456    {
457        dimreg_stereo.set_sensitive(!dimreg_all_dimregs.get_active());
458        update_dimregs();
459    }
460    
461    void MainWindow::dimreg_changed()
462    {
463        update_dimregs();
464        dimreg_edit.set_dim_region(m_DimRegionChooser.get_dimregion());
465    }
466    
467    void MainWindow::on_sel_change()
468    {
469        m_RegionChooser.set_instrument(get_instrument());
470    }
471    
472  void loader_progress_callback(gig::progress_t* progress)  void loader_progress_callback(gig::progress_t* progress)
473  {  {
474      Loader* loader = static_cast<Loader*>(progress->custom);      Loader* loader = static_cast<Loader*>(progress->custom);
# Line 380  void MainWindow::__clear() { Line 554  void MainWindow::__clear() {
554      m_refTreeModel->clear();      m_refTreeModel->clear();
555      m_refSamplesTreeModel->clear();      m_refSamplesTreeModel->clear();
556      // free libgig's gig::File instance      // free libgig's gig::File instance
557      if (file) {      if (file && !file_is_shared) delete file;
558          delete file;      file = NULL;
559          file = NULL;      set_file_is_shared(false);
     }  
560  }  }
561    
562  void MainWindow::on_action_file_new()  void MainWindow::on_action_file_new()
563  {  {
564      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
565    
566        if (file_is_shared && !leaving_shared_mode_dialog()) return;
567    
568      // clear all GUI elements      // clear all GUI elements
569      __clear();      __clear();
# Line 407  bool MainWindow::close_confirmation_dial Line 582  bool MainWindow::close_confirmation_dial
582                                   Glib::filename_display_basename(filename).c_str());                                   Glib::filename_display_basename(filename).c_str());
583      Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);      Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
584      g_free(msg);      g_free(msg);
585    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 6) || GTKMM_MAJOR_VERSION > 2
586      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."));
587    #endif
588      dialog.add_button(_("Close _Without Saving"), Gtk::RESPONSE_NO);      dialog.add_button(_("Close _Without Saving"), Gtk::RESPONSE_NO);
589      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
590      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);
591      dialog.set_default_response(Gtk::RESPONSE_YES);      dialog.set_default_response(Gtk::RESPONSE_YES);
592      int response = dialog.run();      int response = dialog.run();
593        dialog.hide();
594      if (response == Gtk::RESPONSE_YES) return file_save();      if (response == Gtk::RESPONSE_YES) return file_save();
595      return response != Gtk::RESPONSE_CANCEL;      return response != Gtk::RESPONSE_CANCEL;
596  }  }
597    
598    bool MainWindow::leaving_shared_mode_dialog() {
599        Glib::ustring msg = _("Detach from sampler and proceed working stand-alone?");
600        Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
601    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 6) || GTKMM_MAJOR_VERSION > 2
602        dialog.set_secondary_text(
603            _("If you proceed to work on another instrument file, it won't be "
604              "used by the sampler until you tell the sampler explicitly to "
605              "load it.")
606       );
607    #endif
608        dialog.add_button(_("_Yes, Detach"), Gtk::RESPONSE_YES);
609        dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
610        dialog.set_default_response(Gtk::RESPONSE_CANCEL);
611        int response = dialog.run();
612        dialog.hide();
613        return response == Gtk::RESPONSE_YES;
614    }
615    
616  void MainWindow::on_action_file_open()  void MainWindow::on_action_file_open()
617  {  {
618      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
619    
620        if (file_is_shared && !leaving_shared_mode_dialog()) return;
621    
622      Gtk::FileChooserDialog dialog(*this, _("Open file"));      Gtk::FileChooserDialog dialog(*this, _("Open file"));
623      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
# Line 428  void MainWindow::on_action_file_open() Line 626  void MainWindow::on_action_file_open()
626      Gtk::FileFilter filter;      Gtk::FileFilter filter;
627      filter.add_pattern("*.gig");      filter.add_pattern("*.gig");
628      dialog.set_filter(filter);      dialog.set_filter(filter);
629      if (current_dir != "") {      if (current_gig_dir != "") {
630          dialog.set_current_folder(current_dir);          dialog.set_current_folder(current_gig_dir);
631      }      }
632      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
633          std::string filename = dialog.get_filename();          std::string filename = dialog.get_filename();
634          printf("filename=%s\n", filename.c_str());          printf("filename=%s\n", filename.c_str());
         __clear();  
635          printf("on_action_file_open self=%x\n", Glib::Thread::self());          printf("on_action_file_open self=%x\n", Glib::Thread::self());
636          load_file(filename.c_str());          load_file(filename.c_str());
637          current_dir = Glib::path_get_dirname(filename);          current_gig_dir = Glib::path_get_dirname(filename);
638      }      }
639  }  }
640    
641  void MainWindow::load_file(const char* name)  void MainWindow::load_file(const char* name)
642  {  {
643        __clear();
644      load_dialog = new LoadDialog("Loading...", *this);      load_dialog = new LoadDialog("Loading...", *this);
645      load_dialog->show_all();      load_dialog->show_all();
646      loader = new Loader(strdup(name));      loader = new Loader(strdup(name));
# Line 460  void MainWindow::load_instrument(gig::In Line 658  void MainWindow::load_instrument(gig::In
658          msg.run();          msg.run();
659          Gtk::Main::quit();          Gtk::Main::quit();
660      }      }
661        // clear all GUI elements
662        __clear();
663        // load the instrument
664      gig::File* pFile = (gig::File*) instr->GetParent();      gig::File* pFile = (gig::File*) instr->GetParent();
665      load_gig(pFile, 0 /*file name*/);      load_gig(pFile, 0 /*file name*/, true /*shared instrument*/);
666      //TODO: automatically select the given instrument      //TODO: automatically select the given instrument
667  }  }
668    
# Line 483  void MainWindow::on_action_file_save() Line 684  void MainWindow::on_action_file_save()
684      file_save();      file_save();
685  }  }
686    
687  bool MainWindow::file_save()  bool MainWindow::check_if_savable()
688  {  {
689      if (!file) return false;      if (!file) return false;
690      if (!file_has_name) return file_save_as();  
691        if (!file->GetFirstSample()) {
692            Gtk::MessageDialog(*this, _("The file could not be saved "
693                                        "because it contains no samples"),
694                               false, Gtk::MESSAGE_ERROR).run();
695            return false;
696        }
697    
698        for (gig::Instrument* instrument = file->GetFirstInstrument() ; instrument ;
699             instrument = file->GetNextInstrument()) {
700            if (!instrument->GetFirstRegion()) {
701                Gtk::MessageDialog(*this, _("The file could not be saved "
702                                            "because there are instruments "
703                                            "that have no regions"),
704                                   false, Gtk::MESSAGE_ERROR).run();
705                return false;
706            }
707        }
708        return true;
709    }
710    
711    bool MainWindow::file_save()
712    {
713        if (!check_if_savable()) return false;
714        if (!file_is_shared && !file_has_name) return file_save_as();
715    
716      std::cout << "Saving file\n" << std::flush;      std::cout << "Saving file\n" << std::flush;
717        file_structure_to_be_changed_signal.emit(this->file);
718      try {      try {
719          file->Save();          file->Save();
720          if (file_is_changed) {          if (file_is_changed) {
# Line 496  bool MainWindow::file_save() Line 722  bool MainWindow::file_save()
722              file_is_changed = false;              file_is_changed = false;
723          }          }
724      } catch (RIFF::Exception e) {      } catch (RIFF::Exception e) {
725          Glib::ustring txt = "Could not save file: " + e.Message;          file_structure_changed_signal.emit(this->file);
726            Glib::ustring txt = _("Could not save file: ") + e.Message;
727          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
728          msg.run();          msg.run();
729          return false;          return false;
730      }      }
731      std::cout << "Saving file done\n" << std::flush;      std::cout << "Saving file done\n" << std::flush;
732      __import_queued_samples();      __import_queued_samples();
733        file_structure_changed_signal.emit(this->file);
734      return true;      return true;
735  }  }
736    
737  void MainWindow::on_action_file_save_as()  void MainWindow::on_action_file_save_as()
738  {  {
739        if (!check_if_savable()) return;
740      file_save_as();      file_save_as();
741  }  }
742    
743  bool MainWindow::file_save_as()  bool MainWindow::file_save_as()
744  {  {
     if (!file) return false;  
745      Gtk::FileChooserDialog dialog(*this, _("Save as"), Gtk::FILE_CHOOSER_ACTION_SAVE);      Gtk::FileChooserDialog dialog(*this, _("Save as"), Gtk::FILE_CHOOSER_ACTION_SAVE);
746      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
747      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 755  bool MainWindow::file_save_as()
755      filter.add_pattern("*.gig");      filter.add_pattern("*.gig");
756      dialog.set_filter(filter);      dialog.set_filter(filter);
757    
758      if (Glib::path_is_absolute(filename)) {      // set initial dir and filename of the Save As dialog
759          dialog.set_filename(filename);      // and prepare that initial filename as a copy of the gig
760      } else if (current_dir != "") {      {
761          dialog.set_current_folder(current_dir);          std::string basename = Glib::path_get_basename(filename);
762            std::string dir = Glib::path_get_dirname(filename);
763            basename = std::string("copy_of_") + basename;
764            Glib::ustring copyFileName = Glib::build_filename(dir, basename);
765            if (Glib::path_is_absolute(filename)) {
766                dialog.set_filename(copyFileName);
767            } else {
768                if (current_gig_dir != "") dialog.set_current_folder(current_gig_dir);
769            }
770            dialog.set_current_name(Glib::filename_display_basename(copyFileName));
771      }      }
772      dialog.set_current_name(Glib::filename_display_basename(filename));  
773        // show warning in the dialog
774        Gtk::HBox descriptionArea;
775        descriptionArea.set_spacing(15);
776        Gtk::Image warningIcon(Gtk::Stock::DIALOG_WARNING, Gtk::IconSize(Gtk::ICON_SIZE_DIALOG));
777        descriptionArea.pack_start(warningIcon, Gtk::PACK_SHRINK);
778        view::WrapLabel description;
779        description.set_markup(
780            _("\n<b>CAUTION:</b> You <b>MUST</b> use the "
781              "<span style=\"italic\">\"Save\"</span> dialog instead of "
782              "<span style=\"italic\">\"Save As...\"</span> if you want to save "
783              "to the same .gig file. Using "
784              "<span style=\"italic\">\"Save As...\"</span> for writing to the "
785              "same .gig file will end up in corrupted sample wave data!\n")
786        );
787        descriptionArea.pack_start(description);
788        dialog.get_vbox()->pack_start(descriptionArea, Gtk::PACK_SHRINK);
789        descriptionArea.show_all();
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 543  bool MainWindow::file_save_as() Line 798  bool MainWindow::file_save_as()
798              printf("filename=%s\n", filename.c_str());              printf("filename=%s\n", filename.c_str());
799              file->Save(filename);              file->Save(filename);
800              this->filename = filename;              this->filename = filename;
801              current_dir = Glib::path_get_dirname(filename);              current_gig_dir = Glib::path_get_dirname(filename);
802              set_title(Glib::filename_display_basename(filename));              set_title(Glib::filename_display_basename(filename));
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 1067  void MainWindow::on_action_add_sample() Line 1414  void MainWindow::on_action_add_sample()
1414      allpassfilter.set_name("All Files");      allpassfilter.set_name("All Files");
1415      dialog.add_filter(soundfilter);      dialog.add_filter(soundfilter);
1416      dialog.add_filter(allpassfilter);      dialog.add_filter(allpassfilter);
1417        if (current_sample_dir != "") {
1418            dialog.set_current_folder(current_sample_dir);
1419        }
1420      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
1421            current_sample_dir = dialog.get_current_folder();
1422          Glib::ustring error_files;          Glib::ustring error_files;
1423          Glib::SListHandle<Glib::ustring> filenames = dialog.get_filenames();          Glib::SListHandle<Glib::ustring> filenames = dialog.get_filenames();
1424          for (Glib::SListHandle<Glib::ustring>::iterator iter = filenames.begin();          for (Glib::SListHandle<Glib::ustring>::iterator iter = filenames.begin();
# Line 1122  void MainWindow::on_action_add_sample() Line 1473  void MainWindow::on_action_add_sample()
1473                  {                  {
1474                      sample->MIDIUnityNote = instrument.basenote;                      sample->MIDIUnityNote = instrument.basenote;
1475    
1476    #if HAVE_SF_INSTRUMENT_LOOPS
1477                      if (instrument.loop_count && instrument.loops[0].mode != SF_LOOP_NONE) {                      if (instrument.loop_count && instrument.loops[0].mode != SF_LOOP_NONE) {
1478                          sample->Loops = 1;                          sample->Loops = 1;
1479    
# Line 1141  void MainWindow::on_action_add_sample() Line 1493  void MainWindow::on_action_add_sample()
1493                          sample->LoopPlayCount = instrument.loops[0].count;                          sample->LoopPlayCount = instrument.loops[0].count;
1494                          sample->LoopSize = sample->LoopEnd - sample->LoopStart + 1;                          sample->LoopSize = sample->LoopEnd - sample->LoopStart + 1;
1495                      }                      }
1496    #endif
1497                  }                  }
1498    
1499                  // 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 1524  void MainWindow::on_action_add_sample()
1524          }          }
1525          // 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
1526          if (error_files.size()) {          if (error_files.size()) {
1527              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;
1528                Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
1529                msg.run();
1530            }
1531        }
1532    }
1533    
1534    void MainWindow::on_action_replace_all_samples_in_all_groups()
1535    {
1536        if (!file) return;
1537        Gtk::FileChooserDialog dialog(*this, _("Select Folder"),
1538                                      Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
1539        view::WrapLabel description(
1540            _("This is a very specific function. It tries to replace all samples "
1541              "in the current gig file by samples located in the chosen "
1542              "directory.\n\n"
1543              "It works like this: For each sample in the gig file, it tries to "
1544              "find a sample file in the selected directory with the same name as "
1545              "the sample in the gig file. Optionally, you can add a filename "
1546              "extension below, which will be added to the filename expected to be "
1547              "found. That is, assume you have a gig file with a sample called "
1548              "'Snare', if you enter '.wav' below (like it's done by default), it "
1549              "expects to find a sample file called 'Snare.wav' and will replace "
1550              "the sample in the gig file accordingly. If you don't need an "
1551              "extension, blank the field below. Any gig sample where no "
1552              "appropriate sample file could be found will be reported and left "
1553              "untouched.\n")
1554        );
1555        Gtk::HBox entryArea;
1556        Gtk::Label entryLabel( _("Add filename extension: "), Gtk::ALIGN_RIGHT);
1557        Gtk::Entry postfixEntryBox;
1558        postfixEntryBox.set_text(".wav");
1559        entryArea.pack_start(entryLabel);
1560        entryArea.pack_start(postfixEntryBox);
1561        dialog.get_vbox()->pack_start(description, Gtk::PACK_SHRINK);
1562        dialog.get_vbox()->pack_start(entryArea, Gtk::PACK_SHRINK);
1563        description.show();
1564        entryArea.show_all();
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        if (current_sample_dir != "") {
1569            dialog.set_current_folder(current_sample_dir);
1570        }
1571        if (dialog.run() == Gtk::RESPONSE_OK)
1572        {
1573            current_sample_dir = dialog.get_current_folder();
1574            Glib::ustring error_files;
1575            Glib::ustring folder = dialog.get_filename();
1576            for (gig::Sample* sample = file->GetFirstSample();
1577                 sample; sample = file->GetNextSample())
1578            {
1579                std::string filename =
1580                    folder + G_DIR_SEPARATOR_S + sample->pInfo->Name +
1581                    postfixEntryBox.get_text().raw();
1582                SF_INFO info;
1583                info.format = 0;
1584                SNDFILE* hFile = sf_open(filename.c_str(), SFM_READ, &info);
1585                try
1586                {
1587                    if (!hFile) throw std::string("could not open file");
1588                    int bitdepth;
1589                    switch (info.format & 0xff) {
1590                        case SF_FORMAT_PCM_S8:
1591                        case SF_FORMAT_PCM_16:
1592                        case SF_FORMAT_PCM_U8:
1593                            bitdepth = 16;
1594                            break;
1595                        case SF_FORMAT_PCM_24:
1596                        case SF_FORMAT_PCM_32:
1597                        case SF_FORMAT_FLOAT:
1598                        case SF_FORMAT_DOUBLE:
1599                            bitdepth = 24;
1600                            break;
1601                        default:
1602                            sf_close(hFile);
1603                            throw std::string("format not supported");
1604                    }
1605                    SampleImportItem sched_item;
1606                    sched_item.gig_sample  = sample;
1607                    sched_item.sample_path = filename;
1608                    m_SampleImportQueue.push_back(sched_item);
1609                    sf_close(hFile);
1610                    file_changed();
1611                }
1612                catch (std::string what)
1613                {
1614                    if (error_files.size()) error_files += "\n";
1615                        error_files += filename += " (" + what + ")";
1616                }
1617            }
1618            // show error message box when some file(s) could not be opened / added
1619            if (error_files.size()) {
1620                Glib::ustring txt =
1621                    _("Could not replace the following sample(s):\n") + error_files;
1622              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
1623              msg.run();              msg.run();
1624          }          }
# Line 1197  void MainWindow::on_action_remove_sample Line 1644  void MainWindow::on_action_remove_sample
1644                       pSample; pSample = group->GetNextSample()) {                       pSample; pSample = group->GetNextSample()) {
1645                      members.push_back(pSample);                      members.push_back(pSample);
1646                  }                  }
1647                    // notify everybody that we're going to remove these samples
1648                    samples_to_be_removed_signal.emit(members);
1649                  // delete the group in the .gig file including the                  // delete the group in the .gig file including the
1650                  // samples that belong to the group                  // samples that belong to the group
1651                  file->DeleteGroup(group);                  file->DeleteGroup(group);
1652                    // notify that we're done with removal
1653                    samples_removed_signal.emit();
1654                  // if sample(s) were just previously added, remove                  // if sample(s) were just previously added, remove
1655                  // them from the import queue                  // them from the import queue
1656                  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 1667  void MainWindow::on_action_remove_sample
1667                  }                  }
1668                  file_changed();                  file_changed();
1669              } else if (sample) {              } else if (sample) {
1670                    // notify everybody that we're going to remove this sample
1671                    std::list<gig::Sample*> lsamples;
1672                    lsamples.push_back(sample);
1673                    samples_to_be_removed_signal.emit(lsamples);
1674                  // remove sample from the .gig file                  // remove sample from the .gig file
1675                  file->DeleteSample(sample);                  file->DeleteSample(sample);
1676                    // notify that we're done with removal
1677                    samples_removed_signal.emit();
1678                  // if sample was just previously added, remove it from                  // if sample was just previously added, remove it from
1679                  // the import queue                  // the import queue
1680                  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 1686  void MainWindow::on_action_remove_sample
1686                          break;                          break;
1687                      }                      }
1688                  }                  }
1689                    dimreg_changed();
1690                  file_changed();                  file_changed();
1691              }              }
1692              // remove respective row(s) from samples tree view              // remove respective row(s) from samples tree view
1693              m_refSamplesTreeModel->erase(it);              m_refSamplesTreeModel->erase(it);
1694          } catch (RIFF::Exception e) {          } catch (RIFF::Exception e) {
1695                // pretend we're done with removal (i.e. to avoid dead locks)
1696                samples_removed_signal.emit();
1697                // show error message
1698              Gtk::MessageDialog msg(*this, e.Message.c_str(), false, Gtk::MESSAGE_ERROR);              Gtk::MessageDialog msg(*this, e.Message.c_str(), false, Gtk::MESSAGE_ERROR);
1699              msg.run();              msg.run();
1700          }          }
1701      }      }
1702  }  }
1703    
1704    // For some reason drag_data_get gets called two times for each
1705    // drag'n'drop (at least when target is an Entry). This work-around
1706    // makes sure the code in drag_data_get and drop_drag_data_received is
1707    // only executed once, as drag_begin only gets called once.
1708    void MainWindow::on_sample_treeview_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
1709    {
1710        first_call_to_drag_data_get = true;
1711    }
1712    
1713  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>&,
1714                                                    Gtk::SelectionData& selection_data, guint, guint)                                                    Gtk::SelectionData& selection_data, guint, guint)
1715  {  {
1716        if (!first_call_to_drag_data_get) return;
1717        first_call_to_drag_data_get = false;
1718    
1719      // get selected sample      // get selected sample
1720      gig::Sample* sample = NULL;      gig::Sample* sample = NULL;
1721      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 1736  void MainWindow::on_sample_label_drop_dr
1736      gig::Sample* sample = *((gig::Sample**) selection_data.get_data());      gig::Sample* sample = *((gig::Sample**) selection_data.get_data());
1737    
1738      if (sample && selection_data.get_length() == sizeof(gig::Sample*)) {      if (sample && selection_data.get_length() == sizeof(gig::Sample*)) {
1739          if (dimreg_edit.set_sample(sample)) {          std::cout << "Drop received sample \"" <<
1740              std::cout << "Drop received sample \"" <<              sample->pInfo->Name << "\"" << std::endl;
1741                  sample->pInfo->Name << "\"" << std::endl;          // drop success
1742              // drop success          context->drop_reply(true, time);
1743              context->drop_reply(true, time);  
1744              return;          //TODO: we should better move most of the following code to DimRegionEdit::set_sample()
1745    
1746            // notify everybody that we're going to alter the region
1747            gig::Region* region = m_RegionChooser.get_region();
1748            region_to_be_changed_signal.emit(region);
1749    
1750            // find the samplechannel dimension
1751            gig::dimension_def_t* stereo_dimension = 0;
1752            for (int i = 0 ; i < region->Dimensions ; i++) {
1753                if (region->pDimensionDefinitions[i].dimension ==
1754                    gig::dimension_samplechannel) {
1755                    stereo_dimension = &region->pDimensionDefinitions[i];
1756                    break;
1757                }
1758            }
1759            bool channels_changed = false;
1760            if (sample->Channels == 1 && stereo_dimension) {
1761                // remove the samplechannel dimension
1762                region->DeleteDimension(stereo_dimension);
1763                channels_changed = true;
1764                region_changed();
1765          }          }
1766            dimreg_edit.set_sample(sample);
1767    
1768            if (sample->Channels == 2 && !stereo_dimension) {
1769                // add samplechannel dimension
1770                gig::dimension_def_t dim;
1771                dim.dimension = gig::dimension_samplechannel;
1772                dim.bits = 1;
1773                dim.zones = 2;
1774                region->AddDimension(&dim);
1775                channels_changed = true;
1776                region_changed();
1777            }
1778            if (channels_changed) {
1779                // unmap all samples with wrong number of channels
1780                // TODO: maybe there should be a warning dialog for this
1781                for (int i = 0 ; i < region->DimensionRegions ; i++) {
1782                    gig::DimensionRegion* d = region->pDimensionRegions[i];
1783                    if (d->pSample && d->pSample->Channels != sample->Channels) {
1784                        gig::Sample* oldref = d->pSample;
1785                        d->pSample = NULL;
1786                        sample_ref_changed_signal.emit(oldref, NULL);
1787                    }
1788                }
1789            }
1790    
1791            // notify we're done with altering
1792            region_changed_signal.emit(region);
1793    
1794            file_changed();
1795    
1796            return;
1797      }      }
1798      // drop failed      // drop failed
1799      context->drop_reply(false, time);      context->drop_reply(false, time);
# Line 1308  void MainWindow::instrument_name_changed Line 1832  void MainWindow::instrument_name_changed
1832          file_changed();          file_changed();
1833      }      }
1834  }  }
1835    
1836    void MainWindow::set_file_is_shared(bool b) {
1837        this->file_is_shared = b;
1838    
1839        if (file_is_shared) {
1840            m_AttachedStateLabel.set_label(_("live-mode"));
1841            m_AttachedStateImage.set(
1842                Gdk::Pixbuf::create_from_xpm_data(status_attached_xpm)
1843            );
1844        } else {
1845            m_AttachedStateLabel.set_label(_("stand-alone"));
1846            m_AttachedStateImage.set(
1847                Gdk::Pixbuf::create_from_xpm_data(status_detached_xpm)
1848            );
1849        }
1850    }
1851    
1852    sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_to_be_changed() {
1853        return file_structure_to_be_changed_signal;
1854    }
1855    
1856    sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_changed() {
1857        return file_structure_changed_signal;
1858    }
1859    
1860    sigc::signal<void, std::list<gig::Sample*> >& MainWindow::signal_samples_to_be_removed() {
1861        return samples_to_be_removed_signal;
1862    }
1863    
1864    sigc::signal<void>& MainWindow::signal_samples_removed() {
1865        return samples_removed_signal;
1866    }
1867    
1868    sigc::signal<void, gig::Region*>& MainWindow::signal_region_to_be_changed() {
1869        return region_to_be_changed_signal;
1870    }
1871    
1872    sigc::signal<void, gig::Region*>& MainWindow::signal_region_changed() {
1873        return region_changed_signal;
1874    }
1875    
1876    sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/>& MainWindow::signal_sample_ref_changed() {
1877        return sample_ref_changed_signal;
1878    }
1879    
1880    sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_to_be_changed() {
1881        return dimreg_to_be_changed_signal;
1882    }
1883    
1884    sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {
1885        return dimreg_changed_signal;
1886    }
1887    
1888    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_on() {
1889        return note_on_signal;
1890    }
1891    
1892    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_off() {
1893        return note_off_signal;
1894    }
1895    
1896    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_hit() {
1897        return m_RegionChooser.signal_keyboard_key_hit();
1898    }
1899    
1900    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_released() {
1901        return m_RegionChooser.signal_keyboard_key_released();
1902    }
Legend:
Removed from v.1265  
changed lines
  Added in v.1799
  ViewVC Help
Powered by ViewVC